1

gtask/remote/GTaskClient.java
gtask/remote/GTaskManager.java
gtask/remote/GTaskSyncService.java

branch2.txt

@@ -1 +0,0 @@
-66666

master

@@ -1 +0,0 @@
-undefined

src/net/micode/notes/gtask/data/MetaData.java

@@ -0,0 +1,87 @@
+/*
+ * 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.data;
+
+import android.database.Cursor;
+import android.util.Log;
+
+import net.micode.notes.tool.GTaskStringUtils;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+// Metadata类，继承自Task类
+public class MetaData extends Task {
+    private final static String TAG = MetaData.class.getSimpleName(); // 定义日志标签
+
+    private String mRelatedGid = null; // 用于存储关联的GID
+
+    // 设置元数据
+    public void setMeta(String gid, JSONObject metaInfo) {
+        try {
+            metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid); // 将GID放入元数据
+        } catch (JSONException e) {
+            Log.e(TAG, "failed to put related gid"); // 日志记录错误
+        }
+        setNotes(metaInfo.toString()); // 将元数据转换为字符串并设置为笔记
+        setName(GTaskStringUtils.META_NOTE_NAME); // 设置名称
+    }
+
+    // 获取关联的GID
+    public String getRelatedGid() {
+        return mRelatedGid; // 返回关联的GID
+    }
+
+    // 检查是否值得保存
+    @Override
+    public boolean isWorthSaving() {
+        return getNotes() != null; // 如果笔记不为空，则值得保存
+    }
+
+    // 从远程JSON设置内容
+    @Override
+    public void setContentByRemoteJSON(JSONObject js) {
+        super.setContentByRemoteJSON(js); // 调用父类的方法
+        if (getNotes() != null) {
+            try {
+                JSONObject metaInfo = new JSONObject(getNotes().trim()); // 解析笔记内容为JSON对象
+                mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID); // 获取关联的GID
+            } catch (JSONException e) {
+                Log.w(TAG, "failed to get related gid"); // 日志记录警告
+                mRelatedGid = null; // 如果发生错误，设置为null
+            }
+        }
+    }
+
+    // 从本地JSON设置内容（不应调用此方法）
+    @Override
+    public void setContentByLocalJSON(JSONObject js) {
+        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called"); // 引发错误
+    }
+
+    // 从内容获取本地JSON（不应调用此方法）
+    @Override
+    public JSONObject getLocalJSONFromContent() {
+        throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called"); // 引发错误
+    }
+
+    // 获取同步操作（不应调用此方法）
+    @Override
+    public int getSyncAction(Cursor c) {
+        throw new IllegalAccessError("MetaData:getSyncAction should not be called"); // 引发错误
+    }
+}

src/net/micode/notes/gtask/data/Node.java

@@ -0,0 +1,97 @@
+/*
+ * 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.data; // 包声明，用于将相关类分组
+
+import android.database.Cursor; // 导入 Cursor 类以进行数据库操作
+
+import org.json.JSONObject; // 导入 JSONObject 以便进行 JSON 操作
+
+/**
+ * 表示同步上下文中通用 Node 的抽象类。
+ * 此类提供管理笔记或任务在远程/本地数据库上下文中的同步操作的结构。
+ */
+public abstract class Node {
+
+    // 常量，表示 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;            // 操作错误
+
+    // 实例变量，表示 Node 的属性
+    private String mGid; // Node 的唯一标识符
+    private String mName; // Node 的名称或标题
+    private long mLastModified; // 最后修改时间的时间戳
+    private boolean mDeleted; // 标记 Node 是否已删除的标志
+
+    /**
+     * Node 类的构造函数，初始化默认值。
+     */
+    public Node() {
+        mGid = null; // 初始化 GID 为 null
+        mName = ""; // 初始化名称为空字符串
+        mLastModified = 0; // 初始化最后修改时间为零
+        mDeleted = false; // 初始化删除状态为 false
+    }
+
+    // 抽象方法，供子类实现特定操作
+    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(); // 从内容获取本地 JSON
+    public abstract int getSyncAction(Cursor c); // 从 Cursor 获取同步操作
+
+    // 设置私有字段的 setter 方法
+    public void setGid(String gid) {
+        this.mGid = gid; // 设置唯一标识符
+    }
+
+    public void setName(String name) {
+        this.mName = name; // 设置 Node 的名称
+    }
+
+    public void setLastModified(long lastModified) {
+        this.mLastModified = lastModified; // 设置最后修改时间戳
+    }
+
+    public void setDeleted(boolean deleted) {
+        this.mDeleted = deleted; // 设置删除状态
+    }
+
+    // 获取私有字段的 getter 方法
+    public String getGid() {
+        return this.mGid; // 返回唯一标识符
+    }
+
+    public String getName() {
+        return this.mName; // 返回 Node 的名称
+    }
+
+    public long getLastModified() {
+        return this.mLastModified; // 返回最后修改时间戳
+    }
+
+    public boolean getDeleted() {
+        return this.mDeleted; // 返回删除状态
+    }
+}

src/net/micode/notes/gtask/data/SqlData.java

@@ -0,0 +1,216 @@
+/*
+ * 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.data; // 包声明，用于将相关类分组
+
+import android.content.ContentResolver; // 导入 ContentResolver 类，用于访问内容提供者
+import android.content.ContentUris; // 导入 ContentUris 类，用于处理内容 URI
+import android.content.ContentValues; // 导入 ContentValues 类，用于存储数据
+import android.content.Context; // 导入 Context 类，用于获取应用上下文
+import android.database.Cursor; // 导入 Cursor 类，用于数据库操作
+import android.net.Uri; // 导入 Uri 类，用于处理 URI
+import android.util.Log; // 导入 Log 类，用于日志记录
+
+import net.micode.notes.data.Notes; // 导入 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 org.json.JSONException; // 导入 JSONException 类，用于处理 JSON 异常
+import org.json.JSONObject; // 导入 JSONObject 类，用于 JSON 操作
+
+/**
+ * SqlData 类用于处理数据库中的数据操作。
+ * 它提供了从数据库加载、设置内容、提交更改等功能。
+ */
+public class SqlData {
+    private static final String TAG = SqlData.class.getSimpleName(); // 日志标签
+
+    private static final int INVALID_ID = -99999; // 无效 ID 常量
+
+    // 定义要查询的数据列
+    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; // 数据 ID
+    private String mDataMimeType; // 数据 MIME 类型
+    private String mDataContent; // 数据内容
+    private long mDataContentData1; // 数据内容的附加数据 1
+    private String mDataContentData3; // 数据内容的附加数据 3
+    private ContentValues mDiffDataValues; // 存储更改的数据值
+
+    /**
+     * 构造函数，创建新的 SqlData 对象。
+     * @param context 应用程序上下文
+     */
+    public SqlData(Context context) {
+        mContentResolver = context.getContentResolver(); // 获取内容解析器
+        mIsCreate = true; // 设置为创建模式
+        mDataId = INVALID_ID; // 初始化为无效 ID
+        mDataMimeType = DataConstants.NOTE; // 默认 MIME 类型为笔记
+        mDataContent = ""; // 初始化内容为空
+        mDataContentData1 = 0; // 初始化附加数据 1 为 0
+        mDataContentData3 = ""; // 初始化附加数据 3 为空
+        mDiffDataValues = new ContentValues(); // 初始化更改的数据值容器
+    }
+
+    /**
+     * 构造函数，根据 Cursor 创建 SqlData 对象。
+     * @param context 应用程序上下文
+     * @param c      数据游标
+     */
+    public SqlData(Context context, Cursor c) {
+        mContentResolver = context.getContentResolver(); // 获取内容解析器
+        mIsCreate = false; // 设置为加载模式
+        loadFromCursor(c); // 从 Cursor 加载数据
+        mDiffDataValues = new ContentValues(); // 初始化更改的数据值容器
+    }
+
+    /**
+     * 从 Cursor 加载数据到 SqlData 对象的属性
+     * @param c 数据游标
+     */
+    private void loadFromCursor(Cursor c) {
+        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 对象设置内容。
+     * @param js 包含数据的 JSON 对象
+     * @throws JSONException JSON 解析异常
+     */
+    public void setContent(JSONObject js) throws JSONException {
+        long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID; // 解析 ID
+        if (mIsCreate || mDataId != dataId) {
+            mDiffDataValues.put(DataColumns.ID, dataId); // 更新 ID
+        }
+        mDataId = dataId; // 设置 ID
+
+        String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
+                : DataConstants.NOTE; // 解析 MIME 类型
+        if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
+            mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType); // 更新 MIME 类型
+        }
+        mDataMimeType = dataMimeType; // 设置 MIME 类型
+
+        String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : ""; // 解析内容
+        if (mIsCreate || !mDataContent.equals(dataContent)) {
+            mDiffDataValues.put(DataColumns.CONTENT, dataContent); // 更新内容
+        }
+        mDataContent = dataContent; // 设置内容
+
+        long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0; // 解析附加数据 1
+        if (mIsCreate || mDataContentData1 != dataContentData1) {
+            mDiffDataValues.put(DataColumns.DATA1, dataContentData1); // 更新附加数据 1
+        }
+        mDataContentData1 = dataContentData1; // 设置附加数据 1
+
+        String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : ""; // 解析附加数据 3
+        if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
+            mDiffDataValues.put(DataColumns.DATA3, dataContentData3); // 更新附加数据 3
+        }
+        mDataContentData3 = dataContentData3; // 设置附加数据 3
+    }
+
+    /**
+     * 获取当前内容的 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; // 返回 null
+        }
+        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 对象
+    }
+
+    /**
+     * 提交当前数据到数据库。
+     * @param noteId 关联的笔记 ID
+     * @param validateVersion 是否验证版本
+     * @param version 当前版本号
+     */
+    public void commit(long noteId, boolean validateVersion, long version) {
+        if (mIsCreate) {
+            // 创建新记录时
+            if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
+                mDiffDataValues.remove(DataColumns.ID); // 移除无效 ID
+            }
+
+            mDiffDataValues.put(DataColumns.NOTE_ID, noteId); // 设置笔记 ID
+            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues); // 插入数据库
+            try {
+                mDataId = Long.valueOf(uri.getPathSegments().get(1)); // 从 URI 获取新创建的 ID
+            } catch (NumberFormatException e) {
+                Log.e(TAG, "Get note id error :" + e.toString()); // 日志错误
+                throw new ActionFailureException("create note failed"); // 抛出异常
+            }
+        } else { // 更新已有记录时
+            if (mDiffDataValues.size() > 0) {
+                int result = 0;
+                if (!validateVersion) {
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null); // 不验证版本直接更新
+                } else {
+                    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; // 返回数据 ID
+    }
+}

src/net/micode/notes/gtask/data/SqlNote.java

@@ -0,0 +1,570 @@
+/*
+ * 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.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 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 org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+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,
+            NoteColumns.NOTES_COUNT, NoteColumns.PARENT_ID, NoteColumns.SNIPPET, NoteColumns.TYPE,
+            NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.SYNC_ID,
+            NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID,
+            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;
+    // 笔记的 ID
+    private long mId;
+    // 提醒日期
+    private long mAlertDate;
+    // 背景颜色 ID
+    private int mBgColorId;
+    // 创建日期
+    private long mCreatedDate;
+    // 是否有附件
+    private int mHasAttachment;
+    // 修改日期
+    private long mModifiedDate;
+    // 父笔记 ID
+    private long mParentId;
+    // 笔记摘要
+    private String mSnippet;
+    // 笔记类型
+    private int mType;
+    // 小部件 ID
+    private int mWidgetId;
+    // 小部件类型
+    private int mWidgetType;
+    // 原始父笔记 ID
+    private long mOriginParent;
+    // 笔记版本
+    private long mVersion;
+    // 用于记录修改的 ContentValues
+    private ContentValues mDiffNoteValues;
+    // 笔记数据列表
+    private ArrayList<SqlData> mDataList;
+
+    /**
+     * 构造函数，用于创建一个新的 SqlNote 对象。
+     * @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;
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
+        mOriginParent = 0;
+        mVersion = 0;
+        mDiffNoteValues = new ContentValues();
+        mDataList = new ArrayList<SqlData>();
+    }
+
+    /**
+     * 构造函数，用于从数据库中的 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<SqlData>();
+        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<SqlData>();
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent(); // 如果是普通笔记，加载笔记内容
+        mDiffNoteValues = new ContentValues();
+    }
+
+    /**
+     * 通过笔记 ID 从数据库加载笔记数据。
+     * @param id 笔记的 ID
+     */
+    private void loadFromCursor(long id) {
+        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); // 从 Cursor 加载笔记数据
+            } else {
+                Log.w(TAG, "loadFromCursor: cursor = null");
+            }
+        } finally {
+            if (c != null)
+                c.close();
+        }
+    }
+
+    /**
+     * 从 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() {
+        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;
+                }
+                while (c.moveToNext()) {
+                    SqlData data = new SqlData(mContext, c);
+                    mDataList.add(data);
+                }
+            } else {
+                Log.w(TAG, "loadDataContent: cursor = null");
+            }
+        } finally {
+            if (c != null)
+                c.close();
+        }
+    }
+
+    /**
+     * 设置笔记内容，从 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);
+                long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
+                if (mIsCreate || mId != id) {
+                    mDiffNoteValues.put(NoteColumns.ID, id);
+                }
+                mId = id;
+
+                long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note
+                        .getLong(NoteColumns.ALERTED_DATE) : 0;
+                if (mIsCreate || mAlertDate != alertDate) {
+                    mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);
+                }
+                mAlertDate = alertDate;
+
+                int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note
+                        .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
+                if (mIsCreate || mBgColorId != bgColorId) {
+                    mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);
+                }
+                mBgColorId = bgColorId;
+
+                long createDate = note.has(NoteColumns.CREATED_DATE) ? note
+                        .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
+                if (mIsCreate || mCreatedDate != createDate) {
+                    mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
+                }
+                mCreatedDate = createDate;
+
+                int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note
+                        .getInt(NoteColumns.HAS_ATTACHMENT) : 0;
+                if (mIsCreate || mHasAttachment != hasAttachment) {
+                    mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);
+                }
+                mHasAttachment = hasAttachment;
+
+                long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note
+                        .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();
+                if (mIsCreate || mModifiedDate != modifiedDate) {
+                    mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
+                }
+                mModifiedDate = modifiedDate;
+
+                long parentId = note.has(NoteColumns.PARENT_ID) ? note
+                        .getLong(NoteColumns.PARENT_ID) : 0;
+                if (mIsCreate || mParentId != parentId) {
+                    mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
+                }
+                mParentId = parentId;
+
+                String snippet = note.has(NoteColumns.SNIPPET) ? note
+                        .getString(NoteColumns.SNIPPET) : "";
+                if (mIsCreate || !mSnippet.equals(snippet)) {
+                    mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
+                }
+                mSnippet = snippet;
+
+                int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
+                        : Notes.TYPE_NOTE;
+                if (mIsCreate || mType != type) {
+                    mDiffNoteValues.put(NoteColumns.TYPE, type);
+                }
+                mType = type;
+
+                int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)
+                        : AppWidgetManager.INVALID_APPWIDGET_ID;
+                if (mIsCreate || mWidgetId != widgetId) {
+                    mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
+                }
+                mWidgetId = widgetId;
+
+                int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
+                        .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
+                if (mIsCreate || mWidgetType != widgetType) {
+                    mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
+                }
+                mWidgetType = widgetType;
+
+                long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
+                        .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
+                if (mIsCreate || mOriginParent != originParent) {
+                    mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
+                }
+                mOriginParent = originParent;
+
+                // 解析笔记内容数据
+                for (int i = 0; i < dataArray.length(); i++) {
+                    JSONObject data = dataArray.getJSONObject(i);
+                    SqlData sqlData = null;
+                    if (data.has(DataColumns.ID)) {
+                        long dataId = data.getLong(DataColumns.ID);
+                        for (SqlData temp : mDataList) {
+                            if (dataId == temp.getId()) {
+                                sqlData = temp;
+                            }
+                        }
+                    }
+
+                    if (sqlData == null) {
+                        sqlData = new SqlData(mContext);
+                        mDataList.add(sqlData);
+                    }
+
+                    sqlData.setContent(data);
+                }
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * 获取笔记内容，以 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);
+    }
+
+    /**
+     * 设置笔记的 GTask ID。
+     * @param gid GTask 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 是否为普通笔记类型
+     */
+    public boolean isNoteType() {
+        return mType == Notes.TYPE_NOTE;
+    }
+
+    /**
+     * 提交笔记数据到数据库。
+     * @param validateVersion 是否验证版本号
+     */
+    public void commit(boolean validateVersion) {
+        if (mIsCreate) {
+            // 新建笔记
+            if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
+                mDiffNoteValues.remove(NoteColumns.ID);
+            }
+
+            Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
+            try {
+                mId = Long.valueOf(uri.getPathSegments().get(1));
+            } catch (NumberFormatException e) {
+                Log.e(TAG, "Get note id error :" + e.toString());
+                throw new ActionFailureException("create note failed");
+            }
+            if (mId == 0) {
+                throw new IllegalStateException("Create thread id failed");
+            }
+
+            if (mType == Notes.TYPE_NOTE) {
+                for (SqlData sqlData : mDataList) {
+                    sqlData.commit(mId, false, -1);
+                }
+            }
+        } else {
+            // 更新笔记
+            if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
+                Log.e(TAG, "No such note");
+                throw new IllegalStateException("Try to update note with invalid id");
+            }
+            if (mDiffNoteValues.size() > 0) {
+                mVersion++;
+                int result = 0;
+                if (!validateVersion) {
+                    result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+                            + NoteColumns.ID + "=?)", new String[] {
+                            String.valueOf(mId)
+                    });
+                } else {
+                    result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+                                    + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
+                            new String[] {
+                                    String.valueOf(mId), String.valueOf(mVersion)
+                            });
+                }
+                if (result == 0) {
+                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
+                }
+            }
+
+            if (mType == Notes.TYPE_NOTE) {
+                for (SqlData sqlData : mDataList) {
+                    sqlData.commit(mId, validateVersion, mVersion);
+                }
+            }
+        }
+
+        // 刷新本地信息
+        loadFromCursor(mId);
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+
+        mDiffNoteValues.clear();
+        mIsCreate = false;
+    }
+}

src/net/micode/notes/gtask/data/Task.java

@@ -0,0 +1,435 @@
+/*
+ * 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.data;
+
+import android.database.Cursor;
+import android.text.TextUtils;
+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 org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/*
+ * Task类用于表示和处理任务相关的数据和操作。
+ * 它提供了创建、更新任务操作的JSON对象的方法，
+ * 以及从本地和远程JSON对象中设置任务内容的功能。
+ */
+public class Task extends Node {
+    private static final String TAG = Task.class.getSimpleName();
+
+    // 任务是否完成
+    private boolean mCompleted;
+
+    // 任务的笔记内容
+    private String mNotes;
+
+    // 任务的元信息
+    private JSONObject mMetaInfo;
+
+    // 任务的前一个兄弟任务
+    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");
+            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("fail to generate task-create jsonobject");
+        }
+
+        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("fail to generate task-update jsonobject");
+        }
+
+        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("fail to get task content from jsonobject");
+            }
+        }
+    }
+
+    /*
+     * 从本地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: nothing is avaiable");
+        }
+
+        try {
+            // 获取本地JSON对象中的笔记信息和数据数组
+            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;
+            }
+
+            // 遍历数据数组，找到任务名称
+            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, "the note seems to be an empty one");
+                    return null;
+                }
+
+                // 创建新的JSON对象
+                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;
+            } 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;
+        }
+    }
+
+    /*
+     * 设置任务的元信息。
+     * @param metaData 元数据
+     */
+    public void setMetaInfo(MetaData metaData) {
+        if (metaData != null && metaData.getNotes() != null) {
+            try {
+                mMetaInfo = new JSONObject(metaData.getNotes());
+            } catch (JSONException e) {
+                Log.w(TAG, e.toString());
+                mMetaInfo = null;
+            }
+        }
+    }
+
+    /*
+     * 获取任务的同步操作类型。
+     * @param c 数据库游标
+     * @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, "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;
+            }
+
+            // 验证笔记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) {
+                // 如果本地没有更新
+                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, "gtask id doesn't match");
+                    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
+     */
+    public boolean isWorthSaving() {
+        return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
+                || (getNotes() != null && getNotes().trim().length() > 0);
+    }
+
+    /*
+     * 设置任务的完成状态。
+     * @param completed 是否完成
+     */
+    public void setCompleted(boolean completed) {
+        this.mCompleted = completed;
+    }
+
+    /*
+     * 设置任务的笔记内容。
+     * @param notes 笔记内容
+     */
+    public void setNotes(String notes) {
+        this.mNotes = notes;
+    }
+
+    /*
+     * 设置任务的前一个兄弟任务。
+     * @param priorSibling 前一个兄弟任务
+     */
+    public void setPriorSibling(Task priorSibling) {
+        this.mPriorSibling = priorSibling;
+    }
+
+    /*
+     * 设置任务的任务列表。
+     * @param parent 任务列表
+     */
+    public void setParent(TaskList parent) {
+        this.mParent = parent;
+    }
+
+    /*
+     * 获取任务的完成状态。
+     * @return 是否完成
+     */
+    public boolean getCompleted() {
+        return this.mCompleted;
+    }
+
+    /*
+     * 获取任务的笔记内容。
+     * @return 笔记内容
+     */
+    public String getNotes() {
+        return this.mNotes;
+    }
+
+    /*
+     * 获取任务的前一个兄弟任务。
+     * @return 前一个兄弟任务
+     */
+    public Task getPriorSibling() {
+        return this.mPriorSibling;
+    }
+
+    /*
+     * 获取任务的任务列表。
+     * @return 任务列表
+     */
+    public TaskList getParent() {
+        return this.mParent;
+    }
+}

src/net/micode/notes/gtask/data/TaskList.java

@@ -0,0 +1,439 @@
+/*
+ * 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.data;
+
+import android.database.Cursor;
+import android.util.Log;
+
+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;
+
+/*
+ * TaskList类用于表示和处理任务列表相关的数据和操作。
+ * 它提供了创建、更新任务列表操作的JSON对象的方法，
+ * 以及从本地和远程JSON对象中设置任务列表内容的功能。
+ */
+public class TaskList extends Node {
+    private static final String TAG = TaskList.class.getSimpleName();
+
+    // 任务列表的索引
+    private int mIndex;
+
+    // 任务列表中的任务集合
+    private ArrayList<Task> mChildren;
+
+    /*
+     * 构造函数，初始化任务列表的基本属性。
+     */
+    public TaskList() {
+        super();
+        mChildren = new ArrayList<Task>();
+        mIndex = 1;
+    }
+
+    /*
+     * 生成任务列表创建操作的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, mIndex);
+
+            // 设置任务列表的详细信息
+            JSONObject entity = new JSONObject();
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
+            entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("fail to generate tasklist-create jsonobject");
+        }
+
+        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());
+            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");
+        }
+
+        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));
+                }
+
+            } catch (JSONException e) {
+                Log.e(TAG, e.toString());
+                e.printStackTrace();
+                throw new ActionFailureException("fail to get tasklist content from jsonobject");
+            }
+        }
+    }
+
+    /*
+     * 从本地JSON对象中设置任务列表内容。
+     * @param js 本地JSON对象
+     */
+    public void setContentByLocalJSON(JSONObject js) {
+        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
+            Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
+        }
+
+        try {
+            // 获取本地JSON对象中的文件夹信息
+            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");
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+    }
+
+    /*
+     * 从任务列表内容中生成本地JSON对象。
+     * @return 生成的本地JSON对象
+     */
+    public JSONObject getLocalJSONFromContent() {
+        try {
+            // 创建新的JSON对象
+            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;
+        }
+    }
+
+    /*
+     * 获取任务列表的同步操作类型。
+     * @param c 数据库游标
+     * @return 同步操作类型
+     */
+    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, "gtask id doesn't match");
+                    return SYNC_ACTION_ERROR;
+                }
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                    // 只有本地有更新
+                    return SYNC_ACTION_UPDATE_REMOTE;
+                } else {
+                    // 对于文件夹冲突，只应用本地更新
+                    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.isEmpty() ? null : 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, "add child task: invalid index");
+            return false;
+        }
+
+        int pos = mChildren.indexOf(task);
+        if (task != null && pos == -1) {
+            mChildren.add(index, task);
+
+            // 更新任务列表
+            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);
+        }
+
+        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, "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));
+    }
+
+    /*
+     * 根据任务ID查找任务。
+     * @param gid 任务ID
+     * @return 找到的任务，如果找不到则返回null
+     */
+    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;
+    }
+
+    /*
+     * 获取任务在任务列表中的索引。
+     * @param task 任务
+     * @return 索引
+     */
+    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: invalid index");
+            return null;
+        }
+        return mChildren.get(index);
+    }
+
+    /*
+     * 根据任务ID获取任务。
+     * @param gid 任务ID
+     * @return 任务，如果找不到则返回null
+     */
+    public Task getChilTaskByGid(String gid) {
+        for (Task task : mChildren) {
+            if (task.getGid().equals(gid))
+                return task;
+        }
+        return null;
+    }
+
+    /*
+     * 获取任务列表中的所有任务。
+     * @return 任务集合
+     */
+    public ArrayList<Task> getChildTaskList() {
+        return this.mChildren;
+    }
+
+    /*
+     * 设置任务列表的索引。
+     * @param index 索引
+     */
+    public void setIndex(int index) {
+        this.mIndex = index;
+    }
+
+    /*
+     * 获取任务列表的索引。
+     * @return 索引
+     */
+    public int getIndex() {
+        return this.mIndex;
+    }
+}

