提交

src/Date/MetaData.java

@@ -0,0 +1,132 @@
+/*
+ * 版权所有 (c) 2010-2011，MiCode 开源社区 (www.micode.net)
+ * 根据 Apache 许可证 2.0 版本（"许可证"）授权；
+ * 除非符合许可证的规定，否则不得使用本文件。
+ * 您可以从以下网址获取许可证副本：
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 除非适用法律要求或书面同意，本软件按"原样"分发，
+ * 没有任何明示或暗示的保证或条件。
+ * 详见许可证中规定的权限和限制。
+ * （注：这是一份标准的Apache许可证2.0版本的开源声明）
+ */
+
+// 定义MetaData类所在的包路径
+package net.micode.notes.gtask.data;
+
+// 导入Android数据库Cursor类
+import android.database.Cursor;
+// 导入Android日志工具类
+import android.util.Log;
+
+// 导入应用中自定义的字符串工具类
+import net.micode.notes.tool.GTaskStringUtils;
+
+// 导入JSON处理相关类
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * MetaData类 - 继承自Task类
+ * 功能：处理Google Tasks元数据信息
+ * 特性：
+ * 1. 存储关联任务的GID（Google ID）
+ * 2. 将元数据信息以JSON格式存储在notes字段中
+ * 3. 仅用于远程数据同步，不支持本地操作
+ */
+public class MetaData extends Task {
+    // 日志标签，使用类名作为标识
+    private final static String TAG = MetaData.class.getSimpleName();
+
+    // 存储关联任务的Google ID
+    private String mRelatedGid = null;
+
+    /**
+     * 设置元数据信息
+     * @param gid 关联任务的Google ID
+     * @param metaInfo 包含元数据的JSON对象
+     */
+    public void setMeta(String gid, JSONObject metaInfo) {
+        try {
+            // 将GID添加到元数据JSON中
+            metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID,  gid);
+        } catch (JSONException e) {
+            Log.e(TAG, "failed to put related gid"); // 记录错误日志
+        }
+        // 将JSON对象转为字符串存储到notes字段
+        setNotes(metaInfo.toString());
+        // 设置固定名称标识这是一个元数据任务
+        setName(GTaskStringUtils.META_NOTE_NAME);
+    }
+
+    /**
+     * 获取关联任务的Google ID
+     * @return 关联GID，可能为null
+     */
+    public String getRelatedGid() {
+        return mRelatedGid;
+    }
+
+    /**
+     * 判断是否值得保存
+     * @return notes字段不为空时返回true
+     */
+    @Override
+    public boolean isWorthSaving() {
+        return getNotes() != null;
+    }
+
+    /**
+     * 从远程JSON数据设置内容
+     * @param js 包含远程数据的JSON对象
+     */
+    @Override
+    public void setContentByRemoteJSON(JSONObject js) {
+        // 先调用父类方法处理基础字段
+        super.setContentByRemoteJSON(js);
+
+        // 如果notes字段不为空，解析其中的GID
+        if (getNotes() != null) {
+            try {
+                // 将notes字符串转为JSON对象
+                JSONObject metaInfo = new JSONObject(getNotes().trim());
+                // 从JSON中获取关联GID
+                mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
+            } catch (JSONException e) {
+                Log.w(TAG, "failed to get related gid"); // 记录警告日志
+                mRelatedGid = null; // 解析失败时重置GID
+            }
+        }
+    }
+
+    /**
+     * 从本地JSON设置内容（不支持）
+     * @param js JSON对象
+     * @throws IllegalAccessError 总是抛出此异常
+     */
+    @Override
+    public void setContentByLocalJSON(JSONObject js) {
+        // 元数据不应从本地JSON设置，直接抛出异常
+        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
+    }
+
+    /**
+     * 获取本地JSON内容（不支持）
+     * @throws IllegalAccessError 总是抛出此异常
+     */
+    @Override
+    public JSONObject getLocalJSONFromContent() {
+        // 元数据不应生成本地JSON，直接抛出异常
+        throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
+    }
+
+    /**
+     * 获取同步动作（不支持）
+     * @param c 数据库Cursor
+     * @throws IllegalAccessError 总是抛出此异常
+     */
+    @Override
+    public int getSyncAction(Cursor c) {
+        // 元数据不支持同步动作查询，直接抛出异常
+        throw new IllegalAccessError("MetaData:getSyncAction should not be called");
+    }
+}

src/Date/Node.java

@@ -0,0 +1,157 @@
+/*
+ * 版权所有 (c) 2010-2011，MiCode 开源社区 (www.micode.net)
+ * 根据 Apache 许可证 2.0 版本（"许可证"）授权；
+ * 除非符合许可证的规定，否则不得使用本文件。
+ * 您可以从以下网址获取许可证副本：
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 除非适用法律要求或书面同意，本软件按"原样"分发，
+ * 没有任何明示或暗示的保证或条件。
+ * 详见许可证中规定的权限和限制。
+ * （注：这是一份标准的Apache许可证2.0版本的开源声明）
+ */
+// 定义Node类所在的包路径
+package net.micode.notes.gtask.data;
+// 导入Android数据库Cursor类（用于本地数据操作）
+import android.database.Cursor;
+// 导入JSON处理类
+import org.json.JSONObject;
+/**
+ * 抽象Node类 - GTasks数据同步的基础节点类
+ * 功能：
+ * 1. 定义通用的同步动作常量
+ * 2. 提供基本属性管理（GID、名称、修改时间等）
+ * 3. 声明数据同步的核心抽象方法
+ */
+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;
+    // Google任务ID（全局唯一标识）
+    private String mGid;
+    // 节点名称
+    private String mName;
+    // 最后修改时间戳（毫秒）
+    private long mLastModified;
+    // 删除标记
+    private boolean mDeleted;
+
+    /**
+     * 构造函数
+     * 初始化默认值：
+     * - GID为null
+     * - 名称为空字符串
+     * - 最后修改时间为0
+     * - 未删除状态
+     */
+    public Node() {
+        mGid = null;
+        mName = "";
+        mLastModified = 0;
+        mDeleted = false;
+    }
+    /**
+     * 抽象方法：获取创建动作的JSON数据
+     * @param actionId 动作ID
+     * @return 包含创建动作数据的JSON对象
+     */
+    public abstract JSONObject getCreateAction(int actionId);
+
+    /**
+     * 抽象方法：获取更新动作的JSON数据
+     * @param actionId 动作ID
+     * @return 包含更新动作数据的JSON对象
+     */
+    public abstract JSONObject getUpdateAction(int actionId);
+    /**
+     * 抽象方法：从远程JSON数据设置内容
+     * @param js 包含远程数据的JSON对象
+     */
+    public abstract void setContentByRemoteJSON(JSONObject js);
+    /**
+     * 抽象方法：从本地JSON数据设置内容
+     * @param js 包含本地数据的JSON对象
+     */
+    public abstract void setContentByLocalJSON(JSONObject js);
+    /**
+     * 抽象方法：从内容生成本地JSON数据
+     * @return 包含本地数据的JSON对象
+     */
+    public abstract JSONObject getLocalJSONFromContent();
+    /**
+     * 抽象方法：获取同步动作类型
+     * @param c 数据库Cursor对象
+     * @return 同步动作常量（SYNC_ACTION_*）
+     */
+    public abstract int getSyncAction(Cursor c);
+    /**
+     * 设置Google任务ID
+     * @param gid 全局唯一标识
+     */
+    public void setGid(String gid) {
+        this.mGid = gid;
+    }
+    /**
+     * 设置节点名称
+     * @param name 显示名称
+     */
+    public void setName(String name) {
+        this.mName = name;
+    }
+    /**
+     * 设置最后修改时间
+     * @param lastModified 时间戳（毫秒）
+     */
+    public void setLastModified(long lastModified) {
+        this.mLastModified = lastModified;
+    }
+    /**
+     * 设置删除标记
+     * @param deleted 是否已删除
+     */
+    public void setDeleted(boolean deleted) {
+        this.mDeleted = deleted;
+    }
+    /**
+     * 获取Google任务ID
+     * @return 全局唯一标识（可能为null）
+     */
+    public String getGid() {
+        return this.mGid;
+    }
+    /**
+     * 获取节点名称
+     * @return 显示名称
+     */
+    public String getName() {
+        return this.mName;
+    }
+    /**
+     * 获取最后修改时间
+     * @return 时间戳（毫秒）
+     */
+    public long getLastModified() {
+        return this.mLastModified;
+    }
+    /**
+     * 获取删除状态
+     * @return 是否已删除
+     */
+    public boolean getDeleted() {
+        return this.mDeleted;
+    }
+}

src/Date/SqlData.java

