ActionFailureException.java

@@ -0,0 +1,33 @@
+/*
+ * 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;//包 net.micode.notes.gtask.exception。
+
+public class ActionFailureException extends RuntimeException {//公共类 ActionFailureException 继承自 RuntimeException。
+    private static final long serialVersionUID = 4425249765923293627L;//私有静态最终 long 型变量 serialVersionUID，赋值为 4425249765923293627L。
+
+    public ActionFailureException() {//公共的无参数构造函数。
+        super();//调用父类的无参数构造函数。
+    }
+
+    public ActionFailureException(String paramString) {//公共的带有一个字符串参数的构造函数。
+        super(paramString);//调用父类的带有一个字符串参数的构造函数，并将参数传递给父类。
+    }
+
+    public ActionFailureException(String paramString, Throwable paramThrowable) {//公共的带有一个字符串参数和一个 Throwable 参数的构造函数。
+        super(paramString, paramThrowable);//调用父类的带有一个字符串参数和一个 Throwable 参数的构造函数，并将参数传递给父类。
+    }
+}

Contact.java

@@ -0,0 +1,73 @@
+/*
+ * 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.data;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.Data;
+import android.telephony.PhoneNumberUtils;
+import android.util.Log;
+
+import java.util.HashMap;
+
+public class Contact {
+    private static HashMap<String, String> sContactCache;//声明一个静态的哈希表，用于缓存联系人信息。
+    private static final String TAG = "Contact";//定义一个静态常量，用于日志输出的标记。
+
+    private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER
+    + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'"
+    + " AND " + Data.RAW_CONTACT_ID + " IN "
+            + "(SELECT raw_contact_id "
+            + " FROM phone_lookup"
+            + " WHERE min_match = '+')";//定义了一个查询条件的字符串，用于查找与给定电话号码匹配的联系人。
+
+    public static String getContact(Context context, String phoneNumber)//定义了一个静态方法，用于获取与给定电话号码对应的联系人姓名。 {
+        if(sContactCache == null) {
+            sContactCache = new HashMap<String, String>();//如果缓存为空，则创建一个新的缓存。
+        }
+
+        if(sContactCache.containsKey(phoneNumber)) {
+            return sContactCache.get(phoneNumber);//检查缓存中是否已经存在该电话号码对应的联系人姓名，如果存在则直接返回。
+        }
+
+        String selection = CALLER_ID_SELECTION.replace("+",
+                PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));//根据电话号码生成实际的查询条件。
+        Cursor cursor = context.getContentResolver().query(
+                Data.CONTENT_URI,
+                new String [] { Phone.DISPLAY_NAME },
+                selection,
+                new String[] { phoneNumber },
+                null);//使用查询条件进行数据库查询，并获取游标
+
+        if (cursor != null && cursor.moveToFirst()) {
+            try {
+                String name = cursor.getString(0);
+                sContactCache.put(phoneNumber, name);
+                return name;//检查游标是否有效且是否有数据，如果有则尝试获取联系人姓名并放入缓存，同时返回该姓名。
+            } catch (IndexOutOfBoundsException e) {
+                Log.e(TAG, " Cursor get string error " + e.toString());//在获取联系人姓名时发生异常时，记录错误日志。
+                return null;
+            } finally {
+                cursor.close();//关闭游标。
+            }
+        } else {
+            Log.d(TAG, "No contact matched with number:" + phoneNumber);//：如果没有找到匹配的联系人，记录日志。
+            return null;
+        }
+    }
+}

MetaData.java

@@ -0,0 +1,83 @@
+/*
+ * 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;//“包名：net.micode.notes.gtask.data；”。
+
+import android.database.Cursor;//“导入安卓数据库游标类；”。
+import android.util.Log;//导入安卓工具类 Log；”。
+
+import net.micode.notes.tool.GTaskStringUtils;//翻译为“导入来自 net.micode.notes.tool 包下的 GTaskStringUtils 类；”。
+
+import org.json.JSONException;//导入来自 org.json 包下的 JSON 异常类；”。
+import org.json.JSONObject;//导入来自 org.json 包下的 JSON 对象类；”。．
+
+
+public class MetaData extends Task {//公共类 MetaData 继承自 Task 类。”
+    private final static String TAG = MetaData.class.getSimpleName();//“私有最终静态字符串变量 TAG 被赋值为 MetaData 类的简单名称。”
+
+    private String mRelatedGid = null;//私有字符串变量 mRelatedGid 初始化为 null。”
+
+    public void setMeta(String gid, JSONObject metaInfo) {//“公共方法 setMeta，接收一个字符串 gid 和一个 JSON 对象 metaInfo。”
+        try {//“尝试执行以下代码块。”
+            metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);//“将 gid 放入 metaInfo 的键为 GTaskStringUtils.META_HEAD_GTASK_ID 的位置。
+        } catch (JSONException e) {//“将 gid 放入 metaInfo 的键为 GTaskStringUtils.META_HEAD_GTASK_ID 的位置。
+            Log.e(TAG, "failed to put related gid");//“使用错误级别记录日志，TAG 为标识，信息为‘failed to put related gid’（未能放入相关的 gid）。”
+        }
+        setNotes(metaInfo.toString());//“设置注释为 metaInfo 的字符串形式。”
+        setName(GTaskStringUtils.META_NOTE_NAME);//“设置注释为 metaInfo 的字符串形式。”v
+    }
+
+    public String getRelatedGid() {//“公共方法 getRelatedGid，返回一个字符串。”
+        return mRelatedGid;//“返回 mRelatedGid 的值。”
+    }
+
+    @Override
+    public boolean isWorthSaving() {//翻译为“重写父类方法。公共方法 isWorthSaving，返回一个布尔值。”
+        return getNotes() != null;//“返回获取到的注释不为 null 的结果。”
+    }
+
+    @Override
+    public void setContentByRemoteJSON(JSONObject js) {//“重写父类方法。公共方法 setContentByRemoteJSON，接收一个 JSON 对象 js。”
+        super.setContentByRemoteJSON(js);//“重写父类方法。公共方法 setContentByRemoteJSON，接收一个 JSON 对象 js。”
+        if (getNotes() != null) {//“重写父类方法。公共方法 setContentByRemoteJSON，接收一个 JSON 对象 js。”
+            try {//“重写父类方法。公共方法 setContentByRemoteJSON，接收一个 JSON 对象 js。”
+                JSONObject metaInfo = new JSONObject(getNotes().trim());//“创建一个新的 JSON 对象 metaInfo，参数为去除首尾空白的获取到的注释。”
+                mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);//将 metaInfo 中键为 GTaskStringUtils.META_HEAD_GTASK_ID 的值赋给 mRelatedGid。”
+            } catch (JSONException e) {//“捕获 JSON 异常，如果发生异常执行以下代码块。”
+                Log.w(TAG, "failed to get related gid");//“使用警告级别记录日志，TAG 为标识，信息为‘failed to get related gid’（未能获取到相关的 gid）。”
+                mRelatedGid = null;//“将 mRelatedGid 赋值为 null。”
+            }
+        }
+    }
+
+    @Override
+    public void setContentByLocalJSON(JSONObject js) {//“重写父类方法。公共方法 setContentByLocalJSON，接收一个 JSON 对象 js。”
+        // this function should not be called
+      //此函数不应被调用。”
+        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");//“抛出非法访问错误，信息为‘MetaData:setContentByLocalJSON should not be called’（MetaData 的 setContentByLocalJSON 不应被调用）。”
+    }
+
+    @Override
+    public JSONObject getLocalJSONFromContent() {//“重写父类方法。公共方法 getLocalJSONFromContent，返回一个 JSON 对象。”
+        throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");//“抛出非法访问错误，信息为‘MetaData:getLocalJSONFromContent should not be called’（MetaData 的 getLocalJSONFromContent 不应被调用）。”
+    }
+
+    @Override
+    public int getSyncAction(Cursor c) {//“重写父类方法。公共方法 getSyncAction，接收一个游标 c，返回一个整数。”
+        throw new IllegalAccessError("MetaData:getSyncAction should not be called");//抛出非法访问错误，信息为‘MetaData:getSyncAction should not be called’（MetaData 的 getSyncAction 不应被调用）。”
+    }
+
+}

NetworkFailureException.java

@@ -0,0 +1,33 @@
+/*
+ * 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;//这是一个 Java 包声明，指定了该代码所在的包名为net.micode.notes.gtask.exception。
+
+public class NetworkFailureException extends Exception {//定义了一个名为NetworkFailureException的公共类，它继承自Exception类。
+    private static final long serialVersionUID = 2107610287180234136L;//这是一个私有静态最终的长整型变量serialVersionUID，用于标识该类的序列化版本号。
+
+    public NetworkFailureException() {//这是NetworkFailureException类的无参构造函数，它调用了父类Exception的无参构造函数。
+        super();
+    }
+
+    public NetworkFailureException(String paramString) {//这是一个带有一个字符串参数的构造函数，它调用了父类Exception的带有一个字符串参数的构造函数，并将参数传递给父类。
+        super(paramString);
+    }
+
+    public NetworkFailureException(String paramString, Throwable paramThrowable) {//这是一个带有一个字符串参数和一个Throwable参数的构造函数，它调用了父类Exception的带有一个字符串参数和一个Throwable参数的构造函数，并将参数传递给父类。
+        super(paramString, paramThrowable);
+    }
+}

Node.java

@@ -0,0 +1,101 @@
+/*
+ * 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;//“包名：net.micode.notes.gtask.data；”。
+
+import android.database.Cursor;//“导入安卓数据库游标类；”。
+
+import org.json.JSONObject;//“导入 JSON 对象类；”。
+
+public abstract class Node {//“公共抽象类 Node；”。
+    public static final int SYNC_ACTION_NONE = 0;//“公共静态最终整型常量 SYNC_ACTION_NONE（同步动作无）赋值为 0；”。
+
+    public static final int SYNC_ACTION_ADD_REMOTE = 1;//“公共静态最终整型常量 SYNC_ACTION_ADD_REMOTE（远程添加动作）赋值为 1；”。
+
+    public static final int SYNC_ACTION_ADD_LOCAL = 2;//公共静态最终整型常量 SYNC_ACTION_ADD_LOCAL（本地添加动作）赋值为 2；”。
+
+    public static final int SYNC_ACTION_DEL_REMOTE = 3;//“公共静态最终整型常量 SYNC_ACTION_DEL_REMOTE（远程删除动作）赋值为 3；”。
+
+    public static final int SYNC_ACTION_DEL_LOCAL = 4;//“公共静态最终整型常量 SYNC_ACTION_DEL_REMOTE（远程删除动作）赋值为 3；”。
+
+    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;//“公共静态最终整型常量 SYNC_ACTION_UPDATE_REMOTE（远程更新动作）赋值为 5；”。
+
+    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;//“公共静态最终整型常量 SYNC_ACTION_UPDATE_LOCAL（本地更新动作）赋值为 6；”。
+
+    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;//公共静态最终整型常量 SYNC_ACTION_UPDATE_CONFLICT（更新冲突动作）赋值为 7；”。
+
+    public static final int SYNC_ACTION_ERROR = 8;//“公共静态最终整型常量 SYNC_ACTION_ERROR（错误动作）赋值为 8；”。
+
+    private String mGid;//“私有字符串变量 mGid；”。
+
+    private String mName;//“私有字符串变量 mName；”。
+
+    private long mLastModified;//“私有长整型变量 mLastModified；”。
+    private boolean mDeleted;//“私有长整型变量 mLastModified；”。
+
+    public Node() {//公共的 Node 类的构造方法。”
+        mGid = null;//“将成员变量 mGid 赋值为 null。”
+        mName = "";//将成员变量 mName 赋值为空字符串。”
+        mLastModified = 0;//将成员变量 mLastModified 赋值为 0。”
+        mDeleted = false;//将成员变量 mDeleted 赋值为 false。”
+    }
+
+    public abstract JSONObject getCreateAction(int actionId);//“公共的抽象方法 getCreateAction，接收一个整数参数 actionId，返回一个 JSON 对象。”
+
+    public abstract JSONObject getUpdateAction(int actionId);//“公共的抽象方法 getUpdateAction，接收一个整数参数 actionId，返回一个 JSON 对象。”
+
+    public abstract void setContentByRemoteJSON(JSONObject js);//“公共的抽象方法 setContentByRemoteJSON，接收一个 JSON 对象参数 js。”
+
+    public abstract void setContentByLocalJSON(JSONObject js);//“公共的抽象方法 setContentByRemoteJSON，接收一个 JSON 对象参数 js。”
+
+    public abstract JSONObject getLocalJSONFromContent();//“公共的抽象方法 getLocalJSONFromContent，返回一个 JSON 对象。”
+
+    public abstract int getSyncAction(Cursor c);//“公共的抽象方法 getSyncAction，接收一个 Cursor 参数 c，返回一个整数。”
+
+    public void setGid(String gid) {//“公共方法 setGid，接收一个字符串参数 gid。”
+        this.mGid = gid;//“将成员变量 mGid 赋值为传入的 gid。”
+    }
+
+    public void setName(String name) {//公共方法 setName，接收一个字符串参数 name。”
+this.mName = name;//“将成员变量 mName 赋值为传入的 name。”
+      
+    }
+
+    public void setLastModified(long lastModified) {//公共方法 setLastModified，接收一个长整型参数 lastModified。”
+        this.mLastModified = lastModified;//将成员变量 mLastModified 赋值为传入的 lastModified。”
+    }
+
+    public void setDeleted(boolean deleted) {//“公共方法 setDeleted，接收一个布尔型参数 deleted。”
+        this.mDeleted = deleted;//“将成员变量 mDeleted 赋值为传入的 deleted。”
+    }
+
+    public String getGid() {//“公共方法 getGid，返回一个字符串。”
+        return this.mGid;//返回成员变量 mGid。”
+    }
+
+    public String getName() {//“公共方法 getName，返回一个字符串。”
+        return this.mName;//“返回成员变量 mName。”
+    }
+
+    public long getLastModified() {//“公共方法 getLastModified，返回一个长整型。”
+        return this.mLastModified;//“返回成员变量 mLastModified。”
+    }
+
+    public boolean getDeleted() {//公共方法 getDeleted，返回一个布尔型。”
+        return this.mDeleted;//“返回成员变量 mDeleted。”
+    }
+
+}

Notes.java

@@ -0,0 +1,309 @@
+/*
+ * 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.data;
+// 包名：net.micode.notes.data
+import android.net.Uri;
+// 导入 Android 中的 Uri 类
+public class Notes {// 定义名为 Notes 的公共类
+    public static final String AUTHORITY = "micode_notes";// 静态常量，权限字符串为“micode_notes”
+    public static final String TAG = "Notes";// 静态常量，标签字符串为“
+    public static final int TYPE_NOTE     = 0;// 静态常量，笔记类型为 0
+    public static final int TYPE_FOLDER   = 1;// 静态常量，文件夹类型为 1
+    public static final int TYPE_SYSTEM   = 2;// 静态常量，系统类型为 2
+
+    /**
+     * Following IDs are system folders' identifiers
+     * {@link Notes#ID_ROOT_FOLDER } is default folder
+     * {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
+     * {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
+     */
+    public static final int ID_ROOT_FOLDER = 0;// 静态常量，根文件夹 ID 为 0
+    public static final int ID_TEMPARAY_FOLDER = -1;// 静态常量，临时文件夹 ID 为 -1
+    public static final int ID_CALL_RECORD_FOLDER = -2;// 静态常量，通话记录文件夹 ID 为 -2
+    public static final int ID_TRASH_FOLER = -3;// 静态常量，回收站文件夹 ID 为 -3
+
+    public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";// 静态常量，意图额外参数（提醒日期）的字符串为“net.micode.notes.alert_date”
+    public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";// 静态常量，意图额外参数（背景颜色 ID）的字符串为“net.micode.notes.background_color_id”
+    public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";// 静态常量，意图额外参数（小组件 ID）的字符串为“net.micode.notes.widget_id”
+    public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";// 静态常量，意图额外参数（小组件类型）的字符串为“net.micode.notes.widget_type”
+    public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";// 静态常量，意图额外参数（文件夹 ID）的字符串为“net.micode.notes.folder_id”
+    public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";// 静态常量，意图额外参数（通话日期）的字符串为“net.micode.notes.call_date”
+
+    public static final int TYPE_WIDGET_INVALIDE      = -1;// 静态常量，无效小组件类型为 -1
+    public static final int TYPE_WIDGET_2X            = 0;// 静态常量，2X 小组件类型为 0
+    public static final int TYPE_WIDGET_4X            = 1;// 静态常量，2X 小组件类型为 0
+
+    public static class DataConstants {// 定义静态内部类 
+        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;// 静态常量，笔记字符串为 TextNote 类的 CONTENT_ITEM_TYPE 常量
+        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;// 静态常量，通话笔记字符串为 CallNote 类的 CONTENT_ITEM_TYPE 常量
+    }
+
+    /**
+     * Uri to query all notes and folders
+     */
+    public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");// 静态常量，笔记内容的 Uri 为通过解析“content://权限字符串/note”得到的 Uri。
+
+    /**
+     * Uri to query data
+     */    // 注释：用于查询数据的 Uri。
+    public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");// 静态常量，数据内容的 Uri 为通过解析“content://权限字符串/data”得到的 Uri。
+
+    public interface NoteColumns {// 定义名为 NoteColumns 的公共接口
+        /**
+         * The unique ID for a row
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String ID = "_id";
+
+        /**
+         * The parent's id for note or folder
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：一行的唯一 ID。类型：整数（长整型）。
+        public static final String PARENT_ID = "parent_id";// 静态常量，ID 字段为“_id”。
+
+        /**
+         * Created data for note or folder
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：笔记或文件夹的父级 ID。类型：整数（长整型）。
+        public static final String CREATED_DATE = "created_date";// 静态常量，PARENT_ID 字段为“parent_id”。
+
+        /**
+         * Latest modified date
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：笔记或文件夹的创建日期。类型：整数（长整型）。
+        public static final String MODIFIED_DATE = "modified_date";// 静态常量，CREATED_DATE 字段为“created_date”。
+
+
+        /**
+         * Alert date
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：最新修改日期。类型：整数（长整型）。
+        public static final String ALERTED_DATE = "alert_date";// 静态常量，MODIFIED_DATE 字段为“modified_date”。
+
+        /**
+         * Folder's name or text content of note
+         * <P> Type: TEXT </P>
+         */
+        // 注释：提醒日期。类型：整数（长整型）。
+        public static final String SNIPPET = "snippet";// 静态常量，ALERTED_DATE 字段为“alert_date”。
+
+        /**
+         * Note's widget id
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：文件夹的名称或笔记的文本内容。类型：文本。
+        public static final String WIDGET_ID = "widget_id";// 静态常量，小组件 ID 为“
+
+        /**
+         * Note's widget type
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：笔记的小组件类型。类型：整数（长整型）。
+        public static final String WIDGET_TYPE = "widget_type";// 静态常量，小组件类型字段为“widget_type”。
+
+        /**
+         * Note's background color's id
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：笔记的背景颜色 ID。类型：整数（长整型）。
+        public static final String BG_COLOR_ID = "bg_color_id";// 静态常量，背景颜色 ID 字段为“bg_color_id”。
+
+        /**
+         * For text note, it doesn't has attachment, for multi-media
+         * note, it has at least one attachment
+         * <P> Type: INTEGER </P>
+         */
+        // 注释：对于文本笔记，它没有附件；对于多媒体笔记，它至少有一个附件。类型：整数。
+        public static final String HAS_ATTACHMENT = "has_attachment";// 静态常量，是否有附件字段为“has_attachment”。
+
+        /**
+         * Folder's count of notes
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：文件夹中的笔记数量。类型：整数（长整型）。
+        public static final String NOTES_COUNT = "notes_count";// 静态常量，笔记数量字段为“
+
+        /**
+         * The file type: folder or note
+         * <P> Type: INTEGER </P>
+         */
+        // 注释：文件类型：文件夹或笔记。类型：整数。
+        public static final String TYPE = "type";// 静态常量，文件类型字段为“
+
+        /**
+         * The last sync id
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：最后一次同步的 ID。类型：整数（长整型）。
+        public static final String SYNC_ID = "sync_id";// 静态常量，同步 ID 字段为“sync_id”。
+
+        /**
+         * Sign to indicate local modified or not
+         * <P> Type: INTEGER </P>
+         */
+        // 注释：用于指示是否本地修改的标志。类型：整数。
+        public static final String LOCAL_MODIFIED = "local_modified";// 静态常量，本地修改标志字段为
+
+        /**
+         * Original parent id before moving into temporary folder
+         * <P> Type : INTEGER </P>
+         */
+        // 注释：移动到临时文件夹之前的原始父级 ID。类型：整数。
+        public static final String ORIGIN_PARENT_ID = "origin_parent_id";// 静态常量，原始父级 ID 字段为“origin_parent_id”。
+
+        /**
+         * The gtask id
+         * <P> Type : TEXT </P>
+         */
+        // 注释：gtask 的 ID。类型：文本。
+        public static final String GTASK_ID = "gtask_id";// 静态常量，gtask ID 字段为“gtask_id”。
+
+        /**
+         * The version code
+         * <P> Type : INTEGER (long) </P>
+         */
+        // 注释：版本代码。类型：整数（长整型）。
+        public static final String VERSION = "version";// 静态常量，版本字段为“version”。
+    }
+
+    public interface DataColumns {// 定义名为 DataColumns 的公共接口。
+        /**
+         * The unique ID for a row
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：一行的唯一 ID。类型：整数（长整型）。
+        public static final String ID = "_id";// 静态常量，ID 字段为“_id”。
+
+        /**
+         * The MIME type of the item represented by this row.
+         * <P> Type: Text </P>
+         */
+        public static final String MIME_TYPE = "mime_type";// 静态常量，MIME 类型为“mime_type”。
+
+        /**
+         * The reference id to note that this data belongs to
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：此数据所属的引用 ID。类型：整数（长整型）。
+        public static final String NOTE_ID = "note_id";// 静态常量，NOTE_ID 字段为“note_id”。
+
+        /**
+         * Created data for note or folder
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：笔记或文件夹的创建日期。类型：整数（长整型）。
+        public static final String CREATED_DATE = "created_date";// 静态常量，CREATED_DATE 字段为“created_date”。
+
+        /**
+         * Latest modified date
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：最新修改日期。类型：整数（长整型）。
+        public static final String MODIFIED_DATE = "modified_date";// 静态常量，MODIFIED_DATE 字段为“modified_date”。
+
+        /**
+         * Data's content
+         * <P> Type: TEXT </P>
+         */
+        // 注释：数据的内容。类型：文本。
+        public static final String CONTENT = "content";// 静态常量，CONTENT 字段为“content”。
+
+
+        /**
+         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+         * integer data type
+         * <P> Type: INTEGER </P>
+         */
+        // 注释：通用数据列，其含义特定于 MIME 类型，用于整数数据类型。类型：整数。
+        public static final String DATA1 = "data1";// 静态常量，DATA1 字段为“data1”。
+
+        /**
+         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+         * integer data type
+         * <P> Type: INTEGER </P>
+         */
+        // 注释：通用数据列，其含义特定于 MIME 类型，用于整数数据类型。类型：整数。
+        public static final String DATA2 = "data2";// 静态常量，DATA2 字段为“data2”。
+
+        /**
+         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+         * TEXT data type
+         * <P> Type: TEXT </P>
+         */
+        // 注释：通用数据列，其含义特定于 MIME 类型，用于文本数据类型。类型：文本。
+        public static final String DATA3 = "data3";// 静态常量，DATA3 字段为“data3”。
+
+        /**
+         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+         * TEXT data type
+         * <P> Type: TEXT </P>
+         */
+        // 注释：通用数据列，其含义特定于 MIME 类型，用于文本数据类型。类型：文本。
+        public static final String DATA4 = "data4";// 静态常量，DATA4 字段为“data4”。
+
+        /**
+         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+         * TEXT data type
+         * <P> Type: TEXT </P>
+         */
+        // 注释：通用数据列，其含义特定于 MIME 类型，用于文本数据类型。类型：文本。
+        public static final String DATA5 = "data5";// 静态常量，DATA5 字段为“data5”。
+    }
+
+    public static final class TextNote implements DataColumns {// 定义名为 TextNote 的静态内部类并实现 DataColumns 接口。
+        /**
+         * Mode to indicate the text in check list mode or not
+         * <P> Type: Integer 1:check list mode 0: normal mode </P>
+         */
+        // 定义名为 TextNote 的静态内部类并实现 DataColumns 接口。
+        public static final String MODE = DATA1;// 静态常量，模式字段为 DATA1。
+
+        public static final int MODE_CHECK_LIST = 1;// 静态常量，清单模式的值为 1。
+
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";// 静态常量，清单模式的值为 1。
+
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";// 静态常量，内容项类型为“vnd.android.cursor.item/text_note”。
+
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");// 静态常量，内容 Uri 为通过解析“content://权限字符串/text_note”得到的 Uri。
+    }
+
+    public static final class CallNote implements DataColumns {// 定义名为 CallNote 的静态内部类并实现 DataColumns 接口。
+        /**
+         * Call date for this record
+         * <P> Type: INTEGER (long) </P>
+         */
+        // 注释：此记录的通话日期。类型：整数（长整型）。
+        public static final String CALL_DATE = DATA1;// 静态常量，通话日期字段为 DATA1。
+
+        /**
+         * Phone number for this record
+         * <P> Type: TEXT </P>
+         */
+        // 注释：此记录的电话号码。类型：文本。
+        public static final String PHONE_NUMBER = DATA3;// 静态常量，电话号码字段为 DATA3。
+
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";// 静态常量，内容类型为“vnd.android.cursor.dir/call_note”。
+
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";// 静态常量，内容项类型为“vnd.android.cursor.item/call_note”。
+
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");// 静态常量，内容 Uri 为通过解析“content://权限字符串/call_note”得到的 Uri。
+    }
+}