src/net/micode/notes/gtask/exception/ActionFailureException.java

@@ -0,0 +1,50 @@
+/*
+ * 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;
+
+/*
+ * ActionFailureException类用于表示在执行操作时发生的失败情况。
+ * 它继承自RuntimeException，用于在操作失败时抛出异常。
+ */
+public class ActionFailureException extends RuntimeException {
+    // 序列化版本UID，用于标识类的版本
+    private static final long serialVersionUID = 4425249765923293627L;
+
+    /*
+     * 构造一个没有任何消息的ActionFailureException对象。
+     */
+    public ActionFailureException() {
+        super();
+    }
+
+    /*
+     * 构造一个带有指定消息的ActionFailureException对象。
+     * @param paramString 异常消息
+     */
+    public ActionFailureException(String paramString) {
+        super(paramString);
+    }
+
+    /*
+     * 构造一个带有指定消息和原因的ActionFailureException对象。
+     * @param paramString 异常消息
+     * @param paramThrowable 异常原因
+     */
+    public ActionFailureException(String paramString, Throwable paramThrowable) {
+        super(paramString, paramThrowable);
+    }
+}

src/net/micode/notes/gtask/exception/NetworkFailureException.java

@@ -0,0 +1,50 @@
+/*
+ * 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;
+
+/*
+ * NetworkFailureException类用于表示在执行网络操作时发生的失败情况。
+ * 它继承自Exception，用于在在网络请求失败时抛出异常。
+ */
+public class NetworkFailureException extends Exception {
+    // 序列化版本UID，用于标识类的版本
+    private static final long serialVersionUID = 2107610287180234136L;
+
+    /*
+     * 构造一个没有任何消息的NetworkFailureException对象。
+     */
+    public NetworkFailureException() {
+        super();
+    }
+
+    /*
+     * 构造一个带有指定消息的NetworkFailureException对象。
+     * @param paramString 异常消息
+     */
+    public NetworkFailureException(String paramString) {
+        super(paramString);
+    }
+
+    /*
+     * 构造一个带有指定消息和原因的NetworkFailureException对象。
+     * @param paramString 异常消息
+     * @param paramThrowable 异常原因
+     */
+    public NetworkFailureException(String paramString, Throwable paramThrowable) {
+        super(paramString, paramThrowable);
+    }
+}

src/net/micode/notes/gtask/remote/GTaskASyncTask.java

@@ -0,0 +1,137 @@
+/*
+ * 版权声明：此处声明代码的版权属于 MiCode 开放源代码社区，并指定了许可协议为 Apache License 2.0。
+ * 提供了许可协议的获取链接。
+ * 强调除非适用法律要求或书面同意，否则软件按 “原样” 分发，不提供任何形式的明示或暗示保证。
+ * 并指出许可协议中关于权限和限制的具体语言。
+ */
+
+package net.micode.notes.gtask.remote;
+
+import android.app.Notification; // 导入 Notification 类，用于创建通知
+import android.app.NotificationManager; // 导入 NotificationManager 类，用于管理通知
+import android.app.PendingIntent; // 导入 PendingIntent 类，用于创建待定意图
+import android.content.Context; // 导入 Context 类，用于获取系统服务等
+import android.content.Intent; // 导入 Intent 类，用于启动活动等
+import android.os.AsyncTask; // 导入 AsyncTask 类，用于在后台线程执行耗时操作
+
+import net.micode.notes.R; // 导入资源文件
+import net.micode.notes.ui.NotesListActivity; // 导入笔记列表活动类
+import net.micode.notes.ui.NotesPreferenceActivity; // 导入笔记偏好设置活动类
+
+
+/**
+ * GTaskASyncTask 类，继承自 AsyncTask，用于在后台线程执行 Google Tasks 同步操作。
+ */
+public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
+
+    private static int GTASK_SYNC_NOTIFICATION_ID = 5234235; // 定义同步通知的 ID
+
+    /**
+     * 定义同步完成的回调接口，用于在同步完成后执行相应操作。
+     */
+    public interface OnCompleteListener {
+        void onComplete(); // 定义 onComplete 方法，具体实现由调用者提供
+    }
+
+    private Context mContext; // 应用程序上下文
+    private NotificationManager mNotifiManager; // 通知管理器
+    private GTaskManager mTaskManager; // Google Tasks 管理器
+    private OnCompleteListener mOnCompleteListener; // 同步完成回调接口实例
+
+    /**
+     * 构造函数，用于初始化 GTaskASyncTask 对象。
+     *
+     * @param context           应用程序上下文
+     * @param listener          同步完成回调接口实例
+     */
+    public GTaskASyncTask(Context context, OnCompleteListener listener) {
+        mContext = context; // 保存上下文
+        mOnCompleteListener = listener; // 保存回调接口实例
+        mNotifiManager = (NotificationManager) mContext
+                .getSystemService(Context.NOTIFICATION_SERVICE); // 获取通知管理器实例
+        mTaskManager = GTaskManager.getInstance(); // 获取 Google Tasks 管理器实例
+    }
+
+    /**
+     * 取消同步操作。
+     */
+    public void cancelSync() {
+        mTaskManager.cancelSync(); // 调用 Google Tasks 管理器的 cancelSync 方法取消同步
+    }
+
+    /**
+     * 发布进度信息。
+     *
+     * @param message 进度信息
+     */
+    public void publishProgess(String message) {
+        publishProgress(new String[]{ // 调用 AsyncTask 的 publishProgress 方法发布进度
+                message
+        });
+    }
+
+    /**
+     * 显示通知。
+     *
+     * @param tickerId 通知的 ticker 文本资源 ID
+     * @param content  通知内容
+     */
+    private void showNotification(int tickerId, String content) {
+        Notification notification = new Notification(R.drawable.notification, mContext // 创建通知对象
+                .getString(tickerId), System.currentTimeMillis()); // 设置通知图标、ticker 文本和时间
+        notification.defaults = Notification.DEFAULT_LIGHTS; // 设置默认通知灯光
+        notification.flags = Notification.FLAG_AUTO_CANCEL; // 设置通知点击后自动取消
+        PendingIntent pendingIntent;
+        if (tickerId != R.string.ticker_success) { // 如果不是成功通知
+            pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, // 创建指向 NotesPreferenceActivity 的待定意图
+                    NotesPreferenceActivity.class), 0);
+
+        } else { // 如果是成功通知
+            pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, // 创建指向 NotesListActivity 的待定意图
+                    NotesListActivity.class), 0);
+        }
+        notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content, // 设置通知的详细信息
+                pendingIntent);
+        mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification); // 发出通知
+    }
+
+    /**
+     * 在后台线程执行同步操作。
+     *
+     * @param unused 未使用的参数
+     * @return 同步操作的结果状态码
+     */
+    @Override
+    protected Integer doInBackground(Void... unused) {
+        publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity // 发布登录进度信息
+                .getSyncAccountName(mContext)));
+        return mTaskManager.sync(mContext, this); // 执行同步操作并返回结果状态码
+    }
+
+    /**
+     * 在 UI 线程更新进度。
+     *
+     * @param progress 进度信息数组
+     */
+    @Override
+    protected void onProgressUpdate(String... progress) {
+        showNotification(R.string.ticker_syncing, progress[0]); // 显示同步中通知
+        if (mContext instanceof GTaskSyncService) { // 如果上下文是 GTaskSyncService 实例
+            ((GTaskSyncService) mContext).sendBroadcast(progress[0]); // 发送广播更新进度
+        }
+    }
+
+    /**
+     * 在 UI 线程处理同步结果。
+     *
+     * @param result 同步操作的结果状态码
+     */
+    @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()); // 更新最后同步时间
+
+        } else if (result == GTaskManager.STATE_NETWORK_ERROR) { // 如果是网络错误
+            showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_n

src/net/micode/notes/gtask/remote/GTaskClient.java

@@ -0,0 +1,658 @@
+/*
+ * 版权声明：此处声明代码的版权属于 MiCode 开放源代码社区，并指定了许可协议为 Apache License 2.0。
+ * 提供了许可协议的获取链接。
+ * 强调除非适用法律要求或书面同意，否则软件按 “原样” 分发，不提供任何形式的明示或暗示保证。
+ * 并指出许可协议中关于权限和限制的具体语言。
+ */
+
+package net.micode.notes.gtask.remote;
+
+import android.accounts.Account; // 导入 Account 类，用于表示用户账户
+import android.accounts.AccountManager; // 导入 AccountManager 类，用于管理账户
+import android.accounts.AccountManagerFuture; // 导入 AccountManagerFuture 类，用于异步获取账户信息
+import android.app.Activity; // 导入 Activity 类，用于表示 Android 应用程序的活动
+import android.os.Bundle; // 导入 Bundle 类，用于传递数据
+import android.text.TextUtils; // 导入 TextUtils 类，用于处理文本操作
+import android.util.Log; // 导入 Log 类，用于记录日志信息
+
+import net.micode.notes.gtask.data.Node; // 导入 Node 类，表示任务节点
+import net.micode.notes.gtask.data.Task; // 导入 Task 类，表示任务
+import net.micode.notes.gtask.data.TaskList; // 导入 TaskList 类，表示任务列表
+import net.micode.notes.gtask.exception.ActionFailureException; // 导入 ActionFailureException 类，表示操作失败异常
+import net.micode.notes.gtask.exception.NetworkFailureException; // 导入 NetworkFailureException 类，表示网络失败异常
+import net.micode.notes.tool.GTaskStringUtils; // 导入 GTaskStringUtils 类，提供字符串处理工具
+import net.micode.notes.ui.NotesPreferenceActivity; // 导入 NotesPreferenceActivity 类，用于处理笔记偏好设置
+
+import org.apache.http.HttpEntity; // 导入 HttpEntity 类，用于表示 HTTP 响应实体
+import org.apache.http.HttpResponse; // 导入 HttpResponse 类，用于表示 HTTP 响应
+import org.apache.http.client.ClientProtocolException; // 导入 ClientProtocolException 类，表示客户端协议异常
+import org.apache.http.client.entity.UrlEncodedFormEntity; // 导入 UrlEncodedFormEntity 类，用于编码表单实体
+import org.apache.http.client.methods.HttpGet; // 导入 HttpGet 类，用于发送 HTTP GET 请求
+import org.apache.http.client.methods.HttpPost; // 导入 HttpPost 类，用于发送 HTTP POST 请求
+import org.apache.http.cookie.Cookie; // 导入 Cookie 类，用于表示 HTTP Cookie
+import org.apache.http.impl.client.BasicCookieStore; // 导入 BasicCookieStore 类，用于存储 Cookie
+import org.apache.http.impl.client.DefaultHttpClient; // 导入 DefaultHttpClient 类，用于创建 HTTP 客户端
+import org.apache.http.message.BasicNameValuePair; // 导入 BasicNameValuePair 类，用于表示键值对
+import org.apache.http.params.BasicHttpParams; // 导入 BasicHttpParams 类，用于设置 HTTP 参数
+import org.apache.http.params.HttpConnectionParams; // 导入 HttpConnectionParams 类，用于设置连接参数
+import org.apache.http.params.HttpProtocolParams; // 导入 HttpProtocolParams 类，用于设置协议参数
+import org.json.JSONArray; // 导入 JSONArray 类，用于处理 JSON 数组
+import org.json.JSONException; // 导入 JSONException 类，表示 JSON 相关异常
+import org.json.JSONObject; // 导入 JSONObject 类，用于处理 JSON 对象
+
+import java.io.BufferedReader; // 导入 BufferedReader 类，用于读取文本流
+import java.io.IOException; // 导入 IOException 类，表示 I/O 异常
+import java.io.InputStream; // 导入 InputStream 类，表示输入流
+import java.io.InputStreamReader; // 导入 InputStreamReader 类，用于将输入流转换为字符流
+import java.util.LinkedList; // 导入 LinkedList 类，用于创建链表
+import java.util.List; // 导入 List 接口，用于表示列表
+import java.util.zip.GZIPInputStream; // 导入 GZIPInputStream 类，用于处理 GZIP 压缩流
+import java.util.zip.Inflater; // 导入 Inflater 类，用于解压缩
+import java.util.zip.InflaterInputStream; // 导入 InflaterInputStream 类，用于解压缩流
+
+
+/**
+ * GTaskClient 类，用于与 Google Tasks 服务进行交互，执行任务和任务列表的创建、更新、删除等操作。
+ */
+public class GTaskClient {
+
+    private static final String TAG = GTaskClient.class.getSimpleName(); // 定义日志标签
+
+    private static final String GTASK_URL = "https://mail.google.com/tasks/ "; // 定义 Google Tasks 基础 URL
+    private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig "; // 定义 Google Tasks GET 请求 URL
+    private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig "; // 定义 Google Tasks POST 请求 URL
+
+    private static GTaskClient mInstance = null; // 单例实例
+
+    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; // 更新操作数组
+
+    /**
+     * 构造函数，私有化以实现单例模式。
+     */
+    private GTaskClient() {
+        mHttpClient = null;
+        mGetUrl = GTASK_GET_URL;
+        mPostUrl = GTASK_POST_URL;
+        mClientVersion = -1;
+        mLoggedin = false;
+        mLastLoginTime = 0;
+        mActionId = 1;
+        mAccount = null;
+        mUpdateArray = null;
+    }
+
+    /**
+     * 获取 GTaskClient 单例实例。
+     *
+     * @return 单例实例
+     */
+    public static synchronized GTaskClient getInstance() {
+        if (mInstance == null) {
+            mInstance = new GTaskClient();
+        }
+        return mInstance;
+    }
+
+    /**
+     * 登录 Google Tasks 服务。
+     *
+     * @param activity 当前活动
+     * @return 登录是否成功
+     */
+    public boolean login(Activity activity) {
+        // 检查是否需要重新登录
+        final long interval = 1000 * 60 * 5; // 5 分钟间隔
+        if (mLastLoginTime + interval < System.currentTimeMillis()) {
+            mLoggedin = false;
+        }
+
+        // 如果切换了账户，需要重新登录
+        if (mLoggedin
+                && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
+                .getSyncAccountName(activity))) {
+            mLoggedin = false;
+        }
+
+        if (mLoggedin) {
+            Log.d(TAG, "already logged in");
+            return true;
+        }
+
+        mLastLoginTime = System.currentTimeMillis();
+        String authToken = loginGoogleAccount(activity, false);
+        if (authToken == null) {
+            Log.e(TAG, "login google account failed");
+            return false;
+        }
+
+        // 如果是自定义域名账户，尝试使用自定义域名登录
+        if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()
+                .endsWith("googlemail.com"))) {
+            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";
+
+            if (tryToLoginGtask(activity, authToken)) {
+                mLoggedin = true;
+            }
+        }
+
+        // 尝试使用 Google 官方 URL 登录
+        if (!mLoggedin) {
+            mGetUrl = GTASK_GET_URL;
+            mPostUrl = GTASK_POST_URL;
+            if (!tryToLoginGtask(activity, authToken)) {
+                return false;
+            }
+        }
+
+        mLoggedin = true;
+        return true;
+    }
+
+    /**
+     * 登录 Google 账户并获取认证令牌。
+     *
+     * @param activity 当前活动
+     * @param invalidateToken 是否使令牌失效
+     * @return 认证令牌
+     */
+    private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
+        String authToken;
+        AccountManager accountManager = AccountManager.get(activity);
+        Account[] accounts = accountManager.getAccountsByType("com.google");
+
+        if (accounts.length == 0) {
+            Log.e(TAG, "there is no available google account");
+            return null;
+        }
+
+        String accountName = NotesPreferenceActivity.getSyncAccountName(activity);
+        Account account = null;
+        for (Account a : accounts) {
+            if (a.name.equals(accountName)) {
+                account = a;
+                break;
+            }
+        }
+        if (account != null) {
+            mAccount = account;
+        } else {
+            Log.e(TAG, "unable to get an account with the same name in the settings");
+            return null;
+        }
+
+        // 获取认证令牌
+        AccountManagerFuture<Bundle> accountManagerFuture = accountManager.getAuthToken(account,
+                "goanna_mobile", null, activity, null, null);
+        try {
+            Bundle authTokenBundle = accountManagerFuture.getResult();
+            authToken = authTokenBundle.getString(AccountManager.KEY_AUTHTOKEN);
+            if (invalidateToken) {
+                accountManager.invalidateAuthToken("com.google", authToken);
+                loginGoogleAccount(activity, false);
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "get auth token failed");
+            authToken = null;
+        }
+
+        return authToken;
+    }
+
+    /**
+     * 尝试登录 Google Tasks 服务。
+     *
+     * @param activity 当前活动
+     * @param authToken 认证令牌
+     * @return 登录是否成功
+     */
+    private boolean tryToLoginGtask(Activity activity, String authToken) {
+        if (!loginGtask(authToken)) {
+            // 如果认证令牌过期，重新获取令牌并再次尝试登录
+            authToken = loginGoogleAccount(activity, true);
+            if (authToken == null) {
+                Log.e(TAG, "login google account failed");
+                return false;
+            }
+
+            if (!loginGtask(authToken)) {
+                Log.e(TAG, "login gtask failed");
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * 登录 Google Tasks 服务。
+     *
+     * @param authToken 认证令牌
+     * @return 登录是否成功
+     */
+    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);
+
+        try {
+            String loginUrl = mGetUrl + "?auth=" + authToken;
+            HttpGet httpGet = new HttpGet(loginUrl);
+            HttpResponse response = mHttpClient.execute(httpGet);
+
+            // 获取 Cookie
+            List<Cookie> cookies = mHttpClient.getCookieStore().getCookies();
+            boolean hasAuthCookie = false;
+            for (Cookie cookie : cookies) {
+                if (cookie.getName().contains("GTL")) {
+                    hasAuthCookie = true;
+                }
+            }
+            if (!hasAuthCookie) {
+                Log.w(TAG, "it seems that there is no auth cookie");
+            }
+
+            // 获取客户端版本
+            String resString = getResponseContent(response.getEntity());
+            String jsBegin = "_setup(";
+            String jsEnd = ")}</script>";
+            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);
+            }
+            JSONObject js = new JSONObject(jsString);
+            mClientVersion = js.getLong("v");
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return false;
+        } catch (Exception e) {
+            Log.e(TAG, "httpget gtask_url failed");
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * 获取操作 ID。
+     *
+     * @return 操作 ID
+     */
+    private int getActionId() {
+        return mActionId++;
+    }
+
+    /**
+     * 创建 HTTP POST 请求。
+     *
+     * @return 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;
+    }
+
+    /**
+     * 获取 HTTP 响应内容。
+     *
+     * @param entity HTTP 响应实体
+     * @return 响应内容
+     * @throws IOException 如果发生 I/O 异常
+     */
+    private String getResponseContent(HttpEntity entity) throws IOException {
+        String contentEncoding = null;
+        if (entity.getContentEncoding() != null) {
+            contentEncoding = entity.getContentEncoding().getValue();
+            Log.d(TAG, "encoding: " + contentEncoding);
+        }
+
+        InputStream input = entity.getContent();
+        if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip")) {
+            input = new GZIPInputStream(entity.getContent());
+        } else if (contentEncoding != null && contentEncoding.equalsIgnoreCase("deflate")) {
+            Inflater inflater = new Inflater(true);
+            input = new InflaterInputStream(entity.getContent(), inflater);
+        }
+
+        try {
+            InputStreamReader isr = new InputStreamReader(input);
+            BufferedReader br = new BufferedReader(isr);
+            StringBuilder sb = new StringBuilder();
+
+            while (true) {
+                String buff = br.readLine();
+                if (buff == null) {
+                    return sb.toString();
+                }
+                sb = sb.append(buff);
+            }
+        } finally {
+            input.close();
+        }
+    }
+
+    /**
+     * 发送 POST 请求。
+     *
+     * @param js JSON 对象，请求数据
+     * @return 响应 JSON 对象
+     * @throws NetworkFailureException 如果发生网络失败异常
+     */
+    private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
+        if (!mLoggedin) {
+            Log.e(TAG, "please login first");
+            throw new ActionFailureException("not logged in");
+        }
+
+        HttpPost httpPost = createHttpPost();
+        try {
+            LinkedList<BasicNameValuePair> list = new LinkedList<BasicNameValuePair>();
+            list.add(new BasicNameValuePair("r", js.toString()));
+            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8");
+            httpPost.setEntity(entity);
+
+            HttpResponse response = mHttpClient.execute(httpPost);
+            String jsString = getResponseContent(response.getEntity());
+            return new JSONObject(jsString);
+
+        } catch (ClientProtocolException e) {
+            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");
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            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");
+        }
+    }
+
+    /**
+     * 创建任务。
+     *
+     * @param task 任务对象
+     * @throws NetworkFailureException 如果发生网络失败异常
+     */
+    public void createTask(Task task) throws NetworkFailureException {
+        commitUpdate();
+        try {
+            JSONObject jsPost = new JSONObject();
+            JSONArray actionList = new JSONArray();
+
+            actionList.put(task.getCreateAction(getActionId()));
+            jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
+
+            jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+            JSONObject jsResponse = postRequest(jsPost);
+            JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(
+                    GTaskStringUtils.GTASK_JSON_RESULTS).get(0);
+            task.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID));
+
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("create task: handing jsonobject failed");
+        }
+    }
+
+    /**
+     * 创建任务列表。
+     *
+     * @param tasklist 任务列表对象
+     * @throws NetworkFailureException 如果发生网络失败异常
+     */
+    public void createTaskList(TaskList tasklist) throws NetworkFailureException {
+        commitUpdate();
+        try {
+            JSONObject jsPost = new JSONObject();
+            JSONArray actionList = new JSONArray();
+
+            actionList.put(tasklist.getCreateAction(getActionId()));
+            jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
+
+            jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+            JSONObject jsResponse = postRequest(jsPost);
+            JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(
+                    GTaskStringUtils.GTASK_JSON_RESULTS).get(0);
+            tasklist.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID));
+
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("create tasklist: handing jsonobject failed");
+        }
+    }
+
+    /**
+     * 提交更新操作。
+     *
+     * @throws NetworkFailureException 如果发生网络失败异常
+     */
+    public void commitUpdate() throws NetworkFailureException {
+        if (mUpdateArray != null) {
+            try {
+                JSONObject jsPost = new JSONObject();
+
+                jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, mUpdateArray);
+
+                jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+                postRequest(jsPost);
+                mUpdateArray = null;
+            } catch (JSONException e) {
+                Log.e(TAG, e.toString());
+                e.printStackTrace();
+                throw new ActionFailureException("commit update: handing jsonobject failed");
+            }
+        }
+    }
+
+    /**
+     * 添加更新节点。
+     *
+     * @param node 节点对象
+     * @throws NetworkFailureException 如果发生网络失败异常
+     */
+    public void addUpdateNode(Node node) throws NetworkFailureException {
+        if (node != null) {
+            if (mUpdateArray != null && mUpdateArray.length() > 10) {
+                commitUpdate();
+            }
+
+            if (mUpdateArray == null)
+                mUpdateArray = new JSONArray();
+            mUpdateArray.put(node.getUpdateAction(getActionId()));
+        }
+    }
+
+    /**
+     * 移动任务。
+     *
+     * @param task 任务对象
+     * @param preParent 原父任务列表
+     * @param curParent 当前父任务列表
+     * @throws NetworkFailureException 如果发生网络失败异常
+     */
+    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.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());
+            if (preParent == curParent && task.getPriorSibling() != null) {
+                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());
+            if (preParent != curParent) {
+                action.put(GTaskStringUtils.GTASK_JSON_DEST_LIST, curParent.getGid());
+            }
+            actionList.put(action);
+            jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
+
+            jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+            postRequest(jsPost);
+
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("move task: handing jsonobject failed");
+        }
+    }
+
+    /**
+     * 删除节点。
+     *
+     * @param node 节点对象
+     * @throws NetworkFailureException 如果发生网络失败异常
+     */
+    public void deleteNode(Node node) throws NetworkFailureException {
+        commitUpdate();
+        try {
+            JSONObject jsPost = new JSONObject();
+            JSONArray actionList = new JSONArray();
+
+            node.setDeleted(true);
+            actionList.put(node.getUpdateAction(getActionId()));
+            jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
+
+            jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+            postRequest(jsPost);
+            mUpdateArray = null;
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("delete node: handing jsonobject failed");
+        }
+    }
+
+    /**
+     * 获取任务列表。
+     *
+     * @return 任务列表 JSON 数组
+     * @throws NetworkFailureException 如果发生网络失败异常
+     */
+    public JSONArray getTaskLists() throws NetworkFailureException {
+        if (!mLoggedin) {
+            Log.e(TAG, "please login first");
+            throw new ActionFailureException("not logged in");
+        }
+
+        try {
+            HttpGet httpGet = new HttpGet(mGetUrl);
+            HttpResponse response = mHttpClient.execute(httpGet);
+
+            String resString = getResponseContent(response.getEntity());
+            String jsBegin = "_setup(";
+            String jsEnd = ")}</script>";
+            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);
+            }
+            JSONObject js = new JSONObject(jsString);
+            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");
+        } catch (IOException e) {
+            Log.e(TAG, e.toString());
+            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");
+        }
+    }
+
+    /**
+     * 获取指定任务列表中的任务。
+     *
+     * @param listGid 任务列表 ID
+     * @return 任务 JSON 数组
+     * @throws NetworkFailureException 如果发生网络失败异常
+     */
+    public JSONArray getTaskList(String listGid) throws NetworkFailureException {
+        commitUpdate();
+        try {
+            JSONObject jsPost = new JSONObject();
+            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());
+            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);
+
+            jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+            JSONObject jsResponse = postRequest(jsPost);
+            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");
+        }
+    }
+
+    /**
+     * 获取同步账户。
+     *
+     * @return 账户对象
+     */
+    public Account getSyncAccount() {
+        return mAccount;
+    }
+
+    /**
+     * 重置更新操作数组。
+     */
+    public void resetUpdateArray() {
+        mUpdateArray = null;
+    }
+}