@@ -0,0 +1,258 @@
+/*
+ * 版权所有 (c) 2010-2011，MiCode 开源社区 (www.micode.net)
+ * 根据 Apache 许可证 2.0 版本（"许可证"）授权；
+ * 除非符合许可证的规定，否则不得使用本文件。
+ * 您可以从以下网址获取许可证副本：
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 除非适用法律要求或书面同意，本软件按"原样"分发，
+ * 没有任何明示或暗示的保证或条件。
+ * 详见许可证中规定的权限和限制。
+ * （注：这是一份标准的Apache许可证2.0版本的开源声明）
+ */
+
+// 定义当前类所在的包路径
+package net.micode.notes.gtask.data;
+
+// 导入Android内容提供者相关类
+import android.content.ContentResolver;   // 内容解析器，用于访问ContentProvider
+import android.content.ContentUris;       // 用于构建带有ID的URI
+import android.content.ContentValues;     // 键值对存储，用于数据库操作
+import android.content.Context;          // 应用上下文
+import android.database.Cursor;          // 数据库查询结果集
+import android.net.Uri;                  // 通用资源标识符
+import android.os.Build;                 // 获取Android版本信息
+import android.util.Log;                 // 日志工具
+
+// 导入AndroidX注解（版本检查）
+import androidx.annotation.RequiresApi;
+
+// 导入笔记应用数据相关常量
+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;
+
+// 导入JSON处理相关类
+import org.json.JSONException;   // JSON异常
+import org.json.JSONObject;      // JSON对象
+
+// 导入Java工具类
+import java.util.Objects;   // 对象工具类
+
+/**
+ * SqlData类 - 处理笔记数据的SQLite数据库操作
+ * 功能：
+ * 1. 封装笔记数据的增删改查操作
+ * 2. 管理本地数据与JSON格式的相互转换
+ * 3. 处理数据版本控制
+ */
+public class SqlData {
+    // 日志标签
+    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,         // 数据ID
+            DataColumns.MIME_TYPE,  // MIME类型
+            DataColumns.CONTENT,    // 内容
+            DataColumns.DATA1,      // 扩展数据1
+            DataColumns.DATA3       // 扩展数据3
+    };
+
+    // 列索引常量
+    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 final 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 final ContentValues mDiffDataValues;
+
+    /**
+     * 构造函数（用于创建新数据）
+     * @param context 应用上下文
+     */
+    public SqlData(Context context) {
+        mContentResolver = context.getContentResolver();
+        mIsCreate = true;          // 标记为新创建
+        mDataId = INVALID_ID;      // 初始化无效ID
+        mDataMimeType = DataConstants.NOTE; // 默认MIME类型
+        mDataContent = "";         // 空内容
+        mDataContentData1 = 0;     // 默认扩展数据1
+        mDataContentData3 = "";    // 空扩展数据3
+        mDiffDataValues = new ContentValues(); // 初始化变更集合
+    }
+
+    /**
+     * 构造函数（基于Cursor加载已有数据）
+     * @param context 应用上下文
+     * @param c 数据库Cursor对象
+     */
+    public SqlData(Context context, Cursor c) {
+        mContentResolver = context.getContentResolver();
+        mIsCreate = false;         // 标记为已存在数据
+        loadFromCursor(c);         // 从Cursor加载数据
+        mDiffDataValues = new ContentValues(); // 初始化变更集合
+    }
+
+    /**
+     * 从Cursor加载数据
+     * @param c 数据库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);
+    }
+
+    /**
+     * 设置内容（从JSON对象）
+     * @param js 包含数据的JSON对象
+     * @throws JSONException JSON解析异常
+     */
+    public void setContent(JSONObject js) throws JSONException {
+        // 处理数据ID
+        long dataId = js.has(DataColumns.ID)  ? js.getLong(DataColumns.ID)  : INVALID_ID;
+        if (mIsCreate || mDataId != dataId) {
+            mDiffDataValues.put(DataColumns.ID,  dataId);
+        }
+        mDataId = dataId;
+
+        // 处理MIME类型
+        String dataMimeType = js.has(DataColumns.MIME_TYPE)  ? js.getString(DataColumns.MIME_TYPE)
+                : DataConstants.NOTE;
+        if (mIsCreate || !mDataMimeType.equals(dataMimeType))  {
+            mDiffDataValues.put(DataColumns.MIME_TYPE,  dataMimeType);
+        }
+        mDataMimeType = dataMimeType;
+
+        // 处理内容
+        String dataContent = js.has(DataColumns.CONTENT)  ? js.getString(DataColumns.CONTENT)  : "";
+        if (mIsCreate || !mDataContent.equals(dataContent))  {
+            mDiffDataValues.put(DataColumns.CONTENT,  dataContent);
+        }
+        mDataContent = dataContent;
+
+        // 处理扩展数据1
+        long dataContentData1 = js.has(DataColumns.DATA1)  ? js.getLong(DataColumns.DATA1)  : 0;
+        if (mIsCreate || mDataContentData1 != dataContentData1) {
+            mDiffDataValues.put(DataColumns.DATA1,  dataContentData1);
+        }
+        mDataContentData1 = dataContentData1;
+
+        // 处理扩展数据3
+        String dataContentData3 = js.has(DataColumns.DATA3)  ? js.getString(DataColumns.DATA3)  : "";
+        if (mIsCreate || !mDataContentData3.equals(dataContentData3))  {
+            mDiffDataValues.put(DataColumns.DATA3,  dataContentData3);
+        }
+        mDataContentData3 = dataContentData3;
+    }
+
+    /**
+     * 获取内容（转换为JSON对象）
+     * @return 包含数据的JSON对象
+     * @throws JSONException JSON构造异常
+     */
+    public JSONObject getContent() throws JSONException {
+        if (mIsCreate) {
+            Log.e(TAG, "it seems that we haven't created this in database yet");
+            return null;
+        }
+        // 构建JSON对象
+        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;
+    }
+
+    /**
+     * 提交数据到数据库
+     * @param noteId 关联的笔记ID
+     * @param validateVersion 是否验证版本
+     * @param version 版本号（当validateVersion为true时使用）
+     */
+    @RequiresApi(api = Build.VERSION_CODES.R)
+    public void commit(long noteId, boolean validateVersion, long version) {
+        // 处理新建数据的情况
+        if (mIsCreate) {
+            // 如果ID无效且有ID变更，移除无效ID
+            if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID))  {
+                mDiffDataValues.remove(DataColumns.ID);
+            }
+
+            // 设置关联笔记ID
+            mDiffDataValues.put(DataColumns.NOTE_ID,  noteId);
+            // 插入新数据
+            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI,  mDiffDataValues);
+            try {
+                // 从返回的URI中解析出新数据的ID
+                mDataId = Long.parseLong(Objects.requireNonNull(uri).getPathSegments().get(1));
+            } catch (NumberFormatException e) {
+                Log.e(TAG, "Get note id error :" + e);
+                throw new ActionFailureException("create note failed");
+            }
+        } else {
+            // 处理更新已有数据的情况
+            if (!mDiffDataValues.isEmpty())  {
+                int result;
+                if (!validateVersion) {
+                    // 不验证版本的普通更新
+                    result = mContentResolver.update(
+                            ContentUris.withAppendedId(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
+                                    + " WHERE " + NoteColumns.VERSION + "=?)",
+                            new String[] { String.valueOf(noteId),  String.valueOf(version)  }
+                    );
+                }
+                if (result == 0) {
+                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
+                }
+            }
+        }
+
+        // 重置状态
+        mDiffDataValues.clear();
+        mIsCreate = false;
+    }
+    /**
+     * 获取数据ID
+     * @return 数据ID
+     */
+    public long getId() {
+        return mDataId;
+    }
+}

src/Date/SqlNote.java