NotesDatabaseHelper.java

@@ -0,0 +1,380 @@
+/*
+ * 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.data;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.util.Log;
+
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+
+
+public class NotesDatabaseHelper extends SQLiteOpenHelper // 定义一个名为 NotesDatabaseHelper 的公共类，它继承自 SQLiteOpenHelper。{
+    private static final String DB_NAME = "note.db";// 定义一个私有静态常量字符串 DB_NAME，其值为“note.db”，表示数据库名称。
+
+    private static final int DB_VERSION = 4;// 定义一个私有静态常量整数 DB_VERSION，其值为 4，表示数据库版本号。
+
+    public interface TABLE {// 定义一个公共接口 TABLE。
+        public static final String NOTE = "note";// 定义一个公共静态常量字符串 NOTE，其值为“note”。
+
+        public static final String DATA = "data";// 定义一个公共静态常量字符串 DATA，其值为“data”。
+    }
+
+    private static final String TAG = "NotesDatabaseHelper";// 定义一个私有静态常量字符串 TAG，其值为“NotesDatabaseHelper”。
+
+    private static NotesDatabaseHelper mInstance;// 定义一个私有静态变量 mInstance，类型为 NotesDatabaseHelper。
+
+    private static final String CREATE_NOTE_TABLE_SQL =// 定义一个私有静态常量字符串 
+        "CREATE TABLE " + TABLE.NOTE + "(" +// “创建表”+接口 TABLE 中的常量 NOTE+“(”。
+            NoteColumns.ID + " INTEGER PRIMARY KEY," +// NoteColumns 中的常量 ID+“整数类型，为主键”+逗号分隔符。
+            NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +// NoteColumns 中的常量 PARENT_ID+“整数类型，不能为空，默认值为 0”+逗号分隔符。
+            NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +// NoteColumns 中的常量 ALERTED_DATE+“整数类型，不能为空，默认值为 0”+逗号分隔符。
+            NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," +// NoteColumns 中的常量 BG_COLOR_ID+“整数类型，不能为空，默认值为 0”+逗号分隔符。
+            NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +// NoteColumns 中的常量 CREATED_DATE+“整数类型，不能为空，默认值为（通过 strftime 函数获取当前时间的秒数并乘以 1000）”+逗号分隔符。
+            NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," +// NoteColumns 中的常量 HAS_ATTACHMENT+“整数类型，不能为空，默认值为 0”+逗号分隔符。
+            NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +// NoteColumns 中的常量 MODIFIED_DATE+“整数类型，不能为空，默认值为（通过 strftime 函数获取当前时间的秒数并乘以 1000）”+逗号分隔符。
+            NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +// NoteColumns 中的常量 NOTES_COUNT+“整数类型，不能为空，默认值为 0”+逗号分隔符。
+            NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +// NoteColumns 中的常量 SNIPPET+“文本类型，不能为空，默认值为空字符串”+逗号分隔符。
+            NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +// NoteColumns 中的常量 TYPE+“整数类型，不能为空，默认值为 0”+逗号分隔符。
+            NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +// NoteColumns 中的常量 WIDGET_ID+“整数类型，不能为空，默认值为 0”+逗号分隔符。
+            NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +// NoteColumns 中的常量 WIDGET_TYPE+“整数类型，不能为空，默认值为 -1”+逗号分隔符。
+            NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," +// NoteColumns 中的常量 SYNC_ID+“整数类型，不能为空，默认值为 0”+逗号分隔符。
+            NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +// NoteColumns 中的常量 LOCAL_MODIFIED+“整数类型，不能为空，默认值为 0”+逗号分隔符。
+            NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +// NoteColumns 中的常量 ORIGIN_PARENT_ID+“整数类型，不能为空，默认值为 0”+逗号分隔符。
+            NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +// NoteColumns 中的常量 GTASK_ID+“文本类型，不能为空，默认值为空字符串”+逗号分隔符。
+            NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +// NoteColumns 中的常量 VERSION+“整数类型，不能为空，默认值为 0”。
+        ")";
+
+    private static final String CREATE_DATA_TABLE_SQL =// 定义一个私有静态常量字符串 CREATE_DATA_TABLE_SQL。
+        "CREATE TABLE " + TABLE.DATA + "(" +// “创建表”+接口 TABLE 中的常量 DATA+“(”。
+            DataColumns.ID + " INTEGER PRIMARY KEY," +// DataColumns 中的常量 ID+“整数类型，为主键”+逗号分隔符。
+            DataColumns.MIME_TYPE + " TEXT NOT NULL," +// DataColumns 中的常量 MIME_TYPE+“文本类型，不能为空”+逗号分隔符。
+            DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," +// DataColumns 中的常量 NOTE_ID+“整数类型，不能为空，默认值为 0”+逗号分隔符。
+            NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +// NoteColumns 中的常量 CREATED_DATE+“整数类型，不能为空，默认值为（通过 strftime 函数获取当前时间的秒数并乘以 1000）”+逗号分隔符。
+            NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +// NoteColumns 中的常量 MODIFIED_DATE+“整数类型，不能为空，默认值为（通过 strftime 函数获取当前时间的秒数并乘以 1000）”+逗号分隔符。
+            DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," +// DataColumns 中的常量 CONTENT+“文本类型，不能为空，默认值为空字符串”+逗号分隔符。
+            DataColumns.DATA1 + " INTEGER," +// DataColumns 中的常量 DATA1+“整数类型”+逗号分隔符。
+            DataColumns.DATA2 + " INTEGER," +// DataColumns 中的常量 DATA2+“整数类型”+逗号分隔符。
+            DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +// DataColumns 中的常量 DATA3+“文本类型，不能为空，默认值为空字符串”+逗号分隔符。
+            DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +// DataColumns 中的常量 DATA4+“文本类型，不能为空，默认值为空字符串”+逗号分隔符。
+            DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +// DataColumns 中的常量 DATA5+“文本类型，不能为空，默认值为空字符串”。
+        ")";
+
+    private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =// 定义一个私有静态常量字符串 CREATE_DATA_NOTE_ID_INDEX_SQL。
+        "CREATE INDEX IF NOT EXISTS note_id_index ON " +// “创建索引，如果索引不存在，索引名为 note_id_index，在”+。
+        TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";// 接口 TABLE 中的常量 DATA+“(”+DataColumns 中的常量 NOTE_ID+“)”，即基于数据表中的 NOTE_ID 字段创建索引。
+
+    /**
+     * Increase folder's note count when move note to the folder
+     */        
+    // 这是一段注释，意思是“当将笔记移动到文件夹时，增加文件夹的笔记计数”。
+    private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =// 定义一个私有静态常量字符串 NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER。
+        "CREATE TRIGGER increase_folder_count_on_update "+// “创建触发器，触发器名为 increase_folder_count_on_update”+空格分隔符。
+        " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +// “在更新 Note 表中的 PARENT_ID 字段之后”+空格分隔符+NoteColumns 中的常量 PARENT_ID+“在”+接口 TABLE 中的常量 NOTE。
+        " BEGIN " +// “开始”。
+    "  UPDATE " + TABLE.NOTE +
+// “更新”+接口 TABLE 中的常量 NOTE。
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +// “设置”+NoteColumns 中的常量 NOTES_COUNT+“等于”+NoteColumns 中的常量 NOTES_COUNT+“加 1”。
+        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +// “条件是”+NoteColumns 中的常量 ID+“等于 new.”+NoteColumn.PARENT_ID，其中 new 表示新值。
+        " END";// “结束”。
+
+    /**
+     * Decrease folder's note count when move note from folder
+     */
+    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =// 定义一个私有静态常量字符串 NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER。
+        "CREATE TRIGGER decrease_folder_count_on_update " +// “创建触发器，触发器名为 decrease_folder_count_on_update”+空格分隔符。
+        " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +// “在更新 Note 表中的 PARENT_ID 字段之后”+空格分隔符+NoteColumns 中的常量 PARENT_ID+“在”+接口 TABLE 中的常量 NOTE。
+        " BEGIN " +// “开始”。
+        "  UPDATE " + TABLE.NOTE +// “更新”+接口 TABLE 中的常量 NOTE。
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +// “设置”+NoteColumns 中的常量 NOTES_COUNT+“等于”+NoteColumns 中的常量 NOTES_COUNT+“减 1”。
+        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +// “条件是”+NoteColumns 中的常量 ID+“等于 old.”+NoteColumns 中的常量 PARENT_ID，其中 old 表示旧值。
+        "  AND " + NoteColumns.NOTES_COUNT + ">0" + ";" +// “并且”+NoteColumns 中的常量 NOTES_COUNT+“大于 0”+分号分隔符。
+        " END";// “结束”。
+
+    /**
+     * Increase folder's note count when insert new note to the folder
+     */
+    // 这是一段注释，意思是“当向文件夹中插入新笔记时，增加文件夹的笔记计数”。
+    private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =// 定义一个私有静态常量字符串 NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER。
+        "CREATE TRIGGER increase_folder_count_on_insert " +// “创建触发器，触发器名为 increase_folder_count_on_insert”+空格分隔符。
+        " AFTER INSERT ON " + TABLE.NOTE +// “在向 Note 表插入数据之后”+空格分隔符+接口 TABLE 中的常量 NOTE。
+        " BEGIN " +// “开始”。
+        "  UPDATE " + TABLE.NOTE +// “更新”+接口 TABLE 中的常量 NOTE。
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +// “设置”+NoteColumns 中的常量 NOTES_COUNT+“等于”+NoteColumns 中的常量 NOTES_COUNT+“加 1”。
+        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +// “条件是”+NoteColumns 中的常量 ID+“等于 new.”+NoteColumns 中的常量 PARENT_ID，其中 new 表示新值。
+        " END";// “结束”。
+
+    /**
+     * Decrease folder's note count when delete note from the folder
+     */
+    // 这是一段注释，意思是“当从文件夹中删除笔记时，减少文件夹的笔记计数”。
+    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =// 定义一个私有静态常量字符串 NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER。
+        "CREATE TRIGGER decrease_folder_count_on_delete " +// “创建触发器，触发器名为 decrease_folder_count_on_delete”+空格分隔符。
+        " AFTER DELETE ON " + TABLE.NOTE +// “在从 Note 表删除数据之后”+空格分隔符+接口 TABLE 中的常量 NOTE。
+        " BEGIN " +// “开始”。
+        "  UPDATE " + TABLE.NOTE +// “更新”+接口 TABLE 中的常量 NOTE。
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +// “设置”+NoteColumns 中的常量 NOTES_COUNT+“等于”+NoteColumns 中的常量 NOTES_COUNT+“减 1”。
+        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +// “条件是”+NoteColumns 中的常量 ID+“等于 old.”+NoteColumns 中的常量 PARENT_ID，其中 old 表示旧值。
+        "  AND " + NoteColumns.NOTES_COUNT + ">0;" +// “并且”+NoteColumns 中的常量 NOTES_COUNT+“大于 0”+分号分隔符。
+        " END";// “结束”。
+
+    /**
+     * Update note's content when insert data with type {@link DataConstants#NOTE}
+     */
+    // 这是一段注释，意思是“当插入类型为{@link DataConstants#NOTE}的数据时，更新笔记的内容”。
+    private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =// 定义一个私有静态常量字符串 DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER。
+        "CREATE TRIGGER update_note_content_on_insert " +// “创建触发器，触发器名为 update_note_content_on_insert”+空格分隔符。
+        " AFTER INSERT ON " + TABLE.DATA +// “在向 Data 表插入数据之后”+空格分隔符+接口 TABLE 中的常量 DATA。
+        " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +// “当新插入的数据中，DataColumns 中的常量 MIME_TYPE 等于‘DataConstants.NOTE’时”+空格分隔符。
+        " BEGIN" +// “开始”。
+        "  UPDATE " + TABLE.NOTE +// “更新”+接口 TABLE 中的常量 NOTE。
+        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +// “设置”+NoteColumns 中的常量 SNIPPET+“等于新插入数据中的”+DataColumns 中的常量 CONTENT。
+        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +// “条件是”+NoteColumns 中的常量 ID+“等于新插入数据中的”+DataColumns 中的常量 NOTE_ID+分号分隔符。
+        " END";// “结束”。
+
+    /**
+     * Update note's content when data with {@link DataConstants#NOTE} type has changed
+     */
+    // 这是一段注释，意思是“当类型为{@link DataConstants#NOTE}的数据发生变化时，更新笔记的内容”。
+    private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =// 定义一个私有静态常量字符串 DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER。
+        "CREATE TRIGGER update_note_content_on_update " +// “创建触发器，触发器名为 update_note_content_on_update”+空格分隔符。
+        " AFTER UPDATE ON " + TABLE.DATA +// “在更新 Data 表之后”+空格分隔符+接口 TABLE 中的常量 DATA。
+        " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +// “当旧数据中，DataColumns 中的常量 MIME_TYPE 等于‘DataConstants.NOTE’时”+空格分隔符。
+        " BEGIN" +// “开始”。
+        "  UPDATE " + TABLE.NOTE +// “更新”+接口 TABLE 中的常量 NOTE。
+        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +// “设置”+NoteColumns 中的常量 SNIPPET+“等于新数据中的”+DataColumns 中的常量 CONTENT。
+        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +// “条件是”+NoteColumns 中的常量 ID+“等于新数据中的”+DataColumns 中的常量 NOTE_ID+分号分隔符。
+        " END";// “结束”。
+
+    /**
+     * Update note's content when data with {@link DataConstants#NOTE} type has deleted
+     */
+    // 这是一段注释，意思是“当类型为{@link DataConstants#NOTE}的数据被删除时，更新笔记的内容”。
+    private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =// 定义一个私有静态常量字符串 DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER。
+        "CREATE TRIGGER update_note_content_on_delete " +// “创建触发器，触发器名为 update_note_content_on_delete”+空格分隔符。
+        " AFTER delete ON " + TABLE.DATA +// “在删除 Data 表中的数据之后”+空格分隔符+接口 TABLE 中的常量 DATA。
+        " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +// “当旧数据中，DataColumns 中的常量 MIME_TYPE 等于‘DataConstants.NOTE’时”+空格分隔符。
+        " BEGIN" +// “开始”。
+        "  UPDATE " + TABLE.NOTE +// “更新”+接口 TABLE 中的常量 NOTE。
+        "   SET " + NoteColumns.SNIPPET + "=''" +// “设置”+NoteColumns 中的常量 SNIPPET 为空字符串。
+        "  WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" +// “条件是”+NoteColumns 中的常量 ID+“等于旧数据中的”+DataColumns 中的常量 NOTE_ID+分号分隔符。
+        " END";// “结束”。
+
+    /**
+     * Delete datas belong to note which has been deleted
+     */
+    // 这是一段注释，意思是“删除已被删除的笔记所对应的所有数据”。
+    private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =// 定义一个私有静态常量字符串 NOTE_DELETE_DATA_ON_DELETE_TRIGGER。
+        "CREATE TRIGGER delete_data_on_delete " +// “创建触发器，触发器名为 delete_data_on_delete”+空格分隔符。
+        " AFTER DELETE ON " + TABLE.NOTE +// “在删除 Note 表中的数据之后”+空格分隔符+接口 TABLE 中的常量 NOTE。
+        " BEGIN" +// “开始”。
+        "  DELETE FROM " + TABLE.DATA +// “从”+接口 TABLE 中的常量 DATA 表中删除数据。
+        "   WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" +// “条件是”+DataColumns 中的常量 NOTE_ID+“等于旧数据中的”+NoteColumns 中的常量 ID+分号分隔符。
+        " END";// “结束”。
+
+    /**
+     * Delete notes belong to folder which has been deleted
+     */
+    // 这是一段注释，意思是“删除已被删除的文件夹所对应的所有笔记”。
+    private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =// 定义一个私有静态常量字符串 FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER。
+        "CREATE TRIGGER folder_delete_notes_on_delete " +// “创建触发器，触发器名为 folder_delete_notes_on_delete”+空格分隔符。
+        " AFTER DELETE ON " + TABLE.NOTE +// “在删除 Note 表中的数据之后”+空格分隔符+接口 TABLE 中的常量 NOTE。
+        " BEGIN" +// “开始”。
+        "  DELETE FROM " + TABLE.NOTE +// “从”+接口 TABLE 中的常量 NOTE 表中删除数据。
+        "   WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +// “条件是”+NoteColumns 中的常量 PARENT_ID+“等于旧数据中的”+NoteColumns 中的常量 ID+分号分隔符。
+        " END";// “结束”。
+
+    /**
+     * Move notes belong to folder which has been moved to trash folder
+     */
+    // 这是一段注释，意思是“将已被移动到回收站文件夹的文件夹所对应的笔记移动到回收站”。
+    private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =// 定义一个私有静态常量字符串 FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER。
+        "CREATE TRIGGER folder_move_notes_on_trash " +// “创建触发器，触发器名为 folder_move_notes_on_trash”+空格分隔符。
+        " AFTER UPDATE ON " + TABLE.NOTE +// “在更新 Note 表之后”+空格分隔符+接口 TABLE 中的常量 NOTE。
+        " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +// “在更新 Note 表之后”+空格分隔符+接口 TABLE 中的常量 NOTE。
+        " BEGIN" +
+        "  UPDATE " + TABLE.NOTE +// “更新”+接口 TABLE 中的常量 NOTE。
+        "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +// “设置”+NoteColumns 中的常量 PARENT_ID 等于 Notes.ID_TRASH_FOLER。
+        "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +// “条件是”+NoteColumns 中的常量 PARENT_ID+“等于旧数据中的”+NoteColumns 中的常量 ID+分号分隔符。
+        " END";// “结束”。
+
+    public NotesDatabaseHelper(Context context) {// 定义一个公共的构造函数 NotesDatabaseHelper，接收一个 Context 参数。
+        super(context, DB_NAME, null, DB_VERSION);// 调用父类 SQLiteOpenHelper 的构造函数，传入 Context、数据库名、游标工厂（这里为 null）和数据库版本号。
+    }
+
+    public void createNoteTable(SQLiteDatabase db) {// 定义一个公共方法 createNoteTable，接收一个 SQLiteDatabase 类型的参数 db。
+        db.execSQL(CREATE_NOTE_TABLE_SQL);// 执行 SQL 语句 CREATE_NOTE_TABLE_SQL，用于创建 note 表。
+        reCreateNoteTableTriggers(db);// 调用私有方法 reCreateNoteTableTriggers，传入参数 db，用于重新创建 note 表的触发器。
+        createSystemFolder(db);// 调用 createSystemFolder 方法，传入参数 db，可能用于创建系统文件夹。
+        Log.d(TAG, "note table has been created");// 使用日志记录工具打印信息，表明 note 表已被创建，TAG 是一个常量，用于标识日志来源。
+    }
+
+    private void reCreateNoteTableTriggers(SQLiteDatabase db) {// 定义一个私有方法 reCreateNoteTableTriggers，接收一个 SQLiteDatabase 类型的参数 db。
+        db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");// 执行 SQL 语句，如果存在名为 increase_folder_count_on_update 的触发器，则删除它。
+        db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");// 执行 SQL 语句，如果存在名为 decrease_folder_count_on_update 的触发器，则删除它。
+        db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");// 执行 SQL 语句，如果存在名为 decrease_folder_count_on_delete 的触发器，则删除它。
+        db.execSQL("DROP TRIGGER IF EXISTS delete_data_on_delete");// 执行 SQL 语句，如果存在名为 delete_data_on_delete 的触发器，则删除它。
+        db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_insert");// 执行 SQL 语句，如果存在名为 increase_folder_count_on_insert 的触发器，则删除它。
+        db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");// 执行 SQL 语句，如果存在名为 folder_delete_notes_on_delete 的触发器，则删除它。
+        db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash");// 执行 SQL 语句，如果存在名为 folder_move_notes_on_trash 的触发器，则删除它。
+
+        db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);// 执行 SQL 语句，创建名为 NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER 的触发器。
+        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);// 执行 SQL 语句，创建名为 NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER 的触发器。
+        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);// 执行 SQL 语句，创建名为 NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER 的触发器。
+        db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER);// 执行 SQL 语句，创建名为 NOTE_DELETE_DATA_ON_DELETE_TRIGGER 的触发器。
+        db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER);// 执行 SQL 语句，创建名为 NOTE_DELETE_DATA_ON_DELETE_TRIGGER 的触发器。
+        db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);// 执行 SQL 语句，创建名为 FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER 的触发器。
+        db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);// 执行 SQL 语句，创建名为 FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER 的触发器。
+    }
+
+    private void createSystemFolder(SQLiteDatabase db) {// 定义一个私有方法 createSystemFolder，接收一个 SQLiteDatabase 类型的参数 db。
+        ContentValues values = new ContentValues();// 创建一个 ContentValues 对象 values。
+
+        /**
+         * call record foler for call notes
+         */
+        // 这是一段注释，意思是“用于通话记录笔记的通话记录文件夹”。
+        values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);// 将 Notes 类中的常量 ID_CALL_RECORD_FOLDER 放入 values 的键为 NoteColumns.ID 的位置。
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);// 将 Notes 类中的常量 TYPE_SYSTEM 放入 values 的键为 NoteColumns.TYPE 的位置。
+        db.insert(TABLE.NOTE, null, values);// 向表 TABLE.NOTE 插入数据，第三个参数为 values。
+
+        /**
+         * root folder which is default folder
+         */
+        // 这是一段注释，意思是“根文件夹，它是默认文件夹”。
+        values.clear();
+        values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+        db.insert(TABLE.NOTE, null, values);
+
+        /**
+         * temporary folder which is used for moving note
+         */
+        values.clear();// 清空 values。
+        values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);// 将 Notes 类中的常量 ID_ROOT_FOLDER 放入 values 的键为 NoteColumns.ID 的位置。
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);// 将 Notes 类中的常量 TYPE_SYSTEM 放入 values 的键为 NoteColumns.TYPE 的位置。
+        db.insert(TABLE.NOTE, null, values);// 向表 TABLE.NOTE 插入数据，第三个参数为 values。
+
+        /**
+         * create trash folder
+         */
+        // 这是一段注释，意思是“临时文件夹，用于移动笔记”。
+        values.clear();// 清空 values。
+        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);// 将 Notes 类中的常量 ID_TEMPARAY_FOLDER 放入 values 的键为 NoteColumns.ID 的位置。
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);// 将 Notes 类中的常量 TYPE_SYSTEM 放入 values 的键为 NoteColumns.TYPE 的位置。
+        db.insert(TABLE.NOTE, null, values);// 向表 TABLE.NOTE 插入数据，第三个参数为 values。
+    }
+
+    public void createDataTable(SQLiteDatabase db) {// 定义一个公共方法 createDataTable，接收一个 SQLiteDatabase 类型的参数 db。
+        db.execSQL(CREATE_DATA_TABLE_SQL);// 执行 SQL 语句 CREATE_DATA_TABLE_SQL，用于创建 data 表。
+        reCreateDataTableTriggers(db);// 调用私有方法 reCreateDataTableTriggers，传入参数 db，用于重新创建 data 表的触发器。
+        db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);// 执行 SQL 语句 CREATE_DATA_NOTE_ID_INDEX_SQL，用于创建 data 表的索引。
+        Log.d(TAG, "data table has been created");// 使用日志记录工具打印信息，表明 data 表已被创建，TAG 是一个常量，用于标识日志来源。
+    }
+
+    private void reCreateDataTableTriggers(SQLiteDatabase db) {// 定义一个私有方法 reCreateDataTableTriggers，接收一个 SQLiteDatabase 类型的参数 db。
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");// 执行 SQL 语句，如果存在名为 update_note_content_on_insert 的触发器，则删除它。
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");// 执行 SQL 语句，如果存在名为 update_note_content_on_update 的触发器，则删除它。
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete");// 执行 SQL 语句，如果存在名为 update_note_content_on_delete 的触发器，则删除它。
+
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER);// 执行 SQL 语句，创建名为 DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER 的触发器。
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);// 执行 SQL 语句，创建名为 DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER 的触发器。
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);// 执行 SQL 语句，创建名为 DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER 的触发器。
+    }
+
+    static synchronized NotesDatabaseHelper getInstance(Context context) {// 定义一个静态同步方法 getInstance，接收一个 Context 类型的参数 context。
+        if (mInstance == null) {// 如果 mInstance 为 null。
+            mInstance = new NotesDatabaseHelper(context);// 创建一个新的 NotesDatabaseHelper 实例，传入 context 参数，并赋值给 mInstance。
+        }
+        return mInstance;// 返回 mInstance。
+    }
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {// 重写 onCreate 方法，接收一个 SQLiteDatabase 类型的参数 db。
+        createNoteTable(db);// 调用 createNoteTable 方法，传入参数 db，创建 note 表。
+        createDataTable(db);// 调用 createDataTable 方法，传入参数 db，创建 data 表。
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {// 重写 onUpgrade 方法，接收一个 SQLiteDatabase 类型的参数 db，以及旧版本号 oldVersion 和新版本号 newVersion。
+        boolean reCreateTriggers = false;false;
+// 定义一个布尔变量 reCreateTriggers，初始值为 false。
+        boolean skipV2 = false;// 定义一个布尔变量 skipV2，初始值为 false。
+
+        if (oldVersion == 1) {// 如果旧版本号为 1。
+            upgradeToV2(db);// 调用 upgradeToV2 方法，传入参数 db，进行从版本 1 到版本 2 的升级。
+            skipV2 = true; // this upgrade including the upgrade from v2 to v3
+            // 将 skipV2 设置为 true，表示此次升级包括从版本 2 到版本 3 的升级。
+            oldVersion++;// 旧版本号加 1。
+        }
+
+        if (oldVersion == 2 && !skipV2) {// 如果旧版本号为 2 且 skipV2 为 false。
+            upgradeToV3(db);// 调用 upgradeToV3 方法，传入参数 db，进行从版本 2 到版本 3 的升级。
+            reCreateTriggers = true;// 将 reCreateTriggers 设置为 true，表示需要重新创建触发器。
+            oldVersion++;// 旧版本号加 1。
+        }
+
+        if (oldVersion == 3) {// 如果旧版本号为 3。
+            upgradeToV4(db);// 调用 upgradeToV4 方法，传入参数 db，进行从版本 3 到版本 4 的升级。
+            oldVersion++;// 旧版本号加 1。
+        }
+
+        if (reCreateTriggers) {// 如果 reCreateTriggers 为 true。
+            reCreateNoteTableTriggers(db);// 调用 reCreateNoteTableTriggers 方法，传入参数 db，重新创建 note 表的触发器。
+            reCreateDataTableTriggers(db);// 调用 reCreateDataTableTriggers 方法，传入参数 db，重新创建 data 表的触发器。
+        }
+
+        if (oldVersion != newVersion) {// 如果旧版本号不等于新版本号。
+            throw new IllegalStateException("Upgrade notes database to version " + newVersion
+                    + "fails");// 抛出一个 IllegalStateException 异常，表明升级笔记数据库到新版本失败。
+        }
+    }
+
+    private void upgradeToV2(SQLiteDatabase db) {// 定义一个私有方法 upgradeToV2，接收一个 SQLiteDatabase 类型的参数 db。
+        db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);// 执行 SQL 语句，如果存在表 TABLE.NOTE，则删除它。
+        db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);// 执行 SQL 语句，如果存在表 TABLE.DATA，则删除它。
+        createNoteTable(db);// 调用 createNoteTable 方法，传入参数 db，创建 note 表。
+        createDataTable(db);// 调用 createDataTable 方法，传入参数 db，创建 data 表。
+    }
+
+    private void upgradeToV3(SQLiteDatabase db) {// 定义一个私有方法 upgradeToV3，接收一个 SQLiteDatabase 类型的参数 db。
+        // drop unused triggers
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");// 执行 SQL 语句，如果存在名为 update_note_modified_date_on_insert 的触发器，则删除它。
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete");// 执行 SQL 语句，如果存在名为 update_note_modified_date_on_insert 的触发器，则删除它。
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");// 执行 SQL 语句，如果存在名为 update_note_modified_date_on_update 的触发器，则删除它。
+        // add a column for gtask id
+        // 注释：添加一个用于 gtask id 的列。
+        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+                + " TEXT NOT NULL DEFAULT ''");// 执行 SQL 语句，在表 TABLE.NOTE 中添加一个名为 NoteColumns.GTASK_ID 的列，类型为文本，默认值为空字符串。
+        // add a trash system folder
+        // 注释：添加一个回收站系统文件夹。
+        ContentValues values = new ContentValues();// 创建一个 ContentValues 对象 values。
+        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);// 将 Notes 类中的常量 ID_TRASH_FOLER 放入 values 的键为 NoteColumns.ID 的位置。
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);// 将 Notes 类中的常量 TYPE_SYSTEM 放入 values 的键为 NoteColumns.TYPE 的位置。
+        db.insert(TABLE.NOTE, null, values);// 向表 TABLE.NOTE 插入数据，第三个参数为 values。
+    }
+
+    private void upgradeToV4(SQLiteDatabase db) {// 定义一个私有方法 upgradeToV4，接收一个 SQLiteDatabase 类型的参数 db。
+        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+                + " INTEGER NOT NULL DEFAULT 0");// 执行 SQL 语句，在表 TABLE.NOTE 中添加一个名为 NoteColumns.VERSION 的列，类型为整数，默认值为 0。
+    }
+}