src/net/micode/notes/gtask/remote/GTaskManager.java

@@ -0,0 +1,821 @@
+/*
+ * 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
+ *
+ *        <url id="d0vurui1ol7h2e909ih0" type="url" status="parsed" title="Apache License, Version 2.0" wc="10467">http://www.apache.org/licenses/LICENSE-2.0</url>
+ *
+ * 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.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;
+
+
+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;
+
+    // Google 任务列表的哈希映射
+    private HashMap<String, TaskList> mGTaskListHashMap;
+
+    // Google 任务的哈希映射
+    private HashMap<String, Node> mGTaskHashMap;
+
+    // 元数据的哈希映射
+    private HashMap<String, MetaData> mMetaHashMap;
+
+    // 元数据列表
+    private TaskList mMetaList;
+
+    // 本地删除的 ID 集合
+    private HashSet<Long> mLocalDeleteIdMap;
+
+    // Google ID 到本地 ID 的映射
+    private HashMap<String, Long> mGidToNid;
+
+    // 本地 ID 到 Google ID 的映射
+    private HashMap<Long, String> mNidToGid;
+
+    // 私有构造函数，用于单例模式
+    private GTaskManager() {
+        mSyncing = false;
+        mCancelled = false;
+        mGTaskListHashMap = new HashMap<String, TaskList>();
+        mGTaskHashMap = new HashMap<String, Node>();
+        mMetaHashMap = new HashMap<String, MetaData>();
+        mMetaList = null;
+        mLocalDeleteIdMap = new HashSet<Long>();
+        mGidToNid = new HashMap<String, Long>();
+        mNidToGid = new HashMap<Long, String>();
+    }
+
+    // 获取单例实例
+    public static synchronized GTaskManager getInstance() {
+        if (mInstance == null) {
+            mInstance = new GTaskManager();
+        }
+        return mInstance;
+    }
+
+    // 设置活动上下文
+    public synchronized void setActivityContext(Activity activity) {
+        // 用于获取认证令牌
+        mActivity = activity;
+    }
+
+    // 同步任务
+    public int sync(Context context, GTaskASyncTask asyncTask) {
+        if (mSyncing) {
+            Log.d(TAG, "Sync is in progress");
+            return STATE_SYNC_IN_PROGRESS;
+        }
+        mContext = context;
+        mContentResolver = mContext.getContentResolver();
+        mSyncing = true;
+        mCancelled = false;
+        // 清空映射和集合
+        mGTaskListHashMap.clear();
+        mGTaskHashMap.clear();
+        mMetaHashMap.clear();
+        mLocalDeleteIdMap.clear();
+        mGidToNid.clear();
+        mNidToGid.clear();
+
+        try {
+            GTaskClient client = GTaskClient.getInstance();
+            client.resetUpdateArray();
+
+            // 登录 Google 任务
+            if (!mCancelled) {
+                if (!client.login(mActivity)) {
+                    throw new NetworkFailureException("login google task failed");
+                }
+            }
+
+            // 初始化 Google 任务列表
+            asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
+            initGTaskList();
+
+            // 同步内容
+            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) {
+            Log.e(TAG, e.toString());
+            return STATE_INTERNAL_ERROR;
+        } catch (Exception e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return STATE_INTERNAL_ERROR;
+        } finally {
+            // 清空映射和集合
+            mGTaskListHashMap.clear();
+            mGTaskHashMap.clear();
+            mMetaHashMap.clear();
+            mLocalDeleteIdMap.clear();
+            mGidToNid.clear();
+            mNidToGid.clear();
+            mSyncing = false;
+        }
+
+        return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
+    }
+
+    // 初始化 Google 任务列表
+    private void initGTaskList() throws NetworkFailureException {
+        if (mCancelled)
+            return;
+        GTaskClient client = GTaskClient.getInstance();
+        try {
+            JSONArray jsTaskLists = client.getTaskLists();
+
+            // 初始化元数据列表
+            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);
+
+                    // 加载元数据
+                    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);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 如果元数据列表不存在，则创建
+            if (mMetaList == null) {
+                mMetaList = new TaskList();
+                mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+                        + GTaskStringUtils.FOLDER_META);
+                GTaskClient.getInstance().createTaskList(mMetaList);
+            }
+
+            // 初始化任务列表
+            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);
+
+                    // 加载任务
+                    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);
+                        }
+                    }
+                }
+            }
+        } catch (JSONException e) {
+            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;
+
+        mLocalDeleteIdMap.clear();
+
+        if (mCancelled) {
+            return;
+        }
+
+        // 同步本地删除的笔记
+        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);
+                    }
+
+                    mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
+                }
+            } else {
+                Log.w(TAG, "failed to query trash folder");
+            }
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // 同步文件夹
+        syncFolder();
+
+        // 同步数据库中存在的笔记
+        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 {
+                        if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
+                            // 本地添加
+                            syncType = Node.SYNC_ACTION_ADD_REMOTE;
+                        } else {
+                            // 远程删除
+                            syncType = Node.SYNC_ACTION_DEL_LOCAL;
+                        }
+                    }
+                    doContentSync(syncType, node, c);
+                }
+            } else {
+                Log.w(TAG, "failed to query existing note in database");
+            }
+
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // 同步剩余项目
+        Iterator<Map.Entry<String, Node>> iter = mGTaskHashMap.entrySet().iterator();
+        while (iter.hasNext()) {
+            Map.Entry<String, Node> entry = iter.next();
+            node = entry.getValue();
+            doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
+        }
+
+        // 清除本地删除表
+        if (!mCancelled) {
+            if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) {
+                throw new ActionFailureException("failed to batch-delete local deleted notes");
+            }
+        }
+
+        // 刷新本地同步 ID
+        if (!mCancelled) {
+            GTaskClient.getInstance().commitUpdate();
+            refreshLocalSyncId();
+        }
+    }
+
+    // 同步文件夹
+    private void syncFolder() throws NetworkFailureException {
+        Cursor c = null;
+        String gid;
+        Node node;
+        int syncType;
+
+        if (mCancelled) {
+            return;
+        }
+
+        // 同步根文件夹
+        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);
+                    // 如果系统文件夹名称不同，则更新远程名称
+                    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);
+                }
+            } else {
+                Log.w(TAG, "failed to query root folder");
+            }
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // 同步通话记录文件夹
+        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);
+                        // 如果系统文件夹名称不同，则更新远程名称
+                        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);
+                    }
+                }
+            } else {
+                Log.w(TAG, "failed to query call note folder");
+            }
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // 同步数据库中存在的文件夹
+        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);
+                    } else {
+                        if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
+                            // 本地添加
+                            syncType = Node.SYNC_ACTION_ADD_REMOTE;
+                        } else {
+                            // 远程删除
+                            syncType = Node.SYNC_ACTION_DEL_LOCAL;
+                        }
+                    }
+                    doContentSync(syncType, node, c);
+                }
+            } else {
+                Log.w(TAG, "failed to query existing folder");
+            }
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // 同步远程添加的文件夹
+        Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
+        while (iter.hasNext()) {
+            Map.Entry<String, TaskList> entry = iter.next();
+            gid = entry.getKey();
+            node = entry.getValue();
+            if (mGTaskHashMap.containsKey(gid)) {
+                mGTaskHashMap.remove(gid);
+                doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
+            }
+        }
+
+        if (!mCancelled)
+            GTaskClient.getInstance().commitUpdate();
+    }
+
+    // 执行内容同步
+    private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        MetaData meta;
+        switch (syncType) {
+            case Node.SYNC_ACTION_ADD_LOCAL:
+                addLocalNode(node);
+                break;
+            case Node.SYNC_ACTION_ADD_REMOTE:
+                addRemoteNode(node, c);
+                break;
+            case Node.SYNC_ACTION_DEL_LOCAL:
+                meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN));
+                if (meta != null) {
+                    GTaskClient.getInstance().deleteNode(meta);
+                }
+                mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
+                break;
+            case Node.SYNC_ACTION_DEL_REMOTE:
+                meta = mMetaHashMap.get(node.getGid());
+                if (meta != null) {
+                    GTaskClient.getInstance().deleteNode(meta);
+                }
+                GTaskClient.getInstance().deleteNode(node);
+                break;
+            case Node.SYNC_ACTION_UPDATE_LOCAL:
+                updateLocalNode(node, c);
+                break;
+            case Node.SYNC_ACTION_UPDATE_REMOTE:
+                updateRemoteNode(node, c);
+                break;
+            case Node.SYNC_ACTION_UPDATE_CONFLICT:
+                // 合并冲突修改（当前简单地使用本地更新）
+                updateRemoteNode(node, c);
+                break;
+            case Node.SYNC_ACTION_NONE:
+                break;
+            case Node.SYNC_ACTION_ERROR:
+            default:
+                throw new ActionFailureException("unknown sync action type");
+        }
+    }
+
+    // 添加本地节点
+    private void addLocalNode(Node node) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        SqlNote sqlNote;
+        if (node instanceof TaskList) {
+            if (node.getName().equals(
+                    GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) {
+                sqlNote = 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);
+            } else {
+                sqlNote = new SqlNote(mContext);
+                sqlNote.setContent(node.getLocalJSONFromContent());
+                sqlNote.setParentId(Notes.ID_ROOT_FOLDER);
+            }
+        } else {
+            sqlNote = new SqlNote(mContext);
+            JSONObject js = node.getLocalJSONFromContent();
+            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)) {
+                            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)) {
+                                data.remove(DataColumns.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");
+            }
+            sqlNote.setParentId(parentId.longValue());
+        }
+
+        // 创建本地节点
+        sqlNote.setGtaskId(node.getGid());
+        sqlNote.commit(false);
+
+        // 更新 Google ID 到本地 ID 的映射
+        mGidToNid.put(node.getGid(), sqlNote.getId());
+        mNidToGid.put(sqlNote.getId(), node.getGid());
+
+        // 更新元数据
+        updateRemoteMeta(node.getGid(), sqlNote);
+    }
+
+    // 更新本地节点
+    private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        SqlNote sqlNote;
+        // 更新本地节点
+        sqlNote = new SqlNote(mContext, c);
+        sqlNote.setContent(node.getLocalJSONFromContent());
+
+        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);
+    }
+
+    // 添加远程节点
+    private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        SqlNote sqlNote = new SqlNote(mContext, c);
+        Node n;
+
+        // 更新远程节点
+        if (sqlNote.isNoteType()) {
+            Task task = new Task();
+            task.setContentByLocalJSON(sqlNote.getContent());
+
+            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);
+
+            GTaskClient.getInstance().createTask(task);
+            n = (Node) task;
+
+            // 添加元数据
+            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<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
+            while (iter.hasNext()) {
+                Map.Entry<String, TaskList> 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;
+                }
+            }
+
+            // 添加新文件夹
+            if (tasklist == null) {
+                tasklist = new TaskList();
+                tasklist.setContentByLocalJSON(sqlNote.getContent());
+                GTaskClient.getInstance().createTaskList(tasklist);
+                mGTaskListHashMap.put(tasklist.getGid(), tasklist);
+            }
+            n = (Node) tasklist;
+        }
+
+        // 更新本地节点
+        sqlNote.setGtaskId(n.getGid());
+        sqlNote.commit(false);
+        sqlNote.resetLocalModified();
+        sqlNote.commit(true);
+
+        // 更新 Google ID 到本地 ID 的映射
+        mGidToNid.put(n.getGid(), sqlNote.getId());
+        mNidToGid.put(sqlNote.getId(), n.getGid());
+    }
+
+    // 更新远程节点
+    private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        SqlNote sqlNote = new SqlNote(mContext, c);
+
+        // 更新远程节点
+        node.setContentByLocalJSON(sqlNote.getContent());
+        GTaskClient.getInstance().addUpdateNode(node);
+
+        // 更新元数据
+        updateRemoteMeta(node.getGid(), sqlNote);
+
+        // 移动任务（如果需要）
+        if (sqlNote.isNoteType()) {
+            Task task = (Task) node;
+            TaskList preParentList = task.getParent();
+
+            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);
+
+            if (preParentList != curParentList) {
+                preParentList.removeChildTask(task);
+                curParentList.addChildTask(task);
+                GTaskClient.getInstance().moveTask(task, preParentList, curParentList);
+            }
+        }
+
+        // 清除本地修改标记
+        sqlNote.resetLocalModified();
+        sqlNote.commit(true);
+    }
+
+    // 更新远程元数据
+    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);
+            }
+        }
+    }
+
+    // 刷新本地同步 ID
+    private void refreshLocalSyncId() throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        // 获取最新的 Google 任务列表
+        mGTaskHashMap.clear();
+        mGTaskListHashMap.clear();
+        mMetaHashMap.clear();
+        initGTaskList();
+
+        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");
+                    }
+                }
+            } else {
+                Log.w(TAG, "failed to query local note to refresh sync id");
+            }
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+    }
+
+    // 获取同步账户
+    public String getSyncAccount() {
+        return GTaskClient.getInstance().getSyncAccount().name;
+    }
+
+    // 取消同步
+    public void cancelSync() {
+        mCancelled = true;
+    }
+}

src/net/micode/notes/gtask/remote/GTaskSyncService.java

@@ -0,0 +1,146 @@
+/*
+ * 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
+ *
+ *        <url id="d0vutuf37oq2m9lhs9r0" type="url" status="parsed" title="Apache License, Version 2.0" wc="10467">http://www.apache.org/licenses/LICENSE-2.0</url>
+ *
+ * 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.remote;
+
+import android.app.Activity;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.IBinder;
+
+public class GTaskSyncService extends Service {
+    // 广播 Action 名称，用于标识同步服务的广播
+    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";
+
+    // 操作类型常量
+    public final static int ACTION_START_SYNC = 0; // 开始同步
+    public final static int ACTION_CANCEL_SYNC = 1; // 取消同步
+    public final static int ACTION_INVALID = 2; // 无效操作
+
+    // 操作类型键，用于 Intent 额外数据
+    public final static String ACTION_STRING_NAME = "sync_action_type";
+
+    // 同步任务实例
+    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(); // 停止服务
+                }
+            });
+            sendBroadcast(""); // 发送广播通知同步开始
+            mSyncTask.execute(); // 执行同步任务
+        }
+    }
+
+    // 取消同步操作
+    private void cancelSync() {
+        if (mSyncTask != null) {
+            mSyncTask.cancelSync(); // 取消同步任务
+        }
+    }
+
+    // 服务创建时调用
+    @Override
+    public void onCreate() {
+        mSyncTask = null; // 初始化同步任务为 null
+    }
+
+    // 服务启动时调用
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        Bundle bundle = intent.getExtras();
+        if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
+            // 根据操作类型执行相应操作
+            switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
+                case ACTION_START_SYNC:
+                    startSync(); // 开始同步
+                    break;
+                case ACTION_CANCEL_SYNC:
+                    cancelSync(); // 取消同步
+                    break;
+                default:
+                    break;
+            }
+            return START_STICKY; // 返回 sticky 模式，确保服务被系统杀死后重新创建
+        }
+        return super.onStartCommand(intent, flags, startId);
+    }
+
+    // 内存不足时调用
+    @Override
+    public void onLowMemory() {
+        if (mSyncTask != null) {
+            mSyncTask.cancelSync(); // 取消同步任务
+        }
+    }
+
+    // 绑定服务时调用
+    public IBinder onBind(Intent intent) {
+        return null; // 返回 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); // 发送广播
+    }
+
+    // 静态方法，启动同步服务
+    public static void startSync(Activity activity) {
+        GTaskManager.getInstance().setActivityContext(activity); // 设置活动上下文
+        Intent intent = new Intent(activity, GTaskSyncService.class); // 创建 Intent
+        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
+        intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC); // 添加操作类型额外数据
+        context.startService(intent); // 启动服务
+    }
+
+    // 静态方法，检查是否正在同步
+    public static boolean isSyncing() {
+        return mSyncTask != null; // 返回同步任务是否为 null
+    }
+
+    // 静态方法，获取同步进度消息
+    public static String getProgressString() {
+        return mSyncProgress; // 返回同步进度消息
+    }
+}

src/net/micode/notes/model/Note.java

@@ -0,0 +1,245 @@
+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 上下文对象，用于访问ContentResolver
+     * @param folderId 新笔记所属文件夹的ID
+     * @return 新创建的笔记ID。如果创建失败则返回0
+     * @throws IllegalStateException 如果插入后返回的ID为-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);
+        long noteId = 0;
+        try {
+            noteId = Long.parseLong(uri.getPathSegments().get(1)); // 从Uri解析新笔记ID
+        } catch (NumberFormatException e) {
+            Log.e(TAG, "解析笔记ID错误: " + e);
+        }
+        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，否则false
+     * @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, "更新笔记失败，noteId: " + noteId);
+        }
+        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) {
+            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(ContentUris.parseId(uri));
+                    } catch (Exception e) {
+                        Log.e(TAG, "插入文本数据失败, noteId: " + noteId);
+                        mTextDataValues.clear();
+                        return null;
+                    }
+                } else { // 已有数据，执行更新
+                    ContentProviderOperation op = ContentProviderOperation.newUpdate(
+                            ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, mTextDataId))
+                            .withValues(mTextDataValues).build();
+                    operationList.add(op);
+                }
+                mTextDataValues.clear();
+            }
+
+            // 处理通话记录数据（逻辑类似文本数据）
+            if (mCallDataValues.size() > 0) {
+                // ...（省略类似处理逻辑）
+            }
+
+            // 执行批量操作
+            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/net/micode/notes/model/WorkingNote.java

@@ -0,0 +1,206 @@
+package net.micode.notes.model;
+
+import android.appwidget.AppWidgetManager;
+import android.content.ContentUris;
+import android.content.Context;
+import android.database.Cursor;
+import android.text.TextUtils;
+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.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.Notes.TextNote;
+import net.micode.notes.tool.ResourceParser.NoteBgResources;
+
+/**
+ * 表示一个正在编辑或显示的笔记，负责管理笔记的加载、保存和数据同步
+ */
+public class WorkingNote {
+    // 核心Note对象，用于实际数据操作
+    private Note mNote;
+    // 当前笔记的数据库ID（0表示新笔记）
+    private long mNoteId;
+    // 笔记的文本内容
+    private String mContent;
+    // 笔记模式（普通模式/清单模式）
+    private int mMode;
+
+    private long mAlertDate;    // 提醒时间
+    private long mModifiedDate; // 最后修改时间
+    private int mBgColorId;     // 背景颜色ID
+    private int mWidgetId;      // 关联的小部件ID
+    private int mWidgetType;    // 小部件类型
+    private long mFolderId;     // 所属文件夹ID
+    private Context mContext;   // 上下文对象
+    private static final String TAG = "WorkingNote"; // 日志标签
+    private boolean mIsDeleted; // 标记是否已删除
+    private NoteSettingChangedListener mNoteSettingStatusListener; // 设置变更监听器
+
+    // 数据库查询使用的列定义（数据表）
+    public static final String[] DATA_PROJECTION = new String[] {
+            DataColumns.ID,
+            DataColumns.CONTENT,
+            DataColumns.MIME_TYPE,
+            DataColumns.DATA1,  // 模式字段
+            DataColumns.DATA2,
+            DataColumns.DATA3,
+            DataColumns.DATA4,
+    };
+
+    // 数据库查询使用的列定义（笔记表）
+    public static final String[] NOTE_PROJECTION = new String[] {
+            NoteColumns.PARENT_ID,       // 父文件夹ID
+            NoteColumns.ALERTED_DATE,     // 提醒时间
+            NoteColumns.BG_COLOR_ID,     // 背景色ID
+            NoteColumns.WIDGET_ID,        // 小部件ID
+            NoteColumns.WIDGET_TYPE,      // 小部件类型
+            NoteColumns.MODIFIED_DATE     // 修改时间
+    };
+
+    // 数据表列索引常量
+    private static final int DATA_ID_COLUMN = 0;
+    private static final int DATA_CONTENT_COLUMN = 1;
+    private static final int DATA_MIME_TYPE_COLUMN = 2;
+    private static final int DATA_MODE_COLUMN = 3;
+
+    // 笔记表列索引常量
+    private static final int NOTE_PARENT_ID_COLUMN = 0;
+    private static final int NOTE_ALERTED_DATE_COLUMN = 1;
+    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
+    private static final int NOTE_WIDGET_ID_COLUMN = 3;
+    private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
+    private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
+
+    /**
+     * 创建新笔记的构造函数
+     * @param context 上下文对象
+     * @param folderId 所属文件夹ID
+     */
+    private WorkingNote(Context context, long folderId) {
+        mContext = context;
+        mAlertDate = 0;  // 默认无提醒
+        mModifiedDate = System.currentTimeMillis();
+        mFolderId = folderId;
+        mNote = new Note();
+        mNoteId = 0;     // 新笔记初始ID为0
+        mIsDeleted = false;
+        mMode = 0;       // 默认普通模式
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 无效小部件类型
+    }
+
+    /**
+     * 加载现有笔记的构造函数
+     * @param context 上下文对象
+     * @param noteId 存在的笔记ID
+     * @param folderId 所属文件夹ID
+     */
+    private WorkingNote(Context context, long noteId, long folderId) {
+        mContext = context;
+        mNoteId = noteId;
+        mFolderId = folderId;
+        mIsDeleted = false;
+        mNote = new Note();
+        loadNote(); // 从数据库加载数据
+    }
+
+    /**
+     * 从数据库加载笔记元数据
+     * @throws IllegalArgumentException 如果找不到对应笔记时抛出
+     */
+    private void loadNote() {
+        // 构建笔记URI并查询
+        Cursor cursor = mContext.getContentResolver().query(
+                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId),
+                NOTE_PROJECTION, null, null, null);
+
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                // 解析查询结果
+                mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
+                mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
+                mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN);
+                mWidgetType = cursor.getInt(NOTE_WIDGET_TYPE_COLUMN);
+                mAlertDate = cursor.getLong(NOTE_ALERTED_DATE_COLUMN);
+                mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN);
+            }
+            cursor.close();
+        } else {
+            Log.e(TAG, "找不到ID为 " + mNoteId + " 的笔记");
+            throw new IllegalArgumentException("找不到笔记: " + mNoteId);
+        }
+        loadNoteData(); // 加载笔记内容数据
+    }
+
+    /**
+     * 加载笔记的具体内容数据（文本/通话记录）
+     */
+    private void loadNoteData() {
+        // 查询数据表
+        Cursor cursor = mContext.getContentResolver().query(
+                Notes.CONTENT_DATA_URI, 
+                DATA_PROJECTION,
+                DataColumns.NOTE_ID + "=?", 
+                new String[] { String.valueOf(mNoteId) }, 
+                null);
+
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                do {
+                    String type = cursor.getString(DATA_MIME_TYPE_COLUMN);
+                    if (DataConstants.NOTE.equals(type)) { // 文本笔记
+                        mContent = cursor.getString(DATA_CONTENT_COLUMN);
+                        mMode = cursor.getInt(DATA_MODE_COLUMN);
+                        mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN));
+                    } else if (DataConstants.CALL_NOTE.equals(type)) { // 通话笔记
+                        mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN));
+                    } else {
+                        Log.d(TAG, "未知笔记类型: " + type);
+                    }
+                } while (cursor.moveToNext());
+            }
+            cursor.close();
+        } else {
+            Log.e(TAG, "找不到ID为 " + mNoteId + " 的笔记数据");
+            throw new IllegalArgumentException("找不到笔记数据: " + mNoteId);
+        }
+    }
+
+    /**
+     * 创建新的空笔记
+     * @param context 上下文
+     * @param folderId 文件夹ID
+     * @param widgetId 关联小部件ID
+     * @param widgetType 小部件类型
+     * @param defaultBgColorId 默认背景色
+     * @return 新创建的WorkingNote对象
+     */
+    public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
+            int widgetType, int defaultBgColorId) {
+        WorkingNote note = new WorkingNote(context, folderId);
+        note.setBgColorId(defaultBgColorId);
+        note.setWidgetId(widgetId);
+        note.setWidgetType(widgetType);
+        return note;
+    }
+
+    /**
+     * 加载现有笔记
+     * @param context 上下文
+     * @param id 笔记ID
+     * @return 加载后的WorkingNote对象
+     */
+    public static WorkingNote load(Context context, long id) {
+        return new WorkingNote(context, id, 0);
+    }
+
+    /**
+     * 保存笔记到数据库（同步修改）
+     * @return 保存成功返回true，否则false
+     */
+    public synchronized boolean saveNote() {
+        if (isWorthSaving()) { // 检查是否需要保存
+            if (!existInDatabase()) { // 新笔记需要生成ID
+                if ((mNoteId =

src/net/micode/notes/tool/BackupUtils.java

@@ -0,0 +1,361 @@
+/*
+ * 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.tool;
+
+ import android.content.Context;
+ import android.database.Cursor;
+ import android.os.Environment;
+ import android.text.TextUtils;
+ import android.text.format.DateFormat;
+ 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.DataConstants;
+ import net.micode.notes.data.Notes.NoteColumns;
+ 
+ import java.io.File;
+ import java.io.FileNotFoundException;
+ import java.io.FileOutputStream;
+ import java.io.IOException;
+ import java.io.PrintStream;
+ 
+ /**
+  * 备份工具类，用于将笔记数据导出为文本文件
+  */
+ public class BackupUtils {
+     private static final String TAG = "BackupUtils";
+     
+     // 单例模式实现
+     private static BackupUtils sInstance;
+ 
+     public static synchronized BackupUtils getInstance(Context context) {
+         if (sInstance == null) {
+             sInstance = new BackupUtils(context);
+         }
+         return sInstance;
+     }
+ 
+     /**
+      * 备份/恢复状态码常量定义
+      */
+     public static final int STATE_SD_CARD_UNMOUONTED = 0;    // SD卡未挂载
+     public static final int STATE_BACKUP_FILE_NOT_EXIST = 1; // 备份文件不存在
+     public static final int STATE_DATA_DESTROIED = 2;        // 数据被破坏
+     public static final int STATE_SYSTEM_ERROR = 3;          // 系统错误
+     public static final int STATE_SUCCESS = 4;               // 操作成功
+ 
+     private TextExport mTextExport;  // 文本导出处理器
+ 
+     // 私有构造函数初始化文本导出组件
+     private BackupUtils(Context context) {
+         mTextExport = new TextExport(context);
+     }
+ 
+     // 检查外部存储是否可用
+     private static boolean externalStorageAvailable() {
+         return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
+     }
+ 
+     // 执行文本导出操作
+     public int exportToText() {
+         return mTextExport.exportToText();
+     }
+ 
+     // 获取导出文件名
+     public String getExportedTextFileName() {
+         return mTextExport.mFileName;
+     }
+ 
+     // 获取导出文件目录
+     public String getExportedTextFileDir() {
+         return mTextExport.mFileDirectory;
+     }
+ 
+     /**
+      * 文本导出内部类，处理具体的导出逻辑
+      */
+     private static class TextExport {
+         // 笔记查询字段投影
+         private static final String[] NOTE_PROJECTION = {
+                 NoteColumns.ID,
+                 NoteColumns.MODIFIED_DATE,
+                 NoteColumns.SNIPPET,
+                 NoteColumns.TYPE
+         };
+         private static final int NOTE_COLUMN_ID = 0;            // 笔记ID列索引
+         private static final int NOTE_COLUMN_MODIFIED_DATE = 1; // 修改时间列索引
+         private static final int NOTE_COLUMN_SNIPPET = 2;      // 内容片段列索引
+ 
+         // 笔记数据查询字段投影
+         private static final String[] DATA_PROJECTION = {
+                 DataColumns.CONTENT,
+                 DataColumns.MIME_TYPE,
+                 DataColumns.DATA1,
+                 DataColumns.DATA2,
+                 DataColumns.DATA3,
+                 DataColumns.DATA4,
+         };
+         private static final int DATA_COLUMN_CONTENT = 0;     // 内容列索引
+         private static final int DATA_COLUMN_MIME_TYPE = 1;    // MIME类型列索引
+         private static final int DATA_COLUMN_CALL_DATE = 2;    // 通话日期列索引
+         private static final int DATA_COLUMN_PHONE_NUMBER = 4; // 电话号码列索引
+ 
+         // 文本格式化模板数组（从资源文件加载）
+         private final String[] TEXT_FORMAT;
+         private static final int FORMAT_FOLDER_NAME = 0;  // 文件夹名称格式
+         private static final int FORMAT_NOTE_DATE = 1;     // 笔记日期格式
+         private static final int FORMAT_NOTE_CONTENT = 2;  // 笔记内容格式
+ 
+         private Context mContext;        // 上下文对象
+         private String mFileName;        // 导出文件名
+         private String mFileDirectory;   // 导出文件目录
+ 
+         // 构造函数初始化资源
+         public TextExport(Context context) {
+             TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
+             mContext = context;
+             mFileName = "";
+             mFileDirectory = "";
+         }
+ 
+         // 获取指定格式模板
+         private String getFormat(int id) {
+             return TEXT_FORMAT[id];
+         }
+ 
+         /**
+          * 导出指定文件夹下的笔记到文本流
+          * @param folderId 要导出的文件夹ID
+          * @param ps 输出打印流
+          */
+         private void exportFolderToText(String folderId, PrintStream ps) {
+             // 查询属于该文件夹的笔记
+             Cursor notesCursor = mContext.getContentResolver().query(
+                     Notes.CONTENT_NOTE_URI,
+                     NOTE_PROJECTION,
+                     NoteColumns.PARENT_ID + "=?",
+                     new String[]{folderId},
+                     null);
+ 
+             if (notesCursor != null) {
+                 if (notesCursor.moveToFirst()) {
+                     do {
+                         // 输出笔记修改日期
+                         ps.println(String.format(getFormat(FORMAT_NOTE_DATE),
+                                 DateFormat.format(
+                                         mContext.getString(R.string.format_datetime_mdhm),
+                                         notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE)));
+                         // 导出该笔记的具体内容
+                         String noteId = notesCursor.getString(NOTE_COLUMN_ID);
+                         exportNoteToText(noteId, ps);
+                     } while (notesCursor.moveToNext());
+                 }
+                 notesCursor.close();
+             }
+         }
+ 
+         /**
+          * 导出指定笔记到文本流
+          * @param noteId 要导出的笔记ID
+          * @param ps 输出打印流
+          */
+         private void exportNoteToText(String noteId, PrintStream ps) {
+             // 查询该笔记的所有数据项
+             Cursor dataCursor = mContext.getContentResolver().query(
+                     Notes.CONTENT_DATA_URI,
+                     DATA_PROJECTION,
+                     DataColumns.NOTE_ID + "=?",
+                     new String[]{noteId},
+                     null);
+ 
+             if (dataCursor != null) {
+                 if (dataCursor.moveToFirst()) {
+                     do {
+                         String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
+                         if (DataConstants.CALL_NOTE.equals(mimeType)) {
+                             // 处理通话记录类型数据
+                             String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER);
+                             long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE);
+                             String location = dataCursor.getString(DATA_COLUMN_CONTENT);
+ 
+                             if (!TextUtils.isEmpty(phoneNumber)) {
+                                 ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), phoneNumber));
+                             }
+                             // 输出通话日期
+                             ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
+                                     .format(mContext.getString(R.string.format_datetime_mdhm),
+                                             callDate)));
+                             // 输出通话位置信息
+                             if (!TextUtils.isEmpty(location)) {
+                                 ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), location));
+                             }
+                         } else if (DataConstants.NOTE.equals(mimeType)) {
+                             // 处理普通笔记类型数据
+                             String content = dataCursor.getString(DATA_COLUMN_CONTENT);
+                             if (!TextUtils.isEmpty(content)) {
+                                 ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), content));
+                             }
+                         }
+                     } while (dataCursor.moveToNext());
+                 }
+                 dataCursor.close();
+             }
+             // 写入行分隔符
+             try {
+                 ps.write(new byte[]{Character.LINE_SEPARATOR, Character.LETTER_NUMBER});
+             } catch (IOException e) {
+                 Log.e(TAG, "写入分隔符失败", e);
+             }
+         }
+ 
+         /**
+          * 执行文本导出主逻辑
+          * @return 操作状态码
+          */
+         public int exportToText() {
+             if (!externalStorageAvailable()) {
+                 Log.d(TAG, "外部存储不可用");
+                 return STATE_SD_CARD_UNMOUONTED;
+             }
+ 
+             PrintStream ps = getExportToTextPrintStream();
+             if (ps == null) {
+                 Log.e(TAG, "获取输出流失败");
+                 return STATE_SYSTEM_ERROR;
+             }
+ 
+             // 导出所有文件夹（排除回收站）
+             Cursor folderCursor = mContext.getContentResolver().query(
+                     Notes.CONTENT_NOTE_URI,
+                     NOTE_PROJECTION,
+                     "(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND "
+                             + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
+                             + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER,
+                     null,
+                     null);
+ 
+             if (folderCursor != null) {
+                 if (folderCursor.moveToFirst()) {
+                     do {
+                         // 获取文件夹名称
+                         String folderName = "";
+                         if(folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {
+                             folderName = mContext.getString(R.string.call_record_folder_name);
+                         } else {
+                             folderName = folderCursor.getString(NOTE_COLUMN_SNIPPET);
+                         }
+                         if (!TextUtils.isEmpty(folderName)) {
+                             ps.println(String.format(getFormat(FORMAT_FOLDER_NAME), folderName));
+                         }
+                         // 导出该文件夹内容
+                         String folderId = folderCursor.getString(NOTE_COLUMN_ID);
+                         exportFolderToText(folderId, ps);
+                     } while (folderCursor.moveToNext());
+                 }
+                 folderCursor.close();
+             }
+ 
+             // 导出根目录下的笔记
+             Cursor noteCursor = mContext.getContentResolver().query(
+                     Notes.CONTENT_NOTE_URI,
+                     NOTE_PROJECTION,
+                     NoteColumns.TYPE + "=" + Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID + "=0",
+                     null,
+                     null);
+ 
+             if (noteCursor != null) {
+                 if (noteCursor.moveToFirst()) {
+                     do {
+                         ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
+                                 mContext.getString(R.string.format_datetime_mdhm),
+                                 noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
+                         String noteId = noteCursor.getString(NOTE_COLUMN_ID);
+                         exportNoteToText(noteId, ps);
+                     } while (noteCursor.moveToNext());
+                 }
+                 noteCursor.close();
+             }
+             ps.close();
+ 
+             return STATE_SUCCESS;
+         }
+ 
+         /**
+          * 创建导出文件的打印流
+          * @return 配置好的PrintStream对象
+          */
+         private PrintStream getExportToTextPrintStream() {
+             File file = generateFileMountedOnSDcard(
+                     mContext, 
+                     R.string.file_path,
+                     R.string.file_name_txt_format);
+             if (file == null) {
+                 Log.e(TAG, "创建导出文件失败");
+                 return null;
+             }
+             mFileName = file.getName();
+             mFileDirectory = mContext.getString(R.string.file_path);
+             
+             try {
+                 return new PrintStream(new FileOutputStream(file));
+             } catch (FileNotFoundException e) {
+                 Log.e(TAG, "文件未找到", e);
+             } catch (NullPointerException e) {
+                 Log.e(TAG, "空指针异常", e);
+             }
+             return null;
+         }
+     }
+ 
+     /**
+      * 在SD卡上生成指定格式的文件
+      * @param context 上下文对象
+      * @param filePathResId 文件路径资源ID
+      * @param fileNameFormatResId 文件名格式资源ID
+      * @return 生成的文件对象
+      */
+     private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
+         String path = Environment.getExternalStorageDirectory() + context.getString(filePathResId);
+         File dir = new File(path);
+         
+         // 生成完整文件路径
+         String fullPath = path + context.getString(fileNameFormatResId,
+                 DateFormat.format(context.getString(R.string.format_date_ymd), 
+                 System.currentTimeMillis()));
+         File file = new File(fullPath);
+ 
+         try {
+             // 创建目录和文件
+             if (!dir.exists() && !dir.mkdirs()) {
+                 Log.e(TAG, "创建目录失败：" + path);
+                 return null;
+             }
+             if (!file.exists() && !file.createNewFile()) {
+                 Log.e(TAG, "创建文件失败：" + fullPath);
+                 return null;
+             }
+             return file;
+         } catch (SecurityException e) {
+             Log.e(TAG, "安全权限异常", e);
+         } catch (IOException e) {
+             Log.e(TAG, "IO操作异常", e);
+         }
+         return null;
+     }
+ }