@@ -0,0 +1,628 @@
+/*
+ * 版权所有 (c) 2010-2011，MiCode 开源社区 (www.micode.net)
+ * 根据 Apache 许可证 2.0 版本（"许可证"）授权；
+ * 除非符合许可证的规定，否则不得使用本文件。
+ * 您可以从以下网址获取许可证副本：
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 除非适用法律要求或书面同意，本软件按"原样"分发，
+ * 没有任何明示或暗示的保证或条件。
+ * 详见许可证中规定的权限和限制。
+ * （注：这是一份标准的Apache许可证2.0版本的开源声明）
+ */
+
+// 定义当前类所在的包路径
+package net.micode.notes.gtask.data;
+// Android Widget相关类
+import android.appwidget.AppWidgetManager;   // 管理应用小部件
+// Android内容提供者相关类
+import android.content.ContentResolver;     // 内容解析器，用于访问ContentProvider
+import android.content.ContentValues;      // 键值对存储，用于数据库操作
+import android.content.Context;            // 应用上下文
+// Android数据库相关类
+import android.database.Cursor;            // 数据库查询结果集
+// Android网络相关类
+import android.net.Uri;                    // 通用资源标识符
+// Android系统相关类
+import android.os.Build;                   // 获取Android版本信息
+import android.util.Log;                  // 日志工具
+// AndroidX注解支持
+import androidx.annotation.RequiresApi;    // 版本要求注解
+// 笔记应用数据相关类
+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;   // Google Task字符串工具
+import net.micode.notes.tool.ResourceParser;     // 资源解析工具
+// JSON处理相关类
+import org.json.JSONArray;    // JSON数组处理
+import org.json.JSONException;  // JSON异常
+import org.json.JSONObject;   // JSON对象处理
+// Java集合类
+import java.util.ArrayList;   // 动态数组
+import java.util.Objects;     // 对象工具类
+
+// 定义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,             // 笔记ID
+            NoteColumns.ALERTED_DATE,   // 提醒日期
+            NoteColumns.BG_COLOR_ID,    // 背景颜色ID
+            NoteColumns.CREATED_DATE,   // 创建日期
+            NoteColumns.HAS_ATTACHMENT, // 是否有附件
+            NoteColumns.MODIFIED_DATE,  // 修改日期
+            NoteColumns.NOTES_COUNT,    // 子笔记数量
+            NoteColumns.PARENT_ID,      // 父笔记ID
+            NoteColumns.SNIPPET,        // 内容摘要
+            NoteColumns.TYPE,           // 笔记类型
+            NoteColumns.WIDGET_ID,      // 小部件ID
+            NoteColumns.WIDGET_TYPE,    // 小部件类型
+            NoteColumns.SYNC_ID,        // 同步ID
+            NoteColumns.LOCAL_MODIFIED, // 本地修改标记
+            NoteColumns.ORIGIN_PARENT_ID, // 原始父笔记ID
+            NoteColumns.GTASK_ID,       // Google任务ID
+            NoteColumns.VERSION         // 数据版本
+    };
+
+    // 列索引常量定义
+    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;      // 背景颜色列索引
+    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;         // Google任务ID列索引
+    public static final int VERSION_COLUMN = 16;          // 版本列索引
+
+    // 上下文对象
+    private final Context mContext;
+    // 内容解析器
+    private final ContentResolver mContentResolver;
+    // 是否为新建笔记标记
+    private boolean mIsCreate;
+
+    // 笔记字段
+    private long mId;                  // 笔记ID
+    private long mAlertDate;          // 提醒时间
+    private int mBgColorId;           // 背景颜色ID
+    private long mCreatedDate;        // 创建时间
+    private int mHasAttachment;      // 是否有附件(0/1)
+    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 final ContentValues mDiffNoteValues;
+    // 笔记关联的数据列表
+    private final ArrayList<SqlData> mDataList;
+
+    /**
+     * 构造函数（用于创建新笔记）
+     * @param context 应用上下文
+     */
+    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; // 无效小部件ID
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 无效小部件类型
+        mOriginParent = 0;
+        mVersion = 0;
+        mDiffNoteValues = new ContentValues(); // 初始化变更值容器
+        mDataList = new ArrayList<>(); // 初始化数据列表
+    }
+
+    /**
+     * 构造函数（基于Cursor加载已有笔记）
+     * @param context 应用上下文
+     * @param c 数据库Cursor
+     */
+    public SqlNote(Context context, Cursor c) {
+        mContext = context;
+        mContentResolver = context.getContentResolver();
+        mIsCreate = false; // 标记为已有笔记
+        loadFromCursor(c); // 从Cursor加载数据
+        mDataList = new ArrayList<>();
+        // 如果是普通笔记类型，加载关联数据
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+        mDiffNoteValues = new ContentValues();
+    }
+
+    /**
+     * 构造函数（基于笔记ID加载）
+     * @param context 应用上下文
+     * @param id 笔记ID
+     */
+    public SqlNote(Context context, long id) {
+        mContext = context;
+        mContentResolver = context.getContentResolver();
+        mIsCreate = false; // 标记为已有笔记
+        loadFromCursor(id); // 通过ID加载笔记
+        mDataList = new ArrayList<>();
+        // 如果是普通笔记类型，加载关联数据
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+        mDiffNoteValues = new ContentValues();
+    }
+
+    /**
+     * 通过笔记ID从数据库加载数据
+     * @param id 笔记ID
+     */
+    private void loadFromCursor(long id) {
+        // 使用try-with-resources确保Cursor自动关闭
+        try (Cursor c = mContentResolver.query(
+                Notes.CONTENT_NOTE_URI, // 笔记内容URI
+                PROJECTION_NOTE,       // 查询列
+                "(_id=?)",             // 查询条件
+                new String[]{ String.valueOf(id)  }, // 参数
+                null)) {               // 排序
+            if (c != null) {
+                c.moveToNext();  // 移动到第一行
+                loadFromCursor(c); // 从Cursor加载数据
+            } else {
+                Log.w(TAG, "loadFromCursor: cursor = null");
+            }
+        }
+    }
+
+    /**
+     * 从Cursor加载笔记数据
+     * @param c 数据库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);
+    }
+
+    /**
+     * 加载笔记关联的数据内容
+     */
+    private void loadDataContent() {
+        mDataList.clear();  // 清空现有数据
+        // 查询关联数据
+        try (Cursor c = mContentResolver.query(
+                Notes.CONTENT_DATA_URI,  // 数据内容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;
+                }
+                // 遍历所有数据行
+                while (c.moveToNext())  {
+                    SqlData data = new SqlData(mContext, c); // 创建数据对象
+                    mDataList.add(data);  // 添加到列表
+                }
+            } else {
+                Log.w(TAG, "loadDataContent: cursor = null");
+            }
+        }
+    }
+
+    /**
+     * 从JSON设置笔记内容
+     * @param js 包含笔记数据的JSON对象
+     * @return 是否设置成功
+     */
+    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) {
+                // 只能更新摘要和类型
+                String snippet = note.has(NoteColumns.SNIPPET)  ?
+                        note.getString(NoteColumns.SNIPPET)  : "";
+                if (mIsCreate || !mSnippet.equals(snippet))  {
+                    mDiffNoteValues.put(NoteColumns.SNIPPET,  snippet);
+                }
+                mSnippet = snippet;
+
+                int type = note.has(NoteColumns.TYPE)  ?
+                        note.getInt(NoteColumns.TYPE)  : Notes.TYPE_NOTE;
+                if (mIsCreate || mType != type) {
+                    mDiffNoteValues.put(NoteColumns.TYPE,  type);
+                }
+                mType = type;
+            }
+            // 处理普通笔记类型
+            else if (note.getInt(NoteColumns.TYPE)  == Notes.TYPE_NOTE) {
+                // 获取关联数据数组
+                JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+
+                // 处理笔记ID
+                long id = note.has(NoteColumns.ID)  ? note.getLong(NoteColumns.ID)  : INVALID_ID;
+                if (mIsCreate || mId != id) {
+                    mDiffNoteValues.put(NoteColumns.ID,  id);
+                }
+                mId = id;
+
+                // 处理提醒日期
+                long alertDate = note.has(NoteColumns.ALERTED_DATE)  ?
+                        note.getLong(NoteColumns.ALERTED_DATE)  : 0;
+                if (mIsCreate || mAlertDate != alertDate) {
+                    mDiffNoteValues.put(NoteColumns.ALERTED_DATE,  alertDate);
+                }
+                mAlertDate = alertDate;
+
+                // 处理背景颜色
+                int bgColorId = note.has(NoteColumns.BG_COLOR_ID)  ?
+                        note.getInt(NoteColumns.BG_COLOR_ID)  : ResourceParser.getDefaultBgId(mContext);
+                if (mIsCreate || mBgColorId != bgColorId) {
+                    mDiffNoteValues.put(NoteColumns.BG_COLOR_ID,  bgColorId);
+                }
+                mBgColorId = bgColorId;
+
+                // 处理创建日期
+                long createDate = note.has(NoteColumns.CREATED_DATE)  ?
+                        note.getLong(NoteColumns.CREATED_DATE)  : System.currentTimeMillis();
+                if (mIsCreate || mCreatedDate != createDate) {
+                    mDiffNoteValues.put(NoteColumns.CREATED_DATE,  createDate);
+                }
+                mCreatedDate = createDate;
+
+                // 处理附件标记
+                int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT)  ?
+                        note.getInt(NoteColumns.HAS_ATTACHMENT)  : 0;
+                if (mIsCreate || mHasAttachment != hasAttachment) {
+                    mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT,  hasAttachment);
+                }
+                mHasAttachment = hasAttachment;
+
+                // 处理修改日期
+                long modifiedDate = note.has(NoteColumns.MODIFIED_DATE)  ?
+                        note.getLong(NoteColumns.MODIFIED_DATE)  : System.currentTimeMillis();
+                if (mIsCreate || mModifiedDate != modifiedDate) {
+                    mDiffNoteValues.put(NoteColumns.MODIFIED_DATE,  modifiedDate);
+                }
+                mModifiedDate = modifiedDate;
+
+                // 处理父笔记ID
+                long parentId = note.has(NoteColumns.PARENT_ID)  ?
+                        note.getLong(NoteColumns.PARENT_ID)  : 0;
+                if (mIsCreate || mParentId != parentId) {
+                    mDiffNoteValues.put(NoteColumns.PARENT_ID,  parentId);
+                }
+                mParentId = parentId;
+
+                // 处理内容摘要
+                String snippet = note.has(NoteColumns.SNIPPET)  ?
+                        note.getString(NoteColumns.SNIPPET)  : "";
+                if (mIsCreate || !mSnippet.equals(snippet))  {
+                    mDiffNoteValues.put(NoteColumns.SNIPPET,  snippet);
+                }
+                mSnippet = snippet;
+
+                // 处理笔记类型
+                int type = note.has(NoteColumns.TYPE)  ?
+                        note.getInt(NoteColumns.TYPE)  : Notes.TYPE_NOTE;
+                if (mIsCreate || mType != type) {
+                    mDiffNoteValues.put(NoteColumns.TYPE,  type);
+                }
+                mType = type;
+
+                // 处理小部件ID
+                int widgetId = note.has(NoteColumns.WIDGET_ID)  ?
+                        note.getInt(NoteColumns.WIDGET_ID)  : AppWidgetManager.INVALID_APPWIDGET_ID;
+                if (mIsCreate || mWidgetId != widgetId) {
+                    mDiffNoteValues.put(NoteColumns.WIDGET_ID,  widgetId);
+                }
+                mWidgetId = widgetId;
+
+                // 处理小部件类型
+                int widgetType = note.has(NoteColumns.WIDGET_TYPE)  ?
+                        note.getInt(NoteColumns.WIDGET_TYPE)  : Notes.TYPE_WIDGET_INVALIDE;
+                if (mIsCreate || mWidgetType != widgetType) {
+                    mDiffNoteValues.put(NoteColumns.WIDGET_TYPE,  widgetType);
+                }
+                mWidgetType = widgetType;
+
+                // 处理原始父笔记ID
+                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;
+                                break;
+                            }
+                        }
+                    }
+
+                    // 如果不存在则创建新数据
+                    if (sqlData == null) {
+                        sqlData = new SqlData(mContext);
+                        mDataList.add(sqlData);
+                    }
+
+                    // 设置数据内容
+                    sqlData.setContent(data);
+                }
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * 获取笔记内容的JSON表示
+     * @return JSON对象，包含笔记数据
+     */
+    public JSONObject getContent() {
+        try {
+            JSONObject js = new JSONObject();
+
+            // 检查是否已创建
+            if (mIsCreate) {
+                Log.e(TAG, "it seems that we haven't created this in database yet");
+                return 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);
+                    }
+                }
+                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);
+            }
+
+            return js;
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    /**
+     * 设置父笔记ID
+     * @param id 父笔记ID
+     */
+    public void setParentId(long id) {
+        mParentId = id;
+        mDiffNoteValues.put(NoteColumns.PARENT_ID,  id);
+    }
+
+    /**
+     * 设置Google任务ID
+     * @param gid Google任务ID
+     */
+    public void setGtaskId(String gid) {
+        mDiffNoteValues.put(NoteColumns.GTASK_ID,  gid);
+    }
+
+    /**
+     * 设置同步ID
+     * @param syncId 同步ID
+     */
+    public void setSyncId(long syncId) {
+        mDiffNoteValues.put(NoteColumns.SYNC_ID,  syncId);
+    }
+
+    /**
+     * 重置本地修改标记
+     */
+    public void resetLocalModified() {
+        mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED,  0);
+    }
+
+    /**
+     * 获取笔记ID
+     * @return 笔记ID
+     */
+    public long getId() {
+        return mId;
+    }
+
+    /**
+     * 获取父笔记ID
+     * @return 父笔记ID
+     */
+    public long getParentId() {
+        return mParentId;
+    }
+
+    /**
+     * 获取内容摘要
+     * @return 内容摘要
+     */
+    public String getSnippet() {
+        return mSnippet;
+    }
+
+    /**
+     * 检查是否为普通笔记类型
+     * @return 如果是普通笔记返回true
+     */
+    public boolean isNoteType() {
+        return mType == Notes.TYPE_NOTE;
+    }
+
+    /**
+     * 提交笔记数据到数据库
+     * @param validateVersion 是否验证版本
+     */
+    @RequiresApi(api = Build.VERSION_CODES.R)
+    public void commit(boolean validateVersion) {
+        // 处理新建笔记
+        if (mIsCreate) {
+            // 如果ID无效且有ID变更，移除无效ID
+            if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID))  {
+                mDiffNoteValues.remove(NoteColumns.ID);
+            }
+
+            // 插入新笔记
+            Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI,  mDiffNoteValues);
+            try {
+                // 从返回的URI中解析出新笔记ID
+                mId = Long.parseLong(Objects.requireNonNull(uri).getPathSegments().get(1));
+            } catch (NumberFormatException e) {
+                Log.e(TAG, "Get note id error :" + e.toString());
+                throw new ActionFailureException("create note failed");
+            }
+
+            // 检查是否创建成功
+            if (mId == 0) {
+                throw new IllegalStateException("Create thread id failed");
+            }
+
+            // 如果是普通笔记，提交关联数据
+            if (mType == Notes.TYPE_NOTE) {
+                for (SqlData sqlData : mDataList) {
+                    sqlData.commit(mId,  false, -1);
+                }
+            }
+        }
+        // 处理已有笔记更新
+        else {
+            // 检查笔记ID有效性
+            if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
+                Log.e(TAG, "No such note");
+                throw new IllegalStateException("Try to update note with invalid id");
+            }
+
+            // 如果有变更值
+            if (!mDiffNoteValues.isEmpty())  {
+                mVersion++; // 版本号递增
+                int result = 0;
+
+                // 根据是否验证版本执行不同的更新
+                if (!validateVersion) {
+                    // 普通更新
+                    result = mContentResolver.update(
+                            Notes.CONTENT_NOTE_URI,
+                            mDiffNoteValues,
+                            "(" + NoteColumns.ID + "=?)",
+                            new String[]{ String.valueOf(mId)  }
+                    );
+                } else {
+                    // 带版本验证的更新
+                    result = mContentResolver.update(
+                            Notes.CONTENT_NOTE_URI,
+                            mDiffNoteValues,
+                            "(" + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
+                            new String[]{ String.valueOf(mId),  String.valueOf(mVersion)  }
+                    );
+                }
+
+                // 检查更新结果
+                if (result == 0) {
+                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
+                }
+            }
+
+            // 如果是普通笔记，提交关联数据
+            if (mType == Notes.TYPE_NOTE) {
+                for (SqlData sqlData : mDataList) {
+                    sqlData.commit(mId,  validateVersion, mVersion);
+                }
+            }
+        }
+
+        // 刷新本地数据
+        loadFromCursor(mId);
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+
+        // 重置状态
+        mDiffNoteValues.clear();
+        mIsCreate = false;
+    }
+}