NotesProvider.java

@@ -0,0 +1,311 @@
+/*
+ * 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.data;// 包名：net.micode.notes.data
+
+
+import android.app.SearchManager;// 导入 Android 的搜索管理器类
+import android.content.ContentProvider;// 导入 Android 的内容提供器类
+import android.content.ContentUris;// 导入 Android 的内容 URI 工具类
+import android.content.ContentValues;// 导入 Android 的内容值类
+import android.content.Intent;
+import android.content.UriMatcher;// 导入 Android 的 URI 匹配器类
+import android.database.Cursor;// 导入 Android 的游标类
+import android.database.sqlite.SQLiteDatabase;// 导入 Android 的 SQLite 数据库类
+import android.net.Uri;// 导入 Android 的统一资源标识符类
+import android.text.TextUtils;// 导入 Android 的文本工具类
+import android.util.Log;// 导入 Android 的日志工具类
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes.DataColumns;// 导入 net.micode.notes.data.Notes 类中的 DataColumns 内部类
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.NotesDatabaseHelper.TABLE;// 导入 net.micode.notes.data.NotesDatabaseHelper 类中的 TABLE 静态成员
+
+
+public class NotesProvider extends ContentProvider {// 定义一个名为 NotesProvider 的公共类，它继承自 ContentProvider。
+    private static final UriMatcher mMatcher;// 定义一个私有的静态常量 mMatcher，类型为 UriMatcher。
+
+    private NotesDatabaseHelper mHelper;// 定义一个私有的静态常量 mMatcher，类型为 UriMatcher。
+
+    private static final String TAG = "NotesProvider";// 定义一个私有的静态常量 TAG，值为"NotesProvider"。
+
+    private static final int URI_NOTE            = 1;// 定义一个私有的静态常量 URI_NOTE，值为 1。
+    private static final int URI_NOTE_ITEM       = 2;// 定义一个私有的静态常量 URI_NOTE_ITEM，值为 2。
+    private static final int URI_DATA            = 3;// 定义一个私有的静态常量 URI_DATA，值为 3。
+    private static final int URI_DATA_ITEM       = 4;// 定义一个私有的静态常量 URI_DATA_ITEM，值为 4。
+
+    private static final int URI_SEARCH          = 5;// 定义一个私有的静态常量 URI_SEARCH，值为 5。
+    private static final int URI_SEARCH_SUGGEST  = 6;// 定义一个私有的静态常量 URI_SEARCH_SUGGEST，值为 6。
+
+    static {// 静态代码块。
+        mMatcher = new UriMatcher(UriMatcher.NO_MATCH);// 创建一个新的 UriMatcher 对象并赋值给 mMatcher，初始匹配结果为 UriMatcher.NO_MATCH。
+        mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);// 向 mMatcher 添加一个 URI 匹配规则，当 authority 为 Notes.AUTHORITY，路径为"note"时，匹配结果为 URI_NOTE。
+        mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);// 向 mMatcher 添加一个 URI 匹配规则，当 authority 为 Notes.AUTHORITY，路径为"note/任意数字"时，匹配结果为 URI_NOTE_ITEM。
+        mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);// 向 mMatcher 添加一个 URI 匹配规则，当 authority 为 Notes.AUTHORITY，路径为"note/任意数字"时，匹配结果为 URI_NOTE_ITEM。
+        mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);// 向 mMatcher 添加一个 URI 匹配规则，当 authority 为 Notes.AUTHORITY，路径为"data/任意数字"时，匹配结果为 URI_DATA_ITEM。
+        mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);// 向 mMatcher 添加一个 URI 匹配规则，当 authority 为 Notes.AUTHORITY，路径为"search"时，匹配结果为 URI_SEARCH。
+        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);// 向 mMatcher 添加一个 URI 匹配规则，当 authority 为 Notes.AUTHORITY，路径为 SearchManager.SUGGEST_URI_PATH_QUERY 时，匹配结果为 URI_SEARCH_SUGGEST。
+        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);// 向 mMatcher 添加一个 URI 匹配规则，当 authority 为 Notes.AUTHORITY，路径为 SearchManager.SUGGEST_URI_PATH_QUERY 加上任意字符时，匹配结果为 URI_SEARCH_SUGGEST。
+    }
+
+    /**
+     * x'0A' represents the '\n' character in sqlite. For title and content in the search result,
+     * we will trim '\n' and white space in order to show more information.
+     */
+    private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
+        + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
+        + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + ","
+        + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + ","
+        + R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","
+        + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
+        + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
+        // 定义一个私有的静态常量 NOTES_SEARCH_PROJECTION，它是一个字符串，由多个部分组成，分别是 NoteColumns.ID（可能是笔记的 ID）、NoteColumns.ID 作为 SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA、对 NoteColumns.SNIPPET（可能是笔记片段）进行处理后的结果作为 SearchManager.SUGGEST_COLUMN_TEXT_1 和 SearchManager.SUGGEST_COLUMN_TEXT_2、R.drawable.search_result（可能是搜索结果的图标资源）作为 SearchManager.SUGGEST_COLUMN_ICON_1、Intent.ACTION_VIEW（可能是查看的动作）作为 SearchManager.SUGGEST_COLUMN_INTENT_ACTION、Notes.TextNote.CONTENT_TYPE（可能是文本笔记的内容类型）作为 SearchManager.SUGGEST_COLUMN_INTENT_DATA。
+
+    private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
+        + " FROM " + TABLE.NOTE
+        + " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
+        + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
+        + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
+        SNIPPET_SEARCH_QUERY，它是一个 SQL 查询语句，包含选择 NOTES_SEARCH_PROJECTION 指定的列，从 TABLE.NOTE（可能是一个表名）中选择，有条件判断 NoteColumns.SNIPPET（笔记片段）类似某个值，NoteColumns.PARENT_ID（可能是父 ID）不等于 Notes.ID_TRASH_FOLER（可能是垃圾文件夹的 ID），以及 NoteColumns.TYPE（可能是类型）等于 Notes.TYPE_NOTE（可能是笔记类型）。
+
+    @Override
+    public boolean onCreate() {
+        mHelper = NotesDatabaseHelper.getInstance(getContext());
+        return true;
+    }// 重写 onCreate 方法。在这个方法中，获取 NotesDatabaseHelper 的实例并赋值给 mHelper，然后返回 true 表示创建成功。
+
+    @Override
+    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+            String sortOrder) {// 重写 query 方法，该方法接收一个 Uri（统一资源标识符）、一个字符串数组（projection，指定要返回的列）、一个字符串（selection，用于筛选数据的条件）、一个字符串数组（selectionArgs，用于填充 selection 中的占位符）和一个字符串（sortOrder，用于指定排序方式），并返回一个 Cursor（游标）对象。
+        Cursor c = null;// 初始化一个 Cursor 对象为 null。
+        SQLiteDatabase db = mHelper.getReadableDatabase();// 获取一个可读的 SQLiteDatabase 对象。
+        String id = null;// 初始化一个字符串 id 为 null。
+        switch (mMatcher.match(uri)) {// 根据 Uri 匹配器 mMatcher 对传入的 Uri 进行匹配，并根据匹配结果进行不同的处理。
+            case URI_NOTE:// 如果匹配到 URI_NOTE。
+                c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
+                        sortOrder);// 使用数据库对象 db 执行查询操作，从名为 TABLE.NOTE 的表中查询指定的列（projection），根据条件（selection 和 selectionArgs）进行筛选，并按照指定的排序方式（sortOrder）进行排序，结果存储在 Cursor 对象 c 中。
+                break;// 跳出 switch 语句。
+            case URI_NOTE_ITEM:// 如果匹配到 URI_NOTE_ITEM。
+                id = uri.getPathSegments().get(1);// 从 Uri 的路径片段中获取第二个元素（索引为 1），并赋值给 id。
+                c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs, null, null, sortOrder);// 使用数据库对象 db 执行查询操作，从名为 TABLE.NOTE 的表中查询指定的列（projection），根据条件（NoteColumns.ID 等于 id 加上经过 parseSelection 方法处理后的 selection）进行筛选，并按照指定的排序方式（sortOrder）进行排序，结果存储在 Cursor 对象 c 中。
+                break;// 跳出 switch 语句。
+            case URI_DATA:// 如果匹配到 URI_DATA。
+                c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
+                        sortOrder);// 使用数据库对象 db 执行查询操作，从名为 TABLE.DATA 的表中查询指定的列（projection），根据条件（selection 和 selectionArgs）进行筛选，并按照指定的排序方式（sortOrder）进行排序，结果存储在 Cursor 对象 c 中。
+                break;// 跳出 switch 语句。
+            case URI_DATA_ITEM:// 如果匹配到 URI_DATA_ITEM。
+                id = uri.getPathSegments().get(1);// 从 Uri 的路径片段中获取第二个元素（索引为 1），并赋值给 id。
+                c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs, null, null, sortOrder);// 使用数据库对象 db 执行查询操作，从名为 TABLE.DATA 的表中查询指定的列（projection），根据条件（DataColumns.ID 等于 id 加上经过 parseSelection 方法处理后的 selection）进行筛选，并按照指定的排序方式（sortOrder）进行排序，结果存储在 Cursor 对象 c 中。
+                break;// 跳出 switch 语句。
+            case URI_SEARCH:// 如果匹配到 URI_SEARCH。
+            case URI_SEARCH_SUGGEST:// 如果匹配到 URI_SEARCH_SUGGEST。
+                if (sortOrder != null || projection != null) {// 如果 sortOrder 不为 null 或者 projection 不为 null。
+                    throw new IllegalArgumentException(
+                            "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");// 抛出一个非法参数异常，提示在这个查询中不要指定 sortOrder、selection、selectionArgs 或 projection。
+                }
+
+                String searchString = null;// 定义一个字符串 searchString 并初始化为 null。
+                if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {// 如果传入的 Uri 与 URI_SEARCH_SUGGEST 匹配。
+                    if (uri.getPathSegments().size() > 1) {// 如果 Uri 的路径片段数量大于 1。
+                        searchString = uri.getPathSegments().get(1);// 获取 Uri 的第二个路径片段并赋值给 searchString。
+                    }
+                } else {
+                // 如果传入的 Uri 不与 URI_SEARCH_SUGGEST 匹配。
+                    searchString = uri.getQueryParameter("pattern");// 从 Uri 的查询参数中获取名为 "pattern" 的参数值并赋值给 searchString。
+                }
+
+                if (TextUtils.isEmpty(searchString)) {// 如果 searchString 为空。
+                    return null;// 返回 null。
+                }
+
+                try {// 尝试执行以下代码块。
+                    searchString = String.format("%%%s%%", searchString);// 使用 String.format 方法格式化 searchString，在其前后加上 "%%"。
+                    c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
+                            new String[] { searchString });// 使用数据库对象 db 执行原始 SQL 查询 NOTES_SNIPPET_SEARCH_QUERY，并将 searchString 作为参数传入，结果存储在 Cursor 对象 c 中。
+                } catch (IllegalStateException ex) {// 如果发生非法状态异常。
+                    Log.e(TAG, "got exception: " + ex.toString());// 使用日志记录错误信息，包括标签 TAG 和异常的字符串表示。
+                }
+                break;// 跳出 switch 语句。
+            default:// 如果没有匹配到任何已知的 Uri。
+                throw new IllegalArgumentException("Unknown URI " + uri);// 抛出非法参数异常，提示未知的 Uri。
+        }
+        if (c != null) {// 抛出非法参数异常，提示未知的 Uri。
+            c.setNotificationUri(getContext().getContentResolver(), uri);// 设置 Cursor 对象的通知 Uri，以便在数据发生变化时通知内容解析器。
+        }
+        return c;// 返回 Cursor 对象 c。
+    }
+
+    @Override
+    public Uri insert(Uri uri, ContentValues values) {// 重写 insert 方法，该方法接收一个 Uri 和一个 ContentValues 对象，用于插入数据，并返回插入数据的 Uri。
+        SQLiteDatabase db = mHelper.getWritableDatabase();// 获取一个可写的 SQLiteDatabase 对象。
+        long dataId = 0, noteId = 0, insertedId = 0;// 获取一个可写的 SQLiteDatabase 对象。
+        switch (mMatcher.match(uri)) {// 根据 Uri 匹配器 mMatcher 对传入的 Uri 进行匹配，并根据匹配结果进行不同的处理。
+            case URI_NOTE:// 如果匹配到 URI_NOTE。
+                insertedId = noteId = db.insert(TABLE.NOTE, null, values);// 使用数据库对象 db 将 values 插入到名为 TABLE.NOTE 的表中，返回插入的行 ID，并将其同时赋值给 insertedId 和 noteId。
+                break;// 跳出 switch 语句。
+            case URI_DATA:// 如果匹配到 URI_DATA。
+                if (values.containsKey(DataColumns.NOTE_ID)) {// 如果 values 中包含 DataColumns.NOTE_ID 键。
+                    noteId = values.getAsLong(DataColumns.NOTE_ID);// 获取 values 中对应 DataColumns.NOTE_ID 的长整型值，并赋值给 noteId。
+                } else {// 如果 values 中不包含 DataColumns.NOTE_ID 键。
+                    Log.d(TAG, "Wrong data format without note id:" + values.toString());// 使用日志记录错误信息，提示数据格式错误，没有 note id，并打印 values 的字符串表示。
+                }
+                insertedId = dataId = db.insert(TABLE.DATA, null, values);// 使用数据库对象 db 将 values 插入到名为 TABLE.DATA 的表中，返回插入的行 ID，并将其同时赋值给 insertedId 和 dataId。
+                break;// 跳出 switch 语句。
+            default:// 如果没有匹配到任何已知的 Uri。
+                throw new IllegalArgumentException("Unknown URI " + uri);// 抛出非法参数异常，提示未知的 Uri。
+        }
+        // Notify the note uri
+        // 注释：通知 note 的 Uri。
+        if (noteId > 0) {// 如果 noteId 大于 0。
+            getContext().getContentResolver().notifyChange(
+                    ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);// 使用上下文的内容解析器通知 Note 的 Uri 发生了变化，传入带有 noteId 的 Uri 和 null。
+        }
+
+        // Notify the data uri
+        if (dataId > 0) {// 如果 dataId 大于 0。
+            getContext().getContentResolver().notifyChange(
+                    ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);// 使用上下文的内容解析器通知 Data 的 Uri 发生了变化，传入带有 dataId 的 Uri 和 null。
+        }
+
+        return ContentUris.withAppendedId(uri, insertedId);// 返回带有 insertedId 的 Uri。
+    }
+
+    @Override
+    public int delete(Uri uri, String selection, String[] selectionArgs) {// 重写 delete 方法，该方法接收一个 Uri、一个筛选条件字符串和一个筛选参数数组，用于删除数据，并返回删除的行数。
+        int count = 0;// 定义一个整数变量 count 并初始化为 0，表示删除的行数。
+        String id = null;// 定义一个字符串变量 id 并初始化为 null。
+        SQLiteDatabase db = mHelper.getWritableDatabase();// 获取一个可写的 SQLiteDatabase 对象。
+        boolean deleteData = false;// 定义一个布尔变量 deleteData 并初始化为 false，表示是否删除了数据。
+        switch (mMatcher.match(uri)) {// 根据 Uri 匹配器 mMatcher 对传入的 Uri 进行匹配，并根据匹配结果进行不同的处理。
+            case URI_NOTE:// 如果匹配到 URI_NOTE。
+                selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";// 重新构建筛选条件，在原有的筛选条件上加上 NoteColumns.ID 大于 0 的条件。
+                count = db.delete(TABLE.NOTE, selection, selectionArgs);// 使用数据库对象 db 删除名为 TABLE.NOTE 的表中符合筛选条件的行，并将删除的行数赋值给 count。
+                break;// 跳出 switch 语句。
+            case URI_NOTE_ITEM:// 如果匹配到 URI_NOTE_ITEM。
+                id = uri.getPathSegments().get(1);// 从 Uri 的路径片段中获取第二个元素（索引为 1），并赋值给 id。
+                /**
+                 * ID that smaller than 0 is system folder which is not allowed to
+                 * trash
+                 */
+                long noteId = Long.valueOf(id);// 将 id 转换为长整型并赋值给 noteId。
+                if (noteId <= 0) {// 如果 noteId 小于等于 0。
+                    break;// 跳出 switch 语句。
+                }
+                count = db.delete(TABLE.NOTE,
+                        NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);// 使用数据库对象 db 删除名为 TABLE.NOTE 的表中符合筛选条件的行，并将删除的行数赋值给 count。
+                break;
+            case URI_DATA:// 如果匹配到 URI_DATA。
+                count = db.delete(TABLE.DATA, selection, selectionArgs);// 使用数据库对象 db 删除名为 TABLE.DATA 的表中符合筛选条件的行，并将删除的行数赋值给 count。
+                deleteData = true;// 将 deleteData 设置为 true，表示删除了数据。
+                break;
+            case URI_DATA_ITEM:// 将 deleteData 设置为 true，表示删除了数据。
+                id = uri.getPathSegments().get(1);// 从 Uri 的路径片段中获取第二个元素（索引为 1），并赋值给 id。
+                count = db.delete(TABLE.DATA,
+                        DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);// 使用数据库对象 db 删除名为 TABLE.DATA 的表中符合筛选条件的行，并将删除的行数赋值给 count。
+                deleteData = true;// 将 deleteData 设置为 true，表示删除了数据。
+                break;
+            default:// 如果没有匹配到任何已知的 Uri。
+                throw new IllegalArgumentException("Unknown URI " + uri);// 抛出非法参数异常，提示未知的 Uri。
+        }
+        if (count > 0) {// 如果删除的行数大于 0。
+            if (deleteData) {// 如果 deleteData 为 true，表示删除了数据。
+                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);// 使用上下文的内容解析器通知 Notes.CONTENT_NOTE_URI 发生了变化，传入 null。
+            }
+            getContext().getContentResolver().notifyChange(uri, null);// 使用上下文的内容解析器通知传入的 Uri 发生了变化，传入 null。
+        }
+        return count;// 返回删除的行数。
+    }
+
+    @Override
+    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {// 重写 update 方法，该方法接收一个 Uri、一个 ContentValues 对象、一个筛选条件字符串和一个筛选参数数组，用于更新数据，并返回更新的行数。
+        int count = 0;// 定义一个整数变量 count 并初始化为 0，表示更新的行数。
+        String id = null;// 定义一个字符串变量 id 并初始化为 null。
+        SQLiteDatabase db = mHelper.getWritableDatabase();// 获取一个可写的 SQLiteDatabase 对象
+        boolean updateData = false;// 定义一个布尔变量 updateData 并初始化为 false，表示是否更新了数据。
+        switch (mMatcher.match(uri)) {// 根据 Uri 匹配器 mMatcher 对传入的 Uri 进行匹配，并根据匹配结果进行不同的处理。
+            case URI_NOTE:// 如果匹配到 URI_NOTE。
+                increaseNoteVersion(-1, selection, selectionArgs);// 调用 increaseNoteVersion 方法，传入 -1、筛选条件和筛选参数。
+                count = db.update(TABLE.NOTE, values, selection, selectionArgs);// 使用数据库对象 db 更新名为 TABLE.NOTE 的表中符合筛选条件的行，并将更新的行数赋值给 count。
+                break;
+            case URI_NOTE_ITEM:// 使用数据库对象 db 更新名为 TABLE.NOTE 的表中符合筛选条件的行，并将更新的行数赋值给 count。
+                id = uri.getPathSegments().get(1);// 从 Uri 的路径片段中获取第二个元素（索引为 1），并赋值给 id。
+                increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);// 从 Uri 的路径片段中获取第二个元素（索引为 1），并赋值给 id。
+                count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id// 使用数据库对象 db 更新名为 TABLE.NOTE 的表中符合筛选条件的行，并将更新的行数赋值给 count。
+                        + parseSelection(selection), selectionArgs);
+                break;
+            case URI_DATA:// 如果匹配到 URI_DATA。
+                count = db.update(TABLE.DATA, values, selection, selectionArgs);// 使用数据库对象 db 更新名为 TABLE.DATA 的表中符合筛选条件的行，并将更新的行数赋值给 count。
+                updateData = true;// 将 updateData 设置为 true，表示更新了数据。
+                break;
+            case URI_DATA_ITEM:// 如果匹配到 URI_DATA_ITEM。
+                id = uri.getPathSegments().get(1);// 从 Uri 的路径片段中获取第二个元素（索引为 1），并赋值给 id。
+                count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs);// 使用数据库对象 db 更新名为 TABLE.DATA 的表中符合筛选条件的行，并将更新的行数赋值给 count。
+                updateData = true;// 将 updateData 设置为 true，表示更新了数据。
+                break;
+            default:// 如果没有匹配到任何已知的 Uri。
+                throw new IllegalArgumentException("Unknown URI " + uri);// 抛出非法参数异常，提示未知的 Uri。
+        }
+
+        if (count > 0) {// 如果更新的行数大于 0。
+            if (updateData) {// 如果 updateData 为 true，表示更新了数据。
+                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);// 使用上下文的内容解析器通知 Notes.CONTENT_NOTE_URI 发生了变化，传入 null。
+            }
+            getContext().getContentResolver().notifyChange(uri, null);// 使用上下文的内容解析器通知传入的 Uri 发生了变化，传入 null。
+        }
+        return count;// 返回更新的行数。
+    }
+
+    private String parseSelection(String selection) {// 定义一个私有方法 parseSelection，该方法接收一个筛选条件字符串，用于处理筛选条件。
+        return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");// 如果筛选条件不为空，返回 " AND (" + selection + ")"，否则返回空字符串。
+    }
+
+    private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {// 定义一个私有方法 increaseNoteVersion，该方法接收一个长整型 id、一个筛选条件字符串和一个筛选参数数组，用于增加笔记的版本号。
+        StringBuilder sql = new StringBuilder(120);// 创建一个 StringBuilder 对象，初始容量为 120。
+        sql.append("UPDATE ");// 将 "UPDATE " 添加到 StringBuilder 对象中。
+        sql.append(TABLE.NOTE);// 将 TABLE.NOTE（可能是表名）添加到 StringBuilder 对象中。
+        sql.append(" SET ");// 将 " SET " 添加到 StringBuilder 对象中。
+        sql.append(NoteColumns.VERSION);// 将 NoteColumns.VERSION（可能是版本号列名）添加到 StringBuilder 对象中。
+        sql.append("=" + NoteColumns.VERSION + "+1 ");// 将 "=" + NoteColumns.VERSION + "+1 " 添加到 StringBuilder 对象中，表示将版本号设置为当前版本号加 1。
+
+        if (id > 0 || !TextUtils.isEmpty(selection)) {// 如果 id 大于 0 或者筛选条件不为空。
+        sql.append(" WHERE ");
+// 将 " WHERE " 添加到 StringBuilder 对象中。
+            sql.append(" WHERE ");
+        }
+        if (id > 0) {
+            sql.append(NoteColumns.ID + "=" + String.valueOf(id));// 将 NoteColumns.ID + "=" + id 的字符串表示添加到 StringBuilder 对象中，表示根据 id 进行筛选。
+        }
+        if (!TextUtils.isEmpty(selection)) {// 如果筛选条件不为空。
+            String selectString = id > 0 ? parseSelection(selection) : selection;// 如果 id 大于 0，调用 parseSelection 方法处理筛选条件，否则直接使用筛选条件。
+            for (String args : selectionArgs) {// 遍历筛选参数数组。
+                selectString = selectString.replaceFirst("\\?", args);// 将筛选条件中的第一个问号替换为当前的筛选参数。
+            }
+            sql.append(selectString);// 将处理后的筛选条件添加到 
+        }
+
+        mHelper.getWritableDatabase().execSQL(sql.toString());// 使用数据库助手对象 mHelper 获取可写数据库，并执行 StringBuilder 对象中的 SQL 语句。
+    }
+
+    @Override
+    public String getType(Uri uri) {// 重写 getType 方法，该方法接收一个 Uri，用于获取数据的 MIME 类型。
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+}