src/net/micode/notes/tool/DataUtils.java

@@ -0,0 +1,331 @@
+/*
+ * 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.tool;
+
+ import android.content.ContentProviderOperation;
+ import android.content.ContentProviderResult;
+ import android.content.ContentResolver;
+ import android.content.ContentUris;
+ import android.content.ContentValues;
+ import android.content.OperationApplicationException;
+ import android.database.Cursor;
+ 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.NoteColumns;
+ import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
+ 
+ import java.util.ArrayList;
+ import java.util.HashSet;
+ 
+ /**
+  * 数据操作工具类 - 提供笔记批量操作、数据查询等工具方法
+  */
+ public class DataUtils {
+     private static final String TAG = "DataUtils";
+ 
+     /**
+      * 批量删除笔记（支持事务操作）
+      * @param resolver 内容解析器
+      * @param ids 要删除的笔记ID集合
+      * @return true表示全部删除成功，false表示有部分失败
+      */
+     public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
+         if (ids == null) {
+             Log.d(TAG, "参数ids为空");
+             return true;
+         }
+         if (ids.size() == 0) {
+             Log.d(TAG, "ID集合为空");
+             return true;
+         }
+ 
+         // 构建批量删除操作列表
+         ArrayList<ContentProviderOperation> operationList = new ArrayList<>();
+         for (long id : ids) {
+             if(id == Notes.ID_ROOT_FOLDER) {  // 防止删除系统根目录
+                 Log.e(TAG, "禁止删除系统根目录");
+                 continue;
+             }
+             ContentProviderOperation.Builder builder = ContentProviderOperation
+                     .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+             operationList.add(builder.build());
+         }
+         
+         try {
+             // 执行批量操作
+             ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+             return results != null && results.length > 0 && results[0] != null;
+         } catch (RemoteException | OperationApplicationException e) {
+             Log.e(TAG, "批量删除异常: " + e.getMessage());
+         }
+         return false;
+     }
+ 
+     /**
+      * 移动单个笔记到目标文件夹
+      * @param resolver 内容解析器
+      * @param id 笔记ID
+      * @param srcFolderId 原文件夹ID
+      * @param desFolderId 目标文件夹ID
+      */
+     public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
+         ContentValues values = new ContentValues();
+         values.put(NoteColumns.PARENT_ID, desFolderId);   // 新父目录ID
+         values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId); // 记录原始目录
+         values.put(NoteColumns.LOCAL_MODIFIED, 1);  // 标记本地修改
+         resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
+     }
+ 
+     /**
+      * 批量移动笔记到指定文件夹
+      * @param resolver 内容解析器
+      * @param ids 需要移动的笔记ID集合
+      * @param folderId 目标文件夹ID
+      * @return 操作是否成功
+      */
+     public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids, long folderId) {
+         if (ids == null) {
+             Log.d(TAG, "参数ids为空");
+             return true;
+         }
+ 
+         ArrayList<ContentProviderOperation> operationList = new ArrayList<>();
+         for (long id : ids) {
+             ContentProviderOperation.Builder builder = ContentProviderOperation
+                     .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+             builder.withValue(NoteColumns.PARENT_ID, folderId);  // 设置新父目录
+             builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);     // 标记修改状态
+             operationList.add(builder.build());
+         }
+ 
+         try {
+             ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+             return results != null && results.length > 0 && results[0] != null;
+         } catch (RemoteException | OperationApplicationException e) {
+             Log.e(TAG, "批量移动异常: " + e.getMessage());
+         }
+         return false;
+     }
+ 
+     /**
+      * 获取用户创建的文件夹数量（排除系统文件夹和回收站）
+      * @param resolver 内容解析器
+      * @return 用户文件夹数量
+      */
+     public static int getUserFolderCount(ContentResolver resolver) {
+         // 查询条件：类型为文件夹 且 不在回收站中
+         String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?";
+         String[] selectionArgs = { 
+             String.valueOf(Notes.TYPE_FOLDER), 
+             String.valueOf(Notes.ID_TRASH_FOLER) 
+         };
+ 
+         try (Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
+                 new String[] { "COUNT(*)" },
+                 selection,
+                 selectionArgs,
+                 null)) {
+                 
+             if (cursor != null && cursor.moveToFirst()) {
+                 return cursor.getInt(0);  // 获取统计结果
+             }
+         } catch (IndexOutOfBoundsException e) {
+             Log.e(TAG, "获取文件夹数量异常: " + e.getMessage());
+         }
+         return 0;
+     }
+ 
+     /**
+      * 检查指定笔记是否在可见数据库中
+      * @param resolver 内容解析器
+      * @param noteId 笔记ID
+      * @param type 笔记类型
+      * @return 是否存在且可见
+      */
+     public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
+         String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER;
+         try (Cursor cursor = resolver.query(
+                 ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+                 null,
+                 selection,
+                 new String[] { String.valueOf(type) },
+                 null)) {
+             return cursor != null && cursor.getCount() > 0;
+         }
+     }
+ 
+     // region 存在性检查方法
+     /**
+      * 检查笔记是否存在
+      * @param resolver 内容解析器
+      * @param noteId 笔记ID
+      */
+     public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
+         try (Cursor cursor = resolver.query(
+                 ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+                 null, null, null, null)) {
+             return cursor != null && cursor.getCount() > 0;
+         }
+     }
+ 
+     /**
+      * 检查数据项是否存在
+      * @param resolver 内容解析器
+      * @param dataId 数据项ID
+      */
+     public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
+         try (Cursor cursor = resolver.query(
+                 ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
+                 null, null, null, null)) {
+             return cursor != null && cursor.getCount() > 0;
+         }
+     }
+     // endregion
+ 
+     /**
+      * 检查可见文件夹名称是否存在
+      * @param resolver 内容解析器
+      * @param name 文件夹名称
+      */
+     public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
+         String selection = NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER 
+                 + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER 
+                 + " AND " + NoteColumns.SNIPPET + "=?";
+         try (Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
+                 selection,
+                 new String[] { name }, null)) {
+             return cursor != null && cursor.getCount() > 0;
+         }
+     }
+ 
+     /**
+      * 获取文件夹关联的小部件属性集合
+      * @param resolver 内容解析器
+      * @param folderId 文件夹ID
+      * @return 小部件属性集合
+      */
+     public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
+         HashSet<AppWidgetAttribute> set = new HashSet<>();
+         String selection = NoteColumns.PARENT_ID + "=?";
+         try (Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
+                 new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
+                 selection,
+                 new String[] { String.valueOf(folderId) },
+                 null)) {
+                 
+             if (c != null && c.moveToFirst()) {
+                 do {
+                     AppWidgetAttribute widget = new AppWidgetAttribute();
+                     widget.widgetId = c.getInt(0);     // 小部件ID
+                     widget.widgetType = c.getInt(1);   // 小部件类型
+                     set.add(widget);
+                 } while (c.moveToNext());
+             }
+         } catch (IndexOutOfBoundsException e) {
+             Log.e(TAG, "获取小部件属性异常: " + e.getMessage());
+         }
+         return set;
+     }
+ 
+     // region 通话记录相关方法
+     /**
+      * 通过笔记ID获取通话号码
+      * @param resolver 内容解析器
+      * @param noteId 笔记ID
+      */
+     public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
+         String selection = CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?";
+         try (Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
+                 new String[] { CallNote.PHONE_NUMBER },
+                 selection,
+                 new String[] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE },
+                 null)) {
+                 
+             if (cursor != null && cursor.moveToFirst()) {
+                 return cursor.getString(0);
+             }
+         } catch (IndexOutOfBoundsException e) {
+             Log.e(TAG, "获取通话号码异常: " + e.getMessage());
+         }
+         return "";
+     }
+ 
+     /**
+      * 通过电话号码和通话时间获取笔记ID
+      * @param resolver 内容解析器
+      * @param phoneNumber 电话号码
+      * @param callDate 通话时间戳
+      */
+     public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
+         String selection = CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
+                 + CallNote.PHONE_NUMBER + ",?)";
+         try (Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
+                 new String[] { CallNote.NOTE_ID },
+                 selection,
+                 new String[] { 
+                     String.valueOf(callDate),
+                     CallNote.CONTENT_ITEM_TYPE,
+                     phoneNumber 
+                 },
+                 null)) {
+                 
+             if (cursor != null && cursor.moveToFirst()) {
+                 return cursor.getLong(0);
+             }
+         } catch (IndexOutOfBoundsException e) {
+             Log.e(TAG, "获取通话笔记ID异常: " + e.getMessage());
+         }
+         return 0;
+     }
+     // endregion
+ 
+     /**
+      * 获取笔记摘要内容
+      * @param resolver 内容解析器
+      * @param noteId 笔记ID
+      * @throws IllegalArgumentException 当笔记不存在时抛出
+      */
+     public static String getSnippetById(ContentResolver resolver, long noteId) {
+         try (Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
+                 new String[] { NoteColumns.SNIPPET },
+                 NoteColumns.ID + "=?",
+                 new String[] { String.valueOf(noteId)},
+                 null)) {
+                 
+             if (cursor != null && cursor.moveToFirst()) {
+                 return cursor.getString(0);
+             }
+         }
+         throw new IllegalArgumentException("未找到ID为 " + noteId + " 的笔记");
+     }
+ 
+     /**
+      * 格式化摘要文本（去除换行和首尾空格）
+      * @param snippet 原始摘要文本
+      * @return 格式化后的单行文本
+      */
+     public static String getFormattedSnippet(String snippet) {
+         if (snippet == null) return "";
+         
+         String formatted = snippet.trim();
+         int lineBreak = formatted.indexOf('\n');
+         return lineBreak != -1 ? formatted.substring(0, lineBreak) : formatted;
+     }
+ }

src/net/micode/notes/tool/GTaskStringUtils.java