src/Date/Task.java

@@ -0,0 +1,454 @@
+/*
+ * 版权所有 (c) 2010-2011，MiCode 开源社区 (www.micode.net)
+ * 根据 Apache 许可证 2.0 版本（"许可证"）授权；
+ * 除非符合许可证的规定，否则不得使用本文件。
+ * 您可以从以下网址获取许可证副本：
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 除非适用法律要求或书面同意，本软件按"原样"分发，
+ * 没有任何明示或暗示的保证或条件。
+ * 详见许可证中规定的权限和限制。
+ * （注：这是一份标准的Apache许可证2.0版本的开源声明）
+ */
+
+// 定义当前类所在的包路径
+package net.micode.notes.gtask.data;
+
+// Android数据库相关类
+import android.database.Cursor;        // 数据库查询结果集
+// Android文本处理工具
+import android.text.TextUtils;         // 字符串处理工具类
+// Android日志工具
+import android.util.Log;               // 日志记录工具
+
+// 笔记应用数据相关常量
+import androidx.annotation.NonNull;
+
+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;  // 同步操作失败异常
+
+// Google Task工具类
+import net.micode.notes.tool.GTaskStringUtils;  // Google Task字符串工具
+
+// JSON处理相关类
+import org.json.JSONArray;     // JSON数组处理
+import org.json.JSONException;  // JSON异常处理
+import org.json.JSONObject;    // JSON对象处理
+
+// Java工具类
+import java.util.Objects;      // 对象工具类
+// Task类继承自Node基类，表示Google Task中的一个任务项 
+public class Task extends Node {
+    // 日志标签 
+    private static final String TAG = Task.class.getSimpleName();
+
+    // 任务状态字段 
+    private boolean mCompleted;    // 任务是否已完成 
+    private String mNotes;         // 任务备注/描述信息 
+    private JSONObject mMetaInfo;  // 存储元信息的JSON对象 
+
+    // 任务关系字段 
+    private Task mPriorSibling;    // 前一个兄弟任务（用于排序）
+    private TaskList mParent;      // 所属任务列表 
+
+    // 默认构造函数 
+    public Task() {
+        super();  // 调用父类构造函数 
+        mCompleted = false;    // 默认未完成 
+        mNotes = null;         // 默认无备注 
+        mPriorSibling = null;  // 默认无前驱任务 
+        mParent = null;        // 默认无父列表 
+        mMetaInfo = null;      // 默认无元信息 
+    }
+
+    /**
+     * 生成创建任务的JSON动作 
+     * @param actionId 动作ID 
+     * @return 包含创建任务数据的JSON对象
+     */
+    public JSONObject getCreateAction(int actionId) {
+        JSONObject js = new JSONObject();
+
+        try {
+            // 设置动作类型为创建 
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
+
+            // 设置动作ID 
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID,  actionId);
+
+            // 设置任务索引位置 
+            js.put(GTaskStringUtils.GTASK_JSON_INDEX,  mParent.getChildTaskIndex(this));
+
+            // 构建任务实体数据 
+            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_TASK);  // 实体类型设为任务 
+            // 如果有备注则添加 
+            if (getNotes() != null) {
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES,  getNotes());
+            }
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA,  entity);  // 添加实体数据 
+
+            // 设置父任务列表ID 
+            js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID,  mParent.getGid());
+
+            // 设置目标父类型为组 
+            js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
+
+            // 设置列表ID 
+            js.put(GTaskStringUtils.GTASK_JSON_LIST_ID,  mParent.getGid());
+
+            // 如果有前驱任务则设置其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("生成任务创建JSON对象失败");
+        }
+
+        return js;
+    }
+
+    /**
+     * 生成更新任务的JSON动作 
+     * @param actionId 动作ID 
+     * @return 包含更新数据的JSON对象
+     */
+    public JSONObject getUpdateAction(int actionId) {
+        JSONObject js = new JSONObject();
+
+        try {
+            // 设置动作类型为更新 
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
+
+            // 设置动作ID 
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID,  actionId);
+
+            // 设置任务全局ID 
+            js.put(GTaskStringUtils.GTASK_JSON_ID,  getGid());
+
+            // 构建更新数据 
+            JSONObject entity = new JSONObject();
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME,  getName());  // 更新名称 
+            // 如果有备注则更新 
+            if (getNotes() != null) {
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES,  getNotes());
+            }
+            // 设置删除状态 
+            entity.put(GTaskStringUtils.GTASK_JSON_DELETED,  getDeleted());
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA,  entity);  // 添加更新数据 
+
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("生成任务更新JSON对象失败");
+        }
+
+        return js;
+    }
+
+    /**
+     * 从远程JSON数据设置任务内容 
+     * @param js 包含远程数据的JSON对象 
+     */
+    public void setContentByRemoteJSON(JSONObject js) {
+        if (js != null) {
+            try {
+                // 设置任务ID 
+                if (js.has(GTaskStringUtils.GTASK_JSON_ID))  {
+                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
+                }
+
+                // 设置最后修改时间 
+                if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED))  {
+                    setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
+                }
+
+                // 设置任务名称 
+                if (js.has(GTaskStringUtils.GTASK_JSON_NAME))  {
+                    setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
+                }
+
+                // 设置任务备注 
+                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) {
+                Log.e(TAG, e.toString());
+                e.printStackTrace();
+                throw new ActionFailureException("从JSON获取任务内容失败");
+            }
+        }
+    }
+
+    /**
+     * 从本地JSON数据设置任务内容 
+     * @param js 包含本地数据的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: 无可用数据");
+        }
+
+        try {
+            JSONObject note = Objects.requireNonNull(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, "无效的类型");
+                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;
+                }
+            }
+
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * 从任务内容生成本地JSON格式 
+     * @return 包含任务数据的JSON对象
+     */
+    public JSONObject getLocalJSONFromContent() {
+        String name = getName();
+        try {
+            if (mMetaInfo == null) {
+                // 从网页端创建的新任务 
+                if (name == null) {
+                    Log.w(TAG, "笔记内容为空");
+                    return null;
+                }
+
+                // 构建新的JSON结构 
+                return getJsonObject(name);
+            } 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_NOTE);  // 确保类型正确 
+                return mMetaInfo;  // 返回修改后的元信息 
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    @NonNull
+    private static JSONObject getJsonObject(String name) throws JSONException {
+        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;
+    }
+
+    /**
+     * 设置任务元信息 
+     * @param metaData 元数据对象 
+     */
+    public void setMetaInfo(MetaData metaData) {
+        if (metaData != null && metaData.getNotes()  != null) {
+            try {
+                // 将元数据中的notes字符串转换为JSON对象 
+                mMetaInfo = new JSONObject(metaData.getNotes());
+            } catch (JSONException e) {
+                Log.w(TAG, e.toString());
+                mMetaInfo = null;
+            }
+        }
+    }
+
+    /**
+     * 获取同步动作类型 
+     * @param c 数据库Cursor 
+     * @return 同步动作常量
+     */
+    public int getSyncAction(Cursor c) {
+        try {
+            JSONObject noteInfo = null;
+            // 检查元信息中是否有笔记头 
+            if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE))  {
+                noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            }
+
+            if (noteInfo == null) {
+                Log.w(TAG, "笔记元信息似乎已被删除");
+                return SYNC_ACTION_UPDATE_REMOTE;  // 需要从远程更新 
+            }
+
+            if (!noteInfo.has(NoteColumns.ID))  {
+                Log.w(TAG, "远程笔记ID似乎已被删除");
+                return SYNC_ACTION_UPDATE_LOCAL;  // 需要更新本地 
+            }
+
+            // 验证笔记ID是否匹配 
+            if (c.getLong(SqlNote.ID_COLUMN)  != noteInfo.getLong(NoteColumns.ID))  {
+                Log.w(TAG, "笔记ID不匹配");
+                return SYNC_ACTION_UPDATE_LOCAL;
+            }
+
+            if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN)  == 0) {
+                // 本地无修改 
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN)  == getLastModified()) {
+                    // 双方都无更新 
+                    return SYNC_ACTION_NONE;
+                } else {
+                    // 应用远程修改到本地 
+                    return SYNC_ACTION_UPDATE_LOCAL;
+                }
+            } else {
+                // 验证任务ID是否匹配 
+                if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid()))  {
+                    Log.e(TAG, "任务ID不匹配");
+                    return SYNC_ACTION_ERROR;
+                }
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN)  == getLastModified()) {
+                    // 仅本地有修改 
+                    return SYNC_ACTION_UPDATE_REMOTE;
+                } else {
+                    // 存在冲突 
+                    return SYNC_ACTION_UPDATE_CONFLICT;
+                }
+            }
+        } catch (Exception e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+
+        return SYNC_ACTION_ERROR;  // 默认返回错误 
+    }
+
+    /*
+     * 检查任务是否值得保存 
+     * @return 如果有有效数据返回true
+     */
+    /**
+     * 检查当前任务对象是否包含有效数据，值得保存
+     * 满足以下任一条件即认为值得保存：
+     * 1. 存在元信息数据 或
+     * 2. 任务名称非空且不为纯空格 或
+     * 3. 任务备注非空且不为纯空格
+     *
+     * @return 如果包含有效数据返回true，否则false
+     */
+    public boolean isWorthSaving() {
+        return mMetaInfo != null ||                                   // 存在元信息
+                (getName() != null && !getName().trim().isEmpty()) || // 有有效名称
+                (getNotes() != null && !getNotes().trim().isEmpty()); // 有有效备注
+    }
+
+    /**
+     * 设置任务完成状态
+     * @param completed true表示任务已完成，false表示未完成
+     */
+    public void setCompleted(boolean completed) {
+        this.mCompleted = completed;  // 更新完成状态字段
+    }
+
+    /**
+     * 设置任务备注内容
+     * @param notes 要设置的备注文本，可为null表示清空备注
+     */
+    public void setNotes(String notes) {
+        this.mNotes = notes;  // 更新备注字段
+    }
+
+    /**
+     * 设置前驱任务（用于任务排序）
+     * @param priorSibling 前一个任务节点，可为null表示没有前驱
+     */
+    public void setPriorSibling(Task priorSibling) {
+        this.mPriorSibling = priorSibling;  // 更新前驱任务引用
+    }
+
+    /**
+     * 设置所属任务列表
+     * @param parent 父任务列表对象，不可为null
+     */
+    public void setParent(TaskList parent) {
+        this.mParent = parent;  // 更新父列表引用
+    }
+
+    /**
+     * 获取任务完成状态
+     * @return true表示任务已完成，false表示未完成
+     */
+    public boolean getCompleted() {
+        return this.mCompleted;  // 返回当前完成状态
+    }
+
+    /**
+     * 获取任务备注内容
+     * @return 备注文本，可能为null表示无备注
+     */
+    public String getNotes() {
+        return this.mNotes;  // 返回当前备注内容
+    }
+
+    /**
+     * 获取前驱任务（用于任务排序）
+     * @return 前一个任务节点，可能为null表示没有前驱
+     */
+    public Task getPriorSibling() {
+        return this.mPriorSibling;  // 返回前驱任务引用
+    }
+
+    /**
+     * 获取所属任务列表
+     * @return 父任务列表对象
+     */
+    public TaskList getParent() {
+        return this.mParent;  // 返回父列表引用
+    }
+}