SqlData.java

@@ -0,0 +1,190 @@
+/*
+ * 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;//包名：net.micode.notes.gtask.data；”。
+
+import android.content.ContentResolver;//“导入安卓内容解析器类；”
+import android.content.ContentUris;//“导入安卓内容 URI 工具类；”
+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;//“导入 net.micode.notes.data 包下的 Notes 类；”。
+import net.micode.notes.data.Notes.DataColumns;//“导入 net.micode.notes.data.Notes 类中的 DataColumns 内部类；”。
+import net.micode.notes.data.Notes.DataConstants;//导入 net.micode.notes.data.Notes 类中的 DataConstants 内部类；”。
+import net.micode.notes.data.Notes.NoteColumns;//导入 net.micode.notes.data.Notes 类中的 NoteColumns 内部类；”。
+import net.micode.notes.data.NotesDatabaseHelper.TABLE;//导入 net.micode.notes.data.NotesDatabaseHelper 类中的 TABLE 内部类；”。
+import net.micode.notes.gtask.exception.ActionFailureException;//导入 net.micode.notes.gtask.exception 包下的 ActionFailureException 类；”
+
+import org.json.JSONException;//导入 JSON 异常类；”。
+import org.json.JSONObject;//导入 JSON 异常类；”。
+
+
+public class SqlData {//“公共类 SqlData。”
+    private static final String TAG = SqlData.class.getSimpleName();//“私有静态最终字符串变量 TAG 被赋值为 SqlData 类的简单名称。”
+
+    private static final int INVALID_ID = -99999;//“私有静态最终整数变量 INVALID_ID 被赋值为 -99999。”
+
+    public static final String[] PROJECTION_DATA = new String[] {
+            DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
+            DataColumns.DATA3
+    };//“公共静态最终字符串数组变量 PROJECTION_DATA 被赋值为包含 DataColumns 类中的 ID、MIME_TYPE、CONTENT、DATA1 和 DATA3 的字符串数组。”
+
+    public static final int DATA_ID_COLUMN = 0;//“公共静态最终字符串数组变量 PROJECTION_DATA 被赋值为包含 DataColumns 类中的 ID、MIME_TYPE、CONTENT、DATA1 和 DATA3 的字符串数组。”
+
+    public static final int DATA_MIME_TYPE_COLUMN = 1;//“公共静态最终整数变量 DATA_MIME_TYPE_COLUMN 被赋值为 1。”
+
+    public static final int DATA_CONTENT_COLUMN = 2;//“公共静态最终整数变量 DATA_CONTENT_COLUMN 被赋值为 2。”
+
+    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;//“公共静态最终整数变量 DATA_CONTENT_DATA_1_COLUMN 被赋值为 3。”
+
+    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;//公共静态最终整数变量 DATA_CONTENT_DATA_3_COLUMN 被赋值为 4。”
+
+    private ContentResolver mContentResolver;//“私有 ContentResolver 类型变量 mContentResolver。”
+
+    private boolean mIsCreate;//私有布尔类型变量 mIsCreate。”
+
+    private long mDataId;//“私有长整型变量 mDataId。”
+
+    private String mDataMimeType;//私有字符串类型变量 mDataMimeType。”
+
+    private String mDataContent;//“私有字符串类型变量 mDataContent。”
+
+    private long mDataContentData1;//“私有长整型变量 mDataContentData1。”
+
+    private String mDataContentData3;//“私有字符串类型变量 mDataContentData3。”
+
+    private ContentValues mDiffDataValues;//“私有 ContentValues 类型变量 mDiffDataValues。”
+
+    public SqlData(Context context) {//“公共的 SqlData 构造方法，接收一个 Context 参数。”
+        mContentResolver = context.getContentResolver();//“将成员变量 mContentResolver 赋值为传入的 context 的内容解析器。”
+        mIsCreate = true;//“将成员变量 mIsCreate 赋值为 true。”
+        mDataId = INVALID_ID;//“将成员变量 mIsCreate 赋值为 true。”
+        mDataMimeType = DataConstants.NOTE;//“将成员变量 mIsCreate 赋值为 true。”
+        mDataContent = "";//“将成员变量 mDataContent 赋值为空字符串。
+        mDataContentData1 = 0;//“将成员变量 mDataContentData1 赋值为 0。”
+        mDataContentData3 = "";//将成员变量 mDataContentData3 赋值为空字符串。”
+        mDiffDataValues = new ContentValues();//将成员变量 mDataContentData3 赋值为空字符串。”
+    }
+
+    public SqlData(Context context, Cursor c) {//将成员变量 mDataContentData3 赋值为空字符串。”
+        mContentResolver = context.getContentResolver();//将成员变量 mDataContentData3 赋值为空字符串。”
+        mIsCreate = false;//将成员变量 mIsCreate 赋值为 false。”
+        loadFromCursor(c);//调用 loadFromCursor 方法，传入 Cursor 参数 c。”
+        mDiffDataValues = new ContentValues();//“将成员变量 mDiffDataValues 赋值为一个新的 ContentValues 对象。”
+    }
+
+    private void loadFromCursor(Cursor c) {//“私有方法 loadFromCursor，接收一个 Cursor 参数。”
+        mDataId = c.getLong(DATA_ID_COLUMN);//“将成员变量 mDataId 赋值为 Cursor 中对应 DATA_ID_COLUMN 列的长整型值。”
+        mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);//将成员变量 mDataMimeType 赋值为 Cursor 中对应 DATA_MIME_TYPE_COLUMN 列的字符串值。”
+        mDataContent = c.getString(DATA_CONTENT_COLUMN);//“将成员变量 mDataContent 赋值为 Cursor 中对应 DATA_CONTENT_COLUMN 列的字符串值。”
+        mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);//将成员变量 mDataContentData1 赋值为 Cursor 中对应 DATA_CONTENT_DATA_1_COLUMN 列的长整型值。”
+
+        mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);//“将成员变量 mDataContentData3 赋值为 Cursor 中对应 DATA_CONTENT_DATA_3_COLUMN 列的字符串值。”
+    }
+
+    public void setContent(JSONObject js) throws JSONException {//“公共方法 setContent，接收一个 JSON 对象参数 js，可能抛出 JSON 异常。”
+        long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;//“如果 JSON 对象 js 包含键为 DataColumns.ID 的值，则将 dataId 赋值为该值的长整型，否则赋值为无效 ID（INVALID_ID）。”
+        if (mIsCreate || mDataId != dataId) {//“如果 JSON 对象 js 包含键为 DataColumns.ID 的值，则将 dataId 赋值为该值的长整型，否则赋值为无效 ID（INVALID_ID）。”
+            mDiffDataValues.put(DataColumns.ID, dataId);//将 dataId 放入成员变量 mDiffDataValues 的键为 DataColumns.ID 的位置。”
+        }
+        mDataId = dataId;//“将成员变量 mDataId 赋值为 dataId。”
+
+        String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
+                : DataConstants.NOTE;//“如果 JSON 对象 js 包含键为 DataColumns.MIME_TYPE 的值，则将 dataMimeType 赋值为该值的字符串，否则赋值为常量 NOTE。”
+        if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {//如果是创建状态或者成员变量 mDataMimeType 不等于 dataMimeType。”
+            mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);//将 dataMimeType 放入成员变量 mDiffDataValues 的键为 DataColumns.MIME_TYPE 的位置。”
+        }
+        mDataMimeType = dataMimeType;//“将成员变量 mDataMimeType 赋值为 dataMimeType。”
+
+        String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";//如果 JSON 对象 js 包含键为 DataColumns.CONTENT 的值，则将 dataContent 赋值为该值的字符串，否则赋值为空字符串。”
+        if (mIsCreate || !mDataContent.equals(dataContent)) {//“如果是创建状态或者成员变量 mDataContent 不等于 dataContent。”
+            mDiffDataValues.put(DataColumns.CONTENT, dataContent);//“将 dataContent 放入成员变量 mDiffDataValues 的键为 DataColumns.CONTENT 的位置。”
+        }
+        mDataContent = dataContent;//“将成员变量 mDataContent 赋值为 dataContent。”
+
+        long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;//“如果 JSON 对象 js 包含键为 DataColumns.DATA1 的值，则将 dataContentData1 赋值为该值的长整型，否则赋值为 0。”
+        if (mIsCreate || mDataContentData1 != dataContentData1) {//“如果是创建状态或者成员变量 mDataContentData1 不等于 dataContentData1。”
+            mDiffDataValues.put(DataColumns.DATA1, dataContentData1);//将 dataContentData1 放入成员变量 mDiffDataValues 的键为 DataColumns.DATA1 的位置。”
+        }
+        mDataContentData1 = dataContentData1;//将成员变量 mDataContentData1 赋值为 dataContentData1。”
+
+        String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";//“如果 JSON 对象 js 包含键为 DataColumns.DATA3 的值，则将 dataContentData3 赋值为该值的字符串，否则赋值为空字符串。”
+        if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {//如果是创建状态或者成员变量 mDataContentData3 不等于 dataContentData3。”
+            mDiffDataValues.put(DataColumns.DATA3, dataContentData3);//将 dataContentData3 放入成员变量 mDiffDataValues 的键为 DataColumns.DATA3 的位置。”
+        }
+        mDataContentData3 = dataContentData3;//“将成员变量 mDataContentData3 赋值为 dataContentData3。”
+    }
+
+    public JSONObject getContent() throws JSONException {//“公共方法 getContent，返回一个 JSON 对象，可能抛出 JSON 异常。”
+        if (mIsCreate) {//“如果是创建状态。”
+            Log.e(TAG, "it seems that we haven't created this in database yet");//使用错误级别记录日志，TAG 为标识，信息为‘it seems that we haven't created this in database yet’（看起来我们还没有在数据库中创建这个）。”
+            return null;//“返回 null。
+        }
+        JSONObject js = new JSONObject();//“返回 null。
+        js.put(DataColumns.ID, mDataId);//“将成员变量 mDataId 放入 JSON 对象 js 的键为 DataColumns.ID 的位置。”
+        js.put(DataColumns.MIME_TYPE, mDataMimeType);//将成员变量 mDataMimeType 放入 JSON 对象 js 的键为 DataColumns.MIME_TYPE 的位置。”
+        js.put(DataColumns.CONTENT, mDataContent);//“将成员变量 mDataContent 放入 JSON 对象 js 的键为 DataColumns.CONTENT 的位置。”
+        js.put(DataColumns.DATA1, mDataContentData1);//“将成员变量 mDataContentData1 放入 JSON 对象 js 的键为 DataColumns.DATA1 的位置。”
+        js.put(DataColumns.DATA3, mDataContentData3);//“将成员变量 mDataContentData3 放入 JSON 对象 js 的键为 DataColumns.DATA3 的位置。”
+        return js;//“返回 JSON 对象 js。”
+    }
+
+    public void commit(long noteId, boolean validateVersion, long version) {//“公共方法 commit，接收一个长整型 noteId、一个布尔型 validateVersion 和一个长整型 version。”
+
+        if (mIsCreate) {//“如果是创建状态。”
+            if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {//“如果数据 ID 为无效值且差异数据值（mDiffDataValues）中包含键为 DataColumns.ID。”
+                mDiffDataValues.remove(DataColumns.ID);//从差异数据值中移除键为 DataColumns.ID 的数据。
+            }
+
+            mDiffDataValues.put(DataColumns.NOTE_ID, noteId);//“将 noteId 放入差异数据值的键为 DataColumns.NOTE_ID 的位置。”
+            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);//“使用内容解析器插入数据到 Notes 的 CONTENT_DATA_URI，并将返回的 Uri 赋值给 uri。”
+            try {//“尝试执行以下代码块。”
+                mDataId = Long.valueOf(uri.getPathSegments().get(1));//“将 uri 的路径片段中的第二个值转换为长整型并赋值给数据 ID（mDataId）。”
+            } catch (NumberFormatException e) {//“捕获数字格式异常，如果发生异常执行以下代码块。”
+                Log.e(TAG, "Get note id error :" + e.toString());//“使用错误级别记录日志，TAG 为标识，信息为‘Get note id error :’加上异常信息。”
+                throw new ActionFailureException("create note failed");//抛出创建笔记失败的异常。”
+            }
+        } else {//“如果不是创建状态。
+            if (mDiffDataValues.size() > 0) {//如果差异数据值的大小大于 0。”
+                int result = 0;//初始化结果变量为 0。”
+                if (!validateVersion) {//“如果不验证版本。”
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);//使用内容解析器更新数据，将结果赋值给 result。
+                } 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)
+                            });//“使用内容解析器更新数据，带有版本验证，将结果赋值给 result。”
+                }
+                if (result == 0) {//“使用内容解析器更新数据，带有版本验证，将结果赋值给 result。”
+                    Log.w(TAG, "there is no update. maybe user updates note when syncing");//“使用警告级别记录日志，TAG 为标识，信息为‘there is no update. maybe user updates note when syncing’（没有更新。可能用户在同步时更新了笔记）。”
+                }
+            }
+        }
+
+        mDiffDataValues.clear();//“清空差异数据值。”
+        mIsCreate = false;//将创建状态设置为 false。”
+    }
+
+    public long getId() {//公共方法 getId，返回一个长整型。”
+        return mDataId;//返回数据 ID（mDataId）。”
+    }
+}

SqlNote.java

@@ -0,0 +1,518 @@
+/*
+ * 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;//包名为“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;//导入“Notes”类；
+import net.micode.notes.data.Notes.DataColumns;//导入“Notes”类的“DataColumns”内部类；
+ 
+import net.micode.notes.data.Notes.NoteColumns;//导入“Notes”类的“NoteColumns”内部类；
+import net.micode.notes.gtask.exception.ActionFailureException;//导入“gtask 操作失败异常”；
+import net.micode.notes.tool.GTaskStringUtils;//导入“Notes 工具类的字符串操作工具”；
+import net.micode.notes.tool.ResourceParser;//导入资源解析器；
+
+import org.json.JSONArray;//导入 JSON 数组；
+import org.json.JSONException;//导入 JSON 异常；
+import org.json.JSONObject;//导入 JSON 对象；
+
+import java.util.ArrayList;//导入数组列表。
+
+
+public class SqlNote {//：定义一个名为“SqlNote”的公共类；
+    private static final String TAG = SqlNote.class.getSimpleName();//定义一个静态字符串变量“tag”，其值为当前类的简单名称；
+
+    private static final int INVALID_ID = -99999;//定义一个静态整型常量“INVALID_ID”，其值为-99999；
+
+    public static final String[] PROJECTION_NOTE = new String[] {//定义一个公共静态字符串数组“PROJECTION_NOTE”，其中包含了一些列名；
+ 
+            NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,//“PROJECTION_NOTE”数组中的元素，包括“NoteColumns.ID”、“NoteColumns.ALERTED_DATE”和“NoteColumns.BG_COLOR_ID”；
+            NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,//定义“PROJECTION_NOTE”数组中的元素，包括“NoteColumns.CREATED_DATE”、“NoteColumns.HAS_ATTACHMENT”和“NoteColumns.MODIFIED_DATE”；
+            NoteColumns.NOTES_COUNT, NoteColumns.PARENT_ID, NoteColumns.SNIPPET, NoteColumns.TYPE,//定义“PROJECTION_NOTE”数组中的元素，包括“NoteColumns.NOTES_COUNT”、“NoteColumns.PARENT_ID”、“NoteColumns.SNIPPET”和“NoteColumns.TYPE”；
+            NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.SYNC_ID,//定义“PROJECTION_NOTE”数组中的元素，包括“NoteColumns.WIDGET_ID”、“NoteColumns.WIDGET_TYPE”和“NoteColumns.SYNC_ID”；
+            NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID,//定义“PROJECTION_NOTE”数组中的元素，包括“NoteColumns.LOCAL_MODIFIED”、“NoteColumns.ORIGIN_PARENT_ID”和“NoteColumns.GTASK_ID”；
+            NoteColumns.VERSION//定义“PROJECTION_NOTE”数组中的元素，包括“NoteColumns.VERSION”；
+    };
+
+    public static final int ID_COLUMN = 0;//定义一个公共静态整型常量“ID_COLUMN”，其值为 0；
+
+    public static final int ALERTED_DATE_COLUMN = 1;//定义一个公共静态整型常量“ALERTED_DATE_COLUMN”，其值为 1；
+
+    public static final int BG_COLOR_ID_COLUMN = 2;//定义一个公共静态整型常量“BG_COLOR_ID_COLUMN”，其值为 2；
+
+    public static final int CREATED_DATE_COLUMN = 3;//定义一个公共静态整型常量“CREATED_DATE_COLUMN”，其值为 3；
+
+    public static final int HAS_ATTACHMENT_COLUMN = 4;//定义一个公共静态整型常量“HAS_ATTACHMENT_COLUMN”，其值为 4；
+
+    public static final int MODIFIED_DATE_COLUMN = 5;//定义一个公共静态整型常量“MODIFIED_DATE_COLUMN”，其值为 5；
+
+    public static final int NOTES_COUNT_COLUMN = 6;//定义一个公共静态整型常量“NOTES_COUNT_COLUMN”，其值为 6；
+
+    public static final int PARENT_ID_COLUMN = 7;//定义一个公共静态整型常量“PARENT_ID_COLUMN”，其值为 7；
+ 
+
+    public static final int SNIPPET_COLUMN = 8;//定义一个公共静态整型常量“SNIPPET_COLUMN”，其值为 8；
+
+    public static final int TYPE_COLUMN = 9;//定义一个公共静态整型常量“TYPE_COLUMN”，其值为 9；
+
+    public static final int WIDGET_ID_COLUMN = 10;//定义一个公共静态整型常量“WIDGET_ID_COLUMN”，其值为 10；
+
+    public static final int WIDGET_TYPE_COLUMN = 11;//定义一个公共静态整型常量“WIDGET_TYPE_COLUMN”，其值为 11；
+
+    public static final int SYNC_ID_COLUMN = 12;//定义一个公共静态整型常量“SYNC_ID_COLUMN”，其值为 12；
+
+    public static final int LOCAL_MODIFIED_COLUMN = 13;//定义一个公共静态整型常量“LOCAL_MODIFIED_COLUMN”，其值为 13；
+
+    public static final int ORIGIN_PARENT_ID_COLUMN = 14;//定义一个公共静态整型常量“ORIGIN_PARENT_ID_COLUMN”，其值为 14；
+
+    public static final int GTASK_ID_COLUMN = 15;//定义一个公共静态整型常量“GTASK_ID_COLUMN”，其值为 15；
+
+    public static final int VERSION_COLUMN = 16;//定义一个公共静态整型常量“VERSION_COLUMN”，其值为 16；
+
+    private Context mContext;//定义一个私有成员变量“mContext”，其类型为“Context”；
+
+    private ContentResolver mContentResolver;//定义一个私有成员变量“mContentResolver”，其类型为“ContentResolver”；
+
+    private boolean mIsCreate;//定义一个私有成员变量“mIsCreate”，其类型为“boolean”；
+
+    private long mId;//定义一个私有成员变量“mId”，其类型为“long”；
+
+    private long mAlertDate;//定义一个私有成员变量“mAlertDate”，其类型为“long”；
+
+    private int mBgColorId;//定义一个私有成员变量“mBgColorId”，其类型为“int”；
+
+    private long mCreatedDate;//定义一个私有成员变量“mCreatedDate”，其类型为“long”；
+
+    private int mHasAttachment;//定义一个私有成员变量“mHasAttachment”，其类型为“int”；
+
+    private long mModifiedDate;//定义一个私有成员变量“mModifiedDate”，其类型为“long”；
+
+    private long mParentId;//定义一个私有成员变量“mParentId”，其类型为“long”；
+
+    private String mSnippet;//定义一个私有成员变量“mSnippet”，其类型为“String”；
+
+    private int mType;//定义一个私有成员变量“mType”，其类型为“int”；
+
+    private int mWidgetId;//定义一个私有成员变量“mWidgetId”，其类型为“int”；
+
+    private int mWidgetType;//定义一个私有成员变量“mWidgetType”，其类型为“int”；
+
+    private long mOriginParent;//定义一个私有成员变量“mOriginParent”，其类型为“long”；
+
+    private long mVersion;//定义一个私有成员变量“mVersion”，其类型为“long”；
+
+    private ContentValues mDiffNoteValues;//定义一个私有成员变量“mDiffNoteValues”，其类型为“ContentValues”；
+
+    private ArrayList<SqlData> mDataList;//定义一个私有成员变量“mDataList”，其类型为“ArrayList”；
+
+    public SqlNote(Context context) {//定义类的构造函数，接收一个“Context”类型的参数；
+        mContext = context;//在构造函数中，将传入的“context”赋值给成员变量“mContext”；
+        mContentResolver = context.getContentResolver();//获取“context”的内容解析器，并赋值给成员变量“mContentResolver”；
+        mIsCreate = true;//将成员变量“mIsCreate”设置为“true”，表示当前是创建新的笔记；
+        mId = INVALID_ID;//将成员变量“mId”设置为“INVALID_ID”，表示笔记的 ID 无效；
+        mAlertDate = 0;//将成员变量“mAlertDate”设置为 0，表示笔记的提醒日期为 0；
+        mBgColorId = ResourceParser.getDefaultBgId(context);//获取默认的背景颜色 ID，并赋值给成员变量“mBgColorId”；
+        mCreatedDate = System.currentTimeMillis();//获取当前系统时间，并赋值给成员变量“mCreatedDate”，表示笔记的创建日期；
+        mHasAttachment = 0;//将成员变量“mHasAttachment”设置为 0，表示笔记没有附件；
+        mModifiedDate = System.currentTimeMillis();//获取当前系统时间，并赋值给成员变量“mModifiedDate”，表示笔记的修改日期；
+        mParentId = 0;//“mParentId”设置为 0，表示笔记的父 ID 为 0；
+        mSnippet = "";//将成员变量“mSnippet”设置为空字符串，表示笔记的片段为空；
+        mType = Notes.TYPE_NOTE;//Notes.TYPE_NOTE”，表示笔记的类型为普通笔记；
+ 
+        mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;//将成员变量“mWidgetId”设置为“AppWidgetManager.INVALID_APPWIDGET_ID”，表示笔记的小部件 ID 无效；
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;//将成员变量“mWidgetType”设置为“Notes.TYPE_WIDGET_INVALIDE”，表示笔记的小部件类型无效；
+        mOriginParent = 0;//将成员变量“mOriginParent”设置为 0，表示笔记的原始父 ID 为 0；
+        mVersion = 0;//将成员变量“mVersion”设置为 0，表示笔记的版本号为 0；
+        mDiffNoteValues = new ContentValues();//创建一个新的“ContentValues”对象，并赋值给成员变量“mDiffNoteValues”；
+        mDataList = new ArrayList<SqlData>();//创建一个新的“ArrayList”对象，并赋值给成员变量“mDataList”；
+    }
+
+    public SqlNote(Context context, Cursor c) {//定义类的另一个构造函数，接收一个“Context”类型的参数和一个“Cursor”类型的参数；
+        mContext = context;//在构造函数中，将传入的“context”赋值给成员变量“mContext”；
+        mContentResolver = context.getContentResolver();//获取“context”的内容解析器，并赋值给成员变量“mContentResolver”；
+ 
+        mIsCreate = false;//将成员变量“mIsCreate”设置为“false”，表示当前不是创建新的笔记；
+        loadFromCursor(c);//调用“loadFromCursor”方法，从“Cursor”中加载笔记的数据；
+        mDataList = new ArrayList<SqlData>();//创建一个新的“ArrayList”对象，并赋值给成员变量“mDataList”；
+        if (mType == Notes.TYPE_NOTE)//如果笔记的类型为普通笔记，则调用“loadDataContent”方法加载笔记的数据内容；
+            loadDataContent();
+        mDiffNoteValues = new ContentValues();//创建一个新的“ContentValues”对象，并赋值给成员变量“mDiffNoteValues”
+    }
+
+    public SqlNote(Context context, long id) {//定义类的另一个构造函数，接收一个“Context”类型的参数和一个“long”类型的参数；
+        mContext = context;//在构造函数中，将传入的“context”赋值给成员变量“mContext”；
+        mContentResolver = context.getContentResolver();//获取“context”的内容解析器，并赋值给成员变量“mContentResolver”；
+        mIsCreate = false;//：将成员变量“mIsCreate”设置为“false”，表示当前不是创建新的笔记；
+        loadFromCursor(id);//调用“loadFromCursor”方法，根据“id”从数据库中加载笔记的数据；
+        mDataList = new ArrayList<SqlData>();//创建一个新的“ArrayList”对象，并赋值给成员变量“mDataList”；
+        if (mType == Notes.TYPE_NOTE)//如果笔记的类型为普通笔记，则调用“loadDataContent”方法加载笔记的数据内容；
+            loadDataContent();
+        mDiffNoteValues = new ContentValues();//创建一个新的“ContentValues”对象，并赋值给成员变量“mDiffNoteValues”
+
+    }
+
+    private void loadFromCursor(long id) {//定义一个私有方法“loadFromCursor”，接收一个“long”类型的参数；
+        Cursor c = null;//声明一个“Cursor”类型的变量“c”，并初始化为“null”；
+        try {
+            c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",//使用“mContentResolver”查询“Notes.CONTENT_NOTE_URI”表，获取指定“id”的笔记数据，并将结果存储在“c”中；
+                    new String[] {//设置查询条件的参数值；
+                        String.valueOf(id)//将“id”转换为字符串，并作为查询条件的参数值；
+                    }, null);//设置查询的排序方式为“null”；
+ 
+            if (c != null) {//如果“c”不为“null”，则执行以下操作；
+                c.moveToNext();//将游标移动到下一条记录；
+                loadFromCursor(c);//调用“loadFromCursor”方法，从游标中加载笔记的数据；
+            } else {//如果“c”为“null”，则执行以下操作；
+                Log.w(TAG, "loadFromCursor: cursor = null");//输出日志信息，提示游标为空；
+            }
+        } finally {//V在“finally”代码块中，执行以下操作；
+            if (c != null)//如果“c”不为“null”，则执行以下操作；
+                c.close();//关闭游标；
+        }
+    }
+
+    private void loadFromCursor(Cursor c) {//定义一个私有方法“loadFromCursor”，接收一个“Cursor”类型的参数；
+        mId = c.getLong(ID_COLUMN);//从游标中获取“ID_COLUMN”列的值，并赋值给成员变量“mId”；
+        mAlertDate = c.getLong(ALERTED_DATE_COLUMN);//从游标中获取“ALERTED_DATE_COLUMN”列的值，并赋值给成员变量“mAlertDate”；
+        mBgColorId = c.getInt(BG_COLOR_ID_COLUMN);//从游标中获取“BG_COLOR_ID_COLUMN”列的值，并赋值给成员变量“mBgColorId”；
+        mCreatedDate = c.getLong(CREATED_DATE_COLUMN);//从游标中获取“CREATED_DATE_COLUMN”列的值，并赋值给成员变量“mCreatedDate”；
+        mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN);//从游标中获取“HAS_ATTACHMENT_COLUMN”列的值，并赋值给成员变量“mHasAttachment”；
+        mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN);//从游标中获取“MODIFIED_DATE_COLUMN”列的值，并赋值给成员变量“mModifiedDate”；
+        mParentId = c.getLong(PARENT_ID_COLUMN);//从游标中获取“PARENT_ID_COLUMN”列的值，并赋值给成员变量“mParentId”；
+        mSnippet = c.getString(SNIPPET_COLUMN);//从游标中获取“SNIPPET_COLUMN”列的值，并赋值给成员变量“mSnippet”；
+ 
+        mType = c.getInt(TYPE_COLUMN);//：从游标中获取“TYPE_COLUMN”列的值，并赋值给成员变量“mType”；
+        mWidgetId = c.getInt(WIDGET_ID_COLUMN);//从游标中获取“WIDGET_ID_COLUMN”列的值，并赋值给成员变量“mWidgetId”；
+ 
+        mWidgetType = c.getInt(WIDGET_TYPE_COLUMN);//从游标中获取“WIDGET_TYPE_COLUMN”列的值，并赋值给成员变量“mWidgetType”
+        mVersion = c.getLong(VERSION_COLUMN);//从游标中获取“VERSION_COLUMN”列的值，并赋值给成员变量“mVersion”；
+    }
+
+    private void loadDataContent() {//定义一个私有方法“loadDataContent”；
+        Cursor c = null;//明一个“Cursor”类型的变量“c”，并初始化为“null”；
+        mDataList.clear();//清空“mDataList”列表；
+        try {在“try”代码块中，执行以下操作；
+            c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,//使用“mContentResolver”查询“Notes.CONTENT_DATA_URI”表，获取指定笔记的“SqlData”数据，并将结果存储在“c”中；
+                    "(note_id=?)", new String[] {
+                        String.valueOf(mId)// //是一个字符串数组，用于在数据库查询中指定条件。其中， note_id=?  是查询条件，表示要查找的笔记的 ID 为指定的值； new String[] { String.valueOf(mId) }  是条件的值，将当前笔记的 ID 转换为字符串并作为查询条件的值； null  表示不指定排序方式。
+                    }, null);
+                   
+            if (c != null) {//如果游标不为空，则执行以下操作。
+                if (c.getCount() == 0) {//如果游标中的行数为 0，则表示该笔记似乎没有数据。
+                    Log.w(TAG, "it seems that the note has not data");//：输出一条警告日志，提示该笔记似乎没有数据。
+                    return;
+                }
+                while (c.moveToNext()) {//当游标可以向下移动时，执行以下循环。
+                    SqlData data = new SqlData(mContext, c);//创建一个新的  SqlData  对象，用于表示当前游标指向的数据。
+                    mDataList.add(data);//将新创建的  SqlData  对象添加到  mDataList  列表中。
+                }
+            } else {//如果游标为空，则执行以下操作。
+                Log.w(TAG, "loadDataContent: cursor = null");//输出一条警告日志，提示游标为空。
+            }
+        } finally {//无论游标是否为空，都执行以下操作。
+            if (c != null)
+                c.close();//如果游标不为空，则关闭游标。
+        }
+    }
+
+    public boolean setContent(JSONObject js) {
+        try {
+            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);//从传入的  JSONObject  中获取名为  GTaskStringUtils.META_HEAD_NOTE  的子对象，并将其赋值给  note  变量。
+            if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {//如果  note  对象的  type  字段的值为  Notes.TYPE_SYSTEM ，则表示这是一个系统文件夹，不能进行设置操作。
+                Log.w(TAG, "cannot set system folder");//输出一条警告日志，提示不能设置系统文件夹。
+            } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {//如果  note  对象的  type  字段的值为  Notes.TYPE_FOLDER ，则表示这是一个文件夹，可以进行设置操作，但只能更新  snippet  和  type  字段。
+                // for folder we can only update the snnipet and type
+                String snippet = note.has(NoteColumns.SNIPPET) ? note
+                        .getString(NoteColumns.SNIPPET) : "";//获取  note  对象的  snippet  字段的值，如果该字段不存在，则使用空字符串作为默认值。
+                if (mIsCreate || !mSnippet.equals(snippet)) {//如果当前是创建新笔记，或者当前的  snippet  值与从  note  对象中获取的  snippet  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);//将  snippet  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+                }
+                mSnippet = snippet;//将从  note  对象中获取的  snippet  值赋值给当前笔记的  snippet  字段。
+
+                int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
+                        : Notes.TYPE_NOTE;//Notes.TYPE_NOTE; ：获取  note  对象的  type  字段的值，如果该字段不存在，则使用  Notes.TYPE_NOTE  作为默认值。
+                if (mIsCreate || mType != type) {//如果当前是创建新笔记，或者当前的  type  值与从  note  对象中获取的  type  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.TYPE, type);//将  type  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+                }
+                mType = type;//将从  note  对象中获取的  type  值赋值给当前笔记的  type  字段。
+            } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {//如果  note  对象的  type  字段的值为  Notes.TYPE_NOTE ，则表示这是一个普通笔记，可以进行设置操作。
+                JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);//从传入的  JSONObject  中获取名为  GTaskStringUtils.META_HEAD_DATA  的子对象，并将其转换为  JSONArray  类型。
+                long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;//获取  note  对象的  id  字段的值，如果该字段不存在，则使用  INVALID_ID  作为默认值。
+                if (mIsCreate || mId != id) {//如果当前是创建新笔记，或者当前的  id  值与从  note  对象中获取的  id  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.ID, id);//将  id  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+                }
+                mId = id;//将从  note  对象中获取的  id  值赋值给当前笔记的  id  字段。
+
+                long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note
+                        .getLong(NoteColumns.ALERTED_DATE) : 0;//获取  note  对象的  alertDate  字段的值，如果该字段不存在，则使用 0 作为默认值。
+                if (mIsCreate || mAlertDate != alertDate) {//如果当前是创建新笔记，或者当前的  alertDate  值与从  note  对象中获取的  alertDate  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);//将  alertDate  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+3
+                }
+                mAlertDate = alertDate;//将从  note  对象中获取的  alertDate  值赋值给当前笔记的  alertDate  字段。
+
+                int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note
+                        .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);//获取  note  对象的  bgColorId  字段的值，如果该字段不存在，则使用默认的背景颜色 ID。
+                if (mIsCreate || mBgColorId != bgColorId) {//如果当前是创建新笔记，或者当前的  bgColorId  值与从  note  对象中获取的  bgColorId  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);//将  bgColorId  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+。
+                }
+                mBgColorId = bgColorId;//将从  note  对象中获取的  bgColorId  值赋值给当前笔记的  bgColorId  字段。
+
+                long createDate = note.has(NoteColumns.CREATED_DATE) ? note
+                        .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();//获取  note  对象的  createDate  字段的值，如果该字段不存在，则使用当前时间作为默认值。
+                if (mIsCreate || mCreatedDate != createDate) {//如果当前是创建新笔记，或者当前的  createdDate  值与从  note  对象中获取的  createdDate  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);//将  createdDate  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+                }
+                mCreatedDate = createDate;//将从  note  对象中获取的  createdDate  值赋值给当前笔记的  createdDate  字段。
+
+                int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note
+                        .getInt(NoteColumns.HAS_ATTACHMENT) : 0;//获取  note  对象的  hasAttachment  字段的值，如果该字段不存在，则使用 0 作为默认值。
+                if (mIsCreate || mHasAttachment != hasAttachment) {//如果当前是创建新笔记，或者当前的  hasAttachment  值与从  note  对象中获取的  hasAttachment  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);//将  hasAttachment  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+                }
+                mHasAttachment = hasAttachment;//将从  note  对象中获取的  hasAttachment  值赋值给当前笔记的  hasAttachment  字段。
+
+                long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note
+                        .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();//获取  note  对象的  modifiedDate  字段的值，如果该字段不存在，则使用当前时间作为默认值。
+                if (mIsCreate || mModifiedDate != modifiedDate) {//如果当前是创建新笔记，或者当前的  modifiedDate  值与从  note  对象中获取的  modifiedDate  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);//将  modifiedDate  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+                }
+                mModifiedDate = modifiedDate;//将从  note  对象中获取的  modifiedDate  值赋值给当前笔记的  modifiedDate  字段。
+
+                long parentId = note.has(NoteColumns.PARENT_ID) ? note
+                        .getLong(NoteColumns.PARENT_ID) : 0;//获取  note  对象的  parentId  字段的值，如果该字段不存在，则使用 0 作为默认值。
+                if (mIsCreate || mParentId != parentId) {//如果当前是创建新笔记，或者当前的  parentId  值与从  note  对象中获取的  parentId  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);//将  parentId  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+
+                }
+                mParentId = parentId;//将从  note  对象中获取的  parentId  值赋值给当前笔记的  parentId  字段。
+
+                String snippet = note.has(NoteColumns.SNIPPET) ? note
+                        .getString(NoteColumns.SNIPPET) : "";//获取  note  对象的  snippet  字段的值，如果该字段不存在，则使用空字符串作为默认值。
+                if (mIsCreate || !mSnippet.equals(snippet)) {//如果当前是创建新笔记，或者当前的  snippet  值与从  note  对象中获取的  snippet  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);//将  snippet  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+                }
+                mSnippet = snippet;//将从  note  对象中获取的  snippet  值赋值给当前笔记的  snippet  字段。
+
+                int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
+                        : Notes.TYPE_NOTE;//获取  note  对象的  type  字段的值，如果该字段不存在，则使用  Notes.TYPE_NOTE  作为默认值。
+                if (mIsCreate || mType != type) {//如果当前是创建新笔记，或者当前的  type  值与从  note  对象中获取的  type  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.TYPE, type);//将  type  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+                }
+                mType = type;//从  note  对象中获取的  type  值赋值给当前笔记的  type  字段。
+
+                int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)
+                        : AppWidgetManager.INVALID_APPWIDGET_ID;.//获取  note  对象的  widgetId  字段的值，如果该字段不存在，则使用无效的小部件 ID 作为默认值。
+                if (mIsCreate || mWidgetId != widgetId) {//如果当前是创建新笔记，或者当前的  widgetId  值与从  note  对象中获取的  widgetId  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);//将  widgetId  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+                }
+                mWidgetId = widgetId;//将从  note  对象中获取的  widgetId  值赋值给当前笔记的  widgetId  字段。
+
+                int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
+                        .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;//获取  note  对象的  widgetType  字段的值，如果该字段不存在，则使用无效的小部件类型作为默认值。
+                if (mIsCreate || mWidgetType != widgetType) {//如果当前是创建新笔记，或者当前的  widgetType  值与从  note  对象中获取的  widgetType  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);//将  widgetType  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+                }
+                mWidgetType = widgetType;//将从  note  对象中获取的  widgetType  值赋值给当前笔记的  widgetType  字段。
+
+                long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
+                        .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;//获取  note  对象的  originParent  字段的值，如果该字段不存在，则使用 0 作为默认值。
+                if (mIsCreate || mOriginParent != originParent) {//如果当前是创建新笔记，或者当前的  originParent  值与从  note  对象中获取的  originParent  值不相等，则执行以下操作。
+                    mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);//将  originParent  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。
+                }
+                mOriginParent = originParent;//将从  note  对象中获取的  originParent  值赋值给当前笔记的  originParent  字段。
+
+                for (int i = 0; i < dataArray.length(); i++) {//遍历  dataArray  数组，对每个元素执行以下操作。
+                    JSONObject data = dataArray.getJSONObject(i);//获取当前元素，并将其转换为  JSONObject  类型。
+                    SqlData sqlData = null;.//创建一个  SqlData  对象，并将其初始化为  null 。
+                    if (data.has(DataColumns.ID)) {//如果  data  对象包含名为  DataColumns.ID  的字段，则执行以下操作
+                        long dataId = data.getLong(DataColumns.ID);//获取该字段的值，并将其转换为  long  类型。
+                        for (SqlData temp : mDataList) {//遍历  mDataList  列表，对每个元素执行以下操作。
+                            if (dataId == temp.getId()) {//如果当前元素的  id  值与  dataId  相等，则执行以下操作。
+                                sqlData = temp;//将当前元素赋值给  sqlData  变量。
+                            }
+                        }
+                    }
+
+                    if (sqlData == null) {//如果  sqlData  变量仍然为  null ，则执行以下操作。
+                        sqlData = new SqlData(mContext);//创建一个新的  SqlData  对象，并将其赋值给  sqlData  变量。
+                        mDataList.add(sqlData);//新创建的  SqlData  对象添加到  mDataList  列表中。
+                    }
+
+                    sqlData.setContent(data);//将 data 的内容设置到 sqlData 中。
+                }
+            }
+        } catch (JSONException e) {//如果在解析 JSONObject 时发生 JSONException 异常，则执行以下操作。
+            Log.e(TAG, e.toString());//使用 Log.e 方法输出错误日志，其中包含异常的详细信息。
+            e.printStackTrace();//打印异常的堆栈跟踪信息。
+            return false;//返回 false ，表示设置内容失败。
+        }
+        return true;//返回 true ，表示设置内容成功。
+    }
+
+    public JSONObject getContent() {//定义一个公共方法 getContent ，用于获取笔记的内容。
+        try {//在 try 代码块中执行以下操作。
+            JSONObject js = new JSONObject();//创建一个新的 JSONObject 对象 js 。
+
+            if (mIsCreate) {//如果笔记是新创建的，则执行以下操作。
+                Log.e(TAG, "it seems that we haven't created this in database yet");//输出一条错误日志，提示笔记似乎还没有在数据库中创建。
+                return null;//返回 null ，表示获取内容失败。
+            }
+
+            JSONObject note = new JSONObject();//创建一个新的 JSONObject 对象 note 。
+            if (mType == Notes.TYPE_NOTE) {//如果笔记的类型是普通笔记，则执行以下操作。
+                note.put(NoteColumns.ID, mId);//将笔记的 ID 添加到 note 对象中。
+                note.put(NoteColumns.ALERTED_DATE, mAlertDate);//将笔记的提醒日期添加到 note 对象中。
+                note.put(NoteColumns.BG_COLOR_ID, mBgColorId);//将笔记的背景颜色 ID 添加到 note 对象中。
+                note.put(NoteColumns.CREATED_DATE, mCreatedDate);//将笔记的创建日期添加到 note 对象中。
+                note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment);//将笔记是否有附件添加到 note 对象中。
+                note.put(NoteColumns.MODIFIED_DATE, mModifiedDate);//将笔记的修改日期添加到 note 对象中。
+                note.put(NoteColumns.PARENT_ID, mParentId);//将笔记的父 ID 添加到 note 对象中。
+                note.put(NoteColumns.SNIPPET, mSnippet);//将笔记的片段添加到 note 对象中。
+                note.put(NoteColumns.TYPE, mType);//将笔记的类型添加到 note 对象中。
+                note.put(NoteColumns.WIDGET_ID, mWidgetId);//将笔记的小部件 ID 添加到 note 对象中。
+                note.put(NoteColumns.WIDGET_TYPE, mWidgetType);//将笔记的小部件类型添加到 note 对象中。
+                note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);//将笔记的原始父 ID 添加到 note 对象中。
+                js.put(GTaskStringUtils.META_HEAD_NOTE, note);//将 note 对象添加到 js 对象中，键为 GTaskStringUtils.META_HEAD_NOTE 。
+
+                JSONArray dataArray = new JSONArray();//创建一个新的 JSONArray 对象 dataArray 。
+                for (SqlData sqlData : mDataList) {//遍历 mDataList 列表中的每个 SqlData 对象。
+                    JSONObject data = sqlData.getContent();//获取当前 SqlData 对象的内容，并将其转换为 JSONObject 对象。
+                    if (data != null) {//如果 data 对象不为 null ，则执行以下操作。
+                        dataArray.put(data);//将 data 对象添加到 dataArray 对象中。
+                    }
+                }
+                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);//将 dataArray 对象添加到 js 对象中，键为 GTaskStringUtils.META_HEAD_DATA 。
+            } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {//如果笔记的类型是文件夹或系统文件夹，则执行以下操作。
+                note.put(NoteColumns.ID, mId);//将笔记的 ID 添加到 note 对象中。
+                note.put(NoteColumns.TYPE, mType);//将笔记的类型添加到 note 对象中。
+                note.put(NoteColumns.SNIPPET, mSnippet);//将笔记的片段添加到 note 对象中。
+                js.put(GTaskStringUtils.META_HEAD_NOTE, note);//：将 note 对象添加到 js 对象中，键为 GTaskStringUtils.META_HEAD_NOTE 。
+            }
+
+            return js;//返回 js 对象，其中包含笔记的内容。
+        } catch (JSONException e) {//如果在创建 JSONObject 或 JSONArray 时发生 JSONException 异常，则执行以下操作。
+            Log.e(TAG, e.toString());//使用 Log.e 方法输出错误日志，其中包含异常的详细信息。
+            e.printStackTrace();//打印异常的堆栈跟踪信息。
+        }
+        return null;//返回 null ，表示获取内容失败。
+    }
+
+    public void setParentId(long id) {//定义一个公共方法 setParentId ，用于设置笔记的父 ID 。
+        mParentId = id;//将 id 赋值给成员变量 mParentId 。
+        mDiffNoteValues.put(NoteColumns.PARENT_ID, id);//将 id 添加到 mDiffNoteValues 对象中，以便在提交更改时更新数据库中的父 ID 
+    }
+
+    public void setGtaskId(String gid) {//定义一个公共方法 setGtaskId ，用于设置笔记的 gtask_id 。
+        mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);//将 gid 添加到 mDiffNoteValues 对象中，以便在提交更改时更新数据库中的 gtask_id 。
+    }
+
+    public void setSyncId(long syncId) {//定义一个公共方法 setSyncId ，用于设置笔记的同步 ID 。
+        mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);//将 syncId 添加到 mDiffNoteValues 对象中，以便在提交更改时更新数据库中的同步 ID 。
+    }
+
+    public void resetLocalModified() {//定义一个公共方法 resetLocalModified ，用于重置笔记的本地修改状态。
+        mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);//将 0 添加到 mDiffNoteValues 对象中，以便在提交更改时将本地修改状态重置为 false 。
+    }
+
+    public long getId() {//定义一个公共方法 getId ，用于获取笔记的 ID 。
+
+        return mId;//返回成员变量 mId 的值，即笔记的 ID 。
+    }
+
+    public long getParentId() {//定义一个公共方法 getParentId ，用于获取笔记的父 ID 。
+        return mParentId;//返回成员变量 mParentId 的值，即笔记的父 ID 。
+    }
+
+    public String getSnippet() {//定义一个公共方法 getSnippet ，用于获取笔记的片段。
+        return mSnippet;//返回成员变量 mSnippet 的值，即笔记的片段。
+    }
+
+    public boolean isNoteType() {//定义一个公共方法 isNoteType ，用于判断笔记是否为普通笔记。
+        return mType == Notes.TYPE_NOTE;//返回一个布尔值，表示笔记的类型是否为普通笔记。
+    }
+
+    public void commit(boolean validateVersion) {//定义一个公共方法 commit ，用于提交笔记的更改。
+        if (mIsCreate) {//如果笔记是新创建的，则执行以下操作。
+            if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {//如果笔记的 ID 为无效值（ INVALID_ID ），并且 mDiffNoteValues 对象中包含 NoteColumns.ID 键，则执行以下操作。
+                mDiffNoteValues.remove(NoteColumns.ID);//从 mDiffNoteValues 对象中删除 NoteColumns.ID 键及其对应的值。
+            }
+
+            Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);//使用 mContentResolver 对象的 insert 方法将 mDiffNoteValues 对象中的数据插入到数据库中，并获取插入后生成的 Uri 对象。
+            try {//在 try 代码块中执行以下操作。
+                mId = Long.valueOf(uri.getPathSegments().get(1));//从 uri 对象中获取路径段的第二个元素，并将其转换为 long 类型，然后赋值给成员变量 mId 。
+            } catch (NumberFormatException e) {//如果在将路径段元素转换为 long 类型时发生 NumberFormatException 异常，则执行以下操作
+                Log.e(TAG, "Get note id error :" + e.toString());//使用 Log.e 方法输出错误日志，其中包含异常的详细信息。
+                throw new ActionFailureException("create note failed");//抛出一个 ActionFailureException 异常，提示创建笔记失败。
+            }
+            if (mId == 0) {//如果笔记的 ID 为 0，则执行以下操作。
+                throw new IllegalStateException("Create thread id failed");//出一个 IllegalStateException 异常，提示创建线程 ID 失败。
+            }
+
+            if (mType == Notes.TYPE_NOTE) {//果笔记的类型是普通笔记，则执行以下操作。
+                for (SqlData sqlData : mDataList) {//遍历 mDataList 列表中的每个 SqlData 对象。
+                    sqlData.commit(mId, false, -1);//调用 sqlData 对象的 commit 方法，将笔记的 ID 、是否验证版本和版本号作为参数传递给该方法。
+                }
+            }
+        } else {//如果笔记不是新创建的，则执行以下操作。
+            if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {//如果笔记的 ID 小于等于 0，并且不等于根文件夹 ID 和通话记录文件夹 ID ，则执行以下操作。
+                Log.e(TAG, "No such note");//使用 Log.e 方法输出错误日志，提示没有找到这样的笔记。
+                throw new IllegalStateException("Try to update note with invalid id");//抛出一个 IllegalStateException 异常，提示尝试使用无效的 ID 更新笔记。
+            }
+            if (mDiffNoteValues.size() > 0) {//如果 mDiffNoteValues 对象中包含的键值对数量大于 0，则执行以下操作。
+                mVersion ++;//将成员变量 mVersion 的值加 1。
+                int result = 0;//定义一个整型变量 result ，并将其初始化为 0。
+                if (!validateVersion) {//如果不验证版本，则执行以下操作。
+                    result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+                            + NoteColumns.ID + "=?)", new String[] {
+                        String.valueOf(mId)
+                    });//使用 mContentResolver 对象的 update 方法更新数据库中的笔记数据，将 mDiffNoteValues 对象中的键值对作为更新的数据， NoteColumns.ID 作为条件， mId 作为条件的值。
+                } else {
+                    result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+                            + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
+                            new String[] {
+                                    String.valueOf(mId), String.valueOf(mVersion)
+                            });//使用 mContentResolver 对象的 update 方法更新数据库中的笔记数据，将 mDiffNoteValues 对象中的键值对作为更新的数据， NoteColumns.ID 和 NoteColumns.VERSION 作为条件， mId 和 mVersion 作为条件的值。
+                }
+                if (result == 0) {//如果更新操作没有成功执行（即更新的行数为 0），则执行以下操作。
+                    Log.w(TAG, "there is no update. maybe user updates note when syncing");//使用 Log.w 方法输出警告日志，提示没有更新笔记，可能是用户在同步时更新了笔记。
+                }
+            }
+
+            if (mType == Notes.TYPE_NOTE) {//如果笔记的类型是普通笔记，则执行以下操作。
+                for (SqlData sqlData : mDataList) {//遍历 mDataList 列表中的每个 SqlData 对象。
+                    sqlData.commit(mId, validateVersion, mVersion);//调用 sqlData 对象的 commit 方法，将笔记的 ID 、是否验证版本和版本号作为参数传递给该方法。
+                }
+            }
+        }
+
+        // refresh local info
+        loadFromCursor(mId);//从数据库中加载笔记的最新信息。
+        if (mType == Notes.TYPE_NOTE)//如果笔记的类型是普通笔记，则执行以下操作。
+            loadDataContent();//加载笔记的数据内容。
+
+        mDiffNoteValues.clear();//清空 mDiffNoteValues 对象中的键值对。
+        mIsCreate = false;//将成员变量 mIsCreate 的值设置为 false ，表示笔记不再是新创建的。
+    }
+}

Task.java

@@ -0,0 +1,393 @@
+/*
+ * 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;//定义了该Java类所属的包名为net.micode.notes.gtask.data
+
+import android.database.Cursor;//引入Android数据库游标（Cursor）类，用于在数据库查询结果中遍历数据
+import android.text.TextUtils;//引入Android的文本工具类TextUtils，它提供了一些处理文本的实用方法，比如判断文本是否为空等操作
+import android.util.Log;//引入Android的日志工具类Log，用于在应用程序中输出日志信息，方便调试等用途
+
+import net.micode.notes.data.Notes;//入名为Notes的类，它应该是来自net.micode.notes.data包下的，可能用于处理笔记相关的数据或操作
+import net.micode.notes.data.Notes.DataColumns;//引入Notes类中的DataColumns内部类或静态成员类，可能定义了与数据列相关的常量或属性，用于在数据库操作等场景下明确数据列的标识
+import net.micode.notes.data.Notes.DataConstants;//引入Notes类中的DataConstants内部类或静态成员类，可能包含了一些与数据相关的常量定义，用于在整个应用程序中统一使用这些常量值来表示特定的数据相关概念
+import net.micode.notes.data.Notes.NoteColumns;//引入Notes类中的NoteColumns内部类或静态成员类，可能用于定义笔记相关的数据列信息，比如笔记的标题、内容等各列在数据库中的标识等
+import net.micode.notes.gtask.exception.ActionFailureException;//引入名为ActionFailureException的异常类，它应该是来自net.micode.notes.gtask.exception包下的，用于在特定操作失败时抛出相应的异常以便进行错误处理
+import net.micode.notes.tool.GTaskStringUtils;//引入名为GTaskStringUtils的工具类，它应该是来自net.micode.notes.tool包下的，可能提供了一些与处理字符串相关的实用方法，用于在与GTask相关的字符串操作场景中使用
+
+import org.json.JSONArray;//引入JSON数组处理类JSONArray，用于在Java程序中处理JSON格式数据中的数组类型数据
+import org.json.JSONException;//引入JSON异常处理类JSONException，用于在处理JSON数据时捕获可能出现的异常，比如JSON格式不正确等情况导致的异常
+import org.json.JSONObject;//引入JSON对象处理类JSONObject，用于在Java程序中处理JSON格式数据中的对象类型数据
+
+
+public class Task extends Node {//    // 定义一个公共的类Task，它继承自Node类
+    private static final String TAG = Task.class.getSimpleName(); // 定义一个私有静态常量TAG，其值为Task类的简单名称（即类名本身，不包含包名等），通常用于在日志输出等场景中标识当前类
+
+    private boolean mCompleted;// 定义一个私有布尔型变量mCompleted，用于表示任务是否已完成
+
+    private String mNotes; // 定义一个私有字符串变量mNotes，可能用于存储与任务相关的备注信息
+
+    private JSONObject mMetaInfo; // 定义一个私有JSONObject类型的变量mMetaInfo，可能用于存储任务的一些元信息（以JSON对象的形式）
+
+    private Task mPriorSibling;// 定义一个私有Task类型的变量mPriorSibling，用于指向当前任务的前一个兄弟任务（在任务列表等场景下，同一层级的前一个任务）
+
+    private TaskList mParent; // 定义一个私有TaskList类型的变量mParent，用于指向当前任务所属的任务列表（即当前任务的父级任务列表对象）
+
+    public Task() {// 定义Task类的构造函数
+        super();// 调用父类（Node类）的构造函数
+
+        mCompleted = false;// 将任务完成状态mCompleted初始化为false，表示任务初始未完成
+        mNotes = null; // 将任务备注信息mNotes初始化为null
+        mPriorSibling = null; // 将前一个兄弟任务mPriorSibling初始化为null
+        mParent = null;// 将所属任务列表mParent初始化为null
+        mMetaInfo = null; // 将任务元信息mMetaInfo初始化为null
+    }
+
+    public JSONObject getCreateAction(int actionId) {// 定义一个公共方法getCreateAction，它接受一个整数类型的参数actionId，用于生成创建任务的相关操作信息（以JSONObject的形式返回）
+        JSONObject js = new JSONObject();// 创建一个新的JSONObject对象js，用于构建要返回的操作信息
+
+        try {     // 开始一个try块，用于捕获可能出现的JSONException异常
+            // action_type
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
+                       // 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ACTION_TYPE（通过工具类GTaskStringUtils获取的表示操作类型的常量字符串），
+            // 值为GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE（同样通过工具类获取的表示创建操作类型的常量字符串），用于标识此次操作是创建任务的操作类型
+
+            // action_id
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+
+            // index
+            js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
+ // 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ACTION_ID（通过工具类获取的表示操作ID的常量字符串），
+            // 值为传入的参数actionId，用于标识此次创建任务操作的唯一ID
+            // entity_delta
+            JSONObject entity = new JSONObject();
+              // 创建一个新的JSONObject对象entity，用于构建任务实体相关的差异信息（在创建或更新任务等操作中，可能用于表示任务实体的新增、修改等情况的信息）
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());// 在entity这个JSONObject对象中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_CREATOR_ID（通过工具类获取的表示创建者ID的常量字符串），
+            
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");// 值为字符串"null"，可能用于表示当前任务创建者的ID信息，这里暂时设置为"null"（具体含义可能根据业务逻辑而定）
+            entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_TASK); // 在entity这个JSONObject对象中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ENTITY_TYPE（通过工具类获取的表示实体类型的常量字符串），      
+            // 值为GTaskStringUtils.GTASK_JSON_TYPE_TASK（通过工具类获取的表示任务类型的常量字符串），用于明确当前实体是任务类型
+            if (getNotes() != null) {
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
+            }
+            // 如果通过调用getNotes方法（获取任务备注信息的方法）得到的结果不为null，就在entity这个JSONObject对象中添加一个键值对，
+            // 键为GTaskStringUtils.GTASK_JSON_NOTES（通过工具类获取的表示任务备注的常量字符串），值为通过getNotes方法得到的任务备注信息
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ENTITY_DELTA（通过工具类获取的表示实体差异的常量字符串），
+            // 值为前面构建好的entity这个JSONObject对象，用于将任务实体相关的差异信息添加到整体的操作信息中
+            // parent_id
+            js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
+// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_PARENT_ID（通过工具类获取的表示父级ID的常量字符串），
+            // 值为通过mParent（当前任务所属的任务列表对象）调用getGid方法得到的结果，用于设置当前任务所属任务列表的唯一标识（GID），可能用于关联任务和其所属任务列表
+            // dest_parent_type
+            js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
+// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE（通过工具类获取的表示目标父级类型的常量字符串），
+            // 值为GTaskStringUtils.GTASK_JSON_TYPE_GROUP（通过工具类获取的表示组类型的常量字符串），可能用于在某些操作场景下（比如移动任务等）标识目标父级的类型为组类型
+java
+复制
+            // list_id
+            js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
+// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_LIST_ID（通过工具类获取的表示列表ID的常量字符串），
+            // 值为通过mParent（当前任务所属的任务列表对象）调用getGid方法得到的结果，用于设置当前任务所属任务列表的唯一标识（GID），可能用于在某些操作场景下（比如查询任务所在列表等）标识任务所属的列表
+            // prior_sibling_id
+            if (mPriorSibling != null) {
+                js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
+            }
+ // 如果mPriorSibling（当前任务的前一个兄弟任务对象）不为null，就在JSONObject对象js中添加一个键值对，
+            // 键为GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID（通过工具类获取的表示前一个兄弟任务ID的常量字符串），
+            // 值为通过mPriorSibling调用getGid方法得到的结果，用于设置当前任务前一个兄弟任务的唯一标识（GID），可能用于在某些操作场景下（比如排序任务等）标识前一个兄弟任务
+        } catch (JSONException e) {
+             // 如果在上述操作过程中出现了JSONException异常，就执行以下代码块
+            Log.e(TAG, e.toString());// 使用Log类的e方法（用于输出错误级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出错误日志，以便在调试时查看出现异常的情况
+java
+复制
+            e.printStackTrace(); // 打印异常的堆栈跟踪信息，用于更详细地了解异常出现的位置和调用栈情况，方便调试
+            throw new ActionFailureException("fail to generate task-create jsonobject");// 抛出一个ActionFailureException异常，并传入一个字符串参数"fail to generate task-create jsonobject"，表示生成创建任务的JSONObject对象失败
+        }
+        }
+
+        return js;// 如果上述操作过程中没有出现异常，就返回构建好的JSONObject对象js，它包含了创建任务的相关操作信息
+    }
+
+    public JSONObject getUpdateAction(int actionId) {// 定义一个公共方法getUpdateAction，它接受一个整数类型的参数actionId，用于生成更新任务的相关操作信息（以JSONObject的形式返回）
+        JSONObject js = new JSONObject(); // 创建一个新的JSONObject对象js，用于构建要返回的操作信息
+
+        try { // 开始一个try块，用于捕获可能出现的JSONException异常
+            // action_type
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
+ // 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ACTION_TYPE（通过工具类获取的表示操作类型的常量字符串），
+            // 值为GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE（同样通过工具类获取的表示更新操作类型的常量字符串），用于标识此次操作是更新任务的操作类型
+            // action_id
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ACTION_ID（通过工具类获取的表示操作ID的常量字符串），
+            // 值为传入的参数actionId，用于标识此次更新任务操作的唯一ID
+            // id
+            js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
+   // 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ID（通过工具类获取的表示任务ID的常量字符串），
+            // 值为通过调用getGid方法（应该是从父类继承或在当前类中定义的获取任务唯一标识的方法）得到的结果，用于设置要更新的任务的唯一标识（GID）
+            // entity_delta
+            JSONObject entity = new JSONObject();
+             // 创建一个新的JSONObject对象entity，用于构建任务实体相关的差异信息（在创建或更新任务等操作中，可能用于表示任务实体的新增、修改等情况的信息）
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+             // 在entity这个JSONObject对象中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_NAME（通过工具类获取的表示任务名称的常量字符串），
+            // 值为通过调用getName方法（应该是从父类继承或在当前类中定义的获取任务名称的方法）得到的结果，用于设置任务的名称信息
+
+            if (getNotes() != null) {
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
+            } // 如果通过调用getNotes()方法（获取任务备注信息的方法）得到的结果不为null，就在entity这个JSONObject对象中添加一个键值对，
+            // 键为GTaskStringUtils.GTASK_JSON_NOTES（通过工具类获取的表示任务备注的常量字符串），值为通过getNotes()方法得到的任务备注信息
+            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());// 在entity这个JSONObject对象中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_DELETED（通过工具类获取的表示是否删除的常量字符串），
+            // 值为通过调用getDeleted()方法（应该是从父类继承或在当前类中定义的获取任务是否删除状态的方法）得到的结果，用于设置任务的删除状态信息
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ENTITY_DELTA（通过工具类获取的表示实体差异的常量字符串），
+            // 值为前面构建好的entity这个JSONObject对象，用于将任务实体相关的差异信息添加到整体的操作信息中
+
+        } catch (JSONException e) { // 如果在上述操作过程中出现了JSONException异常，就执行以下代码块
+            Log.e(TAG, e.toString());// 使用Log类的e方法（用于输出错误级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出错误日志，以便在调试时查看出现异常的情况
+            e.printStackTrace(); // 打印异常的堆栈跟踪信息，用于更详细地了解异常出现的位置和调用栈情况，方便调试
+            throw new ActionFailureException("fail to generate task-update jsonobject"); // 抛出一个ActionFailureException异常，并传入一个字符串参数"fail to generate task-update jsonobject"，表示生成更新任务的JSONObject对象失败
+        }
+        }
+
+        return js;// 如果上述操作过程中没有出现异常，就返回构建好的JSONObject对象js，它包含了更新任务的相关操作信息
+    }
+
+    public void setContentByRemoteJSON(JSONObject js) {// 定义一个公共方法setContentByRemoteJSON，它接受一个JSONObject类型的参数js，用于根据远程传来的JSON数据设置任务的相关内容
+    if (js!= null) { // 如果传入的JSONObject对象js不为空
+    
+            try {    // 开始一个try块，用于捕获可能出现的JSONException异常
+                // id
+                if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { // 如果传入的JSON对象js包含键为GTaskStringUtils.GTASK_JSON_ID（通过工具类获取的表示任务ID的常量字符串）的键值对
+                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); // 调用setGid方法（应该是在当前类或其父类中定义的设置任务唯一标识的方法），并传入从JSON对象js中获取到的对应键的值（以字符串形式），用于设置任务的唯一标识（GID）
+                }
+
+                // last_modified
+                if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {   // 如果传入的JSON对象js包含键为GTaskStringUtils.GTASK_JSON_LAST_MODIFIED（通过工具类获取的表示最后修改时间的常量字符串）的键值对
+                    setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); // 调用setLastModified方法（应该是在当前类或其父类中定义的设置最后修改时间的方法），并传入从JSON对象js中获取到的对应键的值（以长整型形式），用于设置任务的最后修改时间
+                }
+
+                // name
+                if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {// 如果传入的JSON对象js包含键为GTaskStringUtils.GTASK_JSON_NAME（通过工具类获取的表示任务名称的常量字符串）的键值对
+                    setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); // 调用setName方法（应该是在当前类或其父类中定义的设置任务名称的方法），并传入从JSON对象js中获取到的对应键的值（以字符串形式），用于设置任务的名称
+                }
+
+                // notes
+                if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {  // 如果传入的JSON对象js包含键为GTaskStringUtils.GTASK_JSON_NOTES（通过工具类获取的表示任务备注的常量字符串）的键值对
+                    setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));// 调用setNotes方法（应该是在当前类或其父类中定义的设置任务备注的方法），并传入从JSON对象js中获取到的对应键的值（以字符串形式），用于设置任务的备注信息
+                }
+
+                // deleted
+                if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) { // 如果传入的JSON对象js包含键为GTaskStringUtils.GTASK_JSON_DELETED（通过工具类获取的表示是否删除的常量字符串）的键值对
+                    setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED)); // 调用setDeleted方法（应该是在当前类或其父类中定义的设置任务是否删除状态的方法），并传入从JSON对象js中获取到的对应键的值（以布尔型形式），用于设置任务的删除状态
+                }
+
+                // completed
+                if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {// 如果传入的JSON对象js包含键为GTaskStringUtils.GTASK_JSON_COMPLETED（通过工具类获取的表示是否完成的常量字符串）的键值对
+                    setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED)); // 调用setCompleted方法（应该是在当前类或其父类中定义的设置任务是否完成状态的                    method），并传入从JSON对象js中获取到的对应键的值（以布尔型形式），用于设置任务的完成状态
+                }
+            } catch (JSONException e) { // 如果在上述操作过程中出现了JSONException异常，就执行以下代码块
+                Log.e(TAG, e.toString());   // 使用Log类的e方法（用于输出错误级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出错误日志，以便在调试时查看出现异常的情况
+                e.printStackTrace(); // 打印异常的堆栈跟踪信息，用于更详细地了解异常出现的位置和调用栈情况，方便调试
+                throw new ActionFailureException("fail to get task content from jsonobject");// 抛出一个ActionFailureException异常，并传入一个字符串参数"fail to get task content from jsonobject"，表示从JSON对象中获取任务内容失败
+            }
+        }
+    }
+
+    public void setContentByLocalJSON(JSONObject js) {// 定义一个公共方法setContentByLocalJSON，它接受一个JSONObject类型的参数js，用于根据本地的JSON数据设置任务的相关内容
+        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
+                || !js.has(GTaskStringUtils.META_HEAD_DATA)) {// 如果传入的JSONObject对象js为空，或者不包含键为GTaskStringUtils.META_HEAD_NOTE（通过工具类获取的特定头部信息相关的常量字符串）的键值对，
+        // 或者不包含键为GTaskStringUtils.META_HEAD_DATA（通过工具类获取的特定数据相关的常量字符串）的键值对
+            Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
+        }// 使用Log类的w方法（用于输出警告级别日志），输出一条警告日志，内容为"setContentByLocalJSON: nothing is avaiable"，表示设置本地JSON内容时没有可用信息
+
+        try {
+            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);// 从传入的JSONObject对象js中获取键为GTaskStringUtils.META_HEAD_NOTE的键值对，并将其值（也是一个JSONObject类型）赋给note变量，用于获取特定的笔记相关信息
+            JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);// 从传入的JSONObject对象js中获取键为GTaskStringUtils.META_HEAD_DATA的键值对，并将其值（也是一个JSONArray类型）赋给dataArray变量，用于获取特定的数据数组相关信息
+
+            if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {// 如果从note这个JSONObject对象中获取到的键为NoteColumns.TYPE（通过工具类获取的表示类型的常量字符串）的值不等于Notes.TYPE_NOTE（应该是在Notes类中定义的表示笔记类型的常量）
+                Log.e(TAG, "invalid type");// 使用Log类的e方法（用于输出错误级别日志），输出一条错误日志，内容为"invalid type"，表示类型无效
+                return;// 直接返回，不再执行后续代码
+            }
+
+            for (int i = 0; i < dataArray.length(); i++) { // 遍历dataArray这个JSONArray对象中的每个元素
+                JSONObject data = dataArray.getJSONObject(i);// 获取当前遍历到的元素（也是一个JSONObject类型），并赋给data变量
+                if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { // 如果通过TextUtils工具类的equals方法比较data这个JSONObject对象中键为DataColumns.MIME_TYPE（通过工具类获取的表示MIME类型的常量字符串）的值
+                // 与DataConstants.NOTE（应该是在DataConstants类中定义的表示笔记的常量）相等
+                    setName(data.getString(DataColumns.CONTENT));// 调用setName方法（应该是在当前类或其父类中定义的设置任务名称的方法），并传入从data这个JSONObject对象中获取到的键为DataColumns.CONTENT（通过工具类获取的表示内容的常量字符串）的值（以字符串形式），用于设置任务的名称
+                    break;
+                }
+            }
+
+        } catch (JSONException e) {// 如果在上述操作过程中出现了JSONException异常，就执行以下代码块
+            Log.e(TAG, e.toString());// 使用Log类的e方法（用于输出错误级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出错误日志，以便在调试时查看出现异常的情况
+            e.printStackTrace(); // 打印异常的堆栈跟踪信息，用于更详细地了解异常出现的位置和调用栈情况，方便调试
+    }
+        }
+    }
+
+    public JSONObject getLocalJSONFromContent() { // 定义一个公共方法getLocalJSONFromContent，用于根据任务的内容生成本地的JSON对象
+        String name = getName(); // 获取任务的名称，并赋给name变量
+        try { // 开始一个try块，用于捕获可能出现的JSONException异常
+            if (mMetaInfo == null) {// 如果任务的元信息mMetaInfo为空
+                // new task created from web
+                if (name == null) { // 如果任务的名称name也为空
+                    Log.w(TAG, "the note seems to be an empty one"); // 使用Log类的w方法（用于输出警告级别日志），输出一条警告日志，内容为"the note seems to be an empty one"，表示这个笔记似乎是空的
+                    return null;// 直接返回null，表示无法生成有效的本地JSON对象
+            }
+                }
+
+                JSONObject js = new JSONObject(); // 创建一个新的JSONObject对象js，用于构建要返回的本地JSON对象
+                JSONObject note = new JSONObject(); // 创建一个新的JSONObject对象note，用于构建笔记相关的信息部分
+                JSONArray dataArray = new JSONArray(); // 创建一个新的JSONArray对象dataArray，用于构建数据数组相关的信息部分
+                JSONObject data = new JSONObject(); // 创建一个新的JSONObject对象data，用于构建具体的数据信息部分
+                data.put(DataColumns.CONTENT, name);// 在data这个JSONObject对象中添加一个键值对，键为DataColumns.CONTENT（通过工具类获取的表示内容的常量字符串），值为前面获取到的任务名称name，用于设置数据的内容信息
+                dataArray.put(data);// 将data这个JSONObject对象添加到dataArray这个JSONArray对象中，作为其中的一个元素
+                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); // 在js这个JSONObject对象中添加一个键值对，键为GTreeStringUtils.META_HEAD_DATA（通过工具类获取的表示特定数据头部信息的常量字符串），值为前面构建好的dataArray这个JSONArray对象，用于设置本地JSON对象中的数据数组部分
+                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 在note这个JSONObject对象中添加一个键值对，键为NoteColumns.TYPE（通过工具类获取的表示类型的常量字符串），值为Notes.TYPE_NOTE（应该是在Notes类中定义的表示笔记类型的常量），用于设置笔记的类型信息
+                js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 在js这个JSONObject对象中添加一个键值对，键为GTreeStringUtils.META_HEAD_NOTE（通过工具类获取的表示特定笔记头部信息的常量字符串），值为前面构建好的note这个JSONObject对象，用于设置本地JSON对象中的笔记部分
+                return js; // 返回构建好的js这个JSONObject对象，它就是根据任务内容生成的本地JSON对象
+        } else {
+            } else {
+                // synced task
+                JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 从任务的元信息mMetaInfo中获取键为GTreeStringUtils.META_HEAD_NOTE的键值对，并将其值（也是一个JSONObject类型）赋给note变量，用于获取特定的笔记相关信息
+                JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA); // 从任务的元信息mMetaInfo中获取键为GTreeStringUtils.META_HEAD_DATA的键值对，并将其值（也是一个JSONArray类型）赋给dataArray变量，用于获取特定的数据数组相关信息
+
+                for (int i = 0; i < dataArray.length(); i++) { // 遍历dataArray这个JSONArray对象中的每个元素
+                    JSONObject data = dataArray.getJSONObject(i); // 获取当前遍历到的元素（也是一个JSONObject类型），并赋给data变量
+                    if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {  // 如果通过TextUtils工具类的equals方法比较data这个JSONObject对象中键为DataColumns.MIME_TYPE（通过工具类获取的表示MIME类型的常量字符串）的值
+                        data.put(DataColumns.CONTENT, getName()); // 在data这个JSONObject对象中添加一个键值对，键为DataColumns.CONTENT（通过工具类获取的表示内容的常量字符串），值为通过getName方法获取到的任务名称，用于更新数据的内容信息
+                        break;
+                    }
+                }
+
+                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 在note这个JSONObject对象中添加一个键值对，键为NoteColumns.TYPE（通过工具类获取的表示类型的常量字符串），值为Notes.TYPE_NOTE（应该是在Notes类中定义的表示笔记类型的常量），用于更新笔记的类型信息
+                return mMetaInfo;
+            }
+        } catch (JSONException e) { // 如果在上述操作过程中出现了JSONException异常，就执行以下代码块
+            Log.e(TAG, e.toString());// 使用Log类的e方法（用于输出错误级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出错误日志，以便在调试时查看出现异常的情况
+
+            e.printStackTrace();  // 打印异常的堆栈跟踪信息，用于更详细地了解异常出现的位置和调用栈情况，方便调试
+        return null; // 返回null，表示生成本地JSON对象失败
+          
+        }
+    }
+
+    public void setMetaInfo(MetaData metaData) {// 定义一个公共方法setMetaInfo，它接受一个MetaData类型的参数metaData，用于设置任务的元信息
+        if (metaData != null && metaData.getNotes() != null) { // 如果传入的MetaData对象metaData不为空，并且通过调用其getNotes方法获取到的笔记信息也不为空
+            try {// 开始一个try块，用于捕获可能出现的JSONException异常
+                mMetaInfo = new JSONObject(metaData.getNotes()); // 创建一个新的JSONObject对象mMetaInfo，并将通过metaData.getNotes()获取到的笔记信息（应该是字符串形式）转换为JSONObject类型后赋给mMetaInfo变量，用于设置任务的元信息
+            } catch (JSONException e) { // 如果在上述操作过程中出现了JSONException异常，就执行以下代码块
+                Log.w(TAG, e.toString()); // 使用Log类的w方法（用于输出警告级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出警告日志，以便在调试时查看出现异常的情况
+                mMetaInfo = null; // 使用Log类的w方法（用于输出警告级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出警告日志，以便在调试时查看出现异常的情况
+            }
+        }
+    }
+
+    public int getSyncAction(Cursor c) {// 定义一个公共方法getSyncAction，它接受一个Cursor类型的参数c，用于根据数据库游标（Cursor）中的信息获取同步操作的类型
+        try {   // 开始一个try块，用于捕获可能出现的Exception异常
+            JSONObject noteInfo = null; // 定义一个JSONObject类型的变量noteInfo，并初始化为null，用于存储笔记相关的信息
+            if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) { // 如果任务的元信息mMetaInfo不为空，并且包含键为GTaskStringUtils.META_HEAD_NOTE（通过工具类获取的表示特定笔记头部信息的常量字符串）的键值对
+                noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);// 从mMetaInfo这个JSONObject对象中获取键为GTreeStringUtils.META_HEAD_NOTE的键值对，并将其值（也是一个JSONObject类型）赋给noteInfo变量，用于获取特定的笔记相关信息
+            }
+
+            if (noteInfo == null) { // 如果noteInfo变量为null，即没有获取到有效的笔记相关信息
+                Log.w(TAG, "it seems that note meta has been deleted");            // 使用Log类的
+                return SYNC_ACTION_UPDATE_REMOTE;//返回同步操作更新远程。
+            }
+
+            if (!noteInfo.has(NoteColumns.ID)) {//如果笔记信息不包含（笔记列的 ID）。
+                Log.w(TAG, "remote note id seems to be deleted");//记录警告日志，“远程笔记 ID 似乎已被删除”。
+                return SYNC_ACTION_UPDATE_LOCAL;//返回同步操作更新本地。
+            }
+
+            // validate the note id now
+            if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {//如果 c 中获取的长整型（SQL 笔记的 ID 列）与笔记信息获取的长整型（笔记列的 ID）不相等。
+                Log.w(TAG, "note id doesn't match");//记录警告日志，“笔记 ID 不匹配”。
+                return SYNC_ACTION_UPDATE_LOCAL;
+            }
+
+            if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {//如果 c 中获取的整型（SQL 笔记的本地修改列）为 0。
+                // there is no local update
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {//如果 c 中获取的长整型（SQL 笔记的同步 ID 列）等于最后修改的时间。
+                    // no update both side
+                    return SYNC_ACTION_NONE;//返回同步操作无。
+                } else {
+                    // apply remote to local
+                    return SYNC_ACTION_UPDATE_LOCAL;//返回同步操作更新本地。
+                }
+            } else {
+                // validate gtask id
+                if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {//如果 c 中获取的字符串（SQL 笔记的谷歌任务 ID 列）不等于获取的谷歌任务 ID。
+                    Log.e(TAG, "gtask id doesn't match");//记录错误日志，“谷歌任务 ID 不匹配”。
+                    return SYNC_ACTION_ERROR;//返回同步操作更新远程。
+                }
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {//如果 c 中获取的长整型（SQL 笔记的同步 ID 列）等于最后修改的时间。
+                    // local modification only
+                    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;//返回同步操作错误。
+    }
+
+    public boolean isWorthSaving() {//公共方法，判断是否值得保存。
+        return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
+                || (getNotes() != null && getNotes().trim().length() > 0);
+    }//返回元信息不为空，或者名称不为空且经过修剪后的长度大于 0，或者笔记不为空且经过修剪后的长度大于 0。
+
+    public void setCompleted(boolean completed) {//公共方法，设置已完成状态。
+        this.mCompleted = completed;//将已完成状态设置为传入的值。
+
+    }
+
+    public void setNotes(String notes) {
+        this.mNotes = notes;//将笔记设置为传入的值。
+    }
+
+    public void setPriorSibling(Task priorSibling) {
+        this.mPriorSibling = priorSibling;//前一个兄弟任务设置为传入的值。
+    }
+
+    public void setParent(TaskList parent) {
+        this.mParent = parent;//将父任务列表设置为传入的值。
+    }
+
+    public boolean getCompleted() {
+        return this.mCompleted;//返回已完成状态。
+    }
+
+    public String getNotes() {//公共方法，获取笔记。
+        return this.mNotes;//返回笔记。
+    }
+
+    public Task getPriorSibling() {//：公共方法，获取前一个兄弟任务。
+        return this.mPriorSibling;//返回前一个兄弟任务。
+    }
+
+    public TaskList getParent() {//共方法，获取父任务列表。
+        return this.mParent;//返回父任务列表。
+
+    }
+
+

TaskList.java

@@ -0,0 +1,344 @@
+/*
+ * 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;//包 net.micode.notes.gtask.data
+
+import android.database.Cursor;//导入安卓数据库游标
+import android.util.Log;//导入安卓日志记录
+
+import net.micode.notes.data.Notes;//导入 net.micode.notes 数据的 Notes
+import net.micode.notes.data.Notes.NoteColumns;//导入 net.micode.notes 数据的 Notes 的 NoteColumns
+import net.micode.notes.gtask.exception.ActionFailureException;//导入 net.micode.notes.gtask 异常的操作失败异常
+import net.micode.notes.tool.GTaskStringUtils;//导入 net.micode.notes 工具的 GTaskStringUtils
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+
+
+public class TaskList extends Node {//公共类 TaskList 继承自 Node 类。
+    private static final String TAG = TaskList.class.getSimpleName();//私有静态最终字符串变量 TAG，赋值为 TaskList 类的简单名称。
+
+    private int mIndex;//私有整型变量 mIndex。
+
+    private ArrayList<Task> mChildren;//私有 ArrayList 类型的变量 mChildren，泛型参数为 Task。
+
+    public TaskList() {//公共的 TaskList 构造函数。
+        super();//调用父类的构造函数。
+        mChildren = new ArrayList<Task>();//将 mChildren 初始化为一个新的 ArrayList，用于存储 Task 对象
+        mIndex = 1;//将 mIndex 初始化为 1。
+    }
+
+    public JSONObject getCreateAction(int actionId) {//公共方法 getCreateAction，接收一个整型参数 actionId，返回一个 JSONObject 对象。
+        JSONObject js = new JSONObject();//创建一个新的 JSONObject 对象 js。
+
+        try {//尝试执行以下代码块。
+            // action_type
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);//向 JSONObject 对象 js 中添加键值对，键为‘action_type’，值为 GTaskStringUtils 类中常量 GTASK_JSON_ACTION_TYPE_CREATE。
+
+            // action_id
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);//向 JSONObject 对象 js 中添加键值对，键为‘action_id’，值为传入的参数 actionId。
+
+            // index
+            js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);//向 JSONObject 对象 js 中添加键值对，键为‘index’，值为 mIndex 变量的值。
+
+            // entity_delta
+            JSONObject entity = new JSONObject();//创建一个新的 JSONObject 对象 entity。
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());//向 entity 对象中添加键值对，键为‘name’，值为调用 getName 方法返回的值。
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");//向 entity 对象中添加键值对，键为‘creator_id’，值为字符串‘null’。
+            entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);//向 entity 对象中添加键值对，键为‘entity_type’，值为 GTaskStringUtils 类中常量 GTASK_JSON_TYPE_GROUP。
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);//向 js 对象中添加键值对，键为‘entity_delta’，值为 entity 对象。
+
+        } catch (JSONException e) {//捕获 JSONException 异常。
+            Log.e(TAG, e.toString());//使用日志记录错误信息，TAG 为类名的简单名称，输出异常的字符串表示。
+            e.printStackTrace();//打印异常堆栈跟踪。
+            throw new ActionFailureException("fail to generate tasklist-create jsonobject");//抛出一个 ActionFailureException 异常，异常信息为‘fail to generate tasklist-create jsonobject’。
+        }
+
+        return js;//返回 JSONObject 对象 js。
+    }
+
+    public JSONObject getUpdateAction(int actionId) {//公共的 JSONObject 方法 getUpdateAction，接收一个动作 id。
+        JSONObject js = new JSONObject();//创建一个新的 JSONObject 对象 js
+
+        try {//尝试执行以下代码块
+            // action_type
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);//在 js 对象中添加键值对，action_type 为指定的值。
+
+            // action_id
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);//在 js 对象中添加键值对，action_id 为传入的动作 id。
+
+            // id
+            js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());//在 js 对象中添加键值对，id 为获取的 gid。
+
+            // entity_delta
+            JSONObject entity = new JSONObject();//创建一个新的 JSONObject 对象 entity。
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());//在 entity 对象中添加键值对，name 为获取的名称。
+            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());//在 entity 对象中添加键值对，deleted 为获取的已删除状态。
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);//在 js 对象中添加键值对，entity_delta 为 entity 对象。
+
+        } catch (JSONException e) {//捕获 JSONException 异常。
+            Log.e(TAG, e.toString());//记录错误日志，输出异常信息的字符串表示。
+            e.printStackTrace();//打印异常的堆栈跟踪信息。
+            throw new ActionFailureException("fail to generate tasklist-update jsonobject");//抛出一个 ActionFailureException 异常，提示生成任务列表更新 JSONObject 对象失败。
+        }
+
+        return js;//返回 js 对象。
+    }
+
+    public void setContentByRemoteJSON(JSONObject js) {//公共的方法 setContentByRemoteJSON，接收一个 JSONObject 对象 js。
+        if (js != null) {//如果 js 对象不为空，则执行以下代码块。
+            try {//尝试执行以下代码块。
+                // id
+                if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {//如果 js 对象包含键 GTaskStringUtils.GTASK_JSON_ID，则执行以下代码块。
+                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));//设置 gid 为 js 对象中键 GTaskStringUtils.GTASK_JSON_ID 的对应的值。
+                }
+
+                // last_modified
+                if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {//如果 js 对象包含键 GTaskStringUtils.GTASK_JSON_LAST_MODIFIED，则执行以下代码块。
+                    setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));//设置最后修改时间为 js 对象中键 GTaskStringUtils.GTASK_JSON_LAST_MODIFIED 的对应的值。
+                }
+
+                // name
+                if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {//如果 js 对象包含键 GTaskStringUtils.GTASK_JSON_NAME，则执行以下代码块。
+                    setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));//设置名称为 js 对象中键 GTaskStringUtils.GTASK_JSON_NAME 的对应的值。
+                }
+
+            } catch (JSONException e) {//捕获 JSONException 异常。
+                Log.e(TAG, e.toString());//记录错误日志，输出异常信息的字符串表示。
+                e.printStackTrace();//打印异常的堆栈跟踪信息。
+                throw new ActionFailureException("fail to get tasklist content from jsonobject");//抛出一个 ActionFailureException 异常，提示从 JSONObject 对象获取任务列表内容失败。
+            }
+        }
+    }
+
+    public void setContentByLocalJSON(JSONObject js) {//公共的方法 setContentByLocalJSON，接收一个 JSONObject 对象 js。
+        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {//如果 js 对象为空或者不包含键 GTaskStringUtils.META_HEAD_NOTE，则执行以下代码块。
+            Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");//记录警告日志，提示在 setContentByLocalJSON 方法中没有可用内容。
+        }
+
+        try {//尝试执行以下代码块。
+            JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);//从 js 对象中获取键 GTaskStringUtils.META_HEAD_NOTE 对应的 JSONObject 对象 folder。
+
+            if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {//如果 folder 对象中键 NoteColumns.TYPE 的对应的值为 Notes.TYPE_FOLDER，则执行以下代码块。
+                String name = folder.getString(NoteColumns.SNIPPET);//获取名称为 folder 对象中键 NoteColumns.SNIPPET 对应的值。
+                setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name);//设置名称为指定的前缀加上获取的名称。
+            } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {//否则如果 folder 对象中键 NoteColumns.TYPE 的对应的值为 Notes.TYPE_SYSTEM，则执行以下代码块。
+                if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)//如果 folder 对象中键 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)//否则如果 folder 对象中键 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) {//捕获 JSONException 异常。
+            Log.e(TAG, e.toString());//记录错误日志，输出异常信息的字符串表示。
+            e.printStackTrace();//打印异常的堆栈跟踪信息。
+        }
+    }
+
+    public JSONObject getLocalJSONFromContent() {//公共的 JSONObject 方法，用于从内容中获取本地 JSON 对象。
+        try {
+            JSONObject js = new JSONObject();//创建一个新的 JSONObject 对象 js。
+            JSONObject folder = new JSONObject();//创建一个新的 JSONObject 对象 folder。
+
+
+            String folderName = getName();//获取名称并赋值给变量 folderName。
+            if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))//如果名称以指定前缀开头。
+                folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
+                        folderName.length());//截取名称，去除前缀部分。
+            folder.put(NoteColumns.SNIPPET, folderName);//在 folder 对象中添加键值对。
+            if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
+                    || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))//如果名称等于指定的默认文件夹名或电话笔记文件夹名。
+                folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);//在 folder 对象中设置类型为系统类型。
+            else
+                folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);//在 folder 对象中设置类型为文件夹类型。
+
+            js.put(GTaskStringUtils.META_HEAD_NOTE, folder);//在 js 对象中添加键值对。
+
+            return js;
+        } catch (JSONException e) {//捕获 JSONException 异常。
+            Log.e(TAG, e.toString());//记录错误日志。
+            e.printStackTrace();//打印异常堆栈信息。
+            return null;
+        }
+    }
+
+    public int getSyncAction(Cursor c) {//公共的获取同步操作方法。
+        try {//尝试执行以下代码块。
+            if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {//如果游标中本地修改列的值为 0。
+                // there is no local update
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {//如果同步 ID 列的值等于最后修改的值。
+                    // no update both side
+                    return SYNC_ACTION_NONE;//返回无操作。
+                } else {
+                    // apply remote to local
+                    return SYNC_ACTION_UPDATE_LOCAL;//返回更新本地。
+                }
+            } else {
+                // validate gtask id
+                if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {//如果游标中任务 ID 列的值不等于当前任务的 ID。
+                    Log.e(TAG, "gtask id doesn't match");//记录错误日志（任务 ID 不匹配）。
+                    return SYNC_ACTION_ERROR;//返回错误操作。
+                }
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {//如果同步 ID 列的值等于最后修改的值。
+                    // local modification only
+                    return SYNC_ACTION_UPDATE_REMOTE;
+                } else {
+                    // for folder conflicts, just apply local modification
+                    return SYNC_ACTION_UPDATE_REMOTE;//返回更新远程。
+                }
+            }
+        } catch (Exception e) {//捕获异常。
+            Log.e(TAG, e.toString());//记录错误日志
+            e.printStackTrace();//打印异常堆栈信息
+        }
+
+        return SYNC_ACTION_ERROR;//返回错误操作。
+    }
+
+    public int getChildTaskCount() {//公共的获取子任务数量方法。
+        return mChildren.size();//返回子任务列表的大小。
+    }
+
+    public boolean addChildTask(Task task) {//公共的添加子任务方法。
+        boolean ret = false;//初始化返回值为假。
+        if (task != null && !mChildren.contains(task)) {//如果任务不为空且子任务列表中不包含该任务。
+            ret = mChildren.add(task);//将任务添加到子任务列表中并更新返回值。
+            if (ret) {//如果添加成功。
+                // need to set prior sibling and parent
+                task.setPriorSibling(mChildren.isEmpty() ? null : mChildren
+                        .get(mChildren.size() - 1));//设置前一个兄弟任务。
+                task.setParent(this);//设置父任务为当前任务。
+            }
+        }
+        return ret;//返回添加子任务的结果。
+    }
+
+    public boolean addChildTask(Task task, int index) {//公共的在指定索引处添加子任务方法。
+        if (index < 0 || index > mChildren.size()) {//如果索引无效。
+            Log.e(TAG, "add child task: invalid index");//记录错误日志（添加子任务索引无效）。
+            return false;//返回假。
+        }
+
+        int pos = mChildren.indexOf(task);//获取任务在子任务列表中的索引。
+        if (task != null && pos == -1) {//如果任务不为空且索引为 - 1（即子任务列表中不包含该任务）。
+            mChildren.add(index, task);//在指定索引处添加任务。
+
+            // update the task list
+            Task preTask = null;//初始化前一个任务为 null。
+            Task afterTask = null;//初始化后一个任务为 null
+            if (index != 0)
+                preTask = mChildren.get(index - 1);//如果索引不为 0，获取前一个任务。
+            if (index != mChildren.size() - 1)
+                afterTask = mChildren.get(index + 1);//如果索引不为子任务列表最后一个索引，获取后一个任务。
+
+            task.setPriorSibling(preTask);//设置任务的前一个兄弟任务。
+            if (afterTask != null)
+                afterTask.setPriorSibling(task);//如果后一个任务不为空，设置后一个任务的前一个兄弟任务为当前任务。
+        }
+
+        return true;//返回添加子任务成功。
+    }
+
+    public boolean removeChildTask(Task task) {//公共的移除子任务方法。
+        boolean ret = false;//初始化返回值为假。
+        int index = mChildren.indexOf(task);//获取任务在子任务列表中的索引。
+        if (index != -1) {//如果索引不为 - 1（即子任务列表中包含该任务）。
+            ret = mChildren.remove(task);//从子任务列表中移除任务并更新返回值。
+
+            if (ret) {//如果移除成功。
+                // reset prior sibling and parent
+                task.setPriorSibling(null);//设置任务的前一个兄弟任务为 null。
+                task.setParent(null);//设置任务的父任务为 null。
+
+                // update the task list
+                if (index != mChildren.size()) {//如果索引不是子任务列表最后一个索引。
+                    mChildren.get(index).setPriorSibling(//设置当前索引处任务的前一个兄弟任务。
+                            index == 0 ? null : mChildren.get(index - 1));//如果索引为 0，则前一个兄弟任务为 null，否则为前一个索引处的任务。
+                }
+            }
+        }
+        return ret;//返回移除子任务的结果。
+    }
+
+    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) {//如果索引为 - 1（即子任务列表中不包含该任务）。
+            Log.e(TAG, "move child task: the task should in the list");//记录错误日志（要移动的任务应该在列表中）。
+            return false;
+        }
+
+        if (pos == index)
+            return true;//如果当前索引等于要移动到的索引，则直接返回真。
+        return (removeChildTask(task) && addChildTask(task, index));//移除任务，再在指定索引处添加任务，并返回结果。
+    }
+
+    public Task findChildTaskByGid(String gid) {//公共的通过任务 ID 查找子任务方法
+        for (int i = 0; i < mChildren.size(); i++) {//遍历子任务列表。
+            Task t = mChildren.get(i);//获取当前索引处的子任务
+            if (t.getGid().equals(gid)) {//如果子任务的任务 ID 等于要查找的任务 ID。
+                return t;
+            }
+        }
+        return null;//如果遍历完子任务列表都没有找到，则返回 null。
+    }
+
+    public int getChildTaskIndex(Task task) {//公共的获取子任务索引方法。
+        return mChildren.indexOf(task);//返回子任务在子任务列表中的索引。
+    }
+
+    public Task getChildTaskByIndex(int index) {//公共的通过索引获取子任务方法。
+        if (index < 0 || index >= mChildren.size()) {//如果索引无效。
+            Log.e(TAG, "getTaskByIndex: invalid index");//记录错误日志（通过索引获取子任务索引无效）。
+            return null;
+        }
+        return mChildren.get(index);//返回指定索引处的子任务。
+    }
+
+    public Task getChilTaskByGid(String gid) {//通过任务 ID 获取子任务方法。
+        for (Task task : mChildren) {//遍历子任务列表。
+            if (task.getGid().equals(gid))//如果子任务的任务 ID 等于要查找的任务 ID。
+                return task;//返回该子任务。
+        }
+        return null;//如果遍历完子任务列表都没有找到，则返回 null。
+    }
+
+    public ArrayList<Task> getChildTaskList() {//公共方法，用于获取子任务列表。
+        return this.mChildren;//返回成员变量mChildren，即子任务列表。
+    }
+
+    public void setIndex(int index) {//公共方法，用于设置索引
+        this.mIndex = index;//将传入的索引值赋给成员变量mIndex。
+    }
+
+    public int getIndex() {//公共方法，用于获取索引。
+        return this.mIndex;//返回成员变量mIndex的值，即当前的索引。
+    }
+}