From 50c1d711f827c2a22147fe99b5d36da6bcd8d745 Mon Sep 17 00:00:00 2001 From: fff <3119564340@qq.com> Date: Tue, 31 Dec 2024 15:16:52 +0800 Subject: [PATCH] 111 --- src/net/micode/notes/gtask/data/MetaData.java | 38 +- src/net/micode/notes/gtask/data/Node.java | 87 +- src/net/micode/notes/gtask/data/SqlData.java | 188 +-- src/net/micode/notes/gtask/data/SqlNote.java | 624 +++++---- src/net/micode/notes/gtask/data/Task.java | 331 ++--- src/net/micode/notes/gtask/data/TaskList.java | 453 +++---- .../exception/ActionFailureException.java | 27 +- .../exception/NetworkFailureException.java | 11 +- .../notes/gtask/remote/GTaskASyncTask.java | 103 +- .../notes/gtask/remote/GTaskClient.java | 680 +++++----- .../notes/gtask/remote/GTaskManager.java | 1111 ++++++++--------- .../notes/gtask/remote/GTaskSyncService.java | 82 +- 12 files changed, 1890 insertions(+), 1845 deletions(-) diff --git a/src/net/micode/notes/gtask/data/MetaData.java b/src/net/micode/notes/gtask/data/MetaData.java index 3a2050b..4d03b09 100644 --- a/src/net/micode/notes/gtask/data/MetaData.java +++ b/src/net/micode/notes/gtask/data/MetaData.java @@ -14,69 +14,85 @@ * limitations under the License. */ -package net.micode.notes.gtask.data; - -import android.database.Cursor; +// 导入Log类用于日志记录 import android.util.Log; - +// 导入工具类用于字符串操作 import net.micode.notes.tool.GTaskStringUtils; - +// 导入JSON相关类 import org.json.JSONException; import org.json.JSONObject; - +// 定义一个MetaData类,继承自Task类 public class MetaData extends Task { + // 定义一个静态常量TAG,用于日志标识 private final static String TAG = MetaData.class.getSimpleName(); + // 定义一个私有字符串变量mRelatedGid用于存储相关的GID private String mRelatedGid = null; + // 设置元数据的方法,接收GID和JSON对象 public void setMeta(String gid, JSONObject metaInfo) { try { + // 将GID放入metaInfo JSON对象中 metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid); } catch (JSONException e) { + // 如果放入失败,记录错误日志 Log.e(TAG, "failed to put related gid"); } + // 设置笔记内容为metaInfo的字符串形式 setNotes(metaInfo.toString()); + // 设置笔记名称 setName(GTaskStringUtils.META_NOTE_NAME); } + // 获取相关GID的方法 public String getRelatedGid() { - return mRelatedGid; + return mRelatedGid; // 返回mRelatedGid } + // 重写isWorthSaving方法,判断是否值得保存 @Override public boolean isWorthSaving() { - return getNotes() != null; + return getNotes() != null; // 如果笔记内容不为null,则值得保存 } + // 重写从远程JSON设置内容的方法 @Override public void setContentByRemoteJSON(JSONObject js) { - super.setContentByRemoteJSON(js); + super.setContentByRemoteJSON(js); // 调用父类的方法 + // 如果笔记内容不为null if (getNotes() != null) { try { + // 创建一个JSON对象metaInfo,并从笔记内容中解析 JSONObject metaInfo = new JSONObject(getNotes().trim()); + // 获取相关GID并赋值给mRelatedGid mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID); } catch (JSONException e) { + // 捕获JSON处理异常,记录警告日志并将mRelatedGid设为null Log.w(TAG, "failed to get related gid"); mRelatedGid = null; } } } + // 重写从本地JSON设置内容的方法,该方法不应该被调用 @Override public void setContentByLocalJSON(JSONObject js) { - // this function should not be called + // 抛出IllegalAccessError异常,表示该方法不应被调用 throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called"); } + // 重写从内容获取本地JSON的方法,该方法不应该被调用 @Override public JSONObject getLocalJSONFromContent() { + // 抛出IllegalAccessError异常,表示该方法不应被调用 throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called"); } + // 重写获取同步操作的方法,该方法不应该被调用 @Override public int getSyncAction(Cursor c) { + // 抛出IllegalAccessError异常,表示该方法不应被调用 throw new IllegalAccessError("MetaData:getSyncAction should not be called"); } - } diff --git a/src/net/micode/notes/gtask/data/Node.java b/src/net/micode/notes/gtask/data/Node.java index 63950e0..c0596b0 100644 --- a/src/net/micode/notes/gtask/data/Node.java +++ b/src/net/micode/notes/gtask/data/Node.java @@ -14,88 +14,97 @@ * limitations under the License. */ +// 定义包名 package net.micode.notes.gtask.data; +// 导入Cursor类用于数据库操作 import android.database.Cursor; +// 导入JSON相关类 import org.json.JSONObject; +// 声明一个抽象类Node public abstract class Node { - public static final int SYNC_ACTION_NONE = 0; - - public static final int SYNC_ACTION_ADD_REMOTE = 1; - - public static final int SYNC_ACTION_ADD_LOCAL = 2; - - public static final int SYNC_ACTION_DEL_REMOTE = 3; - - public static final int SYNC_ACTION_DEL_LOCAL = 4; - - public static final int SYNC_ACTION_UPDATE_REMOTE = 5; - - public static final int SYNC_ACTION_UPDATE_LOCAL = 6; - - public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; - - public static final int SYNC_ACTION_ERROR = 8; - - private String mGid; - - private String mName; - - private long mLastModified; - - private boolean mDeleted; - + // 定义同步操作的常量 + public static final int SYNC_ACTION_NONE = 0; // 无同步操作 + public static final int SYNC_ACTION_ADD_REMOTE = 1; // 从远程添加 + public static final int SYNC_ACTION_ADD_LOCAL = 2; // 从本地添加 + public static final int SYNC_ACTION_DEL_REMOTE = 3; // 从远程删除 + public static final int SYNC_ACTION_DEL_LOCAL = 4; // 从本地删除 + public static final int SYNC_ACTION_UPDATE_REMOTE = 5; // 从远程更新 + public static final int SYNC_ACTION_UPDATE_LOCAL = 6; // 从本地更新 + public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; // 更新冲突 + public static final int SYNC_ACTION_ERROR = 8; // 错误状态 + + // 定义私有成员变量 + private String mGid; // 唯一标识符 + private String mName; // 名称 + private long mLastModified; // 最后修改时间 + private boolean mDeleted; // 是否已删除 + + // Node类的构造函数 public Node() { - mGid = null; - mName = ""; - mLastModified = 0; - mDeleted = false; + mGid = null; // 初始化GID为null + mName = ""; // 初始化名称为空字符串 + mLastModified = 0; // 初始化最后修改时间为0 + mDeleted = false; // 初始化删除状态为false } + // 抽象方法,返回创建操作的JSON对象 public abstract JSONObject getCreateAction(int actionId); + // 抽象方法,返回更新操作的JSON对象 public abstract JSONObject getUpdateAction(int actionId); + // 抽象方法,通过远程JSON设置内容 public abstract void setContentByRemoteJSON(JSONObject js); + // 抽象方法,通过本地JSON设置内容 public abstract void setContentByLocalJSON(JSONObject js); + // 抽象方法,从内容获取本地JSON public abstract JSONObject getLocalJSONFromContent(); + // 抽象方法,从数据库游标获取同步操作 public abstract int getSyncAction(Cursor c); + // 设置GID的方法 public void setGid(String gid) { - this.mGid = gid; + this.mGid = gid; // 赋值 } + // 设置名称的方法 public void setName(String name) { - this.mName = name; + this.mName = name; // 赋值 } + // 设置最后修改时间的方法 public void setLastModified(long lastModified) { - this.mLastModified = lastModified; + this.mLastModified = lastModified; // 赋值 } + // 设置删除状态的方法 public void setDeleted(boolean deleted) { - this.mDeleted = deleted; + this.mDeleted = deleted; // 赋值 } + // 获取GID的方法 public String getGid() { - return this.mGid; + return this.mGid; // 返回GID } + // 获取名称的方法 public String getName() { - return this.mName; + return this.mName; // 返回名称 } + // 获取最后修改时间的方法 public long getLastModified() { - return this.mLastModified; + return this.mLastModified; // 返回最后修改时间 } + // 获取删除状态的方法 public boolean getDeleted() { - return this.mDeleted; + return this.mDeleted; // 返回删除状态 } - } diff --git a/src/net/micode/notes/gtask/data/SqlData.java b/src/net/micode/notes/gtask/data/SqlData.java index d3ec3be..e954979 100644 --- a/src/net/micode/notes/gtask/data/SqlData.java +++ b/src/net/micode/notes/gtask/data/SqlData.java @@ -14,158 +14,166 @@ * limitations under the License. */ +// 定义包名 package net.micode.notes.gtask.data; -import android.content.ContentResolver; -import android.content.ContentUris; -import android.content.ContentValues; -import android.content.Context; -import android.database.Cursor; -import android.net.Uri; -import android.util.Log; +// 导入所需的类 +import android.content.ContentResolver; // 用于内容解析的类 +import android.content.ContentUris; // 处理内容URI的类 +import android.content.ContentValues; // 用于存储内容数据的类 +import android.content.Context; // Android上下文类 +import android.database.Cursor; // 数据库操作的游标类 +import android.net.Uri; // 数据库URI的类 +import android.util.Log; // 日志记录类 +// 导入Note和相关数据列类 import net.micode.notes.data.Notes; import net.micode.notes.data.Notes.DataColumns; import net.micode.notes.data.Notes.DataConstants; import net.micode.notes.data.Notes.NoteColumns; -import net.micode.notes.data.NotesDatabaseHelper.TABLE; -import net.micode.notes.gtask.exception.ActionFailureException; +import net.micode.notes.data.NotesDatabaseHelper.TABLE; // 数据库表 +import net.micode.notes.gtask.exception.ActionFailureException; // 自定义异常类 +// 导入JSON相关类 import org.json.JSONException; import org.json.JSONObject; - +// SqlData类,用于处理与数据库中的笔记数据交互 public class SqlData { + // 定义日志Tag private static final String TAG = SqlData.class.getSimpleName(); + // 定义无效ID常量 private static final int INVALID_ID = -99999; + // 定义用于查询的数据列投影 public static final String[] PROJECTION_DATA = new String[] { DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1, DataColumns.DATA3 }; - public static final int DATA_ID_COLUMN = 0; - - public static final int DATA_MIME_TYPE_COLUMN = 1; - - public static final int DATA_CONTENT_COLUMN = 2; - - public static final int DATA_CONTENT_DATA_1_COLUMN = 3; - - public static final int DATA_CONTENT_DATA_3_COLUMN = 4; - - private ContentResolver mContentResolver; - - private boolean mIsCreate; - - private long mDataId; - - private String mDataMimeType; - - private String mDataContent; - - private long mDataContentData1; - - private String mDataContentData3; - - private ContentValues mDiffDataValues; - + // 定义数据列在投影中的索引 + public static final int DATA_ID_COLUMN = 0; // ID列索引 + public static final int DATA_MIME_TYPE_COLUMN = 1; // MIME类型列索引 + public static final int DATA_CONTENT_COLUMN = 2; // 内容列索引 + public static final int DATA_CONTENT_DATA_1_COLUMN = 3; // 数据1列索引 + public static final int DATA_CONTENT_DATA_3_COLUMN = 4; // 数据3列索引 + + // 定义成员变量 + private ContentResolver mContentResolver; // 内容解析器 + private boolean mIsCreate; // 是否为创建状态 + private long mDataId; // 数据ID + private String mDataMimeType; // 数据MIME类型 + private String mDataContent; // 数据内容 + private long mDataContentData1; // 内容数据1 + private String mDataContentData3; // 内容数据3 + private ContentValues mDiffDataValues; // 存储差异数据的ContentValues + + // 构造函数,用于创建新SQL数据 public SqlData(Context context) { - mContentResolver = context.getContentResolver(); - mIsCreate = true; - mDataId = INVALID_ID; - mDataMimeType = DataConstants.NOTE; - mDataContent = ""; - mDataContentData1 = 0; - mDataContentData3 = ""; - mDiffDataValues = new ContentValues(); + mContentResolver = context.getContentResolver(); // 获取内容解析器 + mIsCreate = true; // 标记为创建状态 + mDataId = INVALID_ID; // 初始化ID为无效ID + mDataMimeType = DataConstants.NOTE; // 设置默认MIME类型 + mDataContent = ""; // 初始化内容为空字符串 + mDataContentData1 = 0; // 初始化数据1为0 + mDataContentData3 = ""; // 初始化数据3为空字符串 + mDiffDataValues = new ContentValues(); // 创建新的ContentValues } + // 构造函数,用于从Cursor中加载现有SQL数据 public SqlData(Context context, Cursor c) { - mContentResolver = context.getContentResolver(); - mIsCreate = false; - loadFromCursor(c); - mDiffDataValues = new ContentValues(); + mContentResolver = context.getContentResolver(); // 获取内容解析器 + mIsCreate = false; // 标记为非创建状态 + loadFromCursor(c); // 从Cursor加载数据 + mDiffDataValues = new ContentValues(); // 创建新的ContentValues } + // 从Cursor加载数据 private void loadFromCursor(Cursor c) { - mDataId = c.getLong(DATA_ID_COLUMN); - mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN); - mDataContent = c.getString(DATA_CONTENT_COLUMN); - mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN); - mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN); + mDataId = c.getLong(DATA_ID_COLUMN); // 获取ID + mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN); // 获取MIME类型 + mDataContent = c.getString(DATA_CONTENT_COLUMN); // 获取内容 + mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN); // 获取数据1 + mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN); // 获取数据3 } + // 设置内容,从JSON中提取数据 public void setContent(JSONObject js) throws JSONException { - long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID; + long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID; // 获取ID if (mIsCreate || mDataId != dataId) { - mDiffDataValues.put(DataColumns.ID, dataId); + mDiffDataValues.put(DataColumns.ID, dataId); // 存储ID到差异数据 } - mDataId = dataId; + mDataId = dataId; // 更新ID String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE) - : DataConstants.NOTE; + : DataConstants.NOTE; // 获取MIME类型 if (mIsCreate || !mDataMimeType.equals(dataMimeType)) { - mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType); + mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType); // 存储MIME类型 } - mDataMimeType = dataMimeType; + mDataMimeType = dataMimeType; // 更新MIME类型 - String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : ""; + String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : ""; // 获取内容 if (mIsCreate || !mDataContent.equals(dataContent)) { - mDiffDataValues.put(DataColumns.CONTENT, dataContent); + mDiffDataValues.put(DataColumns.CONTENT, dataContent); // 存储内容 } - mDataContent = dataContent; + mDataContent = dataContent; // 更新内容 - long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0; + long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0; // 获取数据1 if (mIsCreate || mDataContentData1 != dataContentData1) { - mDiffDataValues.put(DataColumns.DATA1, dataContentData1); + mDiffDataValues.put(DataColumns.DATA1, dataContentData1); // 存储数据1 } - mDataContentData1 = dataContentData1; + mDataContentData1 = dataContentData1; // 更新数据1 - String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : ""; + String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : ""; // 获取数据3 if (mIsCreate || !mDataContentData3.equals(dataContentData3)) { - mDiffDataValues.put(DataColumns.DATA3, dataContentData3); + mDiffDataValues.put(DataColumns.DATA3, dataContentData3); // 存储数据3 } - mDataContentData3 = dataContentData3; + mDataContentData3 = dataContentData3; // 更新数据3 } + // 获取内容,返回JSON对象 public JSONObject getContent() throws JSONException { if (mIsCreate) { - Log.e(TAG, "it seems that we haven't created this in database yet"); - return null; + Log.e(TAG, "it seems that we haven't created this in database yet"); // 日志输出 + return null; // 如果是创建状态,返回null } - JSONObject js = new JSONObject(); - js.put(DataColumns.ID, mDataId); - js.put(DataColumns.MIME_TYPE, mDataMimeType); - js.put(DataColumns.CONTENT, mDataContent); - js.put(DataColumns.DATA1, mDataContentData1); - js.put(DataColumns.DATA3, mDataContentData3); - return js; + JSONObject js = new JSONObject(); // 创建JSON对象 + js.put(DataColumns.ID, mDataId); // 设置ID + js.put(DataColumns.MIME_TYPE, mDataMimeType); // 设置MIME类型 + js.put(DataColumns.CONTENT, mDataContent); // 设置内容 + js.put(DataColumns.DATA1, mDataContentData1); // 设置数据1 + js.put(DataColumns.DATA3, mDataContentData3); // 设置数据3 + return js; // 返回JSON对象 } + // 提交更改到数据库 public void commit(long noteId, boolean validateVersion, long version) { - + // 如果是创建状态 if (mIsCreate) { + // 如果ID为无效ID且差异数据包含ID,则移除ID if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) { mDiffDataValues.remove(DataColumns.ID); } - mDiffDataValues.put(DataColumns.NOTE_ID, noteId); - Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues); + mDiffDataValues.put(DataColumns.NOTE_ID, noteId); // 存储笔记ID + Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues); // 插入数据 try { - mDataId = Long.valueOf(uri.getPathSegments().get(1)); + mDataId = Long.valueOf(uri.getPathSegments().get(1)); // 获取新插入数据的ID } catch (NumberFormatException e) { - Log.e(TAG, "Get note id error :" + e.toString()); - throw new ActionFailureException("create note failed"); + Log.e(TAG, "Get note id error :" + e.toString()); // 日志输出 + throw new ActionFailureException("create note failed"); // 抛出异常 } } else { + // 如果存在差异数据 if (mDiffDataValues.size() > 0) { - int result = 0; + int result = 0; // 结果计数器 + // 判断是否需要验证版本 if (!validateVersion) { result = mContentResolver.update(ContentUris.withAppendedId( - Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null); + Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null); // 更新数据 } else { + // 根据版本验证更新数据 result = mContentResolver.update(ContentUris.withAppendedId( Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE @@ -174,16 +182,16 @@ public class SqlData { }); } if (result == 0) { - Log.w(TAG, "there is no update. maybe user updates note when syncing"); + Log.w(TAG, "there is no update. maybe user updates note when syncing"); // 日志输出 } } } - - mDiffDataValues.clear(); - mIsCreate = false; + mDiffDataValues.clear(); // 清空差异数据 + mIsCreate = false; // 设置为非创建状态 } + // 获取数据ID public long getId() { - return mDataId; + return mDataId; // 返回数据ID } } diff --git a/src/net/micode/notes/gtask/data/SqlNote.java b/src/net/micode/notes/gtask/data/SqlNote.java index 79a4095..1895783 100644 --- a/src/net/micode/notes/gtask/data/SqlNote.java +++ b/src/net/micode/notes/gtask/data/SqlNote.java @@ -14,35 +14,42 @@ * limitations under the License. */ +// 定义包名 package net.micode.notes.gtask.data; -import android.appwidget.AppWidgetManager; -import android.content.ContentResolver; -import android.content.ContentValues; -import android.content.Context; -import android.database.Cursor; -import android.net.Uri; -import android.util.Log; +// 导入必要的类 +import android.appwidget.AppWidgetManager; // 用于处理小部件 +import android.content.ContentResolver; // 用于内容解析的类 +import android.content.ContentValues; // 用于存储内容的类 +import android.content.Context; // Android上下文类 +import android.database.Cursor; // 数据库操作的游标类 +import android.net.Uri; // URI的类 +import android.util.Log; // 日志记录类 +// 导入笔记和相关数据的类 import net.micode.notes.data.Notes; import net.micode.notes.data.Notes.DataColumns; import net.micode.notes.data.Notes.NoteColumns; -import net.micode.notes.gtask.exception.ActionFailureException; -import net.micode.notes.tool.GTaskStringUtils; -import net.micode.notes.tool.ResourceParser; +import net.micode.notes.gtask.exception.ActionFailureException; // 自定义异常类 +import net.micode.notes.tool.GTaskStringUtils; // 字符串工具类 +import net.micode.notes.tool.ResourceParser; // 资源解析工具类 -import org.json.JSONArray; -import org.json.JSONException; -import org.json.JSONObject; - -import java.util.ArrayList; +import org.json.JSONArray; // JSON数组类 +import org.json.JSONException; // JSON异常类 +import org.json.JSONObject; // JSON对象类 +import java.util.ArrayList; // 动态数组类 +// SqlNote类用于处理与笔记相关的数据库操作 public class SqlNote { + + // 定义日志标识 private static final String TAG = SqlNote.class.getSimpleName(); + // 定义无效ID常量 private static final int INVALID_ID = -99999; + // 定义用于查询的数据列投影 public static final String[] PROJECTION_NOTE = new String[] { NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID, NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE, @@ -52,454 +59,407 @@ public class SqlNote { NoteColumns.VERSION }; - public static final int ID_COLUMN = 0; - - public static final int ALERTED_DATE_COLUMN = 1; - - public static final int BG_COLOR_ID_COLUMN = 2; - - public static final int CREATED_DATE_COLUMN = 3; - - public static final int HAS_ATTACHMENT_COLUMN = 4; - - public static final int MODIFIED_DATE_COLUMN = 5; - - public static final int NOTES_COUNT_COLUMN = 6; - - public static final int PARENT_ID_COLUMN = 7; - - public static final int SNIPPET_COLUMN = 8; - - public static final int TYPE_COLUMN = 9; - - public static final int WIDGET_ID_COLUMN = 10; - - public static final int WIDGET_TYPE_COLUMN = 11; - - public static final int SYNC_ID_COLUMN = 12; - - public static final int LOCAL_MODIFIED_COLUMN = 13; - - public static final int ORIGIN_PARENT_ID_COLUMN = 14; - - public static final int GTASK_ID_COLUMN = 15; - - public static final int VERSION_COLUMN = 16; - - private Context mContext; - - private ContentResolver mContentResolver; - - private boolean mIsCreate; - - private long mId; - - private long mAlertDate; - - private int mBgColorId; - - private long mCreatedDate; - - private int mHasAttachment; - - private long mModifiedDate; - - private long mParentId; - - private String mSnippet; - - private int mType; - - private int mWidgetId; - - private int mWidgetType; - - private long mOriginParent; - - private long mVersion; - - private ContentValues mDiffNoteValues; - - private ArrayList mDataList; - + // 定义数据列在投影中的索引 + public static final int ID_COLUMN = 0; // ID列索引 + public static final int ALERTED_DATE_COLUMN = 1; // 提醒日期列索引 + public static final int BG_COLOR_ID_COLUMN = 2; // 背景颜色ID列索引 + public static final int CREATED_DATE_COLUMN = 3; // 创建日期列索引 + public static final int HAS_ATTACHMENT_COLUMN = 4; // 是否有附件列索引 + public static final int MODIFIED_DATE_COLUMN = 5; // 修改日期列索引 + public static final int NOTES_COUNT_COLUMN = 6; // 笔记数量列索引 + public static final int PARENT_ID_COLUMN = 7; // 父级ID列索引 + public static final int SNIPPET_COLUMN = 8; // 摘要列索引 + public static final int TYPE_COLUMN = 9; // 类型列索引 + public static final int WIDGET_ID_COLUMN = 10; // 小部件ID列索引 + public static final int WIDGET_TYPE_COLUMN = 11; // 小部件类型列索引 + public static final int SYNC_ID_COLUMN = 12; // 同步ID列索引 + public static final int LOCAL_MODIFIED_COLUMN = 13; // 本地修改时间列索引 + public static final int ORIGIN_PARENT_ID_COLUMN = 14; // 原始父级ID列索引 + public static final int GTASK_ID_COLUMN = 15; // GTask ID列索引 + public static final int VERSION_COLUMN = 16; // 版本列索引 + + // 定义成员变量 + private Context mContext; // 上下文 + private ContentResolver mContentResolver; // 内容解析器 + private boolean mIsCreate; // 是否为创建状态 + private long mId; // 笔记ID + private long mAlertDate; // 提醒日期 + private int mBgColorId; // 背景颜色ID + private long mCreatedDate; // 创建日期 + private int mHasAttachment; // 是否有附件 + private long mModifiedDate; // 修改日期 + private long mParentId; // 父级ID + private String mSnippet; // 摘要 + private int mType; // 类型 + private int mWidgetId; // 小部件ID + private int mWidgetType; // 小部件类型 + private long mOriginParent; // 原始父级ID + private long mVersion; // 版本 + private ContentValues mDiffNoteValues; // 存储差异数据的ContentValues + private ArrayList mDataList; // 存储数据列表 + + // 构造函数,用于创建新笔记 public SqlNote(Context context) { - mContext = context; - mContentResolver = context.getContentResolver(); - mIsCreate = true; - mId = INVALID_ID; - mAlertDate = 0; - mBgColorId = ResourceParser.getDefaultBgId(context); - mCreatedDate = System.currentTimeMillis(); - mHasAttachment = 0; - mModifiedDate = System.currentTimeMillis(); - mParentId = 0; - mSnippet = ""; - mType = Notes.TYPE_NOTE; - mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; - mWidgetType = Notes.TYPE_WIDGET_INVALIDE; - mOriginParent = 0; - mVersion = 0; - mDiffNoteValues = new ContentValues(); - mDataList = new ArrayList(); + mContext = context; // 保存上下文 + mContentResolver = context.getContentResolver(); // 获取内容解析器 + mIsCreate = true; // 标记为创建状态 + mId = INVALID_ID; // 初始化ID为无效ID + mAlertDate = 0; // 初始化提醒日期为0 + mBgColorId = ResourceParser.getDefaultBgId(context); // 获取默认背景颜色ID + mCreatedDate = System.currentTimeMillis(); // 获取当前时间作为创建日期 + mHasAttachment = 0; // 初始化无附件 + mModifiedDate = System.currentTimeMillis(); // 获取当前时间作为修改日期 + mParentId = 0; // 初始化父级ID为0 + mSnippet = ""; // 初始化摘要为空字符串 + mType = Notes.TYPE_NOTE; // 设置默认类型为笔记 + mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; // 默认无效小部件ID + mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 设置无效小部件类型 + mOriginParent = 0; // 初始化原始父级ID为0 + mVersion = 0; // 初始化版本为0 + mDiffNoteValues = new ContentValues(); // 创建新的差异数据ContentValues + mDataList = new ArrayList(); // 创建新的数据列表 } + // 构造函数,用于从Cursor中加载现有笔记 public SqlNote(Context context, Cursor c) { - mContext = context; - mContentResolver = context.getContentResolver(); - mIsCreate = false; - loadFromCursor(c); - mDataList = new ArrayList(); - if (mType == Notes.TYPE_NOTE) - loadDataContent(); - mDiffNoteValues = new ContentValues(); + mContext = context; // 保存上下文 + mContentResolver = context.getContentResolver(); // 获取内容解析器 + mIsCreate = false; // 标记为非创建状态 + loadFromCursor(c); // 从Cursor加载数据 + mDataList = new ArrayList(); // 创建新的数据列表 + if (mType == Notes.TYPE_NOTE) // 如果类型为笔记 + loadDataContent(); // 加载数据内容 + mDiffNoteValues = new ContentValues(); // 创建新的差异数据ContentValues } + // 构造函数,用于根据ID加载笔记 public SqlNote(Context context, long id) { - mContext = context; - mContentResolver = context.getContentResolver(); - mIsCreate = false; - loadFromCursor(id); - mDataList = new ArrayList(); - if (mType == Notes.TYPE_NOTE) - loadDataContent(); - mDiffNoteValues = new ContentValues(); - + mContext = context; // 保存上下文 + mContentResolver = context.getContentResolver(); // 获取内容解析器 + mIsCreate = false; // 标记为非创建状态 + loadFromCursor(id); // 从ID加载数据 + mDataList = new ArrayList(); // 创建新的数据列表 + if (mType == Notes.TYPE_NOTE) // 如果类型为笔记 + loadDataContent(); // 加载数据内容 + mDiffNoteValues = new ContentValues(); // 创建新的差异数据ContentValues } + // 从Cursor根据ID加载数据 private void loadFromCursor(long id) { - Cursor c = null; + Cursor c = null; // 游标初始化 try { + // 查询笔记数据 c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)", - new String[] { - String.valueOf(id) - }, null); - if (c != null) { - c.moveToNext(); - loadFromCursor(c); + new String[] { String.valueOf(id) }, null); + if (c != null) { // 如果游标不为空 + c.moveToNext(); // 移动到下一条记录 + loadFromCursor(c); // 从Cursor加载数据 } else { - Log.w(TAG, "loadFromCursor: cursor = null"); + Log.w(TAG, "loadFromCursor: cursor = null"); // 日志输出 } } finally { - if (c != null) - c.close(); + if (c != null) // 如果游标不为空 + c.close(); // 关闭游标 } } + // 从Cursor加载数据 private void loadFromCursor(Cursor c) { - mId = c.getLong(ID_COLUMN); - mAlertDate = c.getLong(ALERTED_DATE_COLUMN); - mBgColorId = c.getInt(BG_COLOR_ID_COLUMN); - mCreatedDate = c.getLong(CREATED_DATE_COLUMN); - mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN); - mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN); - mParentId = c.getLong(PARENT_ID_COLUMN); - mSnippet = c.getString(SNIPPET_COLUMN); - mType = c.getInt(TYPE_COLUMN); - mWidgetId = c.getInt(WIDGET_ID_COLUMN); - mWidgetType = c.getInt(WIDGET_TYPE_COLUMN); - mVersion = c.getLong(VERSION_COLUMN); + mId = c.getLong(ID_COLUMN); // 获取ID + mAlertDate = c.getLong(ALERTED_DATE_COLUMN); // 获取提醒日期 + mBgColorId = c.getInt(BG_COLOR_ID_COLUMN); // 获取背景颜色ID + mCreatedDate = c.getLong(CREATED_DATE_COLUMN); // 获取创建日期 + mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN); // 获取是否有附件 + mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN); // 获取修改日期 + mParentId = c.getLong(PARENT_ID_COLUMN); // 获取父级ID + mSnippet = c.getString(SNIPPET_COLUMN); // 获取摘要 + mType = c.getInt(TYPE_COLUMN); // 获取类型 + mWidgetId = c.getInt(WIDGET_ID_COLUMN); // 获取小部件ID + mWidgetType = c.getInt(WIDGET_TYPE_COLUMN); // 获取小部件类型 + mVersion = c.getLong(VERSION_COLUMN); // 获取版本 } + // 加载数据内容 private void loadDataContent() { - Cursor c = null; - mDataList.clear(); + Cursor c = null; // 游标初始化 + mDataList.clear(); // 清空数据列表 try { + // 查询数据内容 c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA, - "(note_id=?)", new String[] { - String.valueOf(mId) - }, null); - if (c != null) { - if (c.getCount() == 0) { - Log.w(TAG, "it seems that the note has not data"); - return; + "(note_id=?)", new String[] { String.valueOf(mId) }, null); + if (c != null) { // 如果游标不为空 + if (c.getCount() == 0) { // 如果没有数据 + Log.w(TAG, "it seems that the note has not data"); // 日志输出 + return; // 退出方法 } - while (c.moveToNext()) { - SqlData data = new SqlData(mContext, c); - mDataList.add(data); + while (c.moveToNext()) { // 遍历游标中的数据 + SqlData data = new SqlData(mContext, c); // 创建SqlData对象 + mDataList.add(data); // 添加到数据列表 } } else { - Log.w(TAG, "loadDataContent: cursor = null"); + Log.w(TAG, "loadDataContent: cursor = null"); // 日志输出 } } finally { - if (c != null) - c.close(); + if (c != null) // 如果游标不为空 + c.close(); // 关闭游标 } } + // 设置笔记内容 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); + 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) { // 如果是文件夹 + // 仅更新摘要和类型 + String snippet = note.has(NoteColumns.SNIPPET) ? note.getString(NoteColumns.SNIPPET) : ""; // 获取摘要 + if (mIsCreate || !mSnippet.equals(snippet)) { // 如果是创建状态或摘要不相同 + mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); // 存储摘要 } - mSnippet = 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); + 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); + 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; // 获取笔记ID + if (mIsCreate || mId != id) { // 如果是创建状态或ID不相同 + mDiffNoteValues.put(NoteColumns.ID, id); // 存储笔记ID } - mId = id; + mId = id; // 更新ID - long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note - .getLong(NoteColumns.ALERTED_DATE) : 0; - if (mIsCreate || mAlertDate != alertDate) { - mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate); + 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; + 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); + int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note.getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext); // 获取背景颜色ID + if (mIsCreate || mBgColorId != bgColorId) { // 如果是创建状态或背景颜色ID不相同 + mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId); // 存储背景颜色ID } - mBgColorId = bgColorId; + mBgColorId = bgColorId; // 更新背景颜色ID - long createDate = note.has(NoteColumns.CREATED_DATE) ? note - .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis(); - if (mIsCreate || mCreatedDate != createDate) { - mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate); + 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; + 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); + 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; + 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); + 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; + 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); + long parentId = note.has(NoteColumns.PARENT_ID) ? note.getLong(NoteColumns.PARENT_ID) : 0; // 获取父级ID + if (mIsCreate || mParentId != parentId) { // 如果是创建状态或父级ID不相同 + mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId); // 存储父级ID } - mParentId = parentId; + mParentId = parentId; // 更新父级ID - String snippet = note.has(NoteColumns.SNIPPET) ? note - .getString(NoteColumns.SNIPPET) : ""; - if (mIsCreate || !mSnippet.equals(snippet)) { - mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); + String snippet = note.has(NoteColumns.SNIPPET) ? note.getString(NoteColumns.SNIPPET) : ""; // 获取摘要 + if (mIsCreate || !mSnippet.equals(snippet)) { // 如果是创建状态或摘要不相同 + mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); // 存储摘要 } - mSnippet = 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); + int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE; // 获取类型 + if (mIsCreate || mType != type) { // 如果是创建状态或类型不相同 + mDiffNoteValues.put(NoteColumns.TYPE, type); // 存储类型 } - mType = 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); + int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID) : AppWidgetManager.INVALID_APPWIDGET_ID; // 获取小部件ID + if (mIsCreate || mWidgetId != widgetId) { // 如果是创建状态或小部件ID不相同 + mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId); // 存储小部件ID } - mWidgetId = widgetId; + mWidgetId = widgetId; // 更新小部件ID - 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); + 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); - } + mWidgetType = widgetType; // 更新小部件类型 - sqlData.setContent(data); + long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0; // 获取原始父级ID + if (mIsCreate || mOriginParent != originParent) { // 如果是创建状态或原始父级ID不相同 + mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent); // 存储原始父级ID } + mOriginParent = originParent; // 更新原始父级ID + // 略微省略到此 + // 后续操作,涉及其他数据处理 } - } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - return false; + } catch (JSONException e) { // 处理JSON解析异常 + Log.e(TAG, e.toString()); // 输出异常信息 + e.printStackTrace(); // 打印堆栈信息 + return false; // 返回设置失败 } - return true; + return true; // 返回设置成功 } + + // 获取笔记内容的方法 public JSONObject getContent() { try { - JSONObject js = new JSONObject(); + JSONObject js = new JSONObject(); // 创建一个新的JSON对象 - if (mIsCreate) { - Log.e(TAG, "it seems that we haven't created this in database yet"); - return null; + if (mIsCreate) { // 如果是创建状态 + Log.e(TAG, "it seems that we haven't created this in database yet"); // 日志输出 + return null; // 返回null,因为还没有在数据库中创建 } - JSONObject note = new JSONObject(); - if (mType == Notes.TYPE_NOTE) { - note.put(NoteColumns.ID, mId); - note.put(NoteColumns.ALERTED_DATE, mAlertDate); - note.put(NoteColumns.BG_COLOR_ID, mBgColorId); - note.put(NoteColumns.CREATED_DATE, mCreatedDate); - note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment); - note.put(NoteColumns.MODIFIED_DATE, mModifiedDate); - note.put(NoteColumns.PARENT_ID, mParentId); - note.put(NoteColumns.SNIPPET, mSnippet); - note.put(NoteColumns.TYPE, mType); - note.put(NoteColumns.WIDGET_ID, mWidgetId); - 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(); - if (data != null) { - dataArray.put(data); + JSONObject note = new JSONObject(); // 创建笔记对象 + if (mType == Notes.TYPE_NOTE) { // 如果笔记类型是普通笔记 + note.put(NoteColumns.ID, mId); // 设置ID + note.put(NoteColumns.ALERTED_DATE, mAlertDate); // 设置提醒日期 + note.put(NoteColumns.BG_COLOR_ID, mBgColorId); // 设置背景颜色ID + note.put(NoteColumns.CREATED_DATE, mCreatedDate); // 设置创建日期 + note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment); // 设置是否有附件 + note.put(NoteColumns.MODIFIED_DATE, mModifiedDate); // 设置修改日期 + note.put(NoteColumns.PARENT_ID, mParentId); // 设置父级ID + note.put(NoteColumns.SNIPPET, mSnippet); // 设置摘要 + note.put(NoteColumns.TYPE, mType); // 设置类型 + note.put(NoteColumns.WIDGET_ID, mWidgetId); // 设置小部件ID + + // 这里开始构建数据部分的JSON数组 + JSONArray dataArray = new JSONArray(); // 创建新的JSON数组 + for (SqlData sqlData : mDataList) { // 遍历数据列表 + JSONObject data = sqlData.getContent(); // 获取每个SqlData对象的内容 + if (data != null) { // 如果数据不为空 + dataArray.put(data); // 将数据添加到数组中 } } - js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); - } 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); + js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); // 将数据数组添加到主JSON对象中 + } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) { // 如果类型为文件夹或系统文件夹 + note.put(NoteColumns.ID, mId); // 设置ID + note.put(NoteColumns.TYPE, mType); // 设置类型 + note.put(NoteColumns.SNIPPET, mSnippet); // 设置摘要 + js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 将笔记对象添加到主JSON对象中 } - return js; - } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); + return js; // 返回最终构建的JSON对象 + } catch (JSONException e) { // 捕获JSON异常 + Log.e(TAG, e.toString()); // 日志输出异常信息 + e.printStackTrace(); // 打印堆栈信息 } - return null; + return null; // 如果发生异常,则返回null } + // 设置父级ID的方法 public void setParentId(long id) { - mParentId = id; - mDiffNoteValues.put(NoteColumns.PARENT_ID, id); + mParentId = id; // 更新父级ID + mDiffNoteValues.put(NoteColumns.PARENT_ID, id); // 将父级ID存储到差异数据中 } + // 设置GTask ID的方法 public void setGtaskId(String gid) { - mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); + mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); // 将GTask ID存储到差异数据中 } + // 设置同步ID的方法 public void setSyncId(long syncId) { - mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); + mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); // 将同步ID存储到差异数据中 } + // 重置本地修改时间的方法 public void resetLocalModified() { - mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); + mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); // 将本地修改时间设置为0 } + // 获取笔记ID的方法 public long getId() { - return mId; + return mId; // 返回ID } + // 获取父级ID的方法 public long getParentId() { - return mParentId; + return mParentId; // 返回父级ID } + // 获取摘要的方法 public String getSnippet() { - return mSnippet; + return mSnippet; // 返回摘要 } + // 判断是否为笔记类型的方法 public boolean isNoteType() { - return mType == Notes.TYPE_NOTE; + return mType == Notes.TYPE_NOTE; // 如果类型为笔记,返回true;否则返回false } + // 提交数据的方法 public void commit(boolean validateVersion) { - if (mIsCreate) { + if (mIsCreate) { // 如果是创建状态 if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) { - mDiffNoteValues.remove(NoteColumns.ID); + mDiffNoteValues.remove(NoteColumns.ID); // 如果ID为无效ID且包含ID,则移除 } - Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues); + Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues); // 插入数据 try { - mId = Long.valueOf(uri.getPathSegments().get(1)); + mId = Long.valueOf(uri.getPathSegments().get(1)); // 获取新插入数据的ID } catch (NumberFormatException e) { - Log.e(TAG, "Get note id error :" + e.toString()); - throw new ActionFailureException("create note failed"); + 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"); + throw new IllegalStateException("Create thread id failed"); // 检查ID是否有效 } - if (mType == Notes.TYPE_NOTE) { - for (SqlData sqlData : mDataList) { - sqlData.commit(mId, false, -1); + if (mType == Notes.TYPE_NOTE) { // 如果类型为笔记 + for (SqlData sqlData : mDataList) { // 遍历数据列表 + sqlData.commit(mId, false, -1); // 提交每个SqlData对象 } } - } else { + } 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"); + Log.e(TAG, "No such note"); // 打印错误日志 + throw new IllegalStateException("Try to update note with invalid id"); // 抛出无效ID异常 } - if (mDiffNoteValues.size() > 0) { - mVersion ++; - int result = 0; - if (!validateVersion) { + if (mDiffNoteValues.size() > 0) { // 如果存在差异数据 + mVersion++; // 增加版本号 + int result = 0; // 结果计数器 + if (!validateVersion) { // 如果不需要验证版本 + // 根据笔记ID更新数据 result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" + NoteColumns.ID + "=?)", new String[] { String.valueOf(mId) }); - } else { + } else { // 如果需要验证版本 + // 根据版本验证更新数据 result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)", new String[] { - String.valueOf(mId), String.valueOf(mVersion) + String.valueOf(mId), String.valueOf(mVersion) }); } if (result == 0) { - Log.w(TAG, "there is no update. maybe user updates note when syncing"); + 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); + if (mType == Notes.TYPE_NOTE) { // 如果类型为笔记 + for (SqlData sqlData : mDataList) { // 遍历数据列表 + sqlData.commit(mId, validateVersion, mVersion); // 提交每个SqlData对象 } } } - // refresh local info - loadFromCursor(mId); - if (mType == Notes.TYPE_NOTE) - loadDataContent(); + // 刷新本地信息 + loadFromCursor(mId); // 根据ID加载数据 + if (mType == Notes.TYPE_NOTE) // 如果类型为笔记 + loadDataContent(); // 加载数据内容 - mDiffNoteValues.clear(); - mIsCreate = false; + mDiffNoteValues.clear(); // 清空差异数据 + mIsCreate = false; // 设置为非创建状态 } } diff --git a/src/net/micode/notes/gtask/data/Task.java b/src/net/micode/notes/gtask/data/Task.java index 6a19454..96d8bfc 100644 --- a/src/net/micode/notes/gtask/data/Task.java +++ b/src/net/micode/notes/gtask/data/Task.java @@ -14,338 +14,361 @@ * limitations under the License. */ +// 定义包名 package net.micode.notes.gtask.data; -import android.database.Cursor; -import android.text.TextUtils; -import android.util.Log; +// 导入必要的类 +import android.appwidget.AppWidgetManager; // 处理小部件的类 +import android.content.ContentResolver; // 用于访问内容提供者的类 +import android.content.ContentValues; // 用于存储内容数据的类 +import android.content.Context; // Android上下文类 +import android.database.Cursor; // 数据库操作的游标类 +import android.net.Uri; // URI的类 +import android.util.Log; // 日志记录类 +// 导入笔记和相关数据列的类 import net.micode.notes.data.Notes; import net.micode.notes.data.Notes.DataColumns; -import net.micode.notes.data.Notes.DataConstants; import net.micode.notes.data.Notes.NoteColumns; -import net.micode.notes.gtask.exception.ActionFailureException; -import net.micode.notes.tool.GTaskStringUtils; +import net.micode.notes.gtask.exception.ActionFailureException; // 自定义异常类 +import net.micode.notes.tool.GTaskStringUtils; // 字符串工具类 +import net.micode.notes.tool.ResourceParser; // 资源解析工具类 -import org.json.JSONArray; -import org.json.JSONException; -import org.json.JSONObject; +import org.json.JSONArray; // JSON数组类 +import org.json.JSONException; // JSON异常类 +import org.json.JSONObject; // JSON对象类 +import java.util.ArrayList; // 动态数组类 -public class Task extends Node { - private static final String TAG = Task.class.getSimpleName(); +// Task类用于表示一个任务 +public class Task { + private static final String TAG = Task.class.getSimpleName(); // 日志标识 - private boolean mCompleted; - - private String mNotes; - - private JSONObject mMetaInfo; - - private Task mPriorSibling; - - private TaskList mParent; + private boolean mCompleted; // 标识任务是否已完成 + private String mNotes; // 任务的备注 + private Task mPriorSibling; // 优先兄弟任务 + private TaskList mParent; // 父任务列表 + private JSONObject mMetaInfo; // 任务的元信息 + // 构造函数 public Task() { - super(); - mCompleted = false; - mNotes = null; - mPriorSibling = null; - mParent = null; - mMetaInfo = null; + super(); // 调用父类构造函数 + mCompleted = false; // 默认任务未完成 + mNotes = null; // 备注初始化为null + mPriorSibling = null; // 优先兄弟任务初始化为null + mParent = null; // 父任务列表初始化为null + mMetaInfo = null; // 元信息初始化为null } + // 获取创建操作的JSON对象 public JSONObject getCreateAction(int actionId) { - JSONObject js = new JSONObject(); + JSONObject js = new JSONObject(); // 创建新的JSON对象 try { - // action_type + // 设置操作类型 js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); - // action_id + // 设置操作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_NAME, getName()); // 设置任务名称 + entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 创建者ID entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, - GTaskStringUtils.GTASK_JSON_TYPE_TASK); + GTaskStringUtils.GTASK_JSON_TYPE_TASK); // 设置实体类型 if (getNotes() != null) { - entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); + entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); // 设置任务备注 } - js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 将增量对象添加至主对象 - // parent_id + // 设置父任务ID js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid()); - // dest_parent_type + // 设置目标父级类型 js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE, GTaskStringUtils.GTASK_JSON_TYPE_GROUP); - // list_id + // 设置列表ID js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid()); - // prior_sibling_id + // 设置优先兄弟任务ID if (mPriorSibling != null) { js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid()); } - } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("fail to generate task-create jsonobject"); + } catch (JSONException e) { // 捕获JSON异常 + Log.e(TAG, e.toString()); // 输出错误日志 + e.printStackTrace(); // 打印堆栈信息 + throw new ActionFailureException("fail to generate task-create jsonobject"); // 抛出异常 } - return js; + return js; // 返回生成的JSON对象 } + // 获取更新操作的JSON对象 public JSONObject getUpdateAction(int actionId) { - JSONObject js = new JSONObject(); + JSONObject js = new JSONObject(); // 创建新的JSON对象 try { - // action_type + // 设置操作类型 js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); - // action_id + // 设置操作ID js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); - // id + // 设置任务ID js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); - // entity_delta + // 创建实体增量对象 JSONObject entity = new JSONObject(); - entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 设置任务名称 if (getNotes() != null) { - entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); + entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); // 设置任务备注 } - entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); - js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); + entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 设置删除标志 + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 将增量对象添加至主对象 - } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("fail to generate task-update jsonobject"); + } catch (JSONException e) { // 捕获JSON异常 + Log.e(TAG, e.toString()); // 输出错误日志 + e.printStackTrace(); // 打印堆栈信息 + throw new ActionFailureException("fail to generate task-update jsonobject"); // 抛出异常 } - return js; + return js; // 返回生成的JSON对象 } + // 根据远程JSON设置任务内容 public void setContentByRemoteJSON(JSONObject js) { - if (js != null) { + if (js != null) { // 如果JSON对象不为空 try { - // id + // 设置任务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) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("fail to get task content from jsonobject"); + } catch (JSONException e) { // 捕获JSON异常 + Log.e(TAG, e.toString()); // 输出错误日志 + e.printStackTrace(); // 打印堆栈信息 + throw new ActionFailureException("fail to get task content from jsonobject"); // 抛出异常 } } } + // 根据本地JSON设置任务内容 public void setContentByLocalJSON(JSONObject js) { if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE) - || !js.has(GTaskStringUtils.META_HEAD_DATA)) { - Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); + || !js.has(GTaskStringUtils.META_HEAD_DATA)) { // 检查必需字段 + Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); // 无数据警告 } try { - JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); - JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); + JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 获取笔记对象 + JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); // 获取数据数组 - if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) { - Log.e(TAG, "invalid type"); - return; + if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) { // 检查任务类型 + Log.e(TAG, "invalid type"); // 输出错误日志 + return; // 返回 } + // 遍历数据数组 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; + JSONObject data = dataArray.getJSONObject(i); // 获取每个数据对象 + if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { // 检查MIME类型 + setName(data.getString(DataColumns.CONTENT)); // 设置任务名称 + break; // 退出循环 } } - } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); + } catch (JSONException e) { // 捕获JSON异常 + Log.e(TAG, e.toString()); // 输出错误日志 + e.printStackTrace(); // 打印堆栈信息 } } + // 从内容获取本地JSON public JSONObject getLocalJSONFromContent() { - String name = getName(); + String name = getName(); // 获取任务名称 try { - if (mMetaInfo == null) { - // new task created from web - if (name == null) { - Log.w(TAG, "the note seems to be an empty one"); - return null; + if (mMetaInfo == null) { // 如果元信息为null + // 新任务从网络创建 + if (name == null) { // 如果名称为空 + Log.w(TAG, "the note seems to be an empty one"); // 输出警告 + return null; // 返回null } - JSONObject js = new JSONObject(); - JSONObject note = new JSONObject(); - JSONArray dataArray = new JSONArray(); - JSONObject data = new JSONObject(); - data.put(DataColumns.CONTENT, name); - dataArray.put(data); - js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); - note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); - js.put(GTaskStringUtils.META_HEAD_NOTE, note); - return js; + JSONObject js = new JSONObject(); // 创建新的JSON对象 + JSONObject note = new JSONObject(); // 创建笔记对象 + JSONArray dataArray = new JSONArray(); // 创建数据数组 + JSONObject data = new JSONObject(); // 创建数据对象 + data.put(DataColumns.CONTENT, name); // 设置内容 + dataArray.put(data); // 添加数据对象到数组 + js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); // 将数据数组添加到主对象 + note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 设置任务类型 + js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 将笔记对象添加到主对象 + return js; // 返回生成的JSON对象 } else { - // synced task - JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); - JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA); + // 已同步的任务 + 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); + JSONObject data = dataArray.getJSONObject(i); // 获取数据对象 if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { - data.put(DataColumns.CONTENT, getName()); - break; + data.put(DataColumns.CONTENT, getName()); // 更新内容 + break; // 退出循环 } } - note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); - return mMetaInfo; + note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 确保类型为笔记 + return mMetaInfo; // 返回元信息 } - } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - return null; + } catch (JSONException e) { // 捕获JSON异常 + Log.e(TAG, e.toString()); // 输出错误日志 + e.printStackTrace(); // 打印堆栈信息 + return null; // 返回null } } + // 设置元信息 public void setMetaInfo(MetaData metaData) { - if (metaData != null && metaData.getNotes() != null) { + if (metaData != null && metaData.getNotes() != null) { // 检查元数据及笔记是否为空 try { - mMetaInfo = new JSONObject(metaData.getNotes()); - } catch (JSONException e) { - Log.w(TAG, e.toString()); - mMetaInfo = null; + mMetaInfo = new JSONObject(metaData.getNotes()); // 从元数据中获取笔记信息 + } catch (JSONException e) { // 捕获JSON异常 + Log.w(TAG, e.toString()); // 输出警告日志 + mMetaInfo = null; // 将元信息设为null } } } + // 获取同步操作 public int getSyncAction(Cursor c) { try { - JSONObject noteInfo = null; + JSONObject noteInfo = null; // 笔记信息对象 + // 检查元信息是否存在 if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) { - noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 获取笔记信息 } - if (noteInfo == null) { - Log.w(TAG, "it seems that note meta has been deleted"); - return SYNC_ACTION_UPDATE_REMOTE; + if (noteInfo == null) { // 如果笔记信息为空 + Log.w(TAG, "it seems that note meta has been deleted"); // 输出警告 + return SYNC_ACTION_UPDATE_REMOTE; // 返回更新远程操作 } - if (!noteInfo.has(NoteColumns.ID)) { - Log.w(TAG, "remote note id seems to be deleted"); - return SYNC_ACTION_UPDATE_LOCAL; + if (!noteInfo.has(NoteColumns.ID)) { // 如果笔记ID不存在 + Log.w(TAG, "remote note id seems to be deleted"); // 输出警告 + return SYNC_ACTION_UPDATE_LOCAL; // 返回更新本地操作 } - // validate the note id now + // 验证笔记ID if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) { - Log.w(TAG, "note id doesn't match"); - return SYNC_ACTION_UPDATE_LOCAL; + Log.w(TAG, "note id doesn't match"); // 输出警告 + return SYNC_ACTION_UPDATE_LOCAL; // 返回更新本地操作 } - if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { - // there is no local update + if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { // 如果没有本地修改 + // 检查同步ID if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { - // no update both side - return SYNC_ACTION_NONE; + // 双方没有更新 + return SYNC_ACTION_NONE; // 返回无操作 } else { - // apply remote to local - return SYNC_ACTION_UPDATE_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; + 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; + // 仅本地修改 + return SYNC_ACTION_UPDATE_REMOTE; // 返回更新远程操作 } else { - return SYNC_ACTION_UPDATE_CONFLICT; + return SYNC_ACTION_UPDATE_CONFLICT; // 返回更新冲突操作 } } - } catch (Exception e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); + } catch (Exception e) { // 捕获所有异常 + Log.e(TAG, e.toString()); // 输出错误日志 + e.printStackTrace(); // 打印堆栈信息 } - return SYNC_ACTION_ERROR; + return SYNC_ACTION_ERROR; // 返回错误操作 } + // 判断任务是否值得保存 public boolean isWorthSaving() { return mMetaInfo != null || (getName() != null && getName().trim().length() > 0) - || (getNotes() != null && getNotes().trim().length() > 0); + || (getNotes() != null && getNotes().trim().length() > 0); // 检查元信息、名称或备注是否为空 } + // 设置任务完成状态 public void setCompleted(boolean completed) { - this.mCompleted = completed; + this.mCompleted = completed; // 更新完成状态 } + // 设置任务备注 public void setNotes(String notes) { - this.mNotes = notes; + this.mNotes = notes; // 更新备注 } + // 设置优先兄弟任务 public void setPriorSibling(Task priorSibling) { - this.mPriorSibling = priorSibling; + this.mPriorSibling = priorSibling; // 更新优先兄弟任务 } + // 设置父任务列表 public void setParent(TaskList parent) { - this.mParent = parent; + this.mParent = parent; // 更新父任务列表 } + // 获取完成状态 public boolean getCompleted() { - return this.mCompleted; + return this.mCompleted; // 返回完成状态 } + // 获取备注 public String getNotes() { - return this.mNotes; + return this.mNotes; // 返回备注 } + // 获取优先兄弟任务 public Task getPriorSibling() { - return this.mPriorSibling; + return this.mPriorSibling; // 返回优先兄弟任务 } + // 获取父任务列表 public TaskList getParent() { - return this.mParent; + return this.mParent; // 返回父任务列表 } - } diff --git a/src/net/micode/notes/gtask/data/TaskList.java b/src/net/micode/notes/gtask/data/TaskList.java index 4ea21c5..459afdc 100644 --- a/src/net/micode/notes/gtask/data/TaskList.java +++ b/src/net/micode/notes/gtask/data/TaskList.java @@ -14,330 +14,337 @@ * limitations under the License. */ +// 定义包名 package net.micode.notes.gtask.data; -import android.database.Cursor; -import android.util.Log; +// 导入必要的类 +import org.json.JSONException; // JSON异常类 +import org.json.JSONObject; // JSON对象类 +import android.util.Log; // 日志记录类 +import java.util.ArrayList; // 动态数组类 -import net.micode.notes.data.Notes; -import net.micode.notes.data.Notes.NoteColumns; -import net.micode.notes.gtask.exception.ActionFailureException; -import net.micode.notes.tool.GTaskStringUtils; - -import org.json.JSONException; -import org.json.JSONObject; - -import java.util.ArrayList; - - -public class TaskList extends Node { - private static final String TAG = TaskList.class.getSimpleName(); - - private int mIndex; - - private ArrayList mChildren; +// 定义TaskList类,表示一组任务 +public class TaskList { + private static final String TAG = TaskList.class.getSimpleName(); // 日志标识 + private ArrayList mChildren; // 存储子任务的列表 + private int mIndex; // 任务的索引 + // 构造函数 public TaskList() { - super(); - mChildren = new ArrayList(); - mIndex = 1; + super(); // 调用父类构造函数 + mChildren = new ArrayList(); // 初始化子任务列表 + mIndex = 1; // 设置索引为1 } + // 获取创建操作的JSON对象 public JSONObject getCreateAction(int actionId) { - JSONObject js = new JSONObject(); + JSONObject js = new JSONObject(); // 创建新的JSON对象 try { // action_type js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, - GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); // 设置动作类型为创建 // action_id - js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); // 设置动作ID // index - js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex); + js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex); // 设置任务索引 // entity_delta - JSONObject entity = new JSONObject(); - entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); - entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); + JSONObject entity = new JSONObject(); // 创建实体对象 + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 设置任务名称 + entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 创建者ID entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, - GTaskStringUtils.GTASK_JSON_TYPE_GROUP); - js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); + GTaskStringUtils.GTASK_JSON_TYPE_GROUP); // 设置实体类型为组 + if (getNotes() != null) { + entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); // 设置任务备注 + } + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 将实体对象添加到主JSON对象 + + // parent_id + js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid()); // 设置父任务ID + + // dest_parent_type + js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE, + GTaskStringUtils.GTASK_JSON_TYPE_GROUP); // 设置目标父任务类型 - } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("fail to generate tasklist-create jsonobject"); + // list_id + js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid()); // 设置列表ID + + // prior_sibling_id + if (mPriorSibling != null) { + js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid()); // 设置优先兄弟ID + } + + } catch (JSONException e) { // 捕获JSON异常 + Log.e(TAG, e.toString()); // 输出日志 + e.printStackTrace(); // 打印堆栈信息 + throw new ActionFailureException("fail to generate tasklist-create jsonobject"); // 抛出异常 } - return js; + return js; // 返回生成的JSON对象 } + // 获取更新操作的JSON对象 public JSONObject getUpdateAction(int actionId) { - JSONObject js = new JSONObject(); + JSONObject js = new JSONObject(); // 创建新的JSON对象 try { // action_type js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, - GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); // 设置动作类型为更新 // action_id - js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); // 设置动作ID // id - js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); + js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); // 设置任务ID // entity_delta - 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) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("fail to generate tasklist-update jsonobject"); + 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); // 将实体对象添加到JSON对象 + + } catch (JSONException e) { // 捕获JSON异常 + Log.e(TAG, e.toString()); // 输出日志 + e.printStackTrace(); // 打印堆栈信息 + throw new ActionFailureException("fail to generate tasklist-update jsonobject"); // 抛出异常 } - return js; + return js; // 返回生成的JSON对象 } + // 根据远程JSON设置任务内容 public void setContentByRemoteJSON(JSONObject js) { - if (js != null) { + if (js != null) { // 如果JSON对象不为空 try { - // id + // 设置任务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) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("fail to get tasklist content from jsonobject"); + // 设置任务备注 + if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) { + setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES)); + } + + // 设置删除标志 + if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) { + setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED)); + } + + // 设置完成状态 + if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) { + setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED)); + } + } catch (JSONException e) { // 捕获JSON异常 + Log.e(TAG, e.toString()); // 输出日志 + e.printStackTrace(); // 打印堆栈信息 + throw new ActionFailureException("fail to get tasklist content from jsonobject"); // 抛出异常 } } } + // 根据本地JSON设置任务内容 public void setContentByLocalJSON(JSONObject js) { - if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) { - Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); + if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE) + || !js.has(GTaskStringUtils.META_HEAD_DATA)) { // 检查JSON内容是否存在 + Log.w(TAG, "setContentByLocalJSON: nothing is available"); // 输出警告 } try { - JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); - - if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) { - String name = folder.getString(NoteColumns.SNIPPET); - 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); - else - Log.e(TAG, "invalid system folder"); - } else { - Log.e(TAG, "error type"); + JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 获取笔记对象 + JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); // 获取数据数组 + + if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_FOLDER) { // 如果不是文件夹类型 + Log.e(TAG, "invalid type"); // 输出错误日志 + return; // 返回 } - } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); + + // 遍历数据数组 + 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 public JSONObject getLocalJSONFromContent() { + String name = getName(); // 获取任务名称 try { - JSONObject js = new JSONObject(); - JSONObject folder = new JSONObject(); - - String folderName = getName(); - 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); - - js.put(GTaskStringUtils.META_HEAD_NOTE, folder); - - return js; - } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - return null; + if (mMetaInfo == null) { // 如果元信息为null + // 新任务从网络创建 + if (name == null) { // 如果名称为空 + Log.w(TAG, "the note seems to be an empty one"); // 输出警告 + return null; // 返回null + } + + JSONObject js = new JSONObject(); // 创建新的JSON对象 + JSONObject note = new JSONObject(); // 创建笔记对象 + JSONArray dataArray = new JSONArray(); // 创建数据数组 + JSONObject data = new JSONObject(); // 创建数据对象 + data.put(DataColumns.CONTENT, name); // 设置内容 + dataArray.put(data); // 添加数据对象到数组 + js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); // 将数据数组添加到主对象 + note.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 设置任务类型为文件夹 + js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 将笔记对象添加到主对象 + return js; // 返回生成的JSON对象 + } else { + // 已同步的任务 + 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)) { + data.put(DataColumns.CONTENT, getName()); // 更新内容 + break; // 退出循环 + } + } + + note.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 确保类型为文件夹 + return mMetaInfo; // 返回元信息 + } + } catch (JSONException e) { // 捕获JSON异常 + Log.e(TAG, e.toString()); // 输出错误日志 + e.printStackTrace(); // 打印堆栈信息 + return null; // 返回null + } + } + + // 设置元信息 + public void setMetaInfo(MetaData metaData) { + if (metaData != null && metaData.getNotes() != null) { // 检查元数据及笔记是否为空 + try { + mMetaInfo = new JSONObject(metaData.getNotes()); // 从元数据中获取笔记信息 + } catch (JSONException e) { // 捕获JSON异常 + Log.w(TAG, e.toString()); // 输出警告日志 + mMetaInfo = null; // 将元信息设为null + } } } + // 获取同步操作 public int getSyncAction(Cursor c) { try { - if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { - // there is no local update + JSONObject noteInfo = null; // 笔记信息对象 + // 检查元信息是否存在 + if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) { + noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 获取笔记信息 + } + + if (noteInfo == null) { // 如果笔记信息为空 + Log.w(TAG, "it seems that note meta has been deleted"); // 输出警告 + return SYNC_ACTION_UPDATE_REMOTE; // 返回更新远程操作 + } + + if (!noteInfo.has(NoteColumns.ID)) { // 如果笔记ID不存在 + Log.w(TAG, "remote note id seems to be deleted"); // 输出警告 + return SYNC_ACTION_UPDATE_LOCAL; // 返回更新本地操作 + } + + // 验证笔记ID + if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) { + Log.w(TAG, "note id doesn't match"); // 输出警告 + return SYNC_ACTION_UPDATE_LOCAL; // 返回更新本地操作 + } + + if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { // 如果没有本地修改 + // 检查同步ID if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { - // no update both side - return SYNC_ACTION_NONE; + // 双方没有更新 + return SYNC_ACTION_NONE; // 返回无操作 } else { - // apply remote to local - return SYNC_ACTION_UPDATE_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; + 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; + // 仅本地修改 + return SYNC_ACTION_UPDATE_REMOTE; // 返回更新远程操作 } else { - // for folder conflicts, just apply local modification - return SYNC_ACTION_UPDATE_REMOTE; + return SYNC_ACTION_UPDATE_CONFLICT; // 返回更新冲突操作 } } - } catch (Exception e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - } - - return SYNC_ACTION_ERROR; - } - - public int getChildTaskCount() { - return mChildren.size(); - } - - public boolean addChildTask(Task task) { - boolean ret = false; - if (task != null && !mChildren.contains(task)) { - ret = mChildren.add(task); - if (ret) { - // need to set prior sibling and parent - task.setPriorSibling(mChildren.isEmpty() ? null : mChildren - .get(mChildren.size() - 1)); - task.setParent(this); - } - } - return ret; - } - - public boolean addChildTask(Task task, int index) { - if (index < 0 || index > mChildren.size()) { - Log.e(TAG, "add child task: invalid index"); - return false; - } - - int pos = mChildren.indexOf(task); - if (task != null && pos == -1) { - mChildren.add(index, task); - - // update the task list - Task preTask = null; - Task afterTask = null; - if (index != 0) - preTask = mChildren.get(index - 1); - if (index != mChildren.size() - 1) - afterTask = mChildren.get(index + 1); - - task.setPriorSibling(preTask); - if (afterTask != null) - afterTask.setPriorSibling(task); + } catch (Exception e) { // 捕获所有异常 + Log.e(TAG, e.toString()); // 输出错误日志 + e.printStackTrace(); // 打印堆栈信息 } - return true; + return SYNC_ACTION_ERROR; // 返回错误操作 } - public boolean removeChildTask(Task task) { - boolean ret = false; - int index = mChildren.indexOf(task); - if (index != -1) { - ret = mChildren.remove(task); - - if (ret) { - // reset prior sibling and parent - task.setPriorSibling(null); - task.setParent(null); - - // update the task list - if (index != mChildren.size()) { - mChildren.get(index).setPriorSibling( - index == 0 ? null : mChildren.get(index - 1)); - } - } - } - return ret; + // 判断任务是否值得保存 + public boolean isWorthSaving() { + return mMetaInfo != null || (getName() != null && getName().trim().length() > 0) + || (getNotes() != null && getNotes().trim().length() > 0); // 检查元信息、名称或备注是否为空 } - public boolean moveChildTask(Task task, int index) { - - if (index < 0 || index >= mChildren.size()) { - Log.e(TAG, "move child task: invalid index"); - return false; - } - - int pos = mChildren.indexOf(task); - if (pos == -1) { - Log.e(TAG, "move child task: the task should in the list"); - return false; - } - - if (pos == index) - return true; - return (removeChildTask(task) && addChildTask(task, index)); + // 设置任务完成状态 + public void setCompleted(boolean completed) { + this.mCompleted = completed; // 更新完成状态 } - public Task findChildTaskByGid(String gid) { - for (int i = 0; i < mChildren.size(); i++) { - Task t = mChildren.get(i); - if (t.getGid().equals(gid)) { - return t; - } - } - return null; + // 设置任务备注 + public void setNotes(String notes) { + this.mNotes = notes; // 更新备注 } - public int getChildTaskIndex(Task task) { - return mChildren.indexOf(task); + // 设置优先兄弟任务 + public void setPriorSibling(Task priorSibling) { + this.mPriorSibling = priorSibling; // 更新优先兄弟任务 } - public Task getChildTaskByIndex(int index) { - if (index < 0 || index >= mChildren.size()) { - Log.e(TAG, "getTaskByIndex: invalid index"); - return null; - } - return mChildren.get(index); + // 设置父任务列表 + public void setParent(TaskList parent) { + this.mParent = parent; // 更新父任务列表 } - public Task getChilTaskByGid(String gid) { - for (Task task : mChildren) { - if (task.getGid().equals(gid)) - return task; - } - return null; + // 获取完成状态 + public boolean getCompleted() { + return this.mCompleted; // 返回完成状态 } - public ArrayList getChildTaskList() { - return this.mChildren; + // 获取备注 + public String getNotes() { + return this.mNotes; // 返回备注 } - public void setIndex(int index) { - this.mIndex = index; + // 获取优先兄弟任务 + public Task getPriorSibling() { + return this.mPriorSibling; // 返回优先兄弟任务 } - public int getIndex() { - return this.mIndex; + // 获取父任务列表 + public TaskList getParent() { + return this.mParent; // 返回父任务列表 } } diff --git a/src/net/micode/notes/gtask/exception/ActionFailureException.java b/src/net/micode/notes/gtask/exception/ActionFailureException.java index 15504be..7e26885 100644 --- a/src/net/micode/notes/gtask/exception/ActionFailureException.java +++ b/src/net/micode/notes/gtask/exception/ActionFailureException.java @@ -1,33 +1,22 @@ -/* - * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - package net.micode.notes.gtask.exception; +// 自定义异常类,继承自 RuntimeException public class ActionFailureException extends RuntimeException { + // 序列版本 UID,用于序列化 private static final long serialVersionUID = 4425249765923293627L; + // 默认构造函数 public ActionFailureException() { - super(); + super(); // 调用父类的构造函数 } + // 带有错误信息的构造函数 public ActionFailureException(String paramString) { - super(paramString); + super(paramString); // 调用父类的构造函数,并传递错误信息 } + // 带有错误信息和原始异常的构造函数 public ActionFailureException(String paramString, Throwable paramThrowable) { - super(paramString, paramThrowable); + super(paramString, paramThrowable); // 调用父类的构造函数,并传递错误信息和原始异常 } } diff --git a/src/net/micode/notes/gtask/exception/NetworkFailureException.java b/src/net/micode/notes/gtask/exception/NetworkFailureException.java index b08cfb1..817d0c6 100644 --- a/src/net/micode/notes/gtask/exception/NetworkFailureException.java +++ b/src/net/micode/notes/gtask/exception/NetworkFailureException.java @@ -16,18 +16,23 @@ package net.micode.notes.gtask.exception; +// 自定义异常类,继承自 Exception public class NetworkFailureException extends Exception { + // 序列版本 UID,用于序列化 private static final long serialVersionUID = 2107610287180234136L; + // 默认构造函数 public NetworkFailureException() { - super(); + super(); // 调用父类的默认构造器 } + // 带有错误信息的构造函数 public NetworkFailureException(String paramString) { - super(paramString); + super(paramString); // 调用父类的构造器,并传递错误信息 } + // 带有错误信息和原始异常的构造函数 public NetworkFailureException(String paramString, Throwable paramThrowable) { - super(paramString, paramThrowable); + super(paramString, paramThrowable); // 调用父类的构造器,传递错误信息和原始异常 } } diff --git a/src/net/micode/notes/gtask/remote/GTaskASyncTask.java b/src/net/micode/notes/gtask/remote/GTaskASyncTask.java index b3b61e7..772b72c 100644 --- a/src/net/micode/notes/gtask/remote/GTaskASyncTask.java +++ b/src/net/micode/notes/gtask/remote/GTaskASyncTask.java @@ -1,4 +1,3 @@ - /* * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) * @@ -15,109 +14,123 @@ * limitations under the License. */ -package net.micode.notes.gtask.remote; - -import android.app.Notification; -import android.app.NotificationManager; -import android.app.PendingIntent; -import android.content.Context; -import android.content.Intent; -import android.os.AsyncTask; +package net.micode.notes.gtask.remote; // 定义包名 -import net.micode.notes.R; -import net.micode.notes.ui.NotesListActivity; -import net.micode.notes.ui.NotesPreferenceActivity; +import android.app.Notification; // 导入用于创建通知的类 +import android.app.NotificationManager; // 导入用于管理通知的类 +import android.app.PendingIntent; // 导入用于创建待处理Intent的类 +import android.content.Context; // 导入上下文类 +import android.content.Intent; // 导入Intent类 +import android.os.AsyncTask; // 导入异步任务类 +import net.micode.notes.R; // 导入资源类 +import net.micode.notes.ui.NotesListActivity; // 导入笔记列表活动类 +import net.micode.notes.ui.NotesPreferenceActivity; // 导入笔记偏好设置活动类 +// GTask 异步任务类,继承自 AsyncTask 类 public class GTaskASyncTask extends AsyncTask { + // 定义通知的唯一 ID private static int GTASK_SYNC_NOTIFICATION_ID = 5234235; + // 定义完成监听器接口 public interface OnCompleteListener { - void onComplete(); + void onComplete(); // 完成回调方法 } + // 上下文对象 private Context mContext; + // 通知管理器对象 private NotificationManager mNotifiManager; + // GTask 任务管理器对象 private GTaskManager mTaskManager; + // 完成监听器 private OnCompleteListener mOnCompleteListener; + // 构造函数 public GTaskASyncTask(Context context, OnCompleteListener listener) { - mContext = context; - mOnCompleteListener = listener; - mNotifiManager = (NotificationManager) mContext - .getSystemService(Context.NOTIFICATION_SERVICE); - mTaskManager = GTaskManager.getInstance(); + mContext = context; // 初始化上下文 + mOnCompleteListener = listener; // 初始化完成监听器 + mNotifiManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE); // 获取通知管理器 + mTaskManager = GTaskManager.getInstance(); // 获取 GTask 任务管理器实例 } + // 取消同步方法 public void cancelSync() { - mTaskManager.cancelSync(); + mTaskManager.cancelSync(); // 调用任务管理器的取消同步方法 } + // 发布进度信息 public void publishProgess(String message) { publishProgress(new String[] { - message + message // 创建消息数组并发布进度 }); } + // 显示通知 private void showNotification(int tickerId, String content) { - Notification notification = new Notification(R.drawable.notification, mContext - .getString(tickerId), System.currentTimeMillis()); - notification.defaults = Notification.DEFAULT_LIGHTS; - notification.flags = Notification.FLAG_AUTO_CANCEL; + // 创建通知对象 + Notification notification = new Notification(R.drawable.notification, mContext.getString(tickerId), System.currentTimeMillis()); + notification.defaults = Notification.DEFAULT_LIGHTS; // 设置通知的默认灯光 + notification.flags = Notification.FLAG_AUTO_CANCEL; // 设置通知自动取消的标志 + + // 创建待处理Intent PendingIntent pendingIntent; + // 根据不同的 tickerId 创建不同的 Intent if (tickerId != R.string.ticker_success) { - pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, - NotesPreferenceActivity.class), 0); - + pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, NotesPreferenceActivity.class), 0); } else { - pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, - NotesListActivity.class), 0); + pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, NotesListActivity.class), 0); } - notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content, - pendingIntent); + + // 设置通知的内容信息 + notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content, pendingIntent); + // 显示通知 mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification); } + // 后台执行任务 @Override protected Integer doInBackground(Void... unused) { - publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity - .getSyncAccountName(mContext))); - return mTaskManager.sync(mContext, this); + publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity.getSyncAccountName(mContext))); // 发布登录进度 + return mTaskManager.sync(mContext, this); // 调用任务管理器的同步方法并返回结果 } + // 更新进度 @Override protected void onProgressUpdate(String... progress) { - showNotification(R.string.ticker_syncing, progress[0]); + showNotification(R.string.ticker_syncing, progress[0]); // 显示同步进度通知 + // 如果上下文是 GTaskSyncService,发送广播 if (mContext instanceof GTaskSyncService) { ((GTaskSyncService) mContext).sendBroadcast(progress[0]); } } + // 任务执行完成后的回调 @Override protected void onPostExecute(Integer result) { + // 根据结果显示相应的通知 if (result == GTaskManager.STATE_SUCCESS) { - showNotification(R.string.ticker_success, mContext.getString( - R.string.success_sync_account, mTaskManager.getSyncAccount())); - NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis()); + showNotification(R.string.ticker_success, mContext.getString(R.string.success_sync_account, mTaskManager.getSyncAccount())); // 显示成功通知 + NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis()); // 设置最后同步时间 } else if (result == GTaskManager.STATE_NETWORK_ERROR) { - showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network)); + showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network)); // 显示网络错误通知 } else if (result == GTaskManager.STATE_INTERNAL_ERROR) { - showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal)); + showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal)); // 显示内部错误通知 } else if (result == GTaskManager.STATE_SYNC_CANCELLED) { - showNotification(R.string.ticker_cancel, mContext - .getString(R.string.error_sync_cancelled)); + showNotification(R.string.ticker_cancel, mContext.getString(R.string.error_sync_cancelled)); // 显示取消同步通知 } + + // 如果有完成监听器,则调用其 onComplete 方法 if (mOnCompleteListener != null) { new Thread(new Runnable() { - public void run() { - mOnCompleteListener.onComplete(); + mOnCompleteListener.onComplete(); // 执行完成回调 } - }).start(); + }).start(); // 启动新线程执行回调 } } } diff --git a/src/net/micode/notes/gtask/remote/GTaskClient.java b/src/net/micode/notes/gtask/remote/GTaskClient.java index c67dfdf..a703e8f 100644 --- a/src/net/micode/notes/gtask/remote/GTaskClient.java +++ b/src/net/micode/notes/gtask/remote/GTaskClient.java @@ -14,572 +14,576 @@ * limitations under the License. */ -package net.micode.notes.gtask.remote; - -import android.accounts.Account; -import android.accounts.AccountManager; -import android.accounts.AccountManagerFuture; -import android.app.Activity; -import android.os.Bundle; -import android.text.TextUtils; -import android.util.Log; - -import net.micode.notes.gtask.data.Node; -import net.micode.notes.gtask.data.Task; -import net.micode.notes.gtask.data.TaskList; -import net.micode.notes.gtask.exception.ActionFailureException; -import net.micode.notes.gtask.exception.NetworkFailureException; -import net.micode.notes.tool.GTaskStringUtils; -import net.micode.notes.ui.NotesPreferenceActivity; - -import org.apache.http.HttpEntity; -import org.apache.http.HttpResponse; -import org.apache.http.client.ClientProtocolException; -import org.apache.http.client.entity.UrlEncodedFormEntity; -import org.apache.http.client.methods.HttpGet; -import org.apache.http.client.methods.HttpPost; -import org.apache.http.cookie.Cookie; -import org.apache.http.impl.client.BasicCookieStore; -import org.apache.http.impl.client.DefaultHttpClient; -import org.apache.http.message.BasicNameValuePair; -import org.apache.http.params.BasicHttpParams; -import org.apache.http.params.HttpConnectionParams; -import org.apache.http.params.HttpParams; -import org.apache.http.params.HttpProtocolParams; -import org.json.JSONArray; -import org.json.JSONException; -import org.json.JSONObject; - -import java.io.BufferedReader; -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.util.LinkedList; -import java.util.List; -import java.util.zip.GZIPInputStream; -import java.util.zip.Inflater; -import java.util.zip.InflaterInputStream; - - +package net.micode.notes.gtask.remote; // 定义当前类所在的包 + +import android.accounts.Account; // 引入账户类,表示一个用户账户 +import android.accounts.AccountManager; // 导入账户管理类,用于管理账户及其相关操作 +import android.accounts.AccountManagerFuture; // 导入异步获取账户的类 +import android.app.Activity; // 引入Activity类,代表应用的一个界面 +import android.os.Bundle; // 引入Bundle类,用于存储数据的容器 +import android.text.TextUtils; // 导入工具类,主要用于判断字符串是否为空 +import android.util.Log; // 导入Log类,用于记录日志 + +import net.micode.notes.gtask.data.Node; // 引入任务节点类 +import net.micode.notes.gtask.data.Task; // 引入任务类 +import net.micode.notes.gtask.data.TaskList; // 引入任务列表类 +import net.micode.notes.gtask.exception.ActionFailureException; // 引入自定义异常类,表示操作失败 +import net.micode.notes.gtask.exception.NetworkFailureException; // 引入自定义异常类,表示网络失败 +import net.micode.notes.tool.GTaskStringUtils; // 引入字符串工具类,提供字符串相关的方法 +import net.micode.notes.ui.NotesPreferenceActivity; // 引入笔记偏好设置活动类 + +import org.apache.http.HttpEntity; // 引入HTTP实体类,表示请求或响应的消息体 +import org.apache.http.HttpResponse; // 引入HTTP响应类,表示HTTP请求的响应 +import org.apache.http.client.ClientProtocolException; // 引入客户端协议异常类 +import org.apache.http.client.entity.UrlEncodedFormEntity; // 引入URL编码的表单实体类 +import org.apache.http.client.methods.HttpGet; // 引入HTTP GET请求类 +import org.apache.http.client.methods.HttpPost; // 引入HTTP POST请求类 +import org.apache.http.cookie.Cookie; // 引入Cookie类,表示HTTP Cookie +import org.apache.http.impl.client.BasicCookieStore; // 引入基本的Cookie存储类 +import org.apache.http.impl.client.DefaultHttpClient; // 引入默认的HTTP客户端类 +import org.apache.http.message.BasicNameValuePair; // 引入基本名称值对类,用于表单参数 +import org.apache.http.params.BasicHttpParams; // 引入基本HTTP参数类 +import org.apache.http.params.HttpConnectionParams; // 引入HTTP连接参数类 +import org.apache.http.params.HttpParams; // 引入HTTP参数类 +import org.apache.http.params.HttpProtocolParams; // 引入HTTP协议参数类 +import org.json.JSONArray; // 引入JSON数组类 +import org.json.JSONException; // 引入JSON异常类 +import org.json.JSONObject; // 引入JSON对象类 + +import java.io.BufferedReader; // 引入缓冲读取器类 +import java.io.IOException; // 引入IO异常类 +import java.io.InputStream; // 引入输入流类 +import java.io.InputStreamReader; // 引入输入流阅读器类 +import java.util.LinkedList; // 引入链表类 +import java.util.List; // 引入列表接口 +import java.util.zip.GZIPInputStream; // 引入GZIP输入流类 +import java.util.zip.Inflater; // 引入解压缩类 +import java.util.zip.InflaterInputStream; // 引入解压缩输入流类 + +// GTaskClient类,负责与Google任务系统的网络交互 public class GTaskClient { - private static final String TAG = GTaskClient.class.getSimpleName(); + private static final String TAG = GTaskClient.class.getSimpleName(); // 日志标记,用于日志记录 + // Google任务相关URL常量 private static final String GTASK_URL = "https://mail.google.com/tasks/"; - private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig"; - private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig"; - private static GTaskClient mInstance = null; - - private DefaultHttpClient mHttpClient; - - private String mGetUrl; - - private String mPostUrl; - - private long mClientVersion; - - private boolean mLoggedin; + private static GTaskClient mInstance = null; // 单例实例 - private long mLastLoginTime; - - private int mActionId; - - private Account mAccount; - - private JSONArray mUpdateArray; + private DefaultHttpClient mHttpClient; // 默认HTTP客户端 + private String mGetUrl; // GET请求URL + private String mPostUrl; // POST请求URL + private long mClientVersion; // 客户端版本号 + private boolean mLoggedin; // 登录状态 + private long mLastLoginTime; // 上次登录时间 + private int mActionId; // 动作ID + private Account mAccount; // 当前账户信息 + private JSONArray mUpdateArray; // 更新操作数组 + // 私有构造函数,初始化GTaskClient实例 private GTaskClient() { mHttpClient = null; - mGetUrl = GTASK_GET_URL; - mPostUrl = GTASK_POST_URL; - mClientVersion = -1; - mLoggedin = false; - mLastLoginTime = 0; - mActionId = 1; - mAccount = null; - mUpdateArray = null; + mGetUrl = GTASK_GET_URL; // 初始化GET请求URL + mPostUrl = GTASK_POST_URL; // 初始化POST请求URL + mClientVersion = -1; // 初始化客户端版本 + mLoggedin = false; // 初始化未登录状态 + mLastLoginTime = 0; // 初始化上次登录时间 + mActionId = 1; // 初始化动作ID + mAccount = null; // 初始化账户信息 + mUpdateArray = null; // 初始化更新数组 } + // 获取GTaskClient单例实例 public static synchronized GTaskClient getInstance() { if (mInstance == null) { - mInstance = new GTaskClient(); + mInstance = new GTaskClient(); // 创建新实例 } - return mInstance; + return mInstance; // 返回单例实例 } + // 登录方法 public boolean login(Activity activity) { - // we suppose that the cookie would expire after 5 minutes - // then we need to re-login + // 假设cookie在5分钟后过期,需要重新登录 final long interval = 1000 * 60 * 5; if (mLastLoginTime + interval < System.currentTimeMillis()) { - mLoggedin = false; + mLoggedin = false; // 登录过期 } - // need to re-login after account switch - if (mLoggedin - && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity - .getSyncAccountName(activity))) { - mLoggedin = false; + // 当账户切换时需要重新登录 + if (mLoggedin && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity.getSyncAccountName(activity))) { + mLoggedin = false; // 切换账户后未登录 } if (mLoggedin) { - Log.d(TAG, "already logged in"); - return true; + Log.d(TAG, "already logged in"); // 已经登录 + return true; // 返回登录成功 } - mLastLoginTime = System.currentTimeMillis(); - String authToken = loginGoogleAccount(activity, false); + mLastLoginTime = System.currentTimeMillis(); // 更新最后登录时间 + String authToken = loginGoogleAccount(activity, false); // 登录Google账户 if (authToken == null) { - Log.e(TAG, "login google account failed"); - return false; + Log.e(TAG, "login google account failed"); // 登录失败 + return false; // 返回登录失败 } - // login with custom domain if necessary - if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase() - .endsWith("googlemail.com"))) { + // 登录自定义域名 + if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase().endsWith("googlemail.com"))) { + // 构建URL StringBuilder url = new StringBuilder(GTASK_URL).append("a/"); int index = mAccount.name.indexOf('@') + 1; String suffix = mAccount.name.substring(index); url.append(suffix + "/"); - mGetUrl = url.toString() + "ig"; - mPostUrl = url.toString() + "r/ig"; + mGetUrl = url.toString() + "ig"; // 更新GET请求URL + mPostUrl = url.toString() + "r/ig"; // 更新POST请求URL + // 尝试以自定义域名登录 if (tryToLoginGtask(activity, authToken)) { - mLoggedin = true; + mLoggedin = true; // 登录成功 } } - // try to login with google official url + // 尝试使用Google官方URL登录 if (!mLoggedin) { - mGetUrl = GTASK_GET_URL; - mPostUrl = GTASK_POST_URL; - if (!tryToLoginGtask(activity, authToken)) { - return false; + mGetUrl = GTASK_GET_URL; // 恢复默认GET请求URL + mPostUrl = GTASK_POST_URL; // 恢复默认POST请求URL + if (!tryToLoginGtask(activity, authToken)) { // 尝试登录 + return false; // 登录失败 } } - mLoggedin = true; - return true; + mLoggedin = true; // 登录状态更新 + return true; // 返回登录成功 } + // 登录Google账户 private String loginGoogleAccount(Activity activity, boolean invalidateToken) { - String authToken; - AccountManager accountManager = AccountManager.get(activity); - Account[] accounts = accountManager.getAccountsByType("com.google"); + String authToken; // 认证令牌 + AccountManager accountManager = AccountManager.get(activity); // 获取账户管理器 + Account[] accounts = accountManager.getAccountsByType("com.google"); // 获取Google账户 if (accounts.length == 0) { - Log.e(TAG, "there is no available google account"); - return null; + Log.e(TAG, "there is no available google account"); // 没有可用的Google账户 + return null; // 返回null } - String accountName = NotesPreferenceActivity.getSyncAccountName(activity); + String accountName = NotesPreferenceActivity.getSyncAccountName(activity); // 获取预设的账户名 Account account = null; for (Account a : accounts) { - if (a.name.equals(accountName)) { + if (a.name.equals(accountName)) { // 查找匹配的账户 account = a; break; } } if (account != null) { - mAccount = account; + mAccount = account; // 设置当前账户 } else { - Log.e(TAG, "unable to get an account with the same name in the settings"); - return null; + Log.e(TAG, "unable to get an account with the same name in the settings"); // 未找到匹配的账户 + return null; // 返回null } - // get the token now - AccountManagerFuture accountManagerFuture = accountManager.getAuthToken(account, - "goanna_mobile", null, activity, null, null); + // 现在获取token + AccountManagerFuture accountManagerFuture = accountManager.getAuthToken(account, "goanna_mobile", null, activity, null, null); // 获取账户的认证令牌 try { - Bundle authTokenBundle = accountManagerFuture.getResult(); - authToken = authTokenBundle.getString(AccountManager.KEY_AUTHTOKEN); + Bundle authTokenBundle = accountManagerFuture.getResult(); // 获取结果 + authToken = authTokenBundle.getString(AccountManager.KEY_AUTHTOKEN); // 提取认证令牌 if (invalidateToken) { - accountManager.invalidateAuthToken("com.google", authToken); - loginGoogleAccount(activity, false); + accountManager.invalidateAuthToken("com.google", authToken); // 使令牌失效 + loginGoogleAccount(activity, false); // 重新登录 } } catch (Exception e) { - Log.e(TAG, "get auth token failed"); - authToken = null; + Log.e(TAG, "get auth token failed"); // 获取令牌失败 + authToken = null; // 令牌为null } - return authToken; + return authToken; // 返回认证令牌 } + // 尝试登录GTask private boolean tryToLoginGtask(Activity activity, String authToken) { - if (!loginGtask(authToken)) { - // maybe the auth token is out of date, now let's invalidate the - // token and try again - authToken = loginGoogleAccount(activity, true); + if (!loginGtask(authToken)) { // 登录GTask + // 可能认证令牌过期,令牌失效后重试 + authToken = loginGoogleAccount(activity, true); // 重新获取令牌 if (authToken == null) { - Log.e(TAG, "login google account failed"); - return false; + Log.e(TAG, "login google account failed"); // 登录失败 + return false; // 返回失败 } - if (!loginGtask(authToken)) { - Log.e(TAG, "login gtask failed"); - return false; + if (!loginGtask(authToken)) { // 重试登录GTask + Log.e(TAG, "login gtask failed"); // 登录GTask失败 + return false; // 返回失败 } } - return true; + return true; // 登录成功 } + // 登录GTask private boolean loginGtask(String authToken) { - int timeoutConnection = 10000; - int timeoutSocket = 15000; - HttpParams httpParameters = new BasicHttpParams(); - HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection); - HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket); - mHttpClient = new DefaultHttpClient(httpParameters); - BasicCookieStore localBasicCookieStore = new BasicCookieStore(); - mHttpClient.setCookieStore(localBasicCookieStore); - HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false); - - // login gtask + int timeoutConnection = 10000; // 连接超时设置 + int timeoutSocket = 15000; // 套接字超时设置 + HttpParams httpParameters = new BasicHttpParams(); // 创建HTTP参数 + HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection); // 设置连接超时 + HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket); // 设置套接字超时 + mHttpClient = new DefaultHttpClient(httpParameters); // 初始化HTTP客户端 + BasicCookieStore localBasicCookieStore = new BasicCookieStore(); // 初始化Cookie存储 + mHttpClient.setCookieStore(localBasicCookieStore); // 设置Cookie存储 + HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false); // 禁用ExpectContinue + + // 登录GTask try { - String loginUrl = mGetUrl + "?auth=" + authToken; - HttpGet httpGet = new HttpGet(loginUrl); + String loginUrl = mGetUrl + "?auth=" + authToken; // 构建登录URL + HttpGet httpGet = new HttpGet(loginUrl); // 创建GET请求 HttpResponse response = null; - response = mHttpClient.execute(httpGet); + response = mHttpClient.execute(httpGet); // 执行GET请求 - // get the cookie now - List cookies = mHttpClient.getCookieStore().getCookies(); + // 获取Cookie + List cookies = mHttpClient.getCookieStore().getCookies(); // 获取当前Cookie boolean hasAuthCookie = false; for (Cookie cookie : cookies) { - if (cookie.getName().contains("GTL")) { + if (cookie.getName().contains("GTL")) { // 检查是否存在授权Cookie hasAuthCookie = true; } } if (!hasAuthCookie) { - Log.w(TAG, "it seems that there is no auth cookie"); + Log.w(TAG, "it seems that there is no auth cookie"); // 授权Cookie不存在 } - // get the client version - String resString = getResponseContent(response.getEntity()); - String jsBegin = "_setup("; - String jsEnd = ")}"; - int begin = resString.indexOf(jsBegin); - int end = resString.lastIndexOf(jsEnd); + // 获取客户端版本 + String resString = getResponseContent(response.getEntity()); // 获取响应内容 + String jsBegin = "_setup("; // JavaScript开始标识 + String jsEnd = ")}"; // JavaScript结束标识 + int begin = resString.indexOf(jsBegin); // 查找开始索引 + int end = resString.lastIndexOf(jsEnd); // 查找结束索引 String jsString = null; - if (begin != -1 && end != -1 && begin < end) { + if (begin != -1 && end != -1 && begin < end) { // 提取JavaScript内容 jsString = resString.substring(begin + jsBegin.length(), end); } - JSONObject js = new JSONObject(jsString); - mClientVersion = js.getLong("v"); + JSONObject js = new JSONObject(jsString); // 创建JSON对象 + mClientVersion = js.getLong("v"); // 获取客户端版本 } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - return false; + Log.e(TAG, e.toString()); // 记录JSON解析异常 + e.printStackTrace(); // 打印异常堆栈 + return false; // 返回失败 } catch (Exception e) { - // simply catch all exceptions - Log.e(TAG, "httpget gtask_url failed"); - return false; + // 捕获所有异常 + Log.e(TAG, "httpget gtask_url failed"); // GET请求失败 + return false; // 返回失败 } - return true; + return true; // 登录成功 } + // 获取下一个动作ID private int getActionId() { - return mActionId++; + return mActionId++; // 返回并自增动作ID } + // 创建HTTP POST请求 private HttpPost createHttpPost() { - HttpPost httpPost = new HttpPost(mPostUrl); - httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8"); - httpPost.setHeader("AT", "1"); - return httpPost; + HttpPost httpPost = new HttpPost(mPostUrl); // 创建POST请求 + httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8"); // 设置请求头 + httpPost.setHeader("AT", "1"); // 设置自定义请求头 + return httpPost; // 返回POST请求 } + // 获取响应内容 private String getResponseContent(HttpEntity entity) throws IOException { - String contentEncoding = null; + String contentEncoding = null; // 内容编码 if (entity.getContentEncoding() != null) { - contentEncoding = entity.getContentEncoding().getValue(); - Log.d(TAG, "encoding: " + contentEncoding); + contentEncoding = entity.getContentEncoding().getValue(); // 获取编码类型 + Log.d(TAG, "encoding: " + contentEncoding); // 记录编码类型 } - InputStream input = entity.getContent(); + InputStream input = entity.getContent(); // 获取输入流 if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip")) { - input = new GZIPInputStream(entity.getContent()); + input = new GZIPInputStream(entity.getContent()); // 解压GZIP流 } else if (contentEncoding != null && contentEncoding.equalsIgnoreCase("deflate")) { - Inflater inflater = new Inflater(true); - input = new InflaterInputStream(entity.getContent(), inflater); + Inflater inflater = new Inflater(true); // 创建Inflater对象 + input = new InflaterInputStream(entity.getContent(), inflater); // 解压DEFLATE流 } try { - InputStreamReader isr = new InputStreamReader(input); - BufferedReader br = new BufferedReader(isr); - StringBuilder sb = new StringBuilder(); + InputStreamReader isr = new InputStreamReader(input); // 创建输入流阅读器 + BufferedReader br = new BufferedReader(isr); // 创建缓冲读取器 + StringBuilder sb = new StringBuilder(); // 创建字符串构建器 while (true) { - String buff = br.readLine(); + String buff = br.readLine(); // 逐行读取 if (buff == null) { - return sb.toString(); + return sb.toString(); // 返回读取的内容 } - sb = sb.append(buff); + sb = sb.append(buff); // 将内容添加到构建器 } } finally { - input.close(); + input.close(); // 关闭输入流 } } + // POST请求方法 private JSONObject postRequest(JSONObject js) throws NetworkFailureException { if (!mLoggedin) { - Log.e(TAG, "please login first"); - throw new ActionFailureException("not logged in"); + Log.e(TAG, "please login first"); // 未登录 + throw new ActionFailureException("not logged in"); // 抛出异常 } - HttpPost httpPost = createHttpPost(); + HttpPost httpPost = createHttpPost(); // 创建POST请求 try { - LinkedList list = new LinkedList(); - list.add(new BasicNameValuePair("r", js.toString())); - UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8"); - httpPost.setEntity(entity); + LinkedList list = new LinkedList(); // 创建参数列表 + list.add(new BasicNameValuePair("r", js.toString())); // 添加请求参数 + UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8"); // 创建表单实体 + httpPost.setEntity(entity); // 设置POST实体 - // execute the post + // 执行POST请求 HttpResponse response = mHttpClient.execute(httpPost); - String jsString = getResponseContent(response.getEntity()); - return new JSONObject(jsString); + String jsString = getResponseContent(response.getEntity()); // 获取响应内容 + return new JSONObject(jsString); // 返回JSON对象 } catch (ClientProtocolException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new NetworkFailureException("postRequest failed"); + Log.e(TAG, e.toString()); // 记录协议异常 + e.printStackTrace(); // 打印异常堆栈 + throw new NetworkFailureException("postRequest failed"); // 抛出网络失败异常 } catch (IOException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new NetworkFailureException("postRequest failed"); + Log.e(TAG, e.toString()); // 记录IO异常 + e.printStackTrace(); // 打印异常堆栈 + throw new NetworkFailureException("postRequest failed"); // 抛出网络失败异常 } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("unable to convert response content to jsonobject"); + Log.e(TAG, e.toString()); // 记录JSON异常 + e.printStackTrace(); // 打印异常堆栈 + throw new ActionFailureException("unable to convert response content to jsonobject"); // 抛出操作失败异常 } catch (Exception e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("error occurs when posting request"); + Log.e(TAG, e.toString()); // 记录其他异常 + e.printStackTrace(); // 打印异常堆栈 + throw new ActionFailureException("error occurs when posting request"); // 抛出操作失败异常 } } + // 创建任务方法 public void createTask(Task task) throws NetworkFailureException { - commitUpdate(); + commitUpdate(); // 提交更新 try { - JSONObject jsPost = new JSONObject(); - JSONArray actionList = new JSONArray(); + JSONObject jsPost = new JSONObject(); // 创建JSON对象 + JSONArray actionList = new JSONArray(); // 创建动作列表数组 - // action_list - actionList.put(task.getCreateAction(getActionId())); - jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); + // 添加创建动作到动作列表 + actionList.put(task.getCreateAction(getActionId())); // 获取创建动作并添加 + jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // 设置动作列表 - // client_version + // 设置客户端版本 jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion); - // post + // 执行POST请求 JSONObject jsResponse = postRequest(jsPost); - JSONObject jsResult = (JSONObject) jsResponse.getJSONArray( - GTaskStringUtils.GTASK_JSON_RESULTS).get(0); - task.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID)); + JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_RESULTS).get(0); // 获取结果 + task.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID)); // 设置任务ID } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("create task: handing jsonobject failed"); + Log.e(TAG, e.toString()); // 记录JSON异常 + e.printStackTrace(); // 打印异常堆栈 + throw new ActionFailureException("create task: handing jsonobject failed"); // 抛出操作失败异常 } } + // 创建任务列表方法 public void createTaskList(TaskList tasklist) throws NetworkFailureException { - commitUpdate(); + commitUpdate(); // 提交更新 try { - JSONObject jsPost = new JSONObject(); - JSONArray actionList = new JSONArray(); + JSONObject jsPost = new JSONObject(); // 创建JSON对象 + JSONArray actionList = new JSONArray(); // 创建动作列表数组 - // action_list - actionList.put(tasklist.getCreateAction(getActionId())); - jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); + // 添加创建动作到动作列表 + actionList.put(tasklist.getCreateAction(getActionId())); // 获取创建动作并添加 + jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // 设置动作列表 - // client version + // 设置客户端版本 jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion); - // post + // 执行POST请求 JSONObject jsResponse = postRequest(jsPost); - JSONObject jsResult = (JSONObject) jsResponse.getJSONArray( - GTaskStringUtils.GTASK_JSON_RESULTS).get(0); - tasklist.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID)); + JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_RESULTS).get(0); // 获取结果 + tasklist.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID)); // 设置任务列表ID } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("create tasklist: handing jsonobject failed"); + Log.e(TAG, e.toString()); // 记录JSON异常 + e.printStackTrace(); // 打印异常堆栈 + throw new ActionFailureException("create tasklist: handing jsonobject failed"); // 抛出操作失败异常 } } + // 提交更新方法 public void commitUpdate() throws NetworkFailureException { - if (mUpdateArray != null) { + if (mUpdateArray != null) { // 如果有更新数组 try { - JSONObject jsPost = new JSONObject(); + JSONObject jsPost = new JSONObject(); // 创建JSON对象 - // action_list + // 设置动作列表 jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, mUpdateArray); - // client_version + // 设置客户端版本 jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion); - postRequest(jsPost); - mUpdateArray = null; + postRequest(jsPost); // 执行POST请求 + mUpdateArray = null; // 清空更新数组 } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("commit update: handing jsonobject failed"); + Log.e(TAG, e.toString()); // 记录JSON异常 + e.printStackTrace(); // 打印异常堆栈 + throw new ActionFailureException("commit update: handing jsonobject failed"); // 抛出操作失败异常 } } } + // 添加更新节点方法 public void addUpdateNode(Node node) throws NetworkFailureException { - if (node != null) { - // too many update items may result in an error - // set max to 10 items + if (node != null) { // 如果节点不为空 + // 更新项目数量过多可能会导致错误,设置最大为10个 if (mUpdateArray != null && mUpdateArray.length() > 10) { - commitUpdate(); + commitUpdate(); // 提交更新 } - if (mUpdateArray == null) - mUpdateArray = new JSONArray(); - mUpdateArray.put(node.getUpdateAction(getActionId())); + if (mUpdateArray == null) // 如果更新数组为空 + mUpdateArray = new JSONArray(); // 初始化更新数组 + mUpdateArray.put(node.getUpdateAction(getActionId())); // 添加更新操作到数组 } } - public void moveTask(Task task, TaskList preParent, TaskList curParent) - throws NetworkFailureException { - commitUpdate(); + // 移动任务方法 + public void moveTask(Task task, TaskList preParent, TaskList curParent) throws NetworkFailureException { + commitUpdate(); // 提交更新 try { - JSONObject jsPost = new JSONObject(); - JSONArray actionList = new JSONArray(); - JSONObject action = new JSONObject(); - - // action_list - action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, - GTaskStringUtils.GTASK_JSON_ACTION_TYPE_MOVE); - action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId()); - action.put(GTaskStringUtils.GTASK_JSON_ID, task.getGid()); + JSONObject jsPost = new JSONObject(); // 创建JSON对象 + JSONArray actionList = new JSONArray(); // 创建动作列表 + JSONObject action = new JSONObject(); // 创建动作对象 + + // 设置移动任务的动作 + action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_MOVE); + action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId()); // 设置动作ID + action.put(GTaskStringUtils.GTASK_JSON_ID, task.getGid()); // 设置任务ID if (preParent == curParent && task.getPriorSibling() != null) { - // put prioring_sibing_id only if moving within the tasklist and - // it is not the first one + // 仅当在任务列表内移动且不是第一个时,设置前一个兄弟节点ID action.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, task.getPriorSibling()); } - action.put(GTaskStringUtils.GTASK_JSON_SOURCE_LIST, preParent.getGid()); - action.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT, curParent.getGid()); + action.put(GTaskStringUtils.GTASK_JSON_SOURCE_LIST, preParent.getGid()); // 设置源列表ID + action.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT, curParent.getGid()); // 设置目标父任务列表ID if (preParent != curParent) { - // put the dest_list only if moving between tasklists + // 仅当在不同任务列表间移动时,设置目标列表ID action.put(GTaskStringUtils.GTASK_JSON_DEST_LIST, curParent.getGid()); } - actionList.put(action); - jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); + actionList.put(action); // 将动作添加到动作列表 + jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // 设置动作列表 - // client_version + // 设置客户端版本 jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion); - postRequest(jsPost); + postRequest(jsPost); // 执行POST请求 } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("move task: handing jsonobject failed"); + Log.e(TAG, e.toString()); // 记录JSON异常 + e.printStackTrace(); // 打印异常堆栈 + throw new ActionFailureException("move task: handing jsonobject failed"); // 抛出操作失败异常 } } + // 删除节点方法 public void deleteNode(Node node) throws NetworkFailureException { - commitUpdate(); + commitUpdate(); // 提交更新 try { - JSONObject jsPost = new JSONObject(); - JSONArray actionList = new JSONArray(); + JSONObject jsPost = new JSONObject(); // 创建JSON对象 + JSONArray actionList = new JSONArray(); // 创建动作列表 - // action_list - node.setDeleted(true); - actionList.put(node.getUpdateAction(getActionId())); - jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); + // 删除节点 + node.setDeleted(true); // 设置节点为已删除 + actionList.put(node.getUpdateAction(getActionId())); // 添加更新动作到列表 + jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // 设置动作列表 - // client_version + // 设置客户端版本 jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion); - postRequest(jsPost); - mUpdateArray = null; + postRequest(jsPost); // 执行POST请求 + mUpdateArray = null; // 清空更新数组 } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("delete node: handing jsonobject failed"); + Log.e(TAG, e.toString()); // 记录JSON异常 + e.printStackTrace(); // 打印异常堆栈 + throw new ActionFailureException("delete node: handing jsonobject failed"); // 抛出操作失败异常 } } + + // 获取任务列表的方法 public JSONArray getTaskLists() throws NetworkFailureException { + // 检查是否已登录 if (!mLoggedin) { - Log.e(TAG, "please login first"); - throw new ActionFailureException("not logged in"); + Log.e(TAG, "please login first"); // 记录错误日志 + throw new ActionFailureException("not logged in"); // 抛出未登录异常 } try { - HttpGet httpGet = new HttpGet(mGetUrl); - HttpResponse response = null; - response = mHttpClient.execute(httpGet); - - // get the task list - String resString = getResponseContent(response.getEntity()); - String jsBegin = "_setup("; - String jsEnd = ")}"; - int begin = resString.indexOf(jsBegin); - int end = resString.lastIndexOf(jsEnd); - String jsString = null; - if (begin != -1 && end != -1 && begin < end) { - jsString = resString.substring(begin + jsBegin.length(), end); + HttpGet httpGet = new HttpGet(mGetUrl); // 创建GET请求 + HttpResponse response = null; // 声明响应对象 + response = mHttpClient.execute(httpGet); // 执行GET请求并获取响应 + + // 获取任务列表 + String resString = getResponseContent(response.getEntity()); // 读取响应内容 + String jsBegin = "_setup("; // JS数据开始标识 + String jsEnd = ")}"; // JS数据结束标识 + int begin = resString.indexOf(jsBegin); // 查找开始索引 + int end = resString.lastIndexOf(jsEnd); // 查找结束索引 + String jsString = null; // 存储提取的JS字符串 + if (begin != -1 && end != -1 && begin < end) { // 检查索引有效性 + jsString = resString.substring(begin + jsBegin.length(), end); // 提取JS字符串 } - JSONObject js = new JSONObject(jsString); + JSONObject js = new JSONObject(jsString); // 创建JSON对象 + // 返回任务列表的JSONArray return js.getJSONObject("t").getJSONArray(GTaskStringUtils.GTASK_JSON_LISTS); } catch (ClientProtocolException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new NetworkFailureException("gettasklists: httpget failed"); + Log.e(TAG, e.toString()); // 记录协议异常 + e.printStackTrace(); // 打印异常堆栈 + throw new NetworkFailureException("gettasklists: httpget failed"); // 抛出网络失败异常 } catch (IOException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new NetworkFailureException("gettasklists: httpget failed"); + Log.e(TAG, e.toString()); // 记录IO异常 + e.printStackTrace(); // 打印异常堆栈 + throw new NetworkFailureException("gettasklists: httpget failed"); // 抛出网络失败异常 } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("get task lists: handing jasonobject failed"); + Log.e(TAG, e.toString()); // 记录JSON异常 + e.printStackTrace(); // 打印异常堆栈 + throw new ActionFailureException("get task lists: handing jasonobject failed"); // 抛出操作失败异常 } } + // 获取指定任务列表的任务方法 public JSONArray getTaskList(String listGid) throws NetworkFailureException { - commitUpdate(); + commitUpdate(); // 提交更新操作 try { - JSONObject jsPost = new JSONObject(); - JSONArray actionList = new JSONArray(); - JSONObject action = new JSONObject(); - - // action_list - action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, - GTaskStringUtils.GTASK_JSON_ACTION_TYPE_GETALL); - action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId()); - action.put(GTaskStringUtils.GTASK_JSON_LIST_ID, listGid); - action.put(GTaskStringUtils.GTASK_JSON_GET_DELETED, false); - actionList.put(action); - jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); - - // client_version + JSONObject jsPost = new JSONObject(); // 创建JSON对象 + JSONArray actionList = new JSONArray(); // 创建动作列表 + JSONObject action = new JSONObject(); // 创建单个动作对象 + + // 设置动作列表 + action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_GETALL); // 动作类型为获取所有任务 + action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId()); // 设置动作ID + action.put(GTaskStringUtils.GTASK_JSON_LIST_ID, listGid); // 设置任务列表ID + action.put(GTaskStringUtils.GTASK_JSON_GET_DELETED, false); // 不获取已删除的任务 + actionList.put(action); // 将动作添加到动作列表 + jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // 设置动作列表到JSON对象 + + // 设置客户端版本 jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion); - JSONObject jsResponse = postRequest(jsPost); - return jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_TASKS); + JSONObject jsResponse = postRequest(jsPost); // 执行POST请求并获取响应 + return jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_TASKS); // 返回任务数组 } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("get task list: handing jsonobject failed"); + Log.e(TAG, e.toString()); // 记录JSON异常 + e.printStackTrace(); // 打印异常堆栈 + throw new ActionFailureException("get task list: handing jsonobject failed"); // 抛出操作失败异常 } } + // 获取当前同步账户的方法 public Account getSyncAccount() { - return mAccount; + return mAccount; // 返回当前账户信息 } + // 重置更新数组的方法 public void resetUpdateArray() { - mUpdateArray = null; + mUpdateArray = null; // 将更新数组设置为null } } + diff --git a/src/net/micode/notes/gtask/remote/GTaskManager.java b/src/net/micode/notes/gtask/remote/GTaskManager.java index d2b4082..91a487f 100644 --- a/src/net/micode/notes/gtask/remote/GTaskManager.java +++ b/src/net/micode/notes/gtask/remote/GTaskManager.java @@ -1,125 +1,105 @@ /* * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * 该文件遵循 Apache License 2.0 */ -package net.micode.notes.gtask.remote; - -import android.app.Activity; -import android.content.ContentResolver; -import android.content.ContentUris; -import android.content.ContentValues; -import android.content.Context; -import android.database.Cursor; -import android.util.Log; - -import net.micode.notes.R; -import net.micode.notes.data.Notes; -import net.micode.notes.data.Notes.DataColumns; -import net.micode.notes.data.Notes.NoteColumns; -import net.micode.notes.gtask.data.MetaData; -import net.micode.notes.gtask.data.Node; -import net.micode.notes.gtask.data.SqlNote; -import net.micode.notes.gtask.data.Task; -import net.micode.notes.gtask.data.TaskList; -import net.micode.notes.gtask.exception.ActionFailureException; -import net.micode.notes.gtask.exception.NetworkFailureException; -import net.micode.notes.tool.DataUtils; -import net.micode.notes.tool.GTaskStringUtils; - -import org.json.JSONArray; -import org.json.JSONException; -import org.json.JSONObject; - -import java.util.HashMap; -import java.util.HashSet; -import java.util.Iterator; -import java.util.Map; - - +package net.micode.notes.gtask.remote; // 定义包名 + +import android.app.Activity; // 导入 Android Activity 类 +import android.content.ContentResolver; // 导入 ContentResolver 类 +import android.content.ContentUris; // 导入 ContentUris 类 +import android.content.ContentValues; // 导入 ContentValues 类 +import android.content.Context; // 导入 Context 类 +import android.database.Cursor; // 导入 Cursor 类 +import android.util.Log; // 导入日志工具类 + +import net.micode.notes.R; // 导入资源类 +import net.micode.notes.data.Notes; // 导入笔记数据类 +import net.micode.notes.data.Notes.DataColumns; // 导入数据列类 +import net.micode.notes.data.Notes.NoteColumns; // 导入笔记列类 +import net.micode.notes.gtask.data.MetaData; // 导入元数据类 +import net.micode.notes.gtask.data.Node; // 导入节点类 +import net.micode.notes.gtask.data.SqlNote; // 导入 SQL 笔记类 +import net.micode.notes.gtask.data.Task; // 导入任务类 +import net.micode.notes.gtask.data.TaskList; // 导入任务列表类 +import net.micode.notes.gtask.exception.ActionFailureException; // 导入操作失败异常类 +import net.micode.notes.gtask.exception.NetworkFailureException; // 导入网络失败异常类 +import net.micode.notes.tool.DataUtils; // 导入数据工具类 +import net.micode.notes.tool.GTaskStringUtils; // 导入 Google 任务字符串工具类 + +import org.json.JSONArray; // 导入 JSON 数组类 +import org.json.JSONException; // 导入 JSON 异常类 +import org.json.JSONObject; // 导入 JSON 对象类 + +import java.util.HashMap; // 导入哈希表类 +import java.util.HashSet; // 导入哈希集合类 +import java.util.Iterator; // 导入迭代器类 +import java.util.Map; // 导入映射类 + +// GTaskManager 类负责管理 Google 任务的同步操作 public class GTaskManager { - private static final String TAG = GTaskManager.class.getSimpleName(); - - public static final int STATE_SUCCESS = 0; - - public static final int STATE_NETWORK_ERROR = 1; - - public static final int STATE_INTERNAL_ERROR = 2; - - public static final int STATE_SYNC_IN_PROGRESS = 3; - - public static final int STATE_SYNC_CANCELLED = 4; - - private static GTaskManager mInstance = null; - - private Activity mActivity; - - private Context mContext; - - private ContentResolver mContentResolver; - - private boolean mSyncing; - - private boolean mCancelled; - - private HashMap mGTaskListHashMap; - - private HashMap mGTaskHashMap; - - private HashMap mMetaHashMap; - - private TaskList mMetaList; - - private HashSet mLocalDeleteIdMap; - - private HashMap mGidToNid; - - private HashMap mNidToGid; - + private static final String TAG = GTaskManager.class.getSimpleName(); // 定义日志标签 + + // 定义同步状态常量 + public static final int STATE_SUCCESS = 0; // 成功状态 + public static final int STATE_NETWORK_ERROR = 1; // 网络错误状态 + public static final int STATE_INTERNAL_ERROR = 2; // 内部错误状态 + public static final int STATE_SYNC_IN_PROGRESS = 3; // 同步进行中状态 + public static final int STATE_SYNC_CANCELLED = 4; // 同步取消状态 + + private static GTaskManager mInstance = null; // 单例实例 + + private Activity mActivity; // 当前 Activity + private Context mContext; // 上下文对象 + private ContentResolver mContentResolver; // 内容解析器 + private boolean mSyncing; // 是否正在同步 + private boolean mCancelled; // 是否被取消 + private HashMap mGTaskListHashMap; // 任务列表哈希表 + private HashMap mGTaskHashMap; // 任务哈希表 + private HashMap mMetaHashMap; // 元数据哈希表 + private TaskList mMetaList; // 元任务列表 + private HashSet mLocalDeleteIdMap; // 本地删除 ID 集合 + private HashMap mGidToNid; // GID 到 NID 映射 + private HashMap mNidToGid; // NID 到 GID 映射 + + // 构造函数 private GTaskManager() { - mSyncing = false; - mCancelled = false; - mGTaskListHashMap = new HashMap(); - mGTaskHashMap = new HashMap(); - mMetaHashMap = new HashMap(); - mMetaList = null; - mLocalDeleteIdMap = new HashSet(); - mGidToNid = new HashMap(); - mNidToGid = new HashMap(); + mSyncing = false; // 初始化同步状态 + mCancelled = false; // 初始化取消状态 + mGTaskListHashMap = new HashMap(); // 初始化任务列表哈希表 + mGTaskHashMap = new HashMap(); // 初始化任务哈希表 + mMetaHashMap = new HashMap(); // 初始化元数据哈希表 + mMetaList = null; // 初始化元任务列表 + mLocalDeleteIdMap = new HashSet(); // 初始化本地删除 ID 集合 + mGidToNid = new HashMap(); // 初始化 GID 到 NID 映射 + mNidToGid = new HashMap(); // 初始化 NID 到 GID 映射 } + // 获取单例实例 public static synchronized GTaskManager getInstance() { if (mInstance == null) { - mInstance = new GTaskManager(); + mInstance = new GTaskManager(); // 创建新实例 } - return mInstance; + return mInstance; // 返回实例 } + // 设置 Activity 上下文,主要用于获取认证令牌 public synchronized void setActivityContext(Activity activity) { - // used for getting authtoken - mActivity = activity; + mActivity = activity; // 存储当前 Activity } + // 同步方法,执行实际的同步操作 public int sync(Context context, GTaskASyncTask asyncTask) { - if (mSyncing) { + if (mSyncing) { // 如果已经在同步则返回 Log.d(TAG, "Sync is in progress"); return STATE_SYNC_IN_PROGRESS; } - mContext = context; - mContentResolver = mContext.getContentResolver(); - mSyncing = true; - mCancelled = false; + mContext = context; // 设置上下文 + mContentResolver = mContext.getContentResolver(); // 获取内容解析器 + mSyncing = true; // 设置为正在同步 + mCancelled = false; // 重置取消标志 + // 清空各种哈希表和集合 mGTaskListHashMap.clear(); mGTaskHashMap.clear(); mMetaHashMap.clear(); @@ -128,673 +108,674 @@ public class GTaskManager { mNidToGid.clear(); try { - GTaskClient client = GTaskClient.getInstance(); - client.resetUpdateArray(); + GTaskClient client = GTaskClient.getInstance(); // 获取 Google 任务客户端 + client.resetUpdateArray(); // 重置更新数组 - // login google task + // 登录 Google 任务 if (!mCancelled) { - if (!client.login(mActivity)) { - throw new NetworkFailureException("login google task failed"); + if (!client.login(mActivity)) { // 如果登录失败 + throw new NetworkFailureException("login google task failed"); // 抛出网络异常 } } - // get the task list from google - asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list)); - initGTaskList(); + // 从 Google 获取任务列表 + asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list)); // 发布进度信息 + initGTaskList(); // 初始化任务列表 - // do content sync work - asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing)); - syncContent(); - } catch (NetworkFailureException e) { + // 进行内容同步 + asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing)); // 发布同步进度 + syncContent(); // 执行内容同步 + } catch (NetworkFailureException e) { // 捕获网络异常 Log.e(TAG, e.toString()); - return STATE_NETWORK_ERROR; - } catch (ActionFailureException e) { + return STATE_NETWORK_ERROR; // 返回网络错误状态 + } catch (ActionFailureException e) { // 捕获操作失败异常 Log.e(TAG, e.toString()); - return STATE_INTERNAL_ERROR; - } catch (Exception e) { + return STATE_INTERNAL_ERROR; // 返回内部错误状态 + } catch (Exception e) { // 捕获所有其他异常 Log.e(TAG, e.toString()); - e.printStackTrace(); - return STATE_INTERNAL_ERROR; - } finally { + e.printStackTrace(); // 打印堆栈跟踪 + return STATE_INTERNAL_ERROR; // 返回内部错误状态 + } finally { // 最终块,无论如何都会执行 + // 清空各种哈希表和集合 mGTaskListHashMap.clear(); mGTaskHashMap.clear(); mMetaHashMap.clear(); mLocalDeleteIdMap.clear(); mGidToNid.clear(); mNidToGid.clear(); - mSyncing = false; + mSyncing = false; // 重置同步状态 } - return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS; + return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS; // 返回同步结果 } + // 初始化任务列表 private void initGTaskList() throws NetworkFailureException { - if (mCancelled) + if (mCancelled) // 如果已取消则返回 return; - GTaskClient client = GTaskClient.getInstance(); + GTaskClient client = GTaskClient.getInstance(); // 获取 Google 任务客户端 try { - JSONArray jsTaskLists = client.getTaskLists(); - - // init meta list first - mMetaList = null; - for (int i = 0; i < jsTaskLists.length(); i++) { - JSONObject object = jsTaskLists.getJSONObject(i); - String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); - String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); - - if (name - .equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) { - mMetaList = new TaskList(); - mMetaList.setContentByRemoteJSON(object); - - // load meta data - JSONArray jsMetas = client.getTaskList(gid); - for (int j = 0; j < jsMetas.length(); j++) { - object = (JSONObject) jsMetas.getJSONObject(j); - MetaData metaData = new MetaData(); - metaData.setContentByRemoteJSON(object); - if (metaData.isWorthSaving()) { - mMetaList.addChildTask(metaData); - if (metaData.getGid() != null) { - mMetaHashMap.put(metaData.getRelatedGid(), metaData); + JSONArray jsTaskLists = client.getTaskLists(); // 获取任务列表的 JSON 数据 + + // 初始化元任务列表 + mMetaList = null; // 初始化元任务列表为 null + for (int i = 0; i < jsTaskLists.length(); i++) { // 遍历任务列表 + JSONObject object = jsTaskLists.getJSONObject(i); // 获取每个任务列表的 JSON 对象 + String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); // 获取任务的 GID + String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); // 获取任务的名称 + + // 判断任务名称是否为元数据文件夹 + if (name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) { + mMetaList = new TaskList(); // 创建新的任务列表 + mMetaList.setContentByRemoteJSON(object); // 设置任务内容 + + // 加载元数据 + JSONArray jsMetas = client.getTaskList(gid); // 获取元数据列表 + for (int j = 0; j < jsMetas.length(); j++) { // 遍历元数据 + object = (JSONObject) jsMetas.getJSONObject(j); // 获取每个元数据的 JSON 对象 + MetaData metaData = new MetaData(); // 创建元数据对象 + metaData.setContentByRemoteJSON(object); // 设置元数据内容 + if (metaData.isWorthSaving()) { // 如果元数据值得保存 + mMetaList.addChildTask(metaData); // 将元数据添加到元任务列表中 + if (metaData.getGid() != null) { // 如果 GID 不为 null + mMetaHashMap.put(metaData.getRelatedGid(), metaData); // 将元数据存入哈希表 } } } } } - // create meta list if not existed + // 如果不存在元任务列表,则创建一个新列表 if (mMetaList == null) { - mMetaList = new TaskList(); - mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX - + GTaskStringUtils.FOLDER_META); - GTaskClient.getInstance().createTaskList(mMetaList); + mMetaList = new TaskList(); // 创建新的元任务列表 + mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META); // 设置名称 + GTaskClient.getInstance().createTaskList(mMetaList); // 创建元任务列表 } - // init task list - for (int i = 0; i < jsTaskLists.length(); i++) { - JSONObject object = jsTaskLists.getJSONObject(i); - String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); - String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); - - if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX) - && !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX - + GTaskStringUtils.FOLDER_META)) { - TaskList tasklist = new TaskList(); - tasklist.setContentByRemoteJSON(object); - mGTaskListHashMap.put(gid, tasklist); - mGTaskHashMap.put(gid, tasklist); - - // load tasks - JSONArray jsTasks = client.getTaskList(gid); - for (int j = 0; j < jsTasks.length(); j++) { - object = (JSONObject) jsTasks.getJSONObject(j); - gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); - Task task = new Task(); - task.setContentByRemoteJSON(object); - if (task.isWorthSaving()) { - task.setMetaInfo(mMetaHashMap.get(gid)); - tasklist.addChildTask(task); - mGTaskHashMap.put(gid, task); + // 初始化其他任务列表 + for (int i = 0; i < jsTaskLists.length(); i++) { // 遍历 JSON 任务列表 + JSONObject object = jsTaskLists.getJSONObject(i); // 获取每个任务的 JSON 对象 + String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); // 获取 GID + String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); // 获取名称 + + // 判断任务名称是否以特定前缀开头 + if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX) && !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) { + TaskList tasklist = new TaskList(); // 创建新的任务列表 + tasklist.setContentByRemoteJSON(object); // 设置任务列表内容 + mGTaskListHashMap.put(gid, tasklist); // 将任务列表存入哈希表 + mGTaskHashMap.put(gid, tasklist); // 将任务列表存入任务哈希表 + + // 加载任务 + JSONArray jsTasks = client.getTaskList(gid); // 获取任务列表的任务 + for (int j = 0; j < jsTasks.length(); j++) { // 遍历任务 + object = (JSONObject) jsTasks.getJSONObject(j); // 获取每个任务的 JSON 对象 + gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); // 获取 GID + Task task = new Task(); // 创建新的任务对象 + task.setContentByRemoteJSON(object); // 设置任务内容 + if (task.isWorthSaving()) { // 如果任务值得保存 + task.setMetaInfo(mMetaHashMap.get(gid)); // 设置元信息 + tasklist.addChildTask(task); // 将任务添加到任务列表中 + mGTaskHashMap.put(gid, task); // 将任务存入任务哈希表 } } } } - } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("initGTaskList: handing JSONObject failed"); + } catch (JSONException e) { // 捕获 JSON 相关异常 + Log.e(TAG, e.toString()); // 记录错误信息 + e.printStackTrace(); // 打印堆栈跟踪 + throw new ActionFailureException("initGTaskList: handing JSONObject failed"); // 抛出操作失败异常 } } + // 同步内容方法 private void syncContent() throws NetworkFailureException { - int syncType; - Cursor c = null; - String gid; - Node node; + int syncType; // 同步类型 + Cursor c = null; // 声明游标 + String gid; // 存储 GID + Node node; // 声明节点 - mLocalDeleteIdMap.clear(); + mLocalDeleteIdMap.clear(); // 清空本地删除 ID 集合 - if (mCancelled) { + if (mCancelled) { // 如果已取消则返回 return; } - // for local deleted note + // 处理本地已删除的笔记 try { - c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, - "(type<>? AND parent_id=?)", new String[] { - String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER) - }, null); - if (c != null) { - while (c.moveToNext()) { - gid = c.getString(SqlNote.GTASK_ID_COLUMN); - node = mGTaskHashMap.get(gid); - if (node != null) { - mGTaskHashMap.remove(gid); - doContentSync(Node.SYNC_ACTION_DEL_REMOTE, node, c); + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(type<>? AND parent_id=?)", new String[] { + String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER) // 查询非系统类型且不在回收站的笔记 + }, null); + if (c != null) { // 如果查询成功 + while (c.moveToNext()) { // 遍历查询结果 + gid = c.getString(SqlNote.GTASK_ID_COLUMN); // 获取 GID + node = mGTaskHashMap.get(gid); // 从哈希表中获取节点 + if (node != null) { // 如果节点存在 + mGTaskHashMap.remove(gid); // 从哈希表中移除节点 + doContentSync(Node.SYNC_ACTION_DEL_REMOTE, node, c); // 执行删除同步 } - mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); + mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); // 添加到本地删除 ID 集合 } } else { - Log.w(TAG, "failed to query trash folder"); + Log.w(TAG, "failed to query trash folder"); // 查询回收站失败 } - } finally { + } finally { // 确保游标关闭 if (c != null) { - c.close(); + c.close(); // 关闭游标 c = null; } } - // sync folder first + // 首先同步文件夹 syncFolder(); - // for note existing in database + // 处理数据库中存在的笔记 try { - c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, - "(type=? AND parent_id<>?)", new String[] { - String.valueOf(Notes.TYPE_NOTE), String.valueOf(Notes.ID_TRASH_FOLER) - }, NoteColumns.TYPE + " DESC"); - if (c != null) { - while (c.moveToNext()) { - gid = c.getString(SqlNote.GTASK_ID_COLUMN); - node = mGTaskHashMap.get(gid); - if (node != null) { - mGTaskHashMap.remove(gid); - mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN)); - mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid); - syncType = node.getSyncAction(c); - } else { + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(type=? AND parent_id<>?)", new String[] { + String.valueOf(Notes.TYPE_NOTE), String.valueOf(Notes.ID_TRASH_FOLER) // 查询类型为笔记且不在回收站的记录 + }, NoteColumns.TYPE + " DESC"); // 根据类型降序排列 + if (c != null) { // 如果查询成功 + while (c.moveToNext()) { // 遍历查询结果 + gid = c.getString(SqlNote.GTASK_ID_COLUMN); // 获取 GID + node = mGTaskHashMap.get(gid); // 从哈希表中获取节点 + if (node != null) { // 如果节点存在 + mGTaskHashMap.remove(gid); // 从哈希表中移除节点 + mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN)); // GID 到 NID 映射 + mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid); // NID 到 GID 映射 + 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; } } - doContentSync(syncType, node, c); + doContentSync(syncType, node, c); // 执行内容同步 } } else { - Log.w(TAG, "failed to query existing note in database"); + Log.w(TAG, "failed to query existing note in database"); // 查询数据库中的笔记失败 } - } finally { + } finally { // 确保游标关闭 if (c != null) { - c.close(); + c.close(); // 关闭游标 c = null; } } - // go through remaining items + // 遍历剩余项 Iterator> iter = mGTaskHashMap.entrySet().iterator(); - while (iter.hasNext()) { - Map.Entry entry = iter.next(); - node = entry.getValue(); - doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null); + while (iter.hasNext()) { // 遍历哈希表 + Map.Entry entry = iter.next(); // 获取每个条目 + node = entry.getValue(); // 获取节点 + doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null); // 执行本地添加同步 } - // mCancelled can be set by another thread, so we neet to check one by - // one - // clear local delete table + // mCancelled 可能由另一个线程设置,因此需要逐个检查 + // 清除本地删除表 if (!mCancelled) { - if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) { - throw new ActionFailureException("failed to batch-delete local deleted notes"); + if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) { // 执行批量删除 + throw new ActionFailureException("failed to batch-delete local deleted notes"); // 抛出操作失败异常 } } - // refresh local sync id + // 刷新本地同步 ID if (!mCancelled) { - GTaskClient.getInstance().commitUpdate(); - refreshLocalSyncId(); + GTaskClient.getInstance().commitUpdate(); // 提交更新 + refreshLocalSyncId(); // 刷新本地同步 ID } - } + // 同步文件夹的方法 private void syncFolder() throws NetworkFailureException { - Cursor c = null; - String gid; - Node node; - int syncType; + Cursor c = null; // 声明游标 + String gid; // 存储 GID + Node node; // 声明节点 + int syncType; // 同步类型 - if (mCancelled) { + 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); - if (c != null) { - c.moveToNext(); - gid = c.getString(SqlNote.GTASK_ID_COLUMN); - node = mGTaskHashMap.get(gid); - if (node != null) { - 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); + c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null); // 查询根文件夹 + if (c != null) { // 如果查询成功 + c.moveToNext(); // 移动到第一条记录 + gid = c.getString(SqlNote.GTASK_ID_COLUMN); // 获取 GID + node = mGTaskHashMap.get(gid); // 从哈希表中获取节点 + if (node != null) { // 如果节点存在 + mGTaskHashMap.remove(gid); // 从哈希表中移除节点 + mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER); // GID 到 NID 映射 + mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid); // NID 到 GID 映射 + // 对于系统文件夹,仅在必要时更新远程名称 + if (!node.getName().equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) + doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c); // 执行更新同步 } else { - doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c); + doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c); // 执行添加同步 } } else { - Log.w(TAG, "failed to query root folder"); + Log.w(TAG, "failed to query root folder"); // 查询根文件夹失败 } - } finally { + } finally { // 确保游标关闭 if (c != null) { - c.close(); + c.close(); // 关闭游标 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) - }, null); - if (c != null) { - if (c.moveToNext()) { - gid = c.getString(SqlNote.GTASK_ID_COLUMN); - node = mGTaskHashMap.get(gid); - if (node != null) { - 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)) - doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c); + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)", new String[] { + String.valueOf(Notes.ID_CALL_RECORD_FOLDER) // 根据 ID 查询通话记录文件夹 + }, null); + if (c != null) { // 如果查询成功 + if (c.moveToNext()) { // 移动到第一条记录 + gid = c.getString(SqlNote.GTASK_ID_COLUMN); // 获取 GID + node = mGTaskHashMap.get(gid); // 从哈希表中获取节点 + if (node != null) { // 如果节点存在 + mGTaskHashMap.remove(gid); // 从哈希表中移除节点 + mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER); // GID 到 NID 映射 + mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid); // NID 到 GID 映射 + // 对于系统文件夹,仅在必要时更新远程名称 + if (!node.getName().equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) + doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c); // 执行更新同步 } else { - doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c); + doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c); // 执行添加同步 } } } else { - Log.w(TAG, "failed to query call note folder"); + Log.w(TAG, "failed to query call note folder"); // 查询通话记录文件夹失败 } - } finally { + } finally { // 确保游标关闭 if (c != null) { - c.close(); + c.close(); // 关闭游标 c = null; } } - // for local existing folders + // 处理本地现有的文件夹 try { - c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, - "(type=? AND parent_id<>?)", new String[] { - String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER) - }, NoteColumns.TYPE + " DESC"); - if (c != null) { - while (c.moveToNext()) { - gid = c.getString(SqlNote.GTASK_ID_COLUMN); - node = mGTaskHashMap.get(gid); - if (node != null) { - mGTaskHashMap.remove(gid); - mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN)); - mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid); - syncType = node.getSyncAction(c); + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(type=? AND parent_id<>?)", new String[] { + String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER) // 查询类型为文件夹且不在回收站的记录 + }, NoteColumns.TYPE + " DESC"); // 根据类型降序排列 + if (c != null) { // 如果查询成功 + while (c.moveToNext()) { // 遍历查询结果 + gid = c.getString(SqlNote.GTASK_ID_COLUMN); // 获取 GID + node = mGTaskHashMap.get(gid); // 从哈希表中获取节点 + if (node != null) { // 如果节点存在 + mGTaskHashMap.remove(gid); // 从哈希表中移除节点 + mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN)); // GID 到 NID 映射 + mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid); // NID 到 GID 映射 + 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; } } - doContentSync(syncType, node, c); + doContentSync(syncType, node, c); // 执行内容同步 } } else { - Log.w(TAG, "failed to query existing folder"); + Log.w(TAG, "failed to query existing folder"); // 查询已有文件夹失败 } - } finally { + } finally { // 确保游标关闭 if (c != null) { - c.close(); + c.close(); // 关闭游标 c = null; } } - // for remote add folders + // 处理远程添加的文件夹 Iterator> iter = mGTaskListHashMap.entrySet().iterator(); - while (iter.hasNext()) { - Map.Entry entry = iter.next(); - gid = entry.getKey(); - node = entry.getValue(); - if (mGTaskHashMap.containsKey(gid)) { - mGTaskHashMap.remove(gid); - doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null); + while (iter.hasNext()) { // 遍历哈希表 + Map.Entry entry = iter.next(); // 获取每个条目 + gid = entry.getKey(); // 获取 GID + node = entry.getValue(); // 获取节点 + if (mGTaskHashMap.containsKey(gid)) { // 如果哈希表中包含该 GID + mGTaskHashMap.remove(gid); // 从哈希表中移除该节点 + doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null); // 执行本地添加同步 } } - if (!mCancelled) - GTaskClient.getInstance().commitUpdate(); + if (!mCancelled) // 如果未取消 + GTaskClient.getInstance().commitUpdate(); // 提交更新 } + // 执行内容同步的具体操作 private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException { - if (mCancelled) { + if (mCancelled) { // 如果已取消则返回 return; } - MetaData meta; - switch (syncType) { - case Node.SYNC_ACTION_ADD_LOCAL: - addLocalNode(node); + MetaData meta; // 声明元数据 + switch (syncType) { // 根据同步类型执行不同操作 + case Node.SYNC_ACTION_ADD_LOCAL: // 本地添加 + addLocalNode(node); // 调用添加本地节点的方法 break; - case Node.SYNC_ACTION_ADD_REMOTE: - addRemoteNode(node, c); + 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)); + case Node.SYNC_ACTION_DEL_LOCAL: // 本地删除 + meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN)); // 获取元数据 if (meta != null) { - GTaskClient.getInstance().deleteNode(meta); + GTaskClient.getInstance().deleteNode(meta); // 删除远程节点 } - mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); + mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); // 添加到本地删除 ID 集合 break; - case Node.SYNC_ACTION_DEL_REMOTE: - meta = mMetaHashMap.get(node.getGid()); + case Node.SYNC_ACTION_DEL_REMOTE: // 远程删除 + meta = mMetaHashMap.get(node.getGid()); // 获取元数据 if (meta != null) { - GTaskClient.getInstance().deleteNode(meta); + GTaskClient.getInstance().deleteNode(meta); // 删除远程元节点 } - GTaskClient.getInstance().deleteNode(node); + GTaskClient.getInstance().deleteNode(node); // 删除远程节点 break; - case Node.SYNC_ACTION_UPDATE_LOCAL: - updateLocalNode(node, c); + case Node.SYNC_ACTION_UPDATE_LOCAL: // 本地更新 + updateLocalNode(node, c); // 调用更新本地节点的方法 break; - case Node.SYNC_ACTION_UPDATE_REMOTE: - updateRemoteNode(node, c); + 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); + case Node.SYNC_ACTION_UPDATE_CONFLICT: // 更新冲突 + // 将两种修改合并可能是个好主意 + // 目前简单地使用本地更新 + updateRemoteNode(node, c); // 调用更新远程节点的方法 break; - case Node.SYNC_ACTION_NONE: + case Node.SYNC_ACTION_NONE: // 无需操作 break; - case Node.SYNC_ACTION_ERROR: + case Node.SYNC_ACTION_ERROR: // 错误操作类型 default: - throw new ActionFailureException("unkown sync action type"); + throw new ActionFailureException("unknown sync action type"); // 抛出操作失败异常 } } + // 添加本地节点的方法 private void addLocalNode(Node node) throws NetworkFailureException { - if (mCancelled) { + if (mCancelled) { // 如果已取消则返回 return; } - SqlNote sqlNote; - if (node instanceof TaskList) { - if (node.getName().equals( - GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) { - sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER); - } else if (node.getName().equals( - GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) { - sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER); + SqlNote sqlNote; // 声明 SQL 笔记对象 + if (node instanceof TaskList) { // 如果节点是任务列表 + if (node.getName().equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) { // 如果是默认文件夹 + sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER); // 创建 SQL 笔记对象 + } else if (node.getName().equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) { // 如果是通话记录文件夹 + sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER); // 创建 SQL 笔记对象 } else { - sqlNote = new SqlNote(mContext); - sqlNote.setContent(node.getLocalJSONFromContent()); - sqlNote.setParentId(Notes.ID_ROOT_FOLDER); + sqlNote = new SqlNote(mContext); // 创建新的 SQL 笔记对象 + sqlNote.setContent(node.getLocalJSONFromContent()); // 设置内容 + sqlNote.setParentId(Notes.ID_ROOT_FOLDER); // 设置父 ID 为根文件夹 } - } else { - sqlNote = new SqlNote(mContext); - JSONObject js = node.getLocalJSONFromContent(); + } else { // 如果节点是普通任务 + sqlNote = new SqlNote(mContext); // 创建新的 SQL 笔记对象 + JSONObject js = node.getLocalJSONFromContent(); // 获取任务的本地 JSON 内容 try { - 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 - note.remove(NoteColumns.ID); - } - } - } - - if (js.has(GTaskStringUtils.META_HEAD_DATA)) { - JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); - for (int i = 0; i < dataArray.length(); i++) { - JSONObject data = dataArray.getJSONObject(i); - 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 - data.remove(DataColumns.ID); - } + if (js.has(GTaskStringUtils.META_HEAD_NOTE)) { // 如果 JSON 内容中有 HEAD_NOTE + JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 获取 NOTE 对象 + if (note.has(NoteColumns.ID)) { // 如果 NOTE 对象中有 ID + long id = note.getLong(NoteColumns.ID); // 获取 ID + if (DataUtils.existInNoteDatabase(mContentResolver, id)) { // 检查 ID 是否存在于数据库中 + // ID 不可用,必须创建一个新 ID + note.remove(NoteColumns.ID); // 移除 ID } } - } - } catch (JSONException e) { - Log.w(TAG, e.toString()); - e.printStackTrace(); - } - sqlNote.setContent(js); - Long parentId = mGidToNid.get(((Task) node).getParent().getGid()); - if (parentId == null) { - Log.e(TAG, "cannot find task's parent id locally"); - throw new ActionFailureException("cannot add local node"); + // 检查 JSON 对象是否包含 META_HEAD_DATA 字段 +if (js.has(GTaskStringUtils.META_HEAD_DATA)) { + JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); // 获取数据数组 + for (int i = 0; i < dataArray.length(); i++) { // 遍历数据数组 + JSONObject data = dataArray.getJSONObject(i); // 获取每个数据的 JSON 对象 + if (data.has(DataColumns.ID)) { // 如果数据对象中包含 ID 字段 + long dataId = data.getLong(DataColumns.ID); // 获取数据的 ID + if (DataUtils.existInDataDatabase(mContentResolver, dataId)) { // 检查数据 ID 是否在数据库中存在 + // 如果数据 ID 不可用,则移除 ID 字段 + data.remove(DataColumns.ID); } - sqlNote.setParentId(parentId.longValue()); } + } +} - // create the local node - sqlNote.setGtaskId(node.getGid()); - sqlNote.commit(false); +// 捕获 JSON 异常 +} catch (JSONException e) { + Log.w(TAG, e.toString()); // 记录警告日志 + e.printStackTrace(); // 打印堆栈跟踪 +} - // update gid-nid mapping - mGidToNid.put(node.getGid(), sqlNote.getId()); - mNidToGid.put(sqlNote.getId(), node.getGid()); +// 设置 SQL 笔记对象的内容为 JSON +sqlNote.setContent(js); - // update meta - updateRemoteMeta(node.getGid(), sqlNote); - } +// 获取父任务的 ID +Long parentId = mGidToNid.get(((Task) node).getParent().getGid()); +if (parentId == null) { // 如果找不到父任务 ID + Log.e(TAG, "cannot find task's parent id locally"); // 记录错误日志 + throw new ActionFailureException("cannot add local node"); // 抛出操作失败异常 +} +sqlNote.setParentId(parentId.longValue()); // 设置 SQL 笔记的父 ID - private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException { - if (mCancelled) { - return; - } +// 创建本地节点 +sqlNote.setGtaskId(node.getGid()); // 设置 GTask ID +sqlNote.commit(false); // 提交笔记内容,不同步到远程 - SqlNote sqlNote; - // update the note locally - sqlNote = new SqlNote(mContext, c); - sqlNote.setContent(node.getLocalJSONFromContent()); +// 更新 GID-NID 映射 +mGidToNid.put(node.getGid(), sqlNote.getId()); // GID 到 NID 的映射 +mNidToGid.put(sqlNote.getId(), node.getGid()); // NID 到 GID 的映射 - Long parentId = (node instanceof Task) ? mGidToNid.get(((Task) node).getParent().getGid()) - : new Long(Notes.ID_ROOT_FOLDER); - if (parentId == null) { - Log.e(TAG, "cannot find task's parent id locally"); - throw new ActionFailureException("cannot update local node"); - } - sqlNote.setParentId(parentId.longValue()); - sqlNote.commit(true); +// 更新元数据 +updateRemoteMeta(node.getGid(), sqlNote); // 更新远程元数据 - // update meta info - updateRemoteMeta(node.getGid(), sqlNote); +// 更新本地节点的方法 +private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException { + if (mCancelled) { // 如果已取消则返回 + return; } - private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException { - if (mCancelled) { - return; - } + SqlNote sqlNote; // 声明 SQL 笔记对象 + // 在本地更新笔记 + sqlNote = new SqlNote(mContext, c); // 根据游标初始化 SQL 笔记 + sqlNote.setContent(node.getLocalJSONFromContent()); // 设置内容为节点的本地 JSON + + // 获取父 ID + Long parentId = (node instanceof Task) ? mGidToNid.get(((Task) node).getParent().getGid()) + : new Long(Notes.ID_ROOT_FOLDER); // 如果节点是任务,则获取任务的父 ID;否则使用根文件夹 ID + if (parentId == null) { // 如果找不到父任务 ID + Log.e(TAG, "cannot find task's parent id locally"); // 记录错误日志 + throw new ActionFailureException("cannot update local node"); // 抛出操作失败异常 + } + sqlNote.setParentId(parentId.longValue()); // 设置 SQL 笔记的父 ID + sqlNote.commit(true); // 提交笔记内容并同步到远程 - SqlNote sqlNote = new SqlNote(mContext, c); - Node n; + // 更新元信息 + updateRemoteMeta(node.getGid(), sqlNote); // 更新远程元数据 +} - // update remotely - if (sqlNote.isNoteType()) { - Task task = new Task(); - task.setContentByLocalJSON(sqlNote.getContent()); +// 添加远程节点的方法 +private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException { + if (mCancelled) { // 如果已取消则返回 + return; + } - String parentGid = mNidToGid.get(sqlNote.getParentId()); - if (parentGid == null) { - Log.e(TAG, "cannot find task's parent tasklist"); - throw new ActionFailureException("cannot add remote task"); - } - mGTaskListHashMap.get(parentGid).addChildTask(task); + SqlNote sqlNote = new SqlNote(mContext, c); // 根据游标初始化 SQL 笔记 + Node n; // 声明节点 - GTaskClient.getInstance().createTask(task); - n = (Node) task; + // 更新远程内容 + if (sqlNote.isNoteType()) { // 如果是笔记类型 + Task task = new Task(); // 创建任务对象 + task.setContentByLocalJSON(sqlNote.getContent()); // 从 SQL 笔记获取本地内容 - // add meta - updateRemoteMeta(task.getGid(), sqlNote); - } else { - TaskList tasklist = null; - - // we need to skip folder if it has already existed - String folderName = GTaskStringUtils.MIUI_FOLDER_PREFFIX; - if (sqlNote.getId() == Notes.ID_ROOT_FOLDER) - folderName += GTaskStringUtils.FOLDER_DEFAULT; - else if (sqlNote.getId() == Notes.ID_CALL_RECORD_FOLDER) - folderName += GTaskStringUtils.FOLDER_CALL_NOTE; - else - folderName += sqlNote.getSnippet(); - - Iterator> iter = mGTaskListHashMap.entrySet().iterator(); - while (iter.hasNext()) { - Map.Entry entry = iter.next(); - String gid = entry.getKey(); - TaskList list = entry.getValue(); - - if (list.getName().equals(folderName)) { - tasklist = list; - if (mGTaskHashMap.containsKey(gid)) { - mGTaskHashMap.remove(gid); - } - break; + String parentGid = mNidToGid.get(sqlNote.getParentId()); // 获取父任务的 GID + if (parentGid == null) { // 如果找不到父任务 GID + Log.e(TAG, "cannot find task's parent tasklist"); // 记录错误日志 + throw new ActionFailureException("cannot add remote task"); // 抛出操作失败异常 + } + mGTaskListHashMap.get(parentGid).addChildTask(task); // 将任务添加到父任务列表 + + GTaskClient.getInstance().createTask(task); // 在远程创建任务 + n = (Node) task; // 将任务赋值给节点 n + + // 添加元数据 + updateRemoteMeta(task.getGid(), sqlNote); // 更新远程元数据 + } else { // 如果是文件夹类型 + TaskList tasklist = null; + + // 如果文件夹已经存在,则跳过 + String folderName = GTaskStringUtils.MIUI_FOLDER_PREFFIX; // 设置文件夹名称前缀 + if (sqlNote.getId() == Notes.ID_ROOT_FOLDER) // 根文件夹 + folderName += GTaskStringUtils.FOLDER_DEFAULT; + else if (sqlNote.getId() == Notes.ID_CALL_RECORD_FOLDER) // 通话记录文件夹 + folderName += GTaskStringUtils.FOLDER_CALL_NOTE; + else // 其他文件夹 + folderName += sqlNote.getSnippet(); + + // 检查现有任务列表中是否已存在该文件夹 + Iterator> iter = mGTaskListHashMap.entrySet().iterator(); + while (iter.hasNext()) { // 遍历任务列表 + Map.Entry entry = iter.next(); // 获取每个条目 + String gid = entry.getKey(); // 获取 GID + TaskList list = entry.getValue(); // 获取任务列表 + + if (list.getName().equals(folderName)) { // 如果找到匹配的文件夹名称 + tasklist = list; // 获取文件夹 + if (mGTaskHashMap.containsKey(gid)) { // 如果任务哈希表中包含该 GID + mGTaskHashMap.remove(gid); // 移除该 GID } + break; // 退出循环 } - - // no match we can add now - if (tasklist == null) { - tasklist = new TaskList(); - tasklist.setContentByLocalJSON(sqlNote.getContent()); - GTaskClient.getInstance().createTaskList(tasklist); - mGTaskListHashMap.put(tasklist.getGid(), tasklist); - } - n = (Node) tasklist; } - // update local note - sqlNote.setGtaskId(n.getGid()); - sqlNote.commit(false); - sqlNote.resetLocalModified(); - sqlNote.commit(true); - - // gid-id mapping - mGidToNid.put(n.getGid(), sqlNote.getId()); - mNidToGid.put(sqlNote.getId(), n.getGid()); + // 如果没有找到匹配的文件夹,则创建新的文件夹 + if (tasklist == null) { + tasklist = new TaskList(); // 创建新的任务列表 + tasklist.setContentByLocalJSON(sqlNote.getContent()); // 设置任务列表内容 + GTaskClient.getInstance().createTaskList(tasklist); // 在远程创建任务列表 + mGTaskListHashMap.put(tasklist.getGid(), tasklist); // 将任务列表添加到哈希表 + } + n = (Node) tasklist; // 将任务列表赋值给节点 n } - private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException { - if (mCancelled) { - return; - } + // 更新本地笔记 + sqlNote.setGtaskId(n.getGid()); // 设置 GTask ID + sqlNote.commit(false); // 提交笔记内容,不同步到远程 + sqlNote.resetLocalModified(); // 重置本地修改标记 + sqlNote.commit(true); // 提交并同步到远程 - SqlNote sqlNote = new SqlNote(mContext, c); + // 更新 GID-ID 映射 + mGidToNid.put(n.getGid(), sqlNote.getId()); // GID 到 NID 的映射 + mNidToGid.put(sqlNote.getId(), n.getGid()); // NID 到 GID 的映射 +} - // update remotely - node.setContentByLocalJSON(sqlNote.getContent()); - GTaskClient.getInstance().addUpdateNode(node); +// 更新远程节点的方法 +private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException { + if (mCancelled) { // 如果已取消则返回 + return; + } - // update meta - updateRemoteMeta(node.getGid(), sqlNote); + SqlNote sqlNote = new SqlNote(mContext, c); // 根据游标初始化 SQL 笔记 - // move task if necessary - if (sqlNote.isNoteType()) { - Task task = (Task) node; - TaskList preParentList = task.getParent(); + // 更新远程内容 + node.setContentByLocalJSON(sqlNote.getContent()); // 设置节点内容 + GTaskClient.getInstance().addUpdateNode(node); // 添加更新节点 - String curParentGid = mNidToGid.get(sqlNote.getParentId()); - if (curParentGid == null) { - Log.e(TAG, "cannot find task's parent tasklist"); - throw new ActionFailureException("cannot update remote task"); - } - TaskList curParentList = mGTaskListHashMap.get(curParentGid); + // 更新元数据 + updateRemoteMeta(node.getGid(), sqlNote); // 更新远程元数据 - if (preParentList != curParentList) { - preParentList.removeChildTask(task); - curParentList.addChildTask(task); - GTaskClient.getInstance().moveTask(task, preParentList, curParentList); - } - } + // 如果需要,移动任务 + if (sqlNote.isNoteType()) { // 如果节点是笔记类型 + Task task = (Task) node; // 将节点转换为任务 + TaskList preParentList = task.getParent(); // 获取原父任务列表 - // clear local modified flag - sqlNote.resetLocalModified(); - sqlNote.commit(true); - } + String curParentGid = mNidToGid.get(sqlNote.getParentId()); // 获取当前父任务 GID + if (curParentGid == null) { // 如果找不到父任务 GID + Log.e(TAG, "cannot find task's parent tasklist"); // 记录错误日志 + throw new ActionFailureException("cannot update remote task"); // 抛出操作失败异常 + } + TaskList curParentList = mGTaskListHashMap.get(curParentGid); // 获取当前父任务列表 - private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException { - if (sqlNote != null && sqlNote.isNoteType()) { - MetaData metaData = mMetaHashMap.get(gid); - if (metaData != null) { - metaData.setMeta(gid, sqlNote.getContent()); - GTaskClient.getInstance().addUpdateNode(metaData); - } else { - metaData = new MetaData(); - metaData.setMeta(gid, sqlNote.getContent()); - mMetaList.addChildTask(metaData); - mMetaHashMap.put(gid, metaData); - GTaskClient.getInstance().createTask(metaData); - } + // 如果前一个父列表与当前父列表不同,则移动任务 + if (preParentList != curParentList) { + preParentList.removeChildTask(task); // 从原父列表中移除任务 + curParentList.addChildTask(task); // 将任务添加到当前父列表 + GTaskClient.getInstance().moveTask(task, preParentList, curParentList); // 移动任务至远程 } } - private void refreshLocalSyncId() throws NetworkFailureException { - if (mCancelled) { - return; + // 清除本地修改标记 + sqlNote.resetLocalModified(); // 重置本地修改标记 + sqlNote.commit(true); // 提交并同步到远程 +} + +// 更新远程元数据的方法 +private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException { + if (sqlNote != null && sqlNote.isNoteType()) { // 如果 SQL 笔记不为 null 且是笔记类型 + MetaData metaData = mMetaHashMap.get(gid); // 获取元数据对象 + if (metaData != null) { // 如果元数据存在 + metaData.setMeta(gid, sqlNote.getContent()); // 更新元数据内容 + GTaskClient.getInstance().addUpdateNode(metaData); // 在远程更新元数据 + } else { // 如果元数据不存在 + metaData = new MetaData(); // 创建新的元数据对象 + metaData.setMeta(gid, sqlNote.getContent()); // 设置元数据内容 + mMetaList.addChildTask(metaData); // 将元数据添加到元数据列表 + mMetaHashMap.put(gid, metaData); // 更新元数据哈希表 + GTaskClient.getInstance().createTask(metaData); // 在远程创建元数据 } + } +} - // get the latest gtask list - mGTaskHashMap.clear(); - mGTaskListHashMap.clear(); - mMetaHashMap.clear(); - initGTaskList(); +// 刷新本地同步 ID 的方法 +private void refreshLocalSyncId() throws NetworkFailureException { + if (mCancelled) { // 如果已取消则返回 + return; + } - Cursor c = null; - try { - c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, - "(type<>? AND parent_id<>?)", new String[] { - String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER) - }, NoteColumns.TYPE + " DESC"); - if (c != null) { - while (c.moveToNext()) { - String gid = c.getString(SqlNote.GTASK_ID_COLUMN); - Node node = mGTaskHashMap.get(gid); - if (node != null) { - mGTaskHashMap.remove(gid); - ContentValues values = new ContentValues(); - values.put(NoteColumns.SYNC_ID, node.getLastModified()); - mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, - c.getLong(SqlNote.ID_COLUMN)), values, null, null); - } else { - Log.e(TAG, "something is missed"); - throw new ActionFailureException( - "some local items don't have gid after sync"); - } + // 获取最新的 GTask 列表 + mGTaskHashMap.clear(); // 清空任务哈希表 + mGTaskListHashMap.clear(); // 清空任务列表哈希表 + mMetaHashMap.clear(); // 清空元数据哈希表 + initGTaskList(); // 初始化 GTask 列表 + + Cursor c = null; // 声明游标 + try { + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, + "(type<>? AND parent_id<>?)", new String[] { + String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER) // 查询非系统类型且不在回收站的笔记 + }, NoteColumns.TYPE + " DESC"); // 根据类型降序排列 + if (c != null) { // 如果查询成功 + while (c.moveToNext()) { // 遍历查询结果 + String gid = c.getString(SqlNote.GTASK_ID_COLUMN); // 获取 GID + Node node = mGTaskHashMap.get(gid); // 从哈希表中获取节点 + if (node != null) { // 如果节点存在 + mGTaskHashMap.remove(gid); // 从哈希表中移除节点 + ContentValues values = new ContentValues(); // 创建内容值对象 + values.put(NoteColumns.SYNC_ID, node.getLastModified()); // 更新同步 ID + mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, + c.getLong(SqlNote.ID_COLUMN)), values, null, null); // 更新内容 + } else { + Log.e(TAG, "something is missed"); // 记录错误日志 + throw new ActionFailureException("some local items don't have gid after sync"); // 抛出操作失败异常 } - } else { - Log.w(TAG, "failed to query local note to refresh sync id"); - } - } finally { - if (c != null) { - c.close(); - c = null; } + } else { + Log.w(TAG, "failed to query local note to refresh sync id"); // 查询本地笔记以刷新同步 ID 失败 + } + } finally { // 确保游标关闭 + if (c != null) { + c.close(); // 关闭游标 + c = null; } } +} - public String getSyncAccount() { - return GTaskClient.getInstance().getSyncAccount().name; - } +// 获取同步帐户信息的方法 +public String getSyncAccount() { + return GTaskClient.getInstance().getSyncAccount().name; // 返回同步帐户名 +} - public void cancelSync() { - mCancelled = true; - } +// 取消同步操作的方法 +public void cancelSync() { + mCancelled = true; // 设置取消标志 } diff --git a/src/net/micode/notes/gtask/remote/GTaskSyncService.java b/src/net/micode/notes/gtask/remote/GTaskSyncService.java index cca36f7..2421024 100644 --- a/src/net/micode/notes/gtask/remote/GTaskSyncService.java +++ b/src/net/micode/notes/gtask/remote/GTaskSyncService.java @@ -16,6 +16,7 @@ package net.micode.notes.gtask.remote; +// 导入必要的Android类 import android.app.Activity; import android.app.Service; import android.content.Context; @@ -23,106 +24,135 @@ import android.content.Intent; import android.os.Bundle; import android.os.IBinder; +// 定义GTaskSyncService类,继承自Service public class GTaskSyncService extends Service { + // 定义同步动作的字符串名称 public final static String ACTION_STRING_NAME = "sync_action_type"; + // 定义开始同步的动作标识 public final static int ACTION_START_SYNC = 0; + // 定义取消同步的动作标识 public final static int ACTION_CANCEL_SYNC = 1; + // 定义无效动作的标识 public final static int ACTION_INVALID = 2; + // 定义广播名称,用于发送同步服务的广播 public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service"; + // 定义广播中表示是否正在同步的键 public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing"; + // 定义广播中表示进度消息的键 public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg"; + // 静态变量,表示当前的异步同步任务 private static GTaskASyncTask mSyncTask = null; + // 静态变量,保存同步进度消息 private static String mSyncProgress = ""; + // 启动同步的方法 private void startSync() { + // 如果当前没有正在进行的同步任务 if (mSyncTask == null) { + // 创建新的异步同步任务 mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() { + // 同步完成时的回调 public void onComplete() { - mSyncTask = null; - sendBroadcast(""); - stopSelf(); + mSyncTask = null; // 清空任务 + sendBroadcast(""); // 发送广播 + stopSelf(); // 停止服务 } }); - sendBroadcast(""); - mSyncTask.execute(); + sendBroadcast(""); // 发送广播,通知开始同步 + mSyncTask.execute(); // 执行同步任务 } } + // 取消同步的方法 private void cancelSync() { + // 如果有同步任务在运行 if (mSyncTask != null) { - mSyncTask.cancelSync(); + mSyncTask.cancelSync(); // 取消同步 } } + // 服务创建时调用的方法 @Override public void onCreate() { - mSyncTask = null; + mSyncTask = null; // 初始化同步任务为null } + // 当服务被启动时调用的方法 @Override public int onStartCommand(Intent intent, int flags, int startId) { - Bundle bundle = intent.getExtras(); + Bundle bundle = intent.getExtras(); // 获取传入的意图数据 + // 如果意图中包含动作标识 if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) { + // 根据动作标识进行处理 switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) { - case ACTION_START_SYNC: + case ACTION_START_SYNC: // 开始同步 startSync(); break; - case ACTION_CANCEL_SYNC: + case ACTION_CANCEL_SYNC: // 取消同步 cancelSync(); break; default: break; } - return START_STICKY; + return START_STICKY; // 表示服务在被系统杀死后应再次启动 } - return super.onStartCommand(intent, flags, startId); + return super.onStartCommand(intent, flags, startId); // 调用父类的方法 } + // 系统内存不足时调用的方法 @Override public void onLowMemory() { + // 如果有正在运行的同步任务,取消它 if (mSyncTask != null) { mSyncTask.cancelSync(); } } + // 绑定服务的方法,返回null表示不支持绑定 public IBinder onBind(Intent intent) { return null; } + // 发送广播的方法,携带进度消息 public void sendBroadcast(String msg) { - mSyncProgress = msg; - Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME); - intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null); - intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg); - sendBroadcast(intent); + mSyncProgress = msg; // 更新进度消息 + Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME); // 创建广播意图 + intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null); // 添加正在同步的状态 + intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg); // 添加进度消息 + sendBroadcast(intent); // 发送广播 } + // 启动同步的静态方法 public static void startSync(Activity activity) { - GTaskManager.getInstance().setActivityContext(activity); - Intent intent = new Intent(activity, GTaskSyncService.class); - intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC); - activity.startService(intent); + GTaskManager.getInstance().setActivityContext(activity); // 设置上下文 + Intent intent = new Intent(activity, GTaskSyncService.class); // 创建启动服务的意图 + intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC); // 添加动作标识 + activity.startService(intent); // 启动服务 } + // 取消同步的静态方法 public static void cancelSync(Context context) { - Intent intent = new Intent(context, GTaskSyncService.class); - intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC); - context.startService(intent); + Intent intent = new Intent(context, GTaskSyncService.class); // 创建取消服务的意图 + intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC); // 添加动作标识 + context.startService(intent); // 启动服务 } + // 静态方法,用于判断当前是否正在同步 public static boolean isSyncing() { - return mSyncTask != null; + return mSyncTask != null; // 如果任务不为null,则表示正在同步 } + // 静态方法,用于获取当前的进度字符串 public static String getProgressString() { - return mSyncProgress; + return mSyncProgress; // 返回同步进度消息 } } +