src/Date/TaskList.java

@@ -0,0 +1,435 @@
+/*
+ * 版权所有 (c) 2010-2011，MiCode 开源社区 (www.micode.net)
+ * 根据 Apache 许可证 2.0 版本（"许可证"）授权；
+ * 除非符合许可证的规定，否则不得使用本文件。
+ * 您可以从以下网址获取许可证副本：
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 除非适用法律要求或书面同意，本软件按"原样"分发，
+ * 没有任何明示或暗示的保证或条件。
+ * 详见许可证中规定的权限和限制。
+ * （注：这是一份标准的Apache许可证2.0版本的开源声明）
+ */
+// 声明当前类所在的包路径，属于笔记应用的Google任务数据模块
+package net.micode.notes.gtask.data;
+// 导入Android数据库相关类
+import android.database.Cursor;        // 用于操作和遍历数据库查询结果集
+import android.util.Log;              // Android日志工具类
+// 导入笔记应用的核心数据类
+import net.micode.notes.data.Notes;   // 笔记数据常量类
+import net.micode.notes.data.Notes.NoteColumns;   // 笔记表列名常量
+// 导入异常处理类
+import net.micode.notes.gtask.exception.ActionFailureException;
+// 当Google任务操作失败时抛出的自定义异常
+// 导入Google任务字符串处理工具类
+import net.micode.notes.tool.GTaskStringUtils;
+// 包含Google任务API使用的JSON键名常量
+// 导入JSON处理相关类
+import org.json.JSONException;   // JSON解析异常类
+import org.json.JSONObject;      // JSON对象操作类
+// 导入Java工具类
+import java.util.ArrayList;      // 动态数组集合
+import java.util.Objects;        // 对象操作工具类（判空等）
+// 继承自Node基类，表示Google Tasks中的任务列表
+public class TaskList extends Node {
+    // 日志标签，使用类名作为标识
+    private static final String TAG = TaskList.class.getSimpleName();
+    // 任务列表的排序索引
+    private int mIndex;
+    // 存储子任务的动态数组
+    private final ArrayList<Task> mChildren;
+    // 构造函数
+    public TaskList() {
+        super();  // 调用父类Node的构造函数
+        mChildren = new ArrayList<>();  // 初始化子任务列表
+        mIndex = 1;  // 默认索引从1开始
+    }
+    /**
+     * 生成创建任务列表的JSON动作
+     * @param actionId 动作ID（用于标识操作序列）
+     * @return 包含创建命令的JSON对象
+     * @throws ActionFailureException 当JSON操作失败时抛出
+     */
+    public JSONObject getCreateAction(int actionId) {
+        JSONObject js = new JSONObject();
+
+        try {
+            // 设置动作类型为"create"
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
+
+            // 设置动作ID
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID,  actionId);
+
+            // 设置任务列表索引
+            js.put(GTaskStringUtils.GTASK_JSON_INDEX,  mIndex);
+
+            // 构建实体数据对象
+            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);  // 实体类型设为"group"
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA,  entity);  // 添加实体数据
+
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("生成任务列表创建JSON失败");
+        }
+
+        return js;
+    }
+
+    /**
+     * 生成更新任务列表的JSON动作
+     * @param actionId 动作ID
+     * @return 包含更新命令的JSON对象
+     */
+    public JSONObject getUpdateAction(int actionId) {
+        JSONObject js = new JSONObject();
+
+        try {
+            // 设置动作类型为"update"
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
+
+            // 设置动作ID
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID,  actionId);
+
+            // 设置任务列表全局ID
+            js.put(GTaskStringUtils.GTASK_JSON_ID,  getGid());
+
+            // 构建更新数据对象
+            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("生成任务列表更新JSON失败");
+        }
+
+        return js;
+    }
+
+    /**
+     * 从远程JSON数据设置任务列表内容
+     * @param js 包含远程数据的JSON对象
+     * @throws ActionFailureException 当JSON解析失败时抛出
+     */
+    public void setContentByRemoteJSON(JSONObject js) {
+        if (js != null) {
+            try {
+                // 设置任务列表ID
+                if (js.has(GTaskStringUtils.GTASK_JSON_ID))  {
+                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
+                }
+
+                // 设置最后修改时间戳
+                if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED))  {
+                    setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
+                }
+
+                // 设置任务列表名称
+                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("从JSON解析任务列表内容失败");
+            }
+        }
+    }
+
+    /**
+     * 从本地JSON数据设置任务列表内容
+     * @param js 包含本地数据的JSON对象
+     */
+    public void setContentByLocalJSON(JSONObject js) {
+        // 检查数据有效性
+        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE))  {
+            Log.w(TAG, "setContentByLocalJSON: 无可用数据");
+            return;
+        }
+
+        try {
+            JSONObject folder = Objects.requireNonNull(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);  // 添加MIUI前缀
+            }
+            // 处理系统文件夹类型
+            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, "无效的系统文件夹");
+                }
+            } else {
+                Log.e(TAG, "错误的类型");
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * 从任务列表内容生成本地JSON格式
+     * @return 包含任务列表数据的JSON对象，失败返回null
+     */
+    public JSONObject getLocalJSONFromContent() {
+        try {
+            JSONObject js = new JSONObject();
+            JSONObject folder = new JSONObject();
+
+            // 处理文件夹名称（移除MIUI前缀）
+            String folderName = getName();
+            if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)) {
+                folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.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;
+        }
+    }
+
+    /**
+     * 获取同步动作类型
+     * @param c 数据库Cursor对象，包含本地数据
+     * @return 同步动作常量（SYNC_ACTION_*）
+     */
+    public int getSyncAction(Cursor c) {
+        try {
+            // 检查本地是否有修改
+            if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN)  == 0) {
+                // 无本地修改时
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN)  == getLastModified()) {
+                    return SYNC_ACTION_NONE;  // 双方数据一致
+                } else {
+                    return SYNC_ACTION_UPDATE_LOCAL;  // 需要更新本地
+                }
+            } else {
+                // 有本地修改时验证任务ID
+                if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid()))  {
+                    Log.e(TAG, "任务ID不匹配");
+                    return SYNC_ACTION_ERROR;
+                }
+                return SYNC_ACTION_UPDATE_REMOTE;  // 需要更新远程
+            }
+        } catch (Exception e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+        return SYNC_ACTION_ERROR;  // 默认返回错误
+    }
+
+    // 以下是子任务管理方法
+
+    /**
+     * 获取子任务数量
+     * @return 当前子任务总数
+     */
+    public int getChildTaskCount() {
+        return mChildren.size();
+    }
+
+    /**
+     * 添加子任务到列表末尾
+     * @param task 要添加的子任务
+     * @return 是否添加成功
+     */
+    public boolean addChildTask(Task task) {
+        boolean ret = false;
+        if (task != null && !mChildren.contains(task))  {
+            ret = mChildren.add(task);
+            if (ret) {
+                // 设置前驱任务和父列表
+                task.setPriorSibling(mChildren.get(mChildren.size()  - 1));
+                task.setParent(this);
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * 在指定位置添加子任务
+     * @param task 要添加的子任务
+     * @param index 插入位置
+     * @return 是否添加成功
+     */
+    public boolean addChildTask(Task task, int index) {
+        // 检查索引有效性
+        if (index < 0 || index > mChildren.size())  {
+            Log.e(TAG, "添加子任务：无效的索引");
+            return false;
+        }
+
+        // 检查任务是否已存在
+        int pos = mChildren.indexOf(task);
+        if (task != null && pos == -1) {
+            mChildren.add(index,  task);
+
+            // 更新任务链关系
+            Task preTask = (index != 0) ? mChildren.get(index  - 1) : null;
+            Task afterTask = (index != mChildren.size()  - 1) ? mChildren.get(index  + 1) : null;
+
+            task.setPriorSibling(preTask);
+            if (afterTask != null) {
+                afterTask.setPriorSibling(task);
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * 移除指定子任务
+     * @param task 要移除的子任务
+     * @return 是否移除成功
+     */
+    public boolean removeChildTask(Task task) {
+        boolean ret = false;
+        int index = mChildren.indexOf(task);
+        if (index != -1) {
+            ret = mChildren.remove(task);
+
+            if (ret) {
+                // 重置被移除任务的关系
+                task.setPriorSibling(null);
+                task.setParent(null);
+
+                // 更新剩余任务的关系
+                if (index < mChildren.size())  {
+                    mChildren.get(index).setPriorSibling(
+                            (index == 0) ? null : mChildren.get(index  - 1));
+                }
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * 移动子任务到新位置
+     * @param task 要移动的子任务
+     * @param index 目标位置
+     * @return 是否移动成功
+     */
+    public boolean moveChildTask(Task task, int index) {
+        // 检查索引有效性
+        if (index < 0 || index >= mChildren.size())  {
+            Log.e(TAG, "移动子任务：无效的索引");
+            return false;
+        }
+
+        int pos = mChildren.indexOf(task);
+        if (pos == -1) {
+            Log.e(TAG, "移动子任务：任务不在列表中");
+            return false;
+        }
+
+        if (pos == index) {
+            return true;  // 位置未改变
+        }
+
+        // 先移除再添加实现移动
+        return (removeChildTask(task) && addChildTask(task, index));
+    }
+
+    // 以下是查询方法
+
+    /**
+     * 通过GID查找子任务
+     * @param gid 要查找的任务全局ID
+     * @return 找到的任务对象，未找到返回null
+     */
+    public Task findChildTaskByGid(String gid) {
+        for (Task t : mChildren) {
+            if (t.getGid().equals(gid))  {
+                return t;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 获取子任务索引
+     * @param task 要查询的子任务
+     * @return 索引位置，不存在返回-1
+     */
+    public int getChildTaskIndex(Task task) {
+        return mChildren.indexOf(task);
+    }
+
+    /**
+     * 通过索引获取子任务
+     * @param index 要获取的索引
+     * @return 子任务对象，索引无效返回null
+     */
+    public Task getChildTaskByIndex(int index) {
+        if (index < 0 || index >= mChildren.size())  {
+            Log.e(TAG, "getTaskByIndex: 无效的索引");
+            return null;
+        }
+        return mChildren.get(index);
+    }
+
+    /**
+     * 通过GID获取子任务（别名方法）
+     * @param gid 要查找的任务全局ID
+     * @return 找到的任务对象，未找到返回null
+     */
+    public Task getChilTaskByGid(String gid) {
+        return findChildTaskByGid(gid);
+    }
+
+    /**
+     * 获取所有子任务列表
+     * @return 子任务ArrayList（注意：返回的是引用）
+     */
+    public ArrayList<Task> getChildTaskList() {
+        return this.mChildren;
+    }
+
+    // 以下是索引属性的getter/setter
+
+    /**
+     * 设置任务列表索引
+     * @param index 新的索引值
+     */
+    public void setIndex(int index) {
+        this.mIndex = index;
+    }
+
+    /**
+     * 获取当前索引
+     * @return 当前索引值
+     */
+    public int getIndex() {
+        return this.mIndex;
+    }
+}

src/model/Note.java

@@ -0,0 +1,268 @@
+/*
+ * 便签数据模型类，处理便签的创建、更新及数据同步到数据库的操作
+ */
+package net.micode.notes.model;
+
+import android.content.ContentProviderOperation;
+import android.content.ContentProviderResult;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.OperationApplicationException;
+import android.net.Uri;
+import android.os.RemoteException;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.CallNote;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.Notes.TextNote;
+
+import java.util.ArrayList;
+
+public class Note {
+    // 存储便签元数据变化的键值对（如修改时间、父目录等）
+    private ContentValues mNoteDiffValues;
+    // 处理便签具体数据内容（文本、通话记录等）
+    private NoteData mNoteData;
+    // 日志标签
+    private static final String TAG = "Note";
+
+    /**
+     * 在指定文件夹下创建新便签并返回其ID
+     * @param context 上下文对象
+     * @param folderId 父文件夹ID
+     * @return 新创建的便签ID（大于0）
+     * @throws IllegalStateException 若插入失败返回-1时抛出
+     */
+    public static synchronized long getNewNoteId(Context context, long folderId) {
+        ContentValues values = new ContentValues();
+        long createdTime = System.currentTimeMillis();
+        // 设置基本属性
+        values.put(NoteColumns.CREATED_DATE, createdTime);
+        values.put(NoteColumns.MODIFIED_DATE, createdTime);
+        values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+        values.put(NoteColumns.LOCAL_MODIFIED, 1); // 标记为本地已修改
+        values.put(NoteColumns.PARENT_ID, folderId);
+
+        // 插入新便签到数据库
+        Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
+
+        // 解析返回的URI获取便签ID
+        long noteId = 0;
+        try {
+            noteId = Long.parseLong(uri.getPathSegments().get(1));
+        } catch (NumberFormatException e) {
+            Log.e(TAG, "解析便签ID异常: " + e);
+            noteId = 0;
+        }
+        if (noteId == -1) {
+            throw new IllegalStateException("无效的便签ID: " + noteId);
+        }
+        return noteId;
+    }
+
+    /**
+     * 构造函数，初始化数据存储对象
+     */
+    public Note() {
+        mNoteDiffValues = new ContentValues();
+        mNoteData = new NoteData();
+    }
+
+    /**
+     * 设置便签元数据字段值
+     * @param key 字段名（NoteColumns中的常量）
+     * @param value 要设置的值
+     */
+    public void setNoteValue(String key, String value) {
+        mNoteDiffValues.put(key, value);
+        // 标记为已修改并更新修改时间
+        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+    }
+
+    // 文本数据相关方法组
+    public void setTextData(String key, String value) {
+        mNoteData.setTextData(key, value);
+    }
+    public void setTextDataId(long id) {
+        mNoteData.setTextDataId(id);
+    }
+    public long getTextDataId() {
+        return mNoteData.mTextDataId;
+    }
+
+    // 通话数据相关方法组
+    public void setCallDataId(long id) {
+        mNoteData.setCallDataId(id);
+    }
+    public void setCallData(String key, String value) {
+        mNoteData.setCallData(key, value);
+    }
+
+    /**
+     * 检查便签是否有本地修改
+     * @return true表示存在未同步的修改
+     */
+    public boolean isLocalModified() {
+        return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
+    }
+
+    /**
+     * 将便签修改同步到数据库
+     * @param context 上下文对象
+     * @param noteId 要同步的便签ID
+     * @return true表示同步成功
+     * @throws IllegalArgumentException 如果noteId不合法
+     */
+    public boolean syncNote(Context context, long noteId) {
+        if (noteId <= 0) {
+            throw new IllegalArgumentException("无效便签ID: " + noteId);
+        }
+
+        if (!isLocalModified()) {
+            return true; // 无修改直接返回成功
+        }
+
+        // 先更新便签元数据
+        if (context.getContentResolver().update(
+                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+                mNoteDiffValues, null, null) == 0) {
+            Log.e(TAG, "便签元数据更新失败");
+        }
+        mNoteDiffValues.clear();
+
+        // 再同步具体数据内容
+        if (mNoteData.isLocalModified() && 
+            (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * 内部类，处理便签具体数据（文本/通话记录）的存储
+     */
+    private class NoteData {
+        private long mTextDataId;          // 文本数据项ID
+        private ContentValues mTextDataValues; // 文本数据修改
+        private long mCallDataId;          // 通话数据项ID
+        private ContentValues mCallDataValues; // 通话数据修改
+        private static final String TAG = "NoteData";
+
+        public NoteData() {
+            mTextDataValues = new ContentValues();
+            mCallDataValues = new ContentValues();
+            mTextDataId = 0;
+            mCallDataId = 0;
+        }
+
+        /**
+         * 检查数据是否有本地修改
+         */
+        boolean isLocalModified() {
+            return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
+        }
+
+        // 文本数据设置方法组
+        void setTextDataId(long id) {
+            if (id <= 0) throw new IllegalArgumentException("文本数据ID必须大于0");
+            mTextDataId = id;
+        }
+        void setTextData(String key, String value) {
+            mTextDataValues.put(key, value);
+            // 触发便签元数据修改标记
+            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+        }
+
+        // 通话数据设置方法组
+        void setCallDataId(long id) {
+            if (id <= 0) throw new IllegalArgumentException("通话数据ID必须大于0");
+            mCallDataId = id;
+        }
+        void setCallData(String key, String value) {
+            mCallDataValues.put(key, value);
+            // 触发便签元数据修改标记
+            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+        }
+
+        /**
+         * 将数据修改推送到数据库
+         * @param context 上下文对象
+         * @param noteId 所属便签ID
+         * @return 操作结果的URI，失败返回null
+         */
+        Uri pushIntoContentResolver(Context context, long noteId) {
+            if (noteId <= 0) throw new IllegalArgumentException("无效便签ID: " + noteId);
+
+            ArrayList<ContentProviderOperation> operationList = new ArrayList<>();
+
+            // 处理文本数据
+            if (mTextDataValues.size() > 0) {
+                mTextDataValues.put(DataColumns.NOTE_ID, noteId);
+                if (mTextDataId == 0) { // 新数据：插入
+                    mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
+                    Uri uri = context.getContentResolver().insert(
+                            Notes.CONTENT_DATA_URI, mTextDataValues);
+                    try {
+                        setTextDataId(Long.parseLong(uri.getPathSegments().get(1)));
+                    } catch (NumberFormatException e) {
+                        Log.e(TAG, "插入文本数据失败，便签ID：" + noteId);
+                        mTextDataValues.clear();
+                        return null;
+                    }
+                } else { // 现有数据：更新
+                    ContentProviderOperation.Builder builder = ContentProviderOperation
+                            .newUpdate(ContentUris.withAppendedId(
+                                    Notes.CONTENT_DATA_URI, mTextDataId))
+                            .withValues(mTextDataValues);
+                    operationList.add(builder.build());
+                }
+                mTextDataValues.clear();
+            }
+
+            // 处理通话数据（逻辑同上）
+            if (mCallDataValues.size() > 0) {
+                mCallDataValues.put(DataColumns.NOTE_ID, noteId);
+                if (mCallDataId == 0) {
+                    mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
+                    Uri uri = context.getContentResolver().insert(
+                            Notes.CONTENT_DATA_URI, mCallDataValues);
+                    try {
+                        setCallDataId(Long.parseLong(uri.getPathSegments().get(1)));
+                    } catch (NumberFormatException e) {
+                        Log.e(TAG, "插入通话数据失败，便签ID：" + noteId);
+                        mCallDataValues.clear();
+                        return null;
+                    }
+                } else {
+                    ContentProviderOperation.Builder builder = ContentProviderOperation
+                            .newUpdate(ContentUris.withAppendedId(
+                                    Notes.CONTENT_DATA_URI, mCallDataId))
+                            .withValues(mCallDataValues);
+                    operationList.add(builder.build());
+                }
+                mCallDataValues.clear();
+            }
+
+            // 执行批量操作
+            if (!operationList.isEmpty()) {
+                try {
+                    ContentProviderResult[] results = context.getContentResolver()
+                            .applyBatch(Notes.AUTHORITY, operationList);
+                    return (results != null && results.length > 0) ? 
+                           ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId) : null;
+                } catch (RemoteException | OperationApplicationException e) {
+                    Log.e(TAG, "批量操作异常: " + e.getMessage());
+                    return null;
+                }
+            }
+            return null;
+        }
+    }
+}

src/model/WorkingNote.java

@@ -0,0 +1,132 @@
+/**
+ * WorkingNote 类 - 笔记核心业务逻辑处理模块 
+ * 
+ * 功能概述：
+ * 本类负责处理笔记的创建、加载、保存及属性管理，作为笔记数据与UI组件间的桥梁。
+ * 支持文本笔记、通话记录笔记两种类型，集成小部件关联和提醒功能。
+ */
+ 
+public class WorkingNote {
+    // 核心成员变量说明 
+    private Note mNote;            // 数据库实体对象，处理CRUD操作 
+    private long mNoteId;          // 当前笔记在数据库中的唯一标识 
+    private String mContent;       // 笔记正文内容（Markdown或纯文本）
+    private int mMode;             // 笔记模式 0-普通模式 1-清单模式 
+    private long mAlertDate;       // 提醒时间戳（毫秒级）
+    private int mBgColorId;        // 背景颜色资源索引（关联NoteBgResources）
+    private int mWidgetId;         // 关联的小部件ID（AppWidgetManager分配）
+    private int mWidgetType;       // 小部件类型（见Notes.TYPE_WIDGET_*）
+    private Context mContext;      // 应用上下文（用于访问ContentResolver）
+ 
+    /**
+     * 数据表查询投影（处理笔记元数据）
+     * 字段顺序对应NOTE_PARENT_ID_COLUMN等索引常量 
+     */
+    public static final String[] NOTE_PROJECTION = new String[] {
+            NoteColumns.PARENT_ID,     // 所属文件夹ID 
+            NoteColumns.ALERTED_DATE,  // 激活的提醒时间 
+            NoteColumns.BG_COLOR_ID,   // 背景色标识 
+            NoteColumns.WIDGET_ID,     // 绑定的小部件ID 
+            NoteColumns.WIDGET_TYPE,   // 小部件类型 
+            NoteColumns.MODIFIED_DATE  // 最后修改时间 
+    };
+ 
+    /**
+     * 私有构造函数 - 新建笔记初始化 
+     * @param context 应用上下文 
+     * @param folderId 所属文件夹ID（见Notes.ID_*常量）
+     */
+    private WorkingNote(Context context, long folderId) {
+        // 初始化时间相关字段 
+        mModifiedDate = System.currentTimeMillis();  // 设置创建时间为当前系统时间 
+        // 设置默认值 
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;    // 初始化为无效小部件类型 
+    }
+ 
+    /**
+     * 核心保存逻辑 
+     * @return 保存成功返回true，否则false 
+     * 
+     * 执行流程：
+     * 1. 有效性检测（通过isWorthSaving）
+     * 2. 新笔记生成数据库ID 
+     * 3. 通过Note对象同步数据到数据库 
+     * 4. 触发小部件更新（若关联有效小部件）
+     */
+    public synchronized boolean saveNote() {
+        if (!isWorthSaving()) return false;
+        
+        // 生成新笔记ID（仅当不存在数据库时）
+        if (!existInDatabase()) {
+            mNoteId = Note.getNewNoteId(mContext,  mFolderId);
+        }
+        
+        // 数据同步到数据库 
+        mNote.syncNote(mContext,  mNoteId); 
+        
+        // 小部件更新回调 
+        if (isValidWidget()) {
+            mNoteSettingStatusListener.onWidgetChanged(); 
+        }
+        return true;
+    }
+ 
+    /**
+     * 设置提醒时间（带监听回调）
+     * @param date 时间戳（单位毫秒）
+     * @param set 是否激活提醒（true-设置/false-取消）
+     */
+    public void setAlertDate(long date, boolean set) {
+        if (date != mAlertDate) {
+            mNote.setNoteValue(NoteColumns.ALERTED_DATE,  String.valueOf(date)); 
+        }
+        // 触发UI更新 
+        if (mNoteSettingStatusListener != null) {
+            mNoteSettingStatusListener.onClockAlertChanged(date,  set);
+        }
+    }
+ 
+    /**
+     * 转换笔记为通话记录类型 
+     * @param phoneNumber 通话号码（需符合E.164格式）
+     * @param callDate 通话时间戳（单位毫秒）
+     * 
+     * 实现逻辑：
+     * 1. 设置通话元数据（时间、号码）
+     * 2. 变更父文件夹到通话记录专用目录 
+     */
+    public void convertToCallNote(String phoneNumber, long callDate) {
+        mNote.setCallData(CallNote.CALL_DATE,  String.valueOf(callDate)); 
+        mNote.setCallData(CallNote.PHONE_NUMBER,  phoneNumber);
+        mNote.setNoteValue(NoteColumns.PARENT_ID,  
+            String.valueOf(Notes.ID_CALL_RECORD_FOLDER)); 
+    }
+ 
+    //--------------- 工具方法 ---------------
+    /** 判断是否需要保存（防止无效存储） */
+    private boolean isWorthSaving() {
+        return !mIsDeleted 
+            && (existInDatabase() ? mNote.isLocalModified()  : !TextUtils.isEmpty(mContent)); 
+    }
+ 
+    /** 验证小部件关联有效性 */
+    private boolean isValidWidget() {
+        return mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID 
+            && mWidgetType != Notes.TYPE_WIDGET_INVALIDE;
+    }
+ 
+    /**
+     * 笔记设置变更监听接口 
+     * 功能：桥接业务逻辑层与UI层的双向通信 
+     */
+    public interface NoteSettingChangedListener {
+        /** 背景色变更时触发（需要更新预览） */
+        void onBackgroundColorChanged();
+        
+        /** 清单模式切换时触发（需要重渲染编辑器） */
+        void onCheckListModeChanged(int oldMode, int newMode);
+        
+        /** 小部件内容更新时触发（需刷新小部件视图） */
+        void onWidgetChanged();
+    }
+}