@@ -0,0 +1,256 @@
+/*
+ * 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.tool;
+
+ /**
+  * 该类是一个工具类，主要用于处理与GTask相关的字符串常量。
+  * GTask可能是某种任务管理相关的功能或模块，这些常量可能是用于定义JSON格式数据中的字段名称，
+  * 以便在任务管理过程中进行数据的序列化和反序列化，或者用于标识不同的任务操作类型、任务属性等。
+  * 这些常量的定义有助于在代码中统一管理和使用这些字符串，避免硬编码带来的问题，提高代码的可维护性和可读性。
+  */
+ public class GTaskStringUtils {
+ 
+     /**
+      * JSON数据中表示动作ID的字段名称。
+      */
+     public final static String GTASK_JSON_ACTION_ID = "action_id";
+ 
+     /**
+      * JSON数据中表示动作列表的字段名称。
+      */
+     public final static String GTASK_JSON_ACTION_LIST = "action_list";
+ 
+     /**
+      * JSON数据中表示动作类型的字段名称。
+      */
+     public final static String GTASK_JSON_ACTION_TYPE = "action_type";
+ 
+     /**
+      * JSON数据中表示创建动作类型的值。
+      */
+     public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
+ 
+     /**
+      * JSON数据中表示获取所有动作类型的值。
+      */
+     public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
+ 
+     /**
+      * JSON数据中表示移动动作类型的值。
+      */
+     public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
+ 
+     /**
+      * JSON数据中表示更新动作类型的值。
+      */
+     public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
+ 
+     /**
+      * JSON数据中表示创建者ID的字段名称。
+      */
+     public final static String GTASK_JSON_CREATOR_ID = "creator_id";
+ 
+     /**
+      * JSON数据中表示子实体的字段名称。
+      */
+     public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
+ 
+     /**
+      * JSON数据中表示客户端版本的字段名称。
+      */
+     public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
+ 
+     /**
+      * JSON数据中表示任务是否完成的字段名称。
+      */
+     public final static String GTASK_JSON_COMPLETED = "completed";
+ 
+     /**
+      * JSON数据中表示当前列表ID的字段名称。
+      */
+     public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
+ 
+     /**
+      * JSON数据中表示默认列表ID的字段名称。
+      */
+     public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
+ 
+     /**
+      * JSON数据中表示任务是否被删除的字段名称。
+      */
+     public final static String GTASK_JSON_DELETED = "deleted";
+ 
+     /**
+      * JSON数据中表示目标列表的字段名称。
+      */
+     public final static String GTASK_JSON_DEST_LIST = "dest_list";
+ 
+     /**
+      * JSON数据中表示目标父级的字段名称。
+      */
+     public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
+ 
+     /**
+      * JSON数据中表示目标父级类型的字段名称。
+      */
+     public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
+ 
+     /**
+      * JSON数据中表示实体变化的字段名称。
+      */
+     public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
+ 
+     /**
+      * JSON数据中表示实体类型的字段名称。
+      */
+     public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
+ 
+     /**
+      * JSON数据中表示是否获取已删除任务的字段名称。
+      */
+     public final static String GTASK_JSON_GET_DELETED = "get_deleted";
+ 
+     /**
+      * JSON数据中表示ID的字段名称。
+      */
+     public final static String GTASK_JSON_ID = "id";
+ 
+     /**
+      * JSON数据中表示索引的字段名称。
+      */
+     public final static String GTASK_JSON_INDEX = "index";
+ 
+     /**
+      * JSON数据中表示最后修改时间的字段名称。
+      */
+     public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
+ 
+     /**
+      * JSON数据中表示最新同步点的字段名称。
+      */
+     public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
+ 
+     /**
+      * JSON数据中表示列表ID的字段名称。
+      */
+     public final static String GTASK_JSON_LIST_ID = "list_id";
+ 
+     /**
+      * JSON数据中表示列表的字段名称。
+      */
+     public final static String GTASK_JSON_LISTS = "lists";
+ 
+     /**
+      * JSON数据中表示名称的字段名称。
+      */
+     public final static String GTASK_JSON_NAME = "name";
+ 
+     /**
+      * JSON数据中表示新ID的字段名称。
+      */
+     public final static String GTASK_JSON_NEW_ID = "new_id";
+ 
+     /**
+      * JSON数据中表示笔记的字段名称。
+      */
+     public final static String GTASK_JSON_NOTES = "notes";
+ 
+     /**
+      * JSON数据中表示父级ID的字段名称。
+      */
+     public final static String GTASK_JSON_PARENT_ID = "parent_id";
+ 
+     /**
+      * JSON数据中表示前一个兄弟ID的字段名称。
+      */
+     public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
+ 
+     /**
+      * JSON数据中表示结果的字段名称。
+      */
+     public final static String GTASK_JSON_RESULTS = "results";
+ 
+     /**
+      * JSON数据中表示源列表的字段名称。
+      */
+     public final static String GTASK_JSON_SOURCE_LIST = "source_list";
+ 
+     /**
+      * JSON数据中表示任务的字段名称。
+      */
+     public final static String GTASK_JSON_TASKS = "tasks";
+ 
+     /**
+      * JSON数据中表示类型的字段名称。
+      */
+     public final static String GTASK_JSON_TYPE = "type";
+ 
+     /**
+      * JSON数据中表示组类型的值。
+      */
+     public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
+ 
+     /**
+      * JSON数据中表示任务类型的值。
+      */
+     public final static String GTASK_JSON_TYPE_TASK = "TASK";
+ 
+     /**
+      * JSON数据中表示用户的字段名称。
+      */
+     public final static String GTASK_JSON_USER = "user";
+ 
+     /**
+      * MIUI笔记文件夹前缀。
+      */
+     public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]";
+ 
+     /**
+      * 默认文件夹名称。
+      */
+     public final static String FOLDER_DEFAULT = "Default";
+ 
+     /**
+      * 通话笔记文件夹名称。
+      */
+     public final static String FOLDER_CALL_NOTE = "Call_Note";
+ 
+     /**
+      * 元数据文件夹名称。
+      */
+     public final static String FOLDER_META = "METADATA";
+ 
+     /**
+      * 元数据中GTask ID的字段名称。
+      */
+     public final static String META_HEAD_GTASK_ID = "meta_gid";
+ 
+     /**
+      * 元数据中笔记的字段名称。
+      */
+     public final static String META_HEAD_NOTE = "meta_note";
+ 
+     /**
+      * 元数据中数据的字段名称。
+      */
+     public final static String META_HEAD_DATA = "meta_data";
+ 
+     /**
+      * 元数据笔记名称，提示不要更新和删除。
+      */
+     public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE";
+ }

src/net/micode/notes/tool/ResourceParser.java

@@ -0,0 +1,168 @@
+/*
+ * 资源映射解析工具类，集中管理颜色、背景、字体等资源的ID映射关系
+ * 提供静态方法实现资源ID与逻辑标识符之间的转换，支持多场景资源适配
+ */
+
+ package net.micode.notes.tool;
+
+ import android.content.Context;
+ import android.preference.PreferenceManager;
+ import net.micode.notes.R;
+ import net.micode.notes.ui.NotesPreferenceActivity;
+ 
+ public class ResourceParser {
+     // 颜色标识常量（对应颜色选项索引）
+     public static final int YELLOW           = 0;
+     public static final int BLUE             = 1;
+     public static final int WHITE            = 2;
+     public static final int GREEN            = 3;
+     public static final int RED              = 4;
+ 
+     public static final int BG_DEFAULT_COLOR = YELLOW; // 默认背景颜色标识
+ 
+     // 字体大小等级标识
+     public static final int TEXT_SMALL       = 0;
+     public static final int TEXT_MEDIUM      = 1;
+     public static final int TEXT_LARGE       = 2;
+     public static final int TEXT_SUPER       = 3;
+ 
+     public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM; // 默认字体大小等级
+ 
+     /**
+      * 笔记编辑界面背景资源管理
+      */
+     public static class NoteBgResources {
+         // 笔记内容区域背景资源数组（按颜色顺序存储）
+         private final static int[] BG_EDIT_RESOURCES = {
+             R.drawable.edit_yellow,
+             R.drawable.edit_blue,
+             R.drawable.edit_white,
+             R.drawable.edit_green,
+             R.drawable.edit_red
+         };
+ 
+         // 笔记标题栏背景资源数组
+         private final static int[] BG_EDIT_TITLE_RESOURCES = {
+             R.drawable.edit_title_yellow,
+             R.drawable.edit_title_blue,
+             R.drawable.edit_title_white,
+             R.drawable.edit_title_green,
+             R.drawable.edit_title_red
+         };
+ 
+         /**
+          * 获取笔记内容区域背景资源
+          * @param id 颜色标识符（YELLOW/BLUE等）
+          * @return 对应的可绘制资源ID
+          */
+         public static int getNoteBgResource(int id) {
+             return BG_EDIT_RESOURCES[id];
+         }
+ 
+         /**
+          * 获取笔记标题栏背景资源
+          * @param id 颜色标识符
+          * @return 对应的标题栏背景资源ID
+          */
+         public static int getNoteTitleBgResource(int id) {
+             return BG_EDIT_TITLE_RESOURCES[id];
+         }
+     }
+ 
+     /**
+      * 获取默认背景颜色标识
+      * @param context 上下文对象
+      * @return 颜色标识符：随机颜色（如果启用设置）或默认黄色
+      */
+     public static int getDefaultBgId(Context context) {
+         boolean useRandomColor = PreferenceManager.getDefaultSharedPreferences(context)
+                 .getBoolean(NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false);
+         return useRandomColor ? (int)(Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length)
+                              : BG_DEFAULT_COLOR;
+     }
+ 
+     /**
+      * 笔记列表项背景资源管理
+      */
+     public static class NoteItemBgResources {
+         // 列表项不同位置的背景资源（按颜色顺序存储）
+         private final static int[] BG_FIRST_RESOURCES = { /* 首项背景 */ };
+         private final static int[] BG_NORMAL_RESOURCES = { /* 中间项背景 */ };
+         private final static int[] BG_LAST_RESOURCES = { /* 末项背景 */ };
+         private final static int[] BG_SINGLE_RESOURCES = { /* 单一项背景 */ };
+ 
+         /**
+          * 获取列表首项背景
+          * @param id 颜色标识符
+          * @return 首项背景资源ID
+          */
+         public static int getNoteBgFirstRes(int id) {
+             return BG_FIRST_RESOURCES[id];
+         }
+ 
+         // 其他列表背景获取方法（实现类似）...
+ 
+         /**
+          * 获取文件夹列表项背景
+          * @return 固定文件夹图标资源ID
+          */
+         public static int getFolderBgRes() {
+             return R.drawable.list_folder;
+         }
+     }
+ 
+     /**
+      * 小部件背景资源管理
+      */
+     public static class WidgetBgResources {
+         // 2x尺寸小部件各颜色背景资源
+         private final static int[] BG_2X_RESOURCES = {
+             R.drawable.widget_2x_yellow,
+             R.drawable.widget_2x_blue,
+             // ...其他颜色
+         };
+ 
+         /**
+          * 获取2x小部件背景资源
+          * @param id 颜色标识符
+          * @return 对应的2x背景资源ID
+          */
+         public static int getWidget2xBgResource(int id) {
+             return BG_2X_RESOURCES[id];
+         }
+ 
+         // 4x小部件背景资源数组及获取方法（实现类似）...
+     }
+ 
+     /**
+      * 文本外观资源管理
+      */
+     public static class TextAppearanceResources {
+         // 字体大小样式资源数组（小->大）
+         private final static int[] TEXTAPPEARANCE_RESOURCES = {
+             R.style.TextAppearanceNormal,
+             R.style.TextAppearanceMedium,
+             R.style.TextAppearanceLarge,
+             R.style.TextAppearanceSuper
+         };
+ 
+         /**
+          * 获取字体样式资源
+          * @param id 字体大小标识符
+          * @return 对应的样式资源ID（越界时返回默认中等大小）
+          */
+         public static int getTexAppearanceResource(int id) {
+             // 处理存储错误导致的越界问题
+             return (id < TEXTAPPEARANCE_RESOURCES.length) ? 
+                    TEXTAPPEARANCE_RESOURCES[id] : BG_DEFAULT_FONT_SIZE;
+         }
+ 
+         /**
+          * 获取可用字体样式的数量
+          * @return 支持的字体等级总数
+          */
+         public static int getResourcesSize() {
+             return TEXTAPPEARANCE_RESOURCES.length;
+         }
+     }
+ }

src/net/micode/notes/ui/NoteEditActivity.java

@@ -0,0 +1,923 @@
+/*
+ * 版权信息：由MiCode开源社区（www.micode.net）贡献
+ * Apache 2.0许可证协议
+ * 本文件为NoteEditActivity类实现，用于Android平台的笔记编辑功能
+ */
+
+package net.micode.notes.ui;
+
+import android.app.Activity;
+import android.app.AlarmManager;
+import android.app.AlertDialog;
+import android.app.PendingIntent;
+import android.app.SearchManager;
+import android.appwidget.AppWidgetManager;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.graphics.Paint;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.text.Spannable;
+import android.text.SpannableString;
+import android.text.TextUtils;
+import android.text.format.DateUtils;
+import android.text.style.BackgroundColorSpan;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.WindowManager;
+import android.widget.CheckBox;
+import android.widget.CompoundButton;
+import android.widget.CompoundButton.OnCheckedChangeListener;
+import android.widget.EditText;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.TextNote;
+import net.micode.notes.model.WorkingNote;
+import net.micode.notes.model.WorkingNote.NoteSettingChangedListener;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.ResourceParser;
+import net.micode.notes.tool.ResourceParser.TextAppearanceResources;
+import net.micode.notes.ui.DateTimePickerDialog.OnDateTimeSetListener;
+import net.micode.notes.ui.NoteEditText.OnTextViewChangeListener;
+import net.micode.notes.widget.NoteWidgetProvider_2x;
+import net.micode.notes.widget.NoteWidgetProvider_4x;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 笔记编辑活动
+ * 实现笔记的创建、编辑、保存、分享等功能
+ */
+public class NoteEditActivity extends Activity implements OnClickListener,
+        NoteSettingChangedListener, OnTextViewChangeListener {
+    
+    /**
+     * 头部视图持有者
+     * 用于缓存头部视图的引用
+     */
+    private class HeadViewHolder {
+        public TextView tvModified;      // 修改时间TextView
+        public ImageView ivAlertIcon;    // 提醒图标ImageView
+        public TextView tvAlertDate;     // 提醒时间TextView
+        public ImageView ibSetBgColor;   // 背景颜色设置按钮
+    }
+
+    // 背景颜色选择器按钮映射表
+    private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
+    static {
+        sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
+        sBgSelectorBtnsMap.put(R.id.iv_bg_red, ResourceParser.RED);
+        sBgSelectorBtnsMap.put(R.id.iv_bg_blue, ResourceParser.BLUE);
+        sBgSelectorBtnsMap.put(R.id.iv_bg_green, ResourceParser.GREEN);
+        sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
+    }
+
+    // 背景颜色选择器选中状态映射表
+    private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
+    static {
+        sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
+        sBgSelectorSelectionMap.put(ResourceParser.RED, R.id.iv_bg_red_select);
+        sBgSelectorSelectionMap.put(ResourceParser.BLUE, R.id.iv_bg_blue_select);
+        sBgSelectorSelectionMap.put(ResourceParser.GREEN, R.id.iv_bg_green_select);
+        sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
+    }
+
+    // 字体大小选择器按钮映射表
+    private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
+    static {
+        sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
+        sFontSizeBtnsMap.put(R.id.ll_font_small, ResourceParser.TEXT_SMALL);
+        sFontSizeBtnsMap.put(R.id.ll_font_normal, ResourceParser.TEXT_MEDIUM);
+        sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
+    }
+
+    // 字体大小选择器选中状态映射表
+    private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
+    static {
+        sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
+        sFontSelectorSelectionMap.put(ResourceParser.TEXT_SMALL, R.id.iv_small_select);
+        sFontSelectorSelectionMap.put(ResourceParser.TEXT_MEDIUM, R.id.iv_medium_select);
+        sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
+    }
+
+    private static final String TAG = "NoteEditActivity";  // 日志标签
+
+    private HeadViewHolder mNoteHeaderHolder;              // 头部视图持有者
+    private View mHeadViewPanel;                          // 头部视图
+    private View mNoteBgColorSelector;                    // 背景颜色选择器
+    private View mFontSizeSelector;                       // 字体大小选择器
+    private EditText mNoteEditor;                         // 笔记编辑器
+    private View mNoteEditorPanel;                        // 编辑器面板
+    private WorkingNote mWorkingNote;                     // 当前工作笔记
+    private SharedPreferences mSharedPrefs;               // SharedPreferences
+    private int mFontSizeId;                              // 字体大小ID
+
+    private static final String PREFERENCE_FONT_SIZE = "pref_font_size";  // 字体大小偏好键
+    private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;           // 快捷方式标题最大长度
+
+    public static final String TAG_CHECKED = String.valueOf('\u221A');  // 已选标记
+    public static final String TAG_UNCHECKED = String.valueOf('\u25A1'); // 未选标记
+
+    private LinearLayout mEditTextList;                   // 列表项容器
+    private String mUserQuery;                            // 用户搜索词
+    private Pattern mPattern;                             // 正则表达式模式
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        this.setContentView(R.layout.note_edit);
+
+        if (savedInstanceState == null && !initActivityState(getIntent())) {
+            finish();
+            return;
+        }
+        initResources();
+    }
+
+    /**
+     * 活动被系统杀死后恢复状态
+     */
+    @Override
+    protected void onRestoreInstanceState(Bundle savedInstanceState) {
+        super.onRestoreInstanceState(savedInstanceState);
+        if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) {
+            Intent intent = new Intent(Intent.ACTION_VIEW);
+            intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID));
+            if (!initActivityState(intent)) {
+                finish();
+                return;
+            }
+            Log.d(TAG, "Restoring from killed activity");
+        }
+    }
+
+    /**
+     * 初始化活动状态
+     * @param intent 启动意图
+     * @return 是否初始化成功
+     */
+    private boolean initActivityState(Intent intent) {
+        mWorkingNote = null;
+        if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
+            long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
+            mUserQuery = "";
+
+            if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
+                noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
+                mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);
+            }
+
+            if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {
+                Intent jump = new Intent(this, NotesListActivity.class);
+                startActivity(jump);
+                showToast(R.string.error_note_not_exist);
+                finish();
+                return false;
+            } else {
+                mWorkingNote = WorkingNote.load(this, noteId);
+                if (mWorkingNote == null) {
+                    Log.e(TAG, "load note failed with note id" + noteId);
+                    finish();
+                    return false;
+                }
+            }
+            getWindow().setSoftInputMode(
+                    WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
+                            | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
+        } else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) {
+            // 新建笔记
+            long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0);
+            int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
+                    AppWidgetManager.INVALID_APPWIDGET_ID);
+            int widgetType = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_TYPE,
+                    Notes.TYPE_WIDGET_INVALIDE);
+            int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID,
+                    ResourceParser.getDefaultBgId(this));
+
+            // 处理通话记录笔记
+            String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
+            long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0);
+            if (callDate != 0 && phoneNumber != null) {
+                if (TextUtils.isEmpty(phoneNumber)) {
+                    Log.w(TAG, "The call record number is null");
+                }
+                long noteId = 0;
+                if ((noteId = DataUtils.getNoteIdByPhoneNumberAndCallDate(getContentResolver(),
+                        phoneNumber, callDate)) > 0) {
+                    mWorkingNote = WorkingNote.load(this, noteId);
+                    if (mWorkingNote == null) {
+                        Log.e(TAG, "load call note failed with note id" + noteId);
+                        finish();
+                        return false;
+                    }
+                } else {
+                    mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId,
+                            widgetType, bgResId);
+                    mWorkingNote.convertToCallNote(phoneNumber, callDate);
+                }
+            } else {
+                mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, widgetType,
+                        bgResId);
+            }
+
+            getWindow().setSoftInputMode(
+                    WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
+                            | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
+        } else {
+            Log.e(TAG, "Intent not specified action, should not support");
+            finish();
+            return false;
+        }
+        mWorkingNote.setOnSettingStatusChangedListener(this);
+        return true;
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        initNoteScreen();
+    }
+
+    /**
+     * 初始化笔记界面
+     */
+    private void initNoteScreen() {
+        mNoteEditor.setTextAppearance(this, TextAppearanceResources
+                .getTexAppearanceResource(mFontSizeId));
+        if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+            switchToListMode(mWorkingNote.getContent());
+        } else {
+            mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
+            mNoteEditor.setSelection(mNoteEditor.getText().length());
+        }
+        for (Integer id : sBgSelectorSelectionMap.keySet()) {
+            findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE);
+        }
+        mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
+        mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
+
+        mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this,
+                mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE
+                        | DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME
+                        | DateUtils.FORMAT_SHOW_YEAR));
+
+        showAlertHeader();
+    }
+
+    /**
+     * 显示提醒信息
+     */
+    private void showAlertHeader() {
+        if (mWorkingNote.hasClockAlert()) {
+            long time = System.currentTimeMillis();
+            if (time > mWorkingNote.getAlertDate()) {
+                mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired);
+            } else {
+                mNoteHeaderHolder.tvAlertDate.setText(DateUtils.getRelativeTimeSpanString(
+                        mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS));
+            }
+            mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE);
+            mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE);
+        } else {
+            mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE);
+            mNoteHeaderHolder.ivAlertIcon.setVisibility(View.GONE);
+        };
+    }
+
+    @Override
+    protected void onNewIntent(Intent intent) {
+        super.onNewIntent(intent);
+        initActivityState(intent);
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        if (!mWorkingNote.existInDatabase()) {
+            saveNote();
+        }
+        outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId());
+        Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
+    }
+
+    @Override
+    public boolean dispatchTouchEvent(MotionEvent ev) {
+        if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
+                && !inRangeOfView(mNoteBgColorSelector, ev)) {
+            mNoteBgColorSelector.setVisibility(View.GONE);
+            return true;
+        }
+
+        if (mFontSizeSelector.getVisibility() == View.VISIBLE
+                && !inRangeOfView(mFontSizeSelector, ev)) {
+            mFontSizeSelector.setVisibility(View.GONE);
+            return true;
+        }
+        return super.dispatchTouchEvent(ev);
+    }
+
+    /**
+     * 判断触摸点是否在视图范围内
+     */
+    private boolean inRangeOfView(View view, MotionEvent ev) {
+        int []location = new int[2];
+        view.getLocationOnScreen(location);
+        int x = location[0];
+        int y = location[1];
+        if (ev.getX() < x
+                || ev.getX() > (x + view.getWidth())
+                || ev.getY() < y
+                || ev.getY() > (y + view.getHeight())) {
+                    return false;
+                }
+        return true;
+    }
+
+    /**
+     * 初始化资源
+     */
+    private void initResources() {
+        mHeadViewPanel = findViewById(R.id.note_title);
+        mNoteHeaderHolder = new HeadViewHolder();
+        mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date);
+        mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon);
+        mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date);
+        mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color);
+        mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this);
+        mNoteEditor = (EditText) findViewById(R.id.note_edit_view);
+        mNoteEditorPanel = findViewById(R.id.sv_note_edit);
+        mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector);
+        for (int id : sBgSelectorBtnsMap.keySet()) {
+            ImageView iv = (ImageView) findViewById(id);
+            iv.setOnClickListener(this);
+        }
+
+        mFontSizeSelector = findViewById(R.id.font_size_selector);
+        for (int id : sFontSizeBtnsMap.keySet()) {
+            View view = findViewById(id);
+            view.setOnClickListener(this);
+        };
+        mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
+        mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
+        if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {
+            mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
+        }
+        mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        if(saveNote()) {
+            Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length());
+        }
+        clearSettingState();
+    }
+
+    /**
+     * 更新应用小部件
+     */
+    private void updateWidget() {
+        Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
+        if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
+            intent.setClass(this, NoteWidgetProvider_2x.class);
+        } else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) {
+            intent.setClass(this, NoteWidgetProvider_4x.class);
+        } else {
+            Log.e(TAG, "Unspported widget type");
+            return;
+        }
+
+        intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
+            mWorkingNote.getWidgetId()
+        });
+
+        sendBroadcast(intent);
+        setResult(RESULT_OK, intent);
+    }
+
+    /**
+     * 处理按钮点击事件
+     */
+    public void onClick(View v) {
+        int id = v.getId();
+        if (id == R.id.btn_set_bg_color) {
+            mNoteBgColorSelector.setVisibility(View.VISIBLE);
+            findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
+                    View.VISIBLE);
+        } else if (sBgSelectorBtnsMap.containsKey(id)) {
+            findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
+                    View.GONE);
+            mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id));
+            mNoteBgColorSelector.setVisibility(View.GONE);
+        } else if (sFontSizeBtnsMap.containsKey(id)) {
+            findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE);
+            mFontSizeId = sFontSizeBtnsMap.get(id);
+            mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit();
+            findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
+            if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+                getWorkingText();
+                switchToListMode(mWorkingNote.getContent());
+            } else {
+                mNoteEditor.setTextAppearance(this,
+                        TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
+            }
+            mFontSizeSelector.setVisibility(View.GONE);
+        }
+    }
+
+    @Override
+    public void onBackPressed() {
+        if(clearSettingState()) {
+            return;
+        }
+
+        saveNote();
+        super.onBackPressed();
+    }
+
+    /**
+     * 清除设置状态
+     * @return 是否成功清除
+     */
+    private boolean clearSettingState() {
+        if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
+            mNoteBgColorSelector.setVisibility(View.GONE);
+            return true;
+        } else if (mFontSizeSelector.getVisibility() == View.VISIBLE) {
+            mFontSizeSelector.setVisibility(View.GONE);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 背景颜色变化回调
+     */
+    public void onBackgroundColorChanged() {
+        findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
+                View.VISIBLE);
+        mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
+        mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
+    }
+
+    @Override
+    public boolean onPrepareOptionsMenu(Menu menu) {
+        if (isFinishing()) {
+            return true;
+        }
+        clearSettingState();
+        menu.clear();
+        if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {
+            getMenuInflater().inflate(R.menu.call_note_edit, menu);
+        } else {
+            getMenuInflater().inflate(R.menu.note_edit, menu);
+        }
+        if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+            menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_normal_mode);
+        } else {
+            menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_list_mode);
+        }
+        if (mWorkingNote.hasClockAlert()) {
+            menu.findItem(R.id.menu_alert).setVisible(false);
+        } else {
+            menu.findItem(R.id.menu_delete_remind).setVisible(false);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case R.id.menu_new_note:
+                createNewNote();
+                break;
+            case R.id.menu_delete:
+                AlertDialog.Builder builder = new AlertDialog.Builder(this);
+                builder.setTitle(getString(R.string.alert_title_delete));
+                builder.setIcon(android.R.drawable.ic_dialog_alert);
+                builder.setMessage(getString(R.string.alert_message_delete_note));
+                builder.setPositiveButton(android.R.string.ok,
+                        new DialogInterface.OnClickListener() {
+                            public void onClick(DialogInterface dialog, int which) {
+                                deleteCurrentNote();
+                                finish();
+                            }
+                        });
+                builder.setNegativeButton(android.R.string.cancel, null);
+                builder.show();
+                break;
+            case R.id.menu_font_size:
+                mFontSizeSelector.setVisibility(View.VISIBLE);
+                findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
+                break;
+            case R.id.menu_list_mode:
+                mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?
+                        TextNote.MODE_CHECK_LIST : 0);
+                break;
+            case R.id.menu_share:
+                getWorkingText();
+                sendTo(this, mWorkingNote.getContent());
+                break;
+            case R.id.menu_send_to_desktop:
+                sendToDesktop();
+                break;
+            case R.id.menu_alert:
+                setReminder();
+                break;
+            case R.id.menu_delete_remind:
+                mWorkingNote.setAlertDate(0, false);
+                break;
+            default:
+                break;
+        }
+        return true;
+    }
+
+    /**
+     * 设置提醒时间
+     */
+    private void setReminder() {
+        DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
+        d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
+            public void OnDateTimeSet(AlertDialog dialog, long date) {
+                mWorkingNote.setAlertDate(date, true);
+            }
+        });
+        d.show();
+    }
+
+    /**
+     * 分享笔记内容
+     * @param context 上下文
+     * @param info 内容
+     */
+    private void sendTo(Context context, String info) {
+        Intent intent = new Intent(Intent.ACTION_SEND);
+        intent.putExtra(Intent.EXTRA_TEXT, info);
+        intent.setType("text/plain");
+        context.startActivity(intent);
+    }
+
+    /**
+     * 创建新笔记
+     */
+    private void createNewNote() {
+        saveNote();
+        finish();
+        Intent intent = new Intent(this, NoteEditActivity.class);
+        intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
+        intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mWorkingNote.getFolderId());
+        startActivity(intent);
+    }
+
+    /**
+     * 删除当前笔记
+     */
+    private void deleteCurrentNote() {
+        if (mWorkingNote.existInDatabase()) {
+            HashSet<Long> ids = new HashSet<Long>();
+            long id = mWorkingNote.getNoteId();
+            if (id != Notes.ID_ROOT_FOLDER) {
+                ids.add(id);
+            } else {
+                Log.d(TAG, "Wrong note id, should not happen");
+            }
+            if (!isSyncMode()) {
+                if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) {
+                    Log.e(TAG, "Delete Note error");
+                }
+            } else {
+                if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {
+                    Log.e(TAG, "Move notes to trash folder error, should not happens");
+                }
+            }
+        }
+        mWorkingNote.markDeleted(true);
+    }
+
+    /**
+     * 判断是否处于同步模式
+     * @return 是否同步模式
+     */
+    private boolean isSyncMode() {
+        return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
+    }
+
+    /**
+     * 处理提醒时间变化
+     * @param date 时间
+     * @param set 是否设置
+     */
+    public void onClockAlertChanged(long date, boolean set) {
+        if (!mWorkingNote.existInDatabase()) {
+            saveNote();
+        }
+        if (mWorkingNote.getNoteId() > 0) {
+            Intent intent = new Intent(this, AlarmReceiver.class);
+            intent.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mWorkingNote.getNoteId()));
+            PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
+            AlarmManager alarmManager = ((AlarmManager) getSystemService(ALARM_SERVICE));
+            showAlertHeader();
+            if(!set) {
+                alarmManager.cancel(pendingIntent);
+            } else {
+                alarmManager.set(AlarmManager.RTC_WAKEUP, date, pendingIntent);
+            }
+        } else {
+            Log.e(TAG, "Clock alert setting error");
+            showToast(R.string.error_note_empty_for_clock);
+        }
+    }
+
+    /**
+     * 处理应用小部件变化
+     */
+    public void onWidgetChanged() {
+        updateWidget();
+    }
+
+    /**
+     * 处理文本编辑器删除事件
+     * @param index 索引
+     * @param text 文本
+     */
+    public void onEditTextDelete(int index, String text) {
+        int childCount = mEditTextList.getChildCount();
+        if (childCount == 1) {
+            return;
+        }
+
+        for (int i = index + 1; i < childCount; i++) {
+            ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
+                    .setIndex(i - 1);
+        }
+
+        mEditTextList.removeViewAt(index);
+        NoteEditText edit = null;
+        if(index == 0) {
+            edit = (NoteEditText) mEditTextList.getChildAt(0).findViewById(
+                    R.id.et_edit_text);
+        } else {
+            edit = (NoteEditText) mEditTextList.getChildAt(index - 1).findViewById(
+                    R.id.et_edit_text);
+        }
+        int length = edit.length();
+        edit.append(text);
+        edit.requestFocus();
+        edit.setSelection(length);
+    }
+
+    /**
+     * 处理文本编辑器换行事件
+     * @param index 索引
+     * @param text 文本
+     */
+    public void onEditTextEnter(int index, String text) {
+        if(index > mEditTextList.getChildCount()) {
+            Log.e(TAG, "Index out of mEditTextList boundrary, should not happen");
+        }
+
+        View view = getListItem(text, index);
+        mEditTextList.addView(view, index);
+        NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
+        edit.requestFocus();
+        edit.setSelection(0);
+        for (int i = index + 1; i < mEditTextList.getChildCount(); i++) {
+            ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
+                    .setIndex(i);
+        }
+    }
+
+    /**
+     * 切换到列表模式
+     * @param text 文本
+     */
+    private void switchToListMode(String text) {
+        mEditTextList.removeAllViews();
+        String[] items = text.split("\n");
+        int index = 0;
+        for (String item : items) {
+            if(!TextUtils.isEmpty(item)) {
+                mEditTextList.addView(getListItem(item, index));
+                index++;
+            }
+        }
+        mEditTextList.addView(getListItem("", index));
+        mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus();
+
+        mNoteEditor.setVisibility(View.GONE);
+        mEditTextList.setVisibility(View.VISIBLE);
+    }
+
+    /**
+     * 高亮搜索结果
+     * @param fullText 全文
+     * @param userQuery 用户查询
+     * @return 高亮后的SpannableString
+     */
+    private Spannable getHighlightQueryResult(String fullText, String userQuery) {
+        SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
+        if (!TextUtils.isEmpty(userQuery)) {
+            mPattern = Pattern.compile(userQuery);
+            Matcher m = mPattern.matcher(fullText);
+            int start = 0;
+            while (m.find(start)) {
+                spannable.setSpan(
+                        new BackgroundColorSpan(this.getResources().getColor(
+                                R.color.user_query_highlight)), m.start(), m.end(),
+                        Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
+                start = m.end();
+            }
+        }
+        return spannable;
+    }
+
+    /**
+     * 创建列表项视图
+     * @param item 项目文本
+     * @param index 索引
+     * @return 列表项视图
+     */
+    private View getListItem(String item, int index) {
+        View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);
+        final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
+        edit.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
+        CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item));
+        cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {
+            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+                if (isChecked) {
+                    edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
+                } else {
+                    edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
+                }
+            }
+        });
+
+        if (item.startsWith(TAG_CHECKED)) {
+            cb.setChecked(true);
+            edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
+            item = item.substring(TAG_CHECKED.length(), item.length()).trim();
+        } else if (item.startsWith(TAG_UNCHECKED)) {
+            cb.setChecked(false);
+            edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
+            item = item.substring(TAG_UNCHECKED.length(), item.length()).trim();
+        }
+
+        edit.setOnTextViewChangeListener(this);
+        edit.setIndex(index);
+        edit.setText(getHighlightQueryResult(item, mUserQuery));
+        return view;
+    }
+
+    /**
+     * 处理文本变化事件
+     * @param index 索引
+     * @param hasText 是否有文本
+     */
+    public void onTextChange(int index, boolean hasText) {
+        if (index >= mEditTextList.getChildCount()) {
+            Log.e(TAG, "Wrong index, should not happen");
+            return;
+        }
+        if(hasText) {
+            mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.VISIBLE);
+        } else {
+            mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.GONE);
+        }
+    }
+
+    /**
+     * 处理列表模式变化
+     * @param oldMode 旧模式
+     * @param newMode 新模式
+     */
+    public void onCheckListModeChanged(int oldMode, int newMode) {
+        if (newMode == TextNote.MODE_CHECK_LIST) {
+            switchToListMode(mNoteEditor.getText().toString());
+        } else {
+            if (!getWorkingText()) {
+                mWorkingNote.setWorkingText(mWorkingNote.getContent().replace(TAG_UNCHECKED + " ",
+                        ""));
+            }
+            mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
+            mEditTextList.setVisibility(View.GONE);
+            mNoteEditor.setVisibility(View.VISIBLE);
+        }
+    }
+
+    /**
+     * 获取工作文本
+     * @return 是否有选中项
+     */
+    private boolean getWorkingText() {
+        boolean hasChecked = false;
+        if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < mEditTextList.getChildCount(); i++) {
+                View view = mEditTextList.getChildAt(i);
+                NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
+                if (!TextUtils.isEmpty(edit.getText())) {
+                    if (((CheckBox) view.findViewById(R.id.cb_edit_item)).isChecked()) {
+                        sb.append(TAG_CHECKED).append(" ").append(edit.getText()).append("\n");
+                        hasChecked = true;
+                    } else {
+                        sb.append(TAG_UNCHECKED).append(" ").append(edit.getText()).append("\n");
+                    }
+                }
+            }
+            mWorkingNote.setWorkingText(sb.toString());
+        } else {
+            mWorkingNote.setWorkingText(mNoteEditor.getText().toString());
+        }
+        return hasChecked;
+    }
+
+    /**
+     * 保存笔记
+     * @return 是否保存成功
+     */
+    private boolean saveNote() {
+        getWorkingText();
+        boolean saved = mWorkingNote.saveNote();
+        if (saved) {
+            setResult(RESULT_OK);
+        }
+        return saved;
+    }
+
+    /**
+     * 发送到桌面快捷方式
+     */
+    private void sendToDesktop() {
+        if (!mWorkingNote.existInDatabase()) {
+            saveNote();
+        }
+
+        if (mWorkingNote.getNoteId() > 0) {
+            Intent sender = new Intent();
+            Intent shortcutIntent = new Intent(this, NoteEditActivity.class);
+            shortcutIntent.setAction(Intent.ACTION_VIEW);
+            shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId());
+            sender.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);
+            sender.putExtra(Intent.EXTRA_SHORTCUT_NAME,
+                    makeShortcutIconTitle(mWorkingNote.getContent()));
+            sender.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE,
+                    Intent.ShortcutIconResource.fromContext(this, R.drawable.icon_app));
+            sender.putExtra("duplicate", true);
+            sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT");
+            showToast(R.string.info_note_enter_desktop);
+            sendBroadcast(sender);
+        } else {
+            Log.e(TAG, "Send to desktop error");
+            showToast(R.string.error_note_empty_for_send_to_desktop);
+        }
+    }
+
+    /**
+     * 生成快捷方式标题
+     * @param content 内容
+     * @return 截断后的标题
+     */
+    private String makeShortcutIconTitle(String content) {
+        content = content.replace(TAG_CHECKED, "");
+        content = content.replace(TAG_UNCHECKED, "");
+        return content.length() > SHORTCUT_ICON_TITLE_MAX_LEN ? content.substring(0,
+                SHORTCUT_ICON_TITLE_MAX_LEN) : content;
+    }
+
+    /**
+     * 显示Toast提示
+     * @param resId 资源ID
+     */
+    private void showToast(int resId) {
+        showToast(resId, Toast.LENGTH_SHORT);
+    }
+
+    /**
+     * 显示Toast提示
+     * @param resId 资源ID
+     * @param duration 持续时间
+     */
+    private void showToast(int resId, int duration) {
+        Toast.makeText(this, resId, duration).show();
+    }
+}

src/net/micode/notes/ui/NoteEditText.java

@@ -0,0 +1,273 @@
+/*
+ * 版权信息：由MiCode开源社区（www.micode.net）贡献
+ * Apache 2.0许可证协议
+ * 本文件为NoteEditText类实现，用于Android平台的笔记编辑器扩展功能
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.text.Layout;
+import android.text.Selection;
+import android.text.Spanned;
+import android.text.TextUtils;
+import android.text.style.URLSpan;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.KeyEvent;
+import android.view.MenuItem;
+import android.view.MenuItem.OnMenuItemClickListener;
+import android.view.MotionEvent;
+import android.widget.EditText;
+
+import net.micode.notes.R;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 自定义文本编辑器
+ * 扩展EditText功能，支持笔记编辑场景下的特殊交互需求
+ */
+public class NoteEditText extends EditText {
+    private static final String TAG = "NoteEditText";  // 日志标签
+    
+    // 当前编辑项索引
+    private int mIndex;
+    // 删除操作前的光标位置
+    private int mSelectionStartBeforeDelete;
+
+    // 协议类型与资源ID映射
+    private static final String SCHEME_TEL = "tel:" ;      // 电话协议
+    private static final String SCHEME_HTTP = "http:" ;    // 网站协议
+    private static final String SCHEME_EMAIL = "mailto:" ; // 邮件协议
+
+    private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
+    static {
+        sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);    // 电话链接资源
+        sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);   // 网站链接资源
+        sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email); // 邮件链接资源
+    }
+
+    /**
+     * 文本变化监听器接口
+     * 用于通知外部组件文本编辑事件
+     */
+    public interface OnTextViewChangeListener {
+        /**
+         * 删除事件回调
+         * @param index 当前编辑项索引
+         * @param text 删除的文本内容
+         */
+        void onEditTextDelete(int index, String text);
+
+        /**
+         * 换行事件回调
+         * @param index 当前编辑项索引
+         * @param text 新增的文本内容
+         */
+        void onEditTextEnter(int index, String text);
+
+        /**
+         * 文本变化通知
+         * @param index 当前编辑项索引
+         * @param hasText 是否包含文本
+         */
+        void onTextChange(int index, boolean hasText);
+    }
+
+    // 文本变化监听器
+    private OnTextViewChangeListener mOnTextViewChangeListener;
+
+    /**
+     * 构造函数
+     * @param context 上下文环境
+     */
+    public NoteEditText(Context context) {
+        super(context, null);
+        mIndex = 0;
+    }
+
+    /**
+     * 设置当前编辑项索引
+     * @param index 索引值
+     */
+    public void setIndex(int index) {
+        mIndex = index;
+    }
+
+    /**
+     * 设置文本变化监听器
+     * @param listener 监听器实现
+     */
+    public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
+        mOnTextViewChangeListener = listener;
+    }
+
+    /**
+     * 带属性集的构造函数
+     * @param context 上下文环境
+     * @param attrs 属性集
+     */
+    public NoteEditText(Context context, AttributeSet attrs) {
+        super(context, attrs, android.R.attr.editTextStyle);
+    }
+
+    /**
+     * 带样式和属性集的构造函数
+     * @param context 上下文环境
+     * @param attrs 属性集
+     * @param defStyle 样式
+     */
+    public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        // TODO Auto-generated constructor stub
+    }
+
+    /**
+     * 处理触摸事件
+     * @param event 触摸事件
+     * @return 事件处理结果
+     */
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        switch (event.getAction()) {
+            case MotionEvent.ACTION_DOWN:
+                int x = (int) event.getX();
+                int y = (int) event.getY();
+                x -= getTotalPaddingLeft();
+                y -= getTotalPaddingTop();
+                x += getScrollX();
+                y += getScrollY();
+
+                Layout layout = getLayout();
+                int line = layout.getLineForVertical(y);
+                int off = layout.getOffsetForHorizontal(line, x);
+                Selection.setSelection(getText(), off);
+                break;
+        }
+
+        return super.onTouchEvent(event);
+    }
+
+    /**
+     * 处理按键按下事件
+     * @param keyCode 键码
+     * @param event 键事件
+     * @return 事件处理结果
+     */
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        switch (keyCode) {
+            case KeyEvent.KEYCODE_ENTER:
+                if (mOnTextViewChangeListener != null) {
+                    return false;  // 交由onKeyUp处理
+                }
+                break;
+            case KeyEvent.KEYCODE_DEL:
+                mSelectionStartBeforeDelete = getSelectionStart();
+                break;
+            default:
+                break;
+        }
+        return super.onKeyDown(keyCode, event);
+    }
+
+    /**
+     * 处理按键释放事件
+     * @param keyCode 键码
+     * @param event 键事件
+     * @return 事件处理结果
+     */
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        switch(keyCode) {
+            case KeyEvent.KEYCODE_DEL:
+                if (mOnTextViewChangeListener != null) {
+                    // 删除操作处理：当光标在开头且不是第一个编辑项时触发
+                    if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
+                        mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
+                        return true;
+                    }
+                } else {
+                    Log.d(TAG, "OnTextViewChangeListener was not seted");
+                }
+                break;
+            case KeyEvent.KEYCODE_ENTER:
+                if (mOnTextViewChangeListener != null) {
+                    int selectionStart = getSelectionStart();
+                    String text = getText().subSequence(selectionStart, length()).toString();
+                    setText(getText().subSequence(0, selectionStart));
+                    mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
+                } else {
+                    Log.d(TAG, "OnTextViewChangeListener was not seted");
+                }
+                break;
+            default:
+                break;
+        }
+        return super.onKeyUp(keyCode, event);
+    }
+
+    /**
+     * 焦点变化回调
+     * @param focused 是否获得焦点
+     * @param direction 方向
+     * @param previouslyFocusedRect 之前焦点区域
+     */
+    @Override
+    protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
+        if (mOnTextViewChangeListener != null) {
+            if (!focused && TextUtils.isEmpty(getText())) {
+                mOnTextViewChangeListener.onTextChange(mIndex, false);
+            } else {
+                mOnTextViewChangeListener.onTextChange(mIndex, true);
+            }
+        }
+        super.onFocusChanged(focused, direction, previouslyFocusedRect);
+    }
+
+    /**
+     * 创建上下文菜单
+     * @param menu 上下文菜单
+     */
+    @Override
+    protected void onCreateContextMenu(ContextMenu menu) {
+        if (getText() instanceof Spanned) {
+            int selStart = getSelectionStart();
+            int selEnd = getSelectionEnd();
+
+            int min = Math.min(selStart, selEnd);
+            int max = Math.max(selStart, selEnd);
+
+            final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
+            if (urls.length == 1) {
+                int defaultResId = 0;
+                // 根据URL协议类型选择对应菜单项
+                for(String schema: sSchemaActionResMap.keySet()) {
+                    if(urls[0].getURL().indexOf(schema) >= 0) {
+                        defaultResId = sSchemaActionResMap.get(schema);
+                        break;
+                    }
+                }
+
+                if (defaultResId == 0) {
+                    defaultResId = R.string.note_link_other;
+                }
+
+                // 添加菜单项并设置点击监听
+                menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
+                        new OnMenuItemClickListener() {
+                            public boolean onMenuItemClick(MenuItem item) {
+                                // 触发URL点击事件
+                                urls[0].onClick(NoteEditText.this);
+                                return true;
+                            }
+                        });
+            }
+        }
+        super.onCreateContextMenu(menu);
+    }
+}

src/net/micode/notes/ui/NoteItemData.java

@@ -0,0 +1,241 @@
+/*
+ * 版权信息：由MiCode开源社区（www.micode.net）贡献
+ * Apache 2.0许可证协议
+ * 本文件为NoteItemData类实现，用于封装笔记列表项的数据模型
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.text.TextUtils;
+
+import net.micode.notes.data.Contact;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.tool.DataUtils;
+
+/**
+ * 笔记列表项数据模型
+ * 封装从数据库查询的笔记/文件夹数据，并提供位置状态判断功能
+ */
+public class NoteItemData {
+    // 数据库查询字段投影
+    static final String [] PROJECTION = new String [] {
+        NoteColumns.ID,                // 0: 笔记ID
+        NoteColumns.ALERTED_DATE,      // 1: 提醒日期
+        NoteColumns.BG_COLOR_ID,       // 2: 背景颜色ID
+        NoteColumns.CREATED_DATE,      // 3: 创建日期
+        NoteColumns.HAS_ATTACHMENT,    // 4: 是否包含附件
+        NoteColumns.MODIFIED_DATE,     // 5: 修改日期
+        NoteColumns.NOTES_COUNT,       // 6: 笔记数量
+        NoteColumns.PARENT_ID,         // 7: 父文件夹ID
+        NoteColumns.SNIPPET,           // 8: 摘要内容
+        NoteColumns.TYPE,              // 9: 类型（笔记/文件夹）
+        NoteColumns.WIDGET_ID,         // 10: 小部件ID
+        NoteColumns.WIDGET_TYPE        // 11: 小部件类型
+    };
+
+    // 列索引常量
+    private static final int ID_COLUMN                    = 0;
+    private static final int ALERTED_DATE_COLUMN          = 1;
+    private static final int BG_COLOR_ID_COLUMN           = 2;
+    private static final int CREATED_DATE_COLUMN          = 3;
+    private static final int HAS_ATTACHMENT_COLUMN        = 4;
+    private static final int MODIFIED_DATE_COLUMN         = 5;
+    private static final int NOTES_COUNT_COLUMN           = 6;
+    private static final int PARENT_ID_COLUMN             = 7;
+    private static final int SNIPPET_COLUMN               = 8;
+    private static final int TYPE_COLUMN                  = 9;
+    private static final int WIDGET_ID_COLUMN             = 10;
+    private static final int WIDGET_TYPE_COLUMN           = 11;
+
+    // 数据字段
+    private long mId;                  // 笔记ID
+    private long mAlertDate;           // 提醒日期
+    private int mBgColorId;            // 背景颜色ID
+    private long mCreatedDate;         // 创建日期
+    private boolean mHasAttachment;    // 是否包含附件
+    private long mModifiedDate;        // 修改日期
+    private int mNotesCount;           // 笔记数量
+    private long mParentId;            // 父文件夹ID
+    private String mSnippet;           // 摘要内容
+    private int mType;                 // 类型（笔记/文件夹）
+    private int mWidgetId;             // 小部件ID
+    private int mWidgetType;           // 小部件类型
+
+    // 位置状态字段
+    private boolean mIsLastItem;       // 是否是最后一项
+    private boolean mIsFirstItem;      // 是否是第一项
+    private boolean mIsOnlyOneItem;    // 是否是唯一一项
+    private boolean mIsOneNoteFollowingFolder;  // 是否是文件夹后的单个笔记
+    private boolean mIsMultiNotesFollowingFolder; // 是否是文件夹后的多个笔记
+
+    /**
+     * 构造函数
+     * @param context 上下文环境
+     * @param cursor 数据库游标
+     */
+    public NoteItemData(Context context, Cursor cursor) {
+        // 从游标中提取基础数据
+        mId = cursor.getLong(ID_COLUMN);
+        mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
+        mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
+        mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
+        mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false;
+        mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
+        mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
+        mParentId = cursor.getLong(PARENT_ID_COLUMN);
+        mSnippet = cursor.getString(SNIPPET_COLUMN);
+        
+        // 清理摘要内容中的特殊标记
+        mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
+                NoteEditActivity.TAG_UNCHECKED, "");
+        
+        mType = cursor.getInt(TYPE_COLUMN);
+        mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
+        mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
+
+        // 处理通话记录特殊逻辑
+        mPhoneNumber = "";
+        if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
+            mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
+            if (!TextUtils.isEmpty(mPhoneNumber)) {
+                mName = Contact.getContact(context, mPhoneNumber);
+                if (mName == null) {
+                    mName = mPhoneNumber;
+                }
+            }
+        }
+
+        if (mName == null) {
+            mName = "";
+        }
+        checkPostion(cursor); // 检测当前位置状态
+    }
+
+    /**
+     * 检测当前项在列表中的位置状态
+     * @param cursor 数据库游标
+     */
+    private void checkPostion(Cursor cursor) {
+        mIsLastItem = cursor.isLast() ? true : false;
+        mIsFirstItem = cursor.isFirst() ? true : false;
+        mIsOnlyOneItem = (cursor.getCount() == 1);
+        mIsMultiNotesFollowingFolder = false;
+        mIsOneNoteFollowingFolder = false;
+
+        // 仅对笔记类型进行后续项检测
+        if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
+            int position = cursor.getPosition();
+            if (cursor.moveToPrevious()) {
+                // 检查前一项是否为文件夹或系统项
+                if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
+                        || cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
+                    // 判断后续是否有多个笔记
+                    if (cursor.getCount() > (position + 1)) {
+                        mIsMultiNotesFollowingFolder = true;
+                    } else {
+                        mIsOneNoteFollowingFolder = true;
+                    }
+                }
+                // 确保游标回到原始位置
+                if (!cursor.moveToNext()) {
+                    throw new IllegalStateException("cursor move to previous but can't move back");
+                }
+            }
+        }
+    }
+
+    // 位置状态查询方法
+    public boolean isOneFollowingFolder() {
+        return mIsOneNoteFollowingFolder;
+    }
+
+    public boolean isMultiFollowingFolder() {
+        return mIsMultiNotesFollowingFolder;
+    }
+
+    public boolean isLast() {
+        return mIsLastItem;
+    }
+
+    public String getCallName() {
+        return mName;
+    }
+
+    public boolean isFirst() {
+        return mIsFirstItem;
+    }
+
+    public boolean isSingle() {
+        return mIsOnlyOneItem;
+    }
+
+    // 数据访问方法
+    public long getId() {
+        return mId;
+    }
+
+    public long getAlertDate() {
+        return mAlertDate;
+    }
+
+    public long getCreatedDate() {
+        return mCreatedDate;
+    }
+
+    public boolean hasAttachment() {
+        return mHasAttachment;
+    }
+
+    public long getModifiedDate() {
+        return mModifiedDate;
+    }
+
+    public int getBgColorId() {
+        return mBgColorId;
+    }
+
+    public long getParentId() {
+        return mParentId;
+    }
+
+    public int getNotesCount() {
+        return mNotesCount;
+    }
+
+    public long getFolderId () {
+        return mParentId;
+    }
+
+    public int getType() {
+        return mType;
+    }
+
+    public int getWidgetType() {
+        return mWidgetType;
+    }
+
+    public int getWidgetId() {
+        return mWidgetId;
+    }
+
+    public String getSnippet() {
+        return mSnippet;
+    }
+
+    // 特殊状态判断
+    public boolean hasAlert() {
+        return (mAlertDate > 0);
+    }
+
+    public boolean isCallRecord() {
+        return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
+    }
+
+    // 静态方法
+    public static int getNoteType(Cursor cursor) {
+        return cursor.getInt(TYPE_COLUMN);
+    }
+}

src/net/micode/notes/ui/NotesListActivity.java

@@ -0,0 +1,785 @@
+/*
+ * 版权信息：由MiCode开源社区（www.micode.net）贡献
+ * Apache 2.0许可证协议
+ * 本文件为NotesListActivity类实现，用于Android平台的笔记列表展示与管理功能
+ */
+
+package net.micode.notes.ui;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.appwidget.AppWidgetManager;
+import android.content.AsyncQueryHandler;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.database.Cursor;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.text.Editable;
+import android.text.TextUtils;
+import android.text.TextWatcher;
+import android.util.Log;
+import android.view.ActionMode;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.Display;
+import android.view.HapticFeedbackConstants;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MenuItem.OnMenuItemClickListener;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnCreateContextMenuListener;
+import android.view.View.OnTouchListener;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.AdapterView.OnItemLongClickListener;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ListView;
+import android.widget.PopupMenu;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.remote.GTaskSyncService;
+import net.micode.notes.model.WorkingNote;
+import net.micode.notes.tool.BackupUtils;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.ResourceParser;
+import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
+import net.micode.notes.widget.NoteWidgetProvider_2x;
+import net.micode.notes.widget.NoteWidgetProvider_4x;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.HashSet;
+
+/**
+ * 笔记列表活动
+ * 实现笔记列表的展示、操作、文件夹管理、同步等功能
+ */
+public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {
+    // 查询令牌常量
+    private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0;
+    private static final int FOLDER_LIST_QUERY_TOKEN = 1;
+
+    // 菜单项ID常量
+    private static final int MENU_FOLDER_DELETE = 0;
+    private static final int MENU_FOLDER_VIEW = 1;
+    private static final int MENU_FOLDER_CHANGE_NAME = 2;
+
+    // 列表编辑状态枚举
+    private enum ListEditState {
+        NOTE_LIST, SUB_FOLDER, CALL_RECORD_FOLDER
+    }
+
+    private ListEditState mState; // 当前列表编辑状态
+    private BackgroundQueryHandler mBackgroundQueryHandler; // 异步查询处理器
+    private NotesListAdapter mNotesListAdapter; // 笔记列表适配器
+    private ListView mNotesListView; // 笔记列表视图
+    private Button mAddNewNote; // 新建笔记按钮
+    private boolean mDispatch; // 事件分发标志
+    private int mOriginY; // 原始Y坐标
+    private int mDispatchY; // 分发Y坐标
+    private TextView mTitleBar; // 标题栏
+    private long mCurrentFolderId; // 当前文件夹ID
+    private ContentResolver mContentResolver; // 内容解析器
+    private ModeCallback mModeCallBack; // 多选模式回调
+
+    private static final String TAG = "NotesListActivity"; // 日志标签
+    public static final int NOTES_LISTVIEW_SCROLL_RATE = 30; // 列表滚动速率
+    private NoteItemData mFocusNoteDataItem; // 当前焦点笔记数据
+    private final static int REQUEST_CODE_OPEN_NODE = 102; // 打开节点请求码
+    private final static int REQUEST_CODE_NEW_NODE = 103; // 新建节点请求码
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.note_list);
+        initResources();
+
+        /**
+         * 首次使用时插入介绍内容
+         */
+        setAppInfoFromRawRes();
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (resultCode == RESULT_OK
+                && (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {
+            mNotesListAdapter.changeCursor(null);
+        } else {
+            super.onActivityResult(requestCode, resultCode, data);
+        }
+    }
+
+    /**
+     * 从raw资源加载应用介绍
+     * 首次启动时插入初始笔记
+     */
+    private void setAppInfoFromRawRes() {
+        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
+        if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {
+            StringBuilder sb = new StringBuilder();
+            InputStream in = null;
+            try {
+                in = getResources().openRawResource(R.raw.introduction);
+                if (in != null) {
+                    InputStreamReader isr = new InputStreamReader(in);
+                    BufferedReader br = new BufferedReader(isr);
+                    char[] buf = new char[1024];
+                    int len = 0;
+                    while ((len = br.read(buf)) > 0) {
+                        sb.append(buf, 0, len);
+                    }
+                } else {
+                    Log.e(TAG, "Read introduction file error");
+                    return;
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+                return;
+            } finally {
+                if (in != null) {
+                    try {
+                        in.close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+
+            WorkingNote note = WorkingNote.createEmptyNote(this, Notes.ID_ROOT_FOLDER,
+                    AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
+                    ResourceParser.RED);
+            note.setWorkingText(sb.toString());
+            if (note.saveNote()) {
+                sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit();
+            } else {
+                Log.e(TAG, "Save introduction note error");
+                return;
+            }
+        }
+    }
+
+    @Override
+    protected void onStart() {
+        super.onStart();
+        startAsyncNotesListQuery();
+    }
+
+    /**
+     * 初始化资源
+     * 设置UI组件和监听器
+     */
+    private void initResources() {
+        mContentResolver = this.getContentResolver();
+        mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
+        mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+        mNotesListView = (ListView) findViewById(R.id.notes_list);
+        mNotesListView.addFooterView(LayoutInflater.from(this).inflate(R.layout.note_list_footer, null),
+                null, false);
+        mNotesListView.setOnItemClickListener(new OnListItemClickListener());
+        mNotesListView.setOnItemLongClickListener(this);
+        mNotesListAdapter = new NotesListAdapter(this);
+        mNotesListView.setAdapter(mNotesListAdapter);
+        mAddNewNote = (Button) findViewById(R.id.btn_new_note);
+        mAddNewNote.setOnClickListener(this);
+        mAddNewNote.setOnTouchListener(new NewNoteOnTouchListener());
+        mDispatch = false;
+        mDispatchY = 0;
+        mOriginY = 0;
+        mTitleBar = (TextView) findViewById(R.id.tv_title_bar);
+        mState = ListEditState.NOTE_LIST;
+        mModeCallBack = new ModeCallback();
+    }
+
+    /**
+     * 多选模式回调
+     * 实现多选菜单的创建、销毁和操作
+     */
+    private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
+        private DropdownMenu mDropDownMenu;
+        private ActionMode mActionMode;
+        private MenuItem mMoveMenu;
+
+        public boolean onCreateActionMode(ActionMode mode, Menu menu) {
+            getMenuInflater().inflate(R.menu.note_list_options, menu);
+            menu.findItem(R.id.delete).setOnMenuItemClickListener(this);
+            mMoveMenu = menu.findItem(R.id.move);
+            if (mFocusNoteDataItem.getParentId() == Notes.ID_CALL_RECORD_FOLDER
+                    || DataUtils.getUserFolderCount(mContentResolver) == 0) {
+                mMoveMenu.setVisible(false);
+            } else {
+                mMoveMenu.setVisible(true);
+                mMoveMenu.setOnMenuItemClickListener(this);
+            }
+            mActionMode = mode;
+            mNotesListAdapter.setChoiceMode(true);
+            mNotesListView.setLongClickable(false);
+            mAddNewNote.setVisibility(View.GONE);
+
+            View customView = LayoutInflater.from(NotesListActivity.this).inflate(
+                    R.layout.note_list_dropdown_menu, null);
+            mode.setCustomView(customView);
+            mDropDownMenu = new DropdownMenu(NotesListActivity.this,
+                    (Button) customView.findViewById(R.id.selection_menu),
+                    R.menu.note_list_dropdown);
+            mDropDownMenu.setOnDropdownMenuItemClickListener(new PopupMenu.OnMenuItemClickListener(){
+                public boolean onMenuItemClick(MenuItem item) {
+                    mNotesListAdapter.selectAll(!mNotesListAdapter.isAllSelected());
+                    updateMenu();
+                    return true;
+                }
+
+            });
+            return true;
+        }
+
+        private void updateMenu() {
+            int selectedCount = mNotesListAdapter.getSelectedCount();
+            String format = getResources().getString(R.string.menu_select_title, selectedCount);
+            mDropDownMenu.setTitle(format);
+            MenuItem item = mDropDownMenu.findItem(R.id.action_select_all);
+            if (item != null) {
+                if (mNotesListAdapter.isAllSelected()) {
+                    item.setChecked(true);
+                    item.setTitle(R.string.menu_deselect_all);
+                } else {
+                    item.setChecked(false);
+                    item.setTitle(R.string.menu_select_all);
+                }
+            }
+        }
+
+        public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
+            return false;
+        }
+
+        public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
+            return false;
+        }
+
+        public void onDestroyActionMode(ActionMode mode) {
+            mNotesListAdapter.setChoiceMode(false);
+            mNotesListView.setLongClickable(true);
+            mAddNewNote.setVisibility(View.VISIBLE);
+        }
+
+        public void finishActionMode() {
+            mActionMode.finish();
+        }
+
+        public void onItemCheckedStateChanged(ActionMode mode, int position, long id,
+                boolean checked) {
+            mNotesListAdapter.setCheckedItem(position, checked);
+            updateMenu();
+        }
+
+        public boolean onMenuItemClick(MenuItem item) {
+            if (mNotesListAdapter.getSelectedCount() == 0) {
+                Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
+                        Toast.LENGTH_SHORT).show();
+                return true;
+            }
+
+            switch (item.getItemId()) {
+                case R.id.delete:
+                    AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+                    builder.setTitle(getString(R.string.alert_title_delete));
+                    builder.setIcon(android.R.drawable.ic_dialog_alert);
+                    builder.setMessage(getString(R.string.alert_message_delete_notes,
+                             mNotesListAdapter.getSelectedCount()));
+                    builder.setPositiveButton(android.R.string.ok,
+                             new DialogInterface.OnClickListener() {
+                                 public void onClick(DialogInterface dialog,
+                                         int which) {
+                                     batchDelete();
+                                 }
+                             });
+                    builder.setNegativeButton(android.R.string.cancel, null);
+                    builder.show();
+                    break;
+                case R.id.move:
+                    startQueryDestinationFolders();
+                    break;
+                default:
+                    return false;
+            }
+            return true;
+        }
+    }
+
+    /**
+     * 新建笔记按钮触摸监听器
+     * 处理按钮的触摸事件，支持滚动列表
+     */
+    private class NewNoteOnTouchListener implements OnTouchListener {
+
+        public boolean onTouch(View v, MotionEvent event) {
+            switch (event.getAction()) {
+                case MotionEvent.ACTION_DOWN: {
+                    Display display = getWindowManager().getDefaultDisplay();
+                    int screenHeight = display.getHeight();
+                    int newNoteViewHeight = mAddNewNote.getHeight();
+                    int start = screenHeight - newNoteViewHeight;
+                    int eventY = start + (int) event.getY();
+                    if (mState == ListEditState.SUB_FOLDER) {
+                        eventY -= mTitleBar.getHeight();
+                        start -= mTitleBar.getHeight();
+                    }
+                    if (event.getY() < (event.getX() * (-0.12) + 94) {
+                        View view = mNotesListView.getChildAt(mNotesListView.getChildCount() - 1
+                                - mNotesListView.getFooterViewsCount());
+                        if (view != null && view.getBottom() > start
+                                && (view.getTop() < (start + 94)) {
+                            mOriginY = (int) event.getY();
+                            mDispatchY = eventY;
+                            event.setLocation(event.getX(), mDispatchY);
+                            mDispatch = true;
+                            return mNotesListView.dispatchTouchEvent(event);
+                        }
+                    }
+                    break;
+                }
+                case MotionEvent.ACTION_MOVE: {
+                    if (mDispatch) {
+                        mDispatchY += (int) event.getY() - mOriginY;
+                        event.setLocation(event.getX(), mDispatchY);
+                        return mNotesListView.dispatchTouchEvent(event);
+                    }
+                    break;
+                }
+                default: {
+                    if (mDispatch) {
+                        event.setLocation(event.getX(), mDispatchY);
+                        mDispatch = false;
+                        return mNotesListView.dispatchTouchEvent(event);
+                    }
+                    break;
+                }
+            }
+            return false;
+        }
+
+    };
+
+    /**
+     * 异步查询笔记列表
+     * 根据当前文件夹ID查询笔记数据
+     */
+    private void startAsyncNotesListQuery() {
+        String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
+                : NORMAL_SELECTION;
+        mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null,
+                Notes.CONTENT_NOTE_URI, NoteItemData.PROJECTION, selection, new String[] {
+                    String.valueOf(mCurrentFolderId)
+                }, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
+    }
+
+    /**
+     * 异步查询处理器
+     * 处理数据库查询完成后的回调
+     */
+    private final class BackgroundQueryHandler extends AsyncQueryHandler {
+        public BackgroundQueryHandler(ContentResolver contentResolver) {
+            super(contentResolver);
+        }
+
+        @Override
+        protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
+            switch (token) {
+                case FOLDER_NOTE_LIST_QUERY_TOKEN:
+                    mNotesListAdapter.changeCursor(cursor);
+                    break;
+                case FOLDER_LIST_QUERY_TOKEN:
+                    if (cursor != null && cursor.getCount() > 0) {
+                        showFolderListMenu(cursor);
+                    } else {
+                        Log.e(TAG, "Query folder failed");
+                    }
+                    break;
+                default:
+                    return;
+            }
+        }
+    }
+
+    /**
+     * 显示文件夹选择对话框
+     * 允许用户选择目标文件夹进行移动操作
+     */
+    private void showFolderListMenu(Cursor cursor) {
+        AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+        builder.setTitle(R.string.menu_title_select_folder);
+        final FoldersListAdapter adapter = new FoldersListAdapter(this, cursor);
+        builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
+
+            public void onClick(DialogInterface dialog, int which) {
+                DataUtils.batchMoveToFolder(mContentResolver,
+                        mNotesListAdapter.getSelectedItemIds(), adapter.getItemId(which));
+                Toast.makeText(
+                        NotesListActivity.this,
+                        getString(R.string.format_move_notes_to_folder,
+                                mNotesListAdapter.getSelectedCount(),
+                                adapter.getFolderName(NotesListActivity.this, which)),
+                        Toast.LENGTH_SHORT).show();
+                mModeCallBack.finishActionMode();
+            }
+        });
+        builder.show();
+    }
+
+    /**
+     * 创建新笔记
+     * 启动NoteEditActivity并传递文件夹ID
+     */
+    private void createNewNote() {
+        Intent intent = new Intent(this, NoteEditActivity.class);
+        intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
+        intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId);
+        this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE);
+    }
+
+    /**
+     * 批量删除笔记
+     * 根据同步模式决定是直接删除还是移动到回收站
+     */
+    private void batchDelete() {
+        new AsyncTask<Void, Void, HashSet<AppWidgetAttribute>() {
+            protected HashSet<AppWidgetAttribute> doInBackground(Void... unused) {
+                HashSet<AppWidgetAttribute> widgets = mNotesListAdapter.getSelectedWidget();
+                if (!isSyncMode()) {
+                    if (DataUtils.batchDeleteNotes(mContentResolver, mNotesListAdapter
+                            .getSelectedItemIds())) {
+                    } else {
+                        Log.e(TAG, "Delete notes error, should not happens");
+                    }
+                } else {
+                    if (!DataUtils.batchMoveToFolder(mContentResolver, mNotesListAdapter
+                            .getSelectedItemIds(), Notes.ID_TRASH_FOLER)) {
+                        Log.e(TAG, "Move notes to trash folder error, should not happens");
+                    }
+                }
+                return widgets;
+            }
+
+            @Override
+            protected void onPostExecute(HashSet<AppWidgetAttribute> widgets) {
+                if (widgets != null) {
+                    for (AppWidgetAttribute widget : widgets) {
+                        if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                                && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
+                            updateWidget(widget.widgetId, widget.widgetType);
+                        }
+                    }
+                }
+                mModeCallBack.finishActionMode();
+            }
+        }.execute();
+    }
+
+    /**
+     * 删除文件夹
+     * 根据同步模式决定删除方式
+     */
+    private void deleteFolder(long folderId) {
+        if (folderId == Notes.ID_ROOT_FOLDER) {
+            Log.e(TAG, "Wrong folder id, should not happen " + folderId);
+            return;
+        }
+
+        HashSet<Long> ids = new HashSet<Long>();
+        ids.add(folderId);
+        HashSet<AppWidgetAttribute> widgets = DataUtils.getFolderNoteWidget(mContentResolver,
+                folderId);
+        if (!isSyncMode()) {
+            DataUtils.batchDeleteNotes(mContentResolver, ids);
+        } else {
+            DataUtils.batchMoveToFolder(mContentResolver, ids, Notes.ID_TRASH_FOLER);
+        }
+        if (widgets != null) {
+            for (AppWidgetAttribute widget : widgets) {
+                if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                        && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
+                    updateWidget(widget.widgetId, widget.widgetType);
+                }
+            }
+        }
+    }
+
+    /**
+     * 打开笔记
+     * 启动NoteEditActivity并传递笔记ID
+     */
+    private void openNode(NoteItemData data) {
+        Intent intent = new Intent(this, NoteEditActivity.class);
+        intent.setAction(Intent.ACTION_VIEW);
+        intent.putExtra(Intent.EXTRA_UID, data.getId());
+        this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE);
+    }
+
+    /**
+     * 打开文件夹
+     * 更新当前文件夹ID并重新加载数据
+     */
+    private void openFolder(NoteItemData data) {
+        mCurrentFolderId = data.getId();
+        startAsyncNotesListQuery();
+        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+            mState = ListEditState.CALL_RECORD_FOLDER;
+            mAddNewNote.setVisibility(View.GONE);
+        } else {
+            mState = ListEditState.SUB_FOLDER;
+        }
+        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+            mTitleBar.setText(R.string.call_record_folder_name);
+        } else {
+            mTitleBar.setText(data.getSnippet());
+        }
+        mTitleBar.setVisibility(View.VISIBLE);
+    }
+
+    /**
+     * 按钮点击事件处理
+     * 创建新笔记
+     */
+    public void onClick(View v) {
+        switch (v.getId()) {
+            case R.id.btn_new_note:
+                createNewNote();
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * 显示软键盘
+     */
+    private void showSoftInput() {
+        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+        if (inputMethodManager != null) {
+            inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
+        }
+    }
+
+    /**
+     * 隐藏软键盘
+     */
+    private void hideSoftInput(View view) {
+        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+        inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
+    }
+
+    /**
+     * 显示创建/修改文件夹对话框
+     * 支持创建新文件夹或修改现有文件夹名称
+     */
+    private void showCreateOrModifyFolderDialog(final boolean create) {
+        final AlertDialog.Builder builder = new AlertDialog.Builder(this);
+        View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
+        final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);
+        showSoftInput();
+        if (!create) {
+            if (mFocusNoteDataItem != null) {
+                etName.setText(mFocusNoteDataItem.getSnippet());
+                builder.setTitle(getString(R.string.menu_folder_change_name);
+            } else {
+                Log.e(TAG, "The long click data item is null");
+                return;
+            }
+        } else {
+            etName.setText("");
+            builder.setTitle(this.getString(R.string.menu_create_folder);
+        }
+
+        builder.setPositiveButton(android.R.string.ok, null);
+        builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+            public void onClick(DialogInterface dialog, int which) {
+                hideSoftInput(etName);
+            }
+        });
+
+        final Dialog dialog = builder.setView(view).show();
+        final Button positive = (Button)dialog.findViewById(android.R.id.button1);
+        positive.setOnClickListener(new OnClickListener() {
+            public void onClick(View v) {
+                hideSoftInput(etName);
+                String name = etName.getText().toString();
+                if (DataUtils.checkVisibleFolderName(mContentResolver, name)) {
+                    Toast.makeText(NotesListActivity.this, getString(R.string.folder_exist, name),
+                            Toast.LENGTH_LONG).show();
+                    etName.setSelection(0, etName.length());
+                    return;
+                }
+                if (!create) {
+                    if (!TextUtils.isEmpty(name)) {
+                        ContentValues values = new ContentValues();
+                        values.put(NoteColumns.SNIPPET, name);
+                        values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
+                        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+                        mContentResolver.update(Notes.CONTENT_NOTE_URI, values, NoteColumns.ID
+                                + "=?", new String[] {
+                            String.valueOf(mFocusNoteDataItem.getId())
+                        });
+                    }
+                } else if (!TextUtils.isEmpty(name)) {
+                    ContentValues values = new ContentValues();
+                    values.put(NoteColumns.SNIPPET, name);
+                    values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
+                    mContentResolver.insert(Notes.CONTENT_NOTE_URI, values);
+                }
+                dialog.dismiss();
+            }
+        });
+
+        if (TextUtils.isEmpty(etName.getText())) {
+            positive.setEnabled(false);
+        }
+        etName.addTextChangedListener(new TextWatcher() {
+            public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
+
+            public void onTextChanged(CharSequence s, int start, int before, int count) {
+                if (TextUtils.isEmpty(etName.getText())) {
+                    positive.setEnabled(false);
+                } else {
+                    positive.setEnabled(true);
+                }
+            }
+
+            public void afterTextChanged(Editable s) {}
+        });
+    }
+
+    @Override
+    public void onBackPressed() {
+        switch (mState) {
+            case SUB_FOLDER:
+                mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+                mState = ListEditState.NOTE_LIST;
+                startAsyncNotesListQuery();
+                mTitleBar.setVisibility(View.GONE);
+                break;
+            case CALL_RECORD_FOLDER:
+                mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+                mState = ListEditState.NOTE_LIST;
+                mAddNewNote.setVisibility(View.VISIBLE);
+                mTitleBar.setVisibility(View.GONE);
+                startAsyncNotesListQuery();
+                break;
+            case NOTE_LIST:
+                super.onBackPressed();
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * 更新应用小部件
+     * 根据小部件类型发送更新广播
+     */
+    private void updateWidget(int appWidgetId, int appWidgetType) {
+        Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
+        if (appWidgetType == Notes.TYPE_WIDGET_2X) {
+            intent.setClass(this, NoteWidgetProvider_2x.class);
+        } else if (appWidgetType == Notes.TYPE_WIDGET_4X) {
+            intent.setClass(this, NoteWidgetProvider_4x.class);
+        } else {
+            Log.e(TAG, "Unspported widget type");
+            return;
+        }
+
+        intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
+            appWidgetId
+        });
+
+        sendBroadcast(intent);
+        setResult(RESULT_OK, intent);
+    }
+
+    /**
+     * 文件夹上下文菜单创建监听器
+     * 为文件夹项创建上下文菜单
+     */
+    private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {
+        public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+            if (mFocusNoteDataItem != null) {
+                menu.setHeaderTitle(mFocusNoteDataItem.getSnippet());
+                menu.add(0, MENU_FOLDER_VIEW, 0, R.string.menu_folder_view);
+                menu.add(0, MENU_FOLDER_DELETE, 0, R.string.menu_folder_delete);
+                menu.add(0, MENU_FOLDER_CHANGE_NAME, 0, R.string.menu_folder_change_name);
+            }
+        }
+    };
+
+    @Override
+    public void onContextMenuClosed(Menu menu) {
+        if (mNotesListView != null) {
+            mNotesListView.setOnCreateContextMenuListener(null);
+        }
+        super.onContextMenuClosed(menu);
+    }
+
+    @Override
+    public boolean onContextItemSelected(MenuItem item) {
+        if (mFocusNoteDataItem == null) {
+            Log.e(TAG, "The long click data item is null");
+            return false;
+        }
+        switch (item.getItemId()) {
+            case MENU_FOLDER_VIEW:
+                openFolder(mFocusNoteDataItem);
+                break;
+            case MENU_FOLDER_DELETE:
+                AlertDialog.Builder builder = new AlertDialog.Builder(this);
+                builder.setTitle(getString(R.string.alert_title_delete);
+                builder.setIcon(android.R.drawable.ic_dialog_alert);
+                builder.setMessage(getString(R.string.alert_message_delete_folder));
+                builder.setPositiveButton(android.R.string.ok,
+                        new DialogInterface.OnClickListener() {
+                            public void onClick(DialogInterface dialog, int which) {
+                                deleteFolder(mFocusNoteDataItem.getId());
+                            }
+                        });
+                builder.setNegativeButton(android.R.string.cancel, null);
+                builder.show();
+                break;
+            case MENU_FOLDER_CHANGE_NAME:
+                showCreateOrModifyFolderDialog(false);
+                break;
+            default:
+                break;
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean onPrepareOptionsMenu(Menu menu) {
+        menu.clear();
+        if (mState == ListEditState.NOTE_LIST) {
+            getMenuInflater().inflate(R.menu.note_list, menu);
+            menu.findItem(R.id.menu_sync).setTitle(
+                    GTaskSyncService.isSyncing() ? R.string.menu_sync_cancel : R.string.menu_sync);
+        } else if (mState == ListEditState.SUB_FOLDER) {
+            getMenuInflater().inflate(R.menu.sub_folder, menu);
+        } else if (mState == ListEditState.CALL_RECORD_FOLDER) {
+            getMenuInflater().inflate(R.menu.call_record_folder, menu);
+        } else {
+            Log.e(TAG, "Wrong state:" + m

src/net/micode/notes/ui/NotesListAdapter.java

@@ -0,0 +1,248 @@
+/*
+ * 版权信息：由MiCode开源社区（www.micode.net）贡献
+ * Apache 2.0许可证协议
+ * 本文件为NotesListAdapter类实现，用于Android平台的笔记列表适配器
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.CursorAdapter;
+
+import net.micode.notes.data.Notes;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+
+/**
+ * 笔记列表适配器
+ * 继承自CursorAdapter，用于将数据库中的笔记数据绑定到ListView
+ */
+public class NotesListAdapter extends CursorAdapter {
+    private static final String TAG = "NotesListAdapter"; // 日志标签
+    private Context mContext; // 上下文环境
+    private HashMap<Integer, Boolean> mSelectedIndex; // 记录选中项的位置和状态
+    private int mNotesCount; // 笔记总数
+    private boolean mChoiceMode; // 是否处于多选模式
+
+    /**
+     * 小部件属性容器
+     * 用于存储小部件ID和类型信息
+     */
+    public static class AppWidgetAttribute {
+        public int widgetId; // 小部件ID
+        public int widgetType; // 小部件类型
+    };
+
+    /**
+     * 构造函数
+     * @param context 上下文环境
+     */
+    public NotesListAdapter(Context context) {
+        super(context, null);
+        mSelectedIndex = new HashMap<Integer, Boolean>();
+        mContext = context;
+        mNotesCount = 0;
+    }
+
+    /**
+     * 创建新的列表项视图
+     * @param context 上下文环境
+     * @param cursor 数据库游标
+     * @param parent 父容器
+     * @return 新创建的列表项视图
+     */
+    @Override
+    public View newView(Context context, Cursor cursor, ViewGroup parent) {
+        return new NotesListItem(context);
+    }
+
+    /**
+     * 绑定数据到列表项视图
+     * @param view 目标视图
+     * @param context 上下文环境
+     * @param cursor 数据库游标
+     */
+    @Override
+    public void bindView(View view, Context context, Cursor cursor) {
+        if (view instanceof NotesListItem) {
+            // 从游标创建笔记数据对象
+            NoteItemData itemData = new NoteItemData(context, cursor);
+            // 绑定数据到视图并设置选择状态
+            ((NotesListItem) view).bind(context, itemData, mChoiceMode,
+                    isSelectedItem(cursor.getPosition()));
+        }
+    }
+
+    /**
+     * 设置指定位置的选中状态
+     * @param position 列表位置
+     * @param checked 是否选中
+     */
+    public void setCheckedItem(final int position, final boolean checked) {
+        mSelectedIndex.put(position, checked);
+        notifyDataSetChanged(); // 通知数据集变化
+    }
+
+    /**
+     * 检查是否处于多选模式
+     * @return true表示处于多选模式
+     */
+    public boolean isInChoiceMode() {
+        return mChoiceMode;
+    }
+
+    /**
+     * 设置多选模式
+     * @param mode 是否启用多选模式
+     */
+    public void setChoiceMode(boolean mode) {
+        mSelectedIndex.clear(); // 清除选中状态
+        mChoiceMode = mode;
+    }
+
+    /**
+     * 全选或全不选所有笔记项
+     * @param checked 选中状态
+     */
+    public void selectAll(boolean checked) {
+        Cursor cursor = getCursor();
+        for (int i = 0; i < getCount(); i++) {
+            if (cursor.moveToPosition(i)) {
+                // 仅对笔记类型进行全选操作
+                if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
+                    setCheckedItem(i, checked);
+                }
+            }
+        }
+    }
+
+    /**
+     * 获取所有选中的笔记ID
+     * @return 选中笔记ID的集合
+     */
+    public HashSet<Long> getSelectedItemIds() {
+        HashSet<Long> itemSet = new HashSet<Long>();
+        for (Integer position : mSelectedIndex.keySet()) {
+            if (mSelectedIndex.get(position) == true) {
+                Long id = getItemId(position);
+                if (id == Notes.ID_ROOT_FOLDER) {
+                    Log.d(TAG, "Wrong item id, should not happen");
+                } else {
+                    itemSet.add(id);
+                }
+            }
+        }
+        return itemSet;
+    }
+
+    /**
+     * 获取所有选中的小部件属性
+     * @return 小部件属性集合
+     */
+    public HashSet<AppWidgetAttribute> getSelectedWidget() {
+        HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
+        for (Integer position : mSelectedIndex.keySet()) {
+            if (mSelectedIndex.get(position) == true) {
+                Cursor c = (Cursor) getItem(position);
+                if (c != null) {
+                    AppWidgetAttribute widget = new AppWidgetAttribute();
+                    NoteItemData item = new NoteItemData(mContext, c);
+                    widget.widgetId = item.getWidgetId();
+                    widget.widgetType = item.getWidgetType();
+                    itemSet.add(widget);
+                    // 不在此处关闭游标，由适配器统一管理
+                } else {
+                    Log.e(TAG, "Invalid cursor");
+                    return null;
+                }
+            }
+        }
+        return itemSet;
+    }
+
+    /**
+     * 获取选中项的数量
+     * @return 选中项数
+     */
+    public int getSelectedCount() {
+        Collection<Boolean> values = mSelectedIndex.values();
+        if (null == values) {
+            return 0;
+        }
+        Iterator<Boolean> iter = values.iterator();
+        int count = 0;
+        while (iter.hasNext()) {
+            if (true == iter.next()) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    /**
+     * 检查是否全部选中
+     * @return true表示全部选中
+     */
+    public boolean isAllSelected() {
+        int checkedCount = getSelectedCount();
+        return (checkedCount != 0 && checkedCount == mNotesCount);
+    }
+
+    /**
+     * 检查指定位置是否被选中
+     * @param position 位置
+     * @return true表示被选中
+     */
+    public boolean isSelectedItem(final int position) {
+        if (null == mSelectedIndex.get(position)) {
+            return false;
+        }
+        return mSelectedIndex.get(position);
+    }
+
+    /**
+     * 内容变化回调
+     * 重新计算笔记数量
+     */
+    @Override
+    protected void onContentChanged() {
+        super.onContentChanged();
+        calcNotesCount();
+    }
+
+    /**
+     * 更换游标时的回调
+     * 重新计算笔记数量
+     */
+    @Override
+    public void changeCursor(Cursor cursor) {
+        super.changeCursor(cursor);
+        calcNotesCount();
+    }
+
+    /**
+     * 计算笔记数量
+     * 遍历游标统计笔记项数量
+     */
+    private void calcNotesCount() {
+        mNotesCount = 0;
+        for (int i = 0; i < getCount(); i++) {
+            Cursor c = (Cursor) getItem(i);
+            if (c != null) {
+                if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
+                    mNotesCount++;
+                }
+            } else {
+                Log.e(TAG, "Invalid cursor");
+                return;
+            }
+        }
+    }
+}

src/net/micode/notes/ui/NotesListItem.java

@@ -0,0 +1,157 @@
+/*
+ * 版权信息：由MiCode开源社区（www.micode.net）贡献
+ * Apache 2.0许可证协议
+ * 本文件为NotesListItem类实现，用于Android平台的笔记列表项视图组件
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.text.format.DateUtils;
+import android.view.View;
+import android.widget.CheckBox;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
+
+/**
+ * 笔记列表项视图组件
+ * 用于在笔记列表中显示单个笔记或文件夹的UI元素
+ */
+public class NotesListItem extends LinearLayout {
+    // 视图组件引用
+    private ImageView mAlert;           // 提醒图标
+    private TextView mTitle;            // 标题文本
+    private TextView mTime;             // 时间文本
+    private TextView mCallName;         // 通话记录联系人名称
+    private NoteItemData mItemData;     // 绑定的笔记数据
+    private CheckBox mCheckBox;         // 多选模式下的复选框
+
+    /**
+     * 构造函数
+     * @param context 上下文环境
+     */
+    public NotesListItem(Context context) {
+        super(context);
+        // 加载布局文件并附加到当前LinearLayout
+        inflate(context, R.layout.note_item, this);
+        
+        // 初始化视图组件
+        mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
+        mTitle = (TextView) findViewById(R.id.tv_title);
+        mTime = (TextView) findViewById(R.id.tv_time);
+        mCallName = (TextView) findViewById(R.id.tv_name);
+        mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
+    }
+
+    /**
+     * 绑定数据到视图
+     * @param context 上下文环境
+     * @param data 笔记/文件夹数据对象
+     * @param choiceMode 是否处于多选模式
+     * @param checked 当前项是否被选中
+     */
+    public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
+        // 多选模式下显示复选框
+        if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
+            mCheckBox.setVisibility(View.VISIBLE);
+            mCheckBox.setChecked(checked);
+        } else {
+            mCheckBox.setVisibility(View.GONE);
+        }
+
+        mItemData = data;
+
+        // 处理通话记录文件夹
+        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+            mCallName.setVisibility(View.GONE);
+            mAlert.setVisibility(View.VISIBLE);
+            mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
+            mTitle.setText(context.getString(R.string.call_record_folder_name)
+                    + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
+            mAlert.setImageResource(R.drawable.call_record);
+        } 
+        // 处理通话记录笔记
+        else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
+            mCallName.setVisibility(View.VISIBLE);
+            mCallName.setText(data.getCallName());
+            mTitle.setTextAppearance(context, R.style.TextAppearanceSecondaryItem);
+            mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
+            
+            // 设置提醒图标
+            if (data.hasAlert()) {
+                mAlert.setImageResource(R.drawable.clock);
+                mAlert.setVisibility(View.VISIBLE);
+            } else {
+                mAlert.setVisibility(View.GONE);
+            }
+        } 
+        // 处理普通笔记或文件夹
+        else {
+            mCallName.setVisibility(View.GONE);
+            mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
+
+            if (data.getType() == Notes.TYPE_FOLDER) {
+                // 文件夹显示
+                mTitle.setText(data.getSnippet()
+                        + context.getString(R.string.format_folder_files_count,
+                                data.getNotesCount()));
+                mAlert.setVisibility(View.GONE);
+            } else {
+                // 普通笔记显示
+                mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
+                
+                // 设置提醒图标
+                if (data.hasAlert()) {
+                    mAlert.setImageResource(R.drawable.clock);
+                    mAlert.setVisibility(View.VISIBLE);
+                } else {
+                    mAlert.setVisibility(View.GONE);
+                }
+            }
+        }
+
+        // 设置修改时间
+        mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
+
+        // 设置背景
+        setBackground(data);
+    }
+
+    /**
+     * 根据数据设置背景样式
+     * @param data 笔记/文件夹数据对象
+     */
+    private void setBackground(NoteItemData data) {
+        int id = data.getBgColorId();
+        
+        if (data.getType() == Notes.TYPE_NOTE) {
+            // 笔记项的背景设置逻辑
+            if (data.isSingle() || data.isOneFollowingFolder()) {
+                setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
+            } else if (data.isLast()) {
+                setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id));
+            } else if (data.isFirst() || data.isMultiFollowingFolder()) {
+                setBackgroundResource(NoteItemBgResources.getNoteBgFirstRes(id));
+            } else {
+                setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
+            }
+        } else {
+            // 文件夹项的背景设置
+            setBackgroundResource(NoteItemBgResources.getFolderBgRes());
+        }
+    }
+
+    /**
+     * 获取当前绑定的笔记数据
+     * @return NoteItemData对象
+     */
+    public NoteItemData getItemData() {
+        return mItemData;
+    }
+}

src/net/micode/notes/ui/NotesPreferenceActivity.java

@@ -0,0 +1,439 @@
+/*
+ * 版权信息：由MiCode开源社区（www.micode.net）贡献
+ * Apache 2.0许可证协议
+ * 本文件为NotesPreferenceActivity类实现，用于Android平台的笔记应用偏好设置管理
+ */
+
+package net.micode.notes.ui;
+
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.app.ActionBar;
+import android.app.AlertDialog;
+import android.content.BroadcastReceiver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.Preference;
+import android.preference.Preference.OnPreferenceClickListener;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceCategory;
+import android.text.TextUtils;
+import android.text.format.DateFormat;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.Button;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.remote.GTaskSyncService;
+
+/**
+ * 笔记应用偏好设置活动
+ * 实现Google Tasks同步账户管理、同步状态显示等功能
+ */
+public class NotesPreferenceActivity extends PreferenceActivity {
+    // 共享偏好设置常量
+    public static final String PREFERENCE_NAME = "notes_preferences";
+    public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name";
+    public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time";
+    public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear";
+
+    // 账户设置相关常量
+    private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key";
+    private static final String AUTHORITIES_FILTER_KEY = "authorities";
+
+    // UI组件
+    private PreferenceCategory mAccountCategory; // 账户偏好分类
+    private GTaskReceiver mReceiver; // Google Tasks广播接收器
+    private Account[] mOriAccounts; // 原始账户列表
+    private boolean mHasAddedAccount; // 是否新增过账户
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        // 设置导航栏返回图标
+        getActionBar().setDisplayHomeAsUpEnabled(true);
+
+        // 从XML资源加载偏好设置
+        addPreferencesFromResource(R.xml.preferences);
+        
+        // 初始化账户偏好分类
+        mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
+        
+        // 注册Google Tasks同步服务广播接收器
+        mReceiver = new GTaskReceiver();
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
+        registerReceiver(mReceiver, filter);
+
+        // 添加自定义头部视图
+        View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
+        getListView().addHeaderView(header, null, true);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        // 检查是否新增过账户并自动设置
+        if (mHasAddedAccount) {
+            Account[] accounts = getGoogleAccounts();
+            if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
+                for (Account accountNew : accounts) {
+                    boolean found = false;
+                    for (Account accountOld : mOriAccounts) {
+                        if (TextUtils.equals(accountOld.name, accountNew.name)) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found) {
+                        setSyncAccount(accountNew.name);
+                        break;
+                    }
+                }
+            }
+        }
+
+        // 刷新UI显示
+        refreshUI();
+    }
+
+    @Override
+    protected void onDestroy() {
+        if (mReceiver != null) {
+            unregisterReceiver(mReceiver);
+        }
+        super.onDestroy();
+    }
+
+    /**
+     * 加载账户偏好设置
+     * 创建账户选择项并设置点击监听器
+     */
+    private void loadAccountPreference() {
+        mAccountCategory.removeAll();
+
+        Preference accountPref = new Preference(this);
+        final String defaultAccount = getSyncAccountName(this);
+        accountPref.setTitle(getString(R.string.preferences_account_title));
+        accountPref.setSummary(getString(R.string.preferences_account_summary));
+        accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+            public boolean onPreferenceClick(Preference preference) {
+                if (!GTaskSyncService.isSyncing()) {
+                    if (TextUtils.isEmpty(defaultAccount)) {
+                        // 首次设置账户时显示选择账户对话框
+                        showSelectAccountAlertDialog();
+                    } else {
+                        // 已有账户时显示确认对话框
+                        showChangeAccountConfirmAlertDialog();
+                    }
+                } else {
+                    Toast.makeText(NotesPreferenceActivity.this,
+                            R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
+                            .show();
+                }
+                return true;
+            }
+        });
+
+        mAccountCategory.addPreference(accountPref);
+    }
+
+    /**
+     * 加载同步按钮和上次同步时间显示
+     * 根据同步状态更新按钮文本和状态
+     */
+    private void loadSyncButton() {
+        Button syncButton = (Button) findViewById(R.id.preference_sync_button);
+        TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
+
+        // 设置同步按钮状态
+        if (GTaskSyncService.isSyncing()) {
+            syncButton.setText(getString(R.string.preferences_button_sync_cancel));
+            syncButton.setOnClickListener(new View.OnClickListener() {
+                public void onClick(View v) {
+                    GTaskSyncService.cancelSync(NotesPreferenceActivity.this);
+                }
+            });
+        } else {
+            syncButton.setText(getString(R.string.preferences_button_sync_immediately));
+            syncButton.setOnClickListener(new View.OnClickListener() {
+                public void onClick(View v) {
+                    GTaskSyncService.startSync(NotesPreferenceActivity.this);
+                }
+            });
+        }
+        syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
+
+        // 设置上次同步时间显示
+        if (GTaskSyncService.isSyncing()) {
+            lastSyncTimeView.setText(GTaskSyncService.getProgressString());
+            lastSyncTimeView.setVisibility(View.VISIBLE);
+        } else {
+            long lastSyncTime = getLastSyncTime(this);
+            if (lastSyncTime != 0) {
+                lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
+                        DateFormat.format(getString(R.string.preferences_last_sync_time_format),
+                                lastSyncTime));
+                lastSyncTimeView.setVisibility(View.VISIBLE);
+            } else {
+                lastSyncTimeView.setVisibility(View.GONE);
+            }
+        }
+    }
+
+    /**
+     * 刷新UI显示
+     * 包括账户设置和同步状态
+     */
+    private void refreshUI() {
+        loadAccountPreference();
+        loadSyncButton();
+    }
+
+    /**
+     * 显示选择账户对话框
+     * 列出可用的Google账户供用户选择
+     */
+    private void showSelectAccountAlertDialog() {
+        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
+
+        // 创建自定义标题视图
+        View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+        TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+        titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
+        TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
+        subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
+
+        dialogBuilder.setCustomTitle(titleView);
+        dialogBuilder.setPositiveButton(null, null);
+
+        Account[] accounts = getGoogleAccounts();
+        String defAccount = getSyncAccountName(this);
+
+        mOriAccounts = accounts;
+        mHasAddedAccount = false;
+
+        if (accounts.length > 0) {
+            CharSequence[] items = new CharSequence[accounts.length];
+            final CharSequence[] itemMapping = items;
+            int checkedItem = -1;
+            int index = 0;
+            for (Account account : accounts) {
+                if (TextUtils.equals(account.name, defAccount)) {
+                    checkedItem = index;
+                }
+                items[index++] = account.name;
+            }
+            dialogBuilder.setSingleChoiceItems(items, checkedItem,
+                    new DialogInterface.OnClickListener() {
+                        public void onClick(DialogInterface dialog, int which) {
+                            setSyncAccount(itemMapping[which].toString());
+                            dialog.dismiss();
+                            refreshUI();
+                        }
+                    });
+        }
+
+        // 添加"添加账户"视图
+        View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
+        dialogBuilder.setView(addAccountView);
+
+        final AlertDialog dialog = dialogBuilder.show();
+        addAccountView.setOnClickListener(new View.OnClickListener() {
+            public void onClick(View v) {
+                mHasAddedAccount = true;
+                Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
+                intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] {
+                    "gmail-ls"
+                });
+                startActivityForResult(intent, -1);
+                dialog.dismiss();
+            }
+        });
+    }
+
+    /**
+     * 显示更改账户确认对话框
+     * 提供更改账户、移除账户和取消选项
+     */
+    private void showChangeAccountConfirmAlertDialog() {
+        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
+
+        // 创建自定义标题视图
+        View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+        TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+        titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
+                getSyncAccountName(this)));
+        TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
+        subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg));
+        dialogBuilder.setCustomTitle(titleView);
+
+        // 设置对话框选项
+        CharSequence[] menuItemArray = new CharSequence[] {
+                getString(R.string.preferences_menu_change_account),
+                getString(R.string.preferences_menu_remove_account),
+                getString(R.string.preferences_menu_cancel)
+        };
+        dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
+            public void onClick(DialogInterface dialog, int which) {
+                if (which == 0) {
+                    showSelectAccountAlertDialog();
+                } else if (which == 1) {
+                    removeSyncAccount();
+                    refreshUI();
+                }
+            }
+        });
+        dialogBuilder.show();
+    }
+
+    /**
+     * 获取Google账户列表
+     * @return Google账户数组
+     */
+    private Account[] getGoogleAccounts() {
+        AccountManager accountManager = AccountManager.get(this);
+        return accountManager.getAccountsByType("com.google");
+    }
+
+    /**
+     * 设置同步账户
+     * @param account 要设置的账户名称
+     */
+    private void setSyncAccount(String account) {
+        if (!getSyncAccountName(this).equals(account)) {
+            SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+            SharedPreferences.Editor editor = settings.edit();
+            if (account != null) {
+                editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account);
+            } else {
+                editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
+            }
+            editor.commit();
+
+            // 清除上次同步时间
+            setLastSyncTime(this, 0);
+
+            // 清除本地Google Tasks相关数据
+            new Thread(new Runnable() {
+                public void run() {
+                    ContentValues values = new ContentValues();
+                    values.put(NoteColumns.GTASK_ID, "");
+                    values.put(NoteColumns.SYNC_ID, 0);
+                    getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
+                }
+            }).start();
+
+            Toast.makeText(NotesPreferenceActivity.this,
+                    getString(R.string.preferences_toast_success_set_accout, account),
+                    Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    /**
+     * 移除同步账户
+     * 清除账户信息和本地同步数据
+     */
+    private void removeSyncAccount() {
+        SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+        SharedPreferences.Editor editor = settings.edit();
+        if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
+            editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME);
+        }
+        if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) {
+            editor.remove(PREFERENCE_LAST_SYNC_TIME);
+        }
+        editor.commit();
+
+        // 清除本地Google Tasks相关数据
+        new Thread(new Runnable() {
+            public void run() {
+                ContentValues values = new ContentValues();
+                values.put(NoteColumns.GTASK_ID, "");
+                values.put(NoteColumns.SYNC_ID, 0);
+                getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
+            }
+        }).start();
+    }
+
+    /**
+     * 获取当前同步账户名称
+     * @param context 上下文
+     * @return 账户名称
+     */
+    public static String getSyncAccountName(Context context) {
+        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+                Context.MODE_PRIVATE);
+        return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
+    }
+
+    /**
+     * 设置上次同步时间
+     * @param context 上下文
+     * @param time 时间戳
+     */
+    public static void setLastSyncTime(Context context, long time) {
+        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+                Context.MODE_PRIVATE);
+        SharedPreferences.Editor editor = settings.edit();
+        editor.putLong(PREFERENCE_LAST_SYNC_TIME, time);
+        editor.commit();
+    }
+
+    /**
+     * 获取上次同步时间
+     * @param context 上下文
+     * @return 时间戳
+     */
+    public static long getLastSyncTime(Context context) {
+        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+                Context.MODE_PRIVATE);
+        return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
+    }
+
+    /**
+     * Google Tasks广播接收器
+     * 用于接收同步状态更新广播
+     */
+    private class GTaskReceiver extends BroadcastReceiver {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            refreshUI();
+            if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
+                TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
+                syncStatus.setText(intent
+                        .getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
+            }
+        }
+    }
+
+    /**
+     * 处理选项菜单项选择
+     * 返回主界面
+     */
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case android.R.id.home:
+                Intent intent = new Intent(this, NotesListActivity.class);
+                intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+                startActivity(intent);
+                return true;
+            default:
+                return false;
+        }
+    }
+}

src/新建 文本文档.txt

@@ -1 +0,0 @@
-1

test1.txt

@@ -1,3 +0,0 @@
-111222333
-8858585
-33333