app/src/main/java/net/micode/notes/data/Contact.java

@@ -1,78 +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//如果查询结果不为空且有数据//如果查询结果不为空且有数据//
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
  *
- *        http://www.apache.org/licenses/LICENSE-2.0//如果查询结果不为空且有数据//
+ * 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
  *
- * 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; // 导入Context类
-import android.database.Cursor; // 导入Cursor类
-import android.provider.ContactsContract.CommonDataKinds.Phone; // 导入Phone类
-import android.provider.ContactsContract.Data; // 导入Data类
-import android.telephony.PhoneNumberUtils; // 导入PhoneNumberUtils类
-import android.util.Log; // 导入Log类
-// 如果查询结果不为空且有数据
-import java.util.HashMap; // 导入HashMap类
-// 如果查询结果不为空且有数据
-public class Contact {//如果查询结果不为空且有数据
-    private static HashMap<String, String> sContactCache; // 定义一个静态HashMap用于缓存联系人信息
-    private static final String TAG = "Contact"; // 定义日志标签// 如果查询结果不为空且有数据
+ *        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);
 
-    // 定义查询条件字符串，用于匹配电话号码// 如果查询结果不为空且有数据
-    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; // 返回空
-        }// 返回空
-    }// 返回空
-}// 返回空
-//如果查询结果不为空且有数据
+        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;
+        }
+    }
+}

app/src/main/java/net/micode/notes/data/Notes.java

@@ -1,26 +1,40 @@
-package net.micode.notes.data;  // 定义该类所在的包名
+/*
+ * 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.
+ */
 
-import android.net.Uri;  // 导入Android的Uri类
+package net.micode.notes.data;
 
-// 定义一个公共类 Notes，用于管理笔记应用中的常量和数据结构
+import android.net.Uri;
 public class Notes {
-    // 定义权限名，用于内容提供者的访问
     public static final String AUTHORITY = "micode_notes";
-    // 定义日志标签名，便于调试
     public static final String TAG = "Notes";
+    public static final int TYPE_NOTE     = 0;
+    public static final int TYPE_FOLDER   = 1;
+    public static final int TYPE_SYSTEM   = 2;
 
-    // 定义笔记类型：普通笔记、文件夹、系统类型
-    public static final int TYPE_NOTE     = 0;   // 普通笔记类型
-    public static final int TYPE_FOLDER   = 1;   // 文件夹类型
-    public static final int TYPE_SYSTEM   = 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;
+    public static final int ID_TEMPARAY_FOLDER = -1;
+    public static final int ID_CALL_RECORD_FOLDER = -2;
+    public static final int ID_TRASH_FOLER = -3;
 
-    // 系统文件夹标识符
-    public static final int ID_ROOT_FOLDER = 0;          // 根文件夹的ID
-    public static final int ID_TEMPARAY_FOLDER = -1;     // 临时文件夹的ID
-    public static final int ID_CALL_RECORD_FOLDER = -2;  // 通话记录文件夹的ID
-    public static final int ID_TRASH_FOLER = -3;         // 垃圾箱文件夹的ID
-
-    // 定义各种Intent额外数据的key
     public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
     public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
     public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
@@ -28,74 +42,238 @@ public class Notes {
     public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
     public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
 
-    // 定义Widget类型
-    public static final int TYPE_WIDGET_INVALIDE = -1;  // 无效Widget类型
-    public static final int TYPE_WIDGET_2X = 0;         // 2x的Widget类型
-    public static final int TYPE_WIDGET_4X = 1;         // 4x的Widget类型
+    public static final int TYPE_WIDGET_INVALIDE      = -1;
+    public static final int TYPE_WIDGET_2X            = 0;
+    public static final int TYPE_WIDGET_4X            = 1;
 
-    // 定义数据常量类
     public static class DataConstants {
-        // 定义文本笔记类型和通话笔记类型
-        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;  // 文本笔记类型
-        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;  // 通话笔记类型
+        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
+        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
     }
 
-    // 定义访问所有笔记和文件夹的Uri
+    /**
+     * Uri to query all notes and folders
+     */
     public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
-    // 定义访问数据的Uri
+
+    /**
+     * Uri to query data
+     */
     public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
 
-    // 定义笔记的列名接口
     public interface NoteColumns {
-        public static final String ID = "_id";  // 每行的唯一ID
-        public static final String PARENT_ID = "parent_id";  // 父ID（文件夹的ID或上级ID）
-        public static final String CREATED_DATE = "created_date";  // 创建日期
-        public static final String MODIFIED_DATE = "modified_date";  // 最后修改日期
-        public static final String ALERTED_DATE = "alert_date";  // 提醒日期
-        public static final String SNIPPET = "snippet";  // 文件夹名称或笔记文本内容
-        public static final String WIDGET_ID = "widget_id";  // Widget的ID
-        public static final String WIDGET_TYPE = "widget_type";  // Widget的类型
-        public static final String BG_COLOR_ID = "bg_color_id";  // 背景颜色ID
-        public static final String HAS_ATTACHMENT = "has_attachment";  // 是否有附件
-        public static final String NOTES_COUNT = "notes_count";  // 文件夹内笔记数量
-        public static final String TYPE = "type";  // 文件类型（笔记或文件夹）
-        public static final String SYNC_ID = "sync_id";  // 同步ID
-        public static final String LOCAL_MODIFIED = "local_modified";  // 是否本地修改
-        public static final String ORIGIN_PARENT_ID = "origin_parent_id";  // 移动前的父ID
-        public static final String GTASK_ID = "gtask_id";  // 任务ID
-        public static final String VERSION = "version";  // 版本号
+        /**
+         * 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>
+         */
+        public static final String PARENT_ID = "parent_id";
+
+        /**
+         * Created data for note or folder
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String CREATED_DATE = "created_date";
+
+        /**
+         * Latest modified date
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String MODIFIED_DATE = "modified_date";
+
+
+        /**
+         * Alert date
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String ALERTED_DATE = "alert_date";
+
+        /**
+         * Folder's name or text content of note
+         * <P> Type: TEXT </P>
+         */
+        public static final String SNIPPET = "snippet";
+
+        /**
+         * Note's widget id
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String WIDGET_ID = "widget_id";
+
+        /**
+         * Note's widget type
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String WIDGET_TYPE = "widget_type";
+
+        /**
+         * Note's background color's id
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String BG_COLOR_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";
+
+        /**
+         * 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>
+         */
+        public static final String SYNC_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>
+         */
+        public static final String ORIGIN_PARENT_ID = "origin_parent_id";
+
+        /**
+         * The gtask id
+         * <P> Type : TEXT </P>
+         */
+        public static final String GTASK_ID = "gtask_id";
+
+        /**
+         * The version code
+         * <P> Type : INTEGER (long) </P>
+         */
+        public static final String VERSION = "version";
     }
 
-    // 定义数据列的接口
     public interface DataColumns {
-        public static final String ID = "_id";  // 数据的唯一ID
-        public static final String MIME_TYPE = "mime_type";  // 数据的MIME类型
-        public static final String NOTE_ID = "note_id";  // 数据所属的笔记ID
-        public static final String CREATED_DATE = "created_date";  // 数据创建日期
-        public static final String MODIFIED_DATE = "modified_date";  // 数据最后修改日期
-        public static final String CONTENT = "content";  // 数据内容
-        public static final String DATA1 = "data1";  // 通用数据列1
-        public static final String DATA2 = "data2";  // 通用数据列2
-        public static final String DATA3 = "data3";  // 通用数据列3
-        public static final String DATA4 = "data4";  // 通用数据列4
-        public static final String DATA5 = "data5";  // 通用数据列5
+        /**
+         * The unique ID for a row
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String ID = "_id";
+
+        /**
+         * The MIME type of the item represented by this row.
+         * <P> Type: Text </P>
+         */
+        public static final String MIME_TYPE = "mime_type";
+
+        /**
+         * The reference id to note that this data belongs to
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String NOTE_ID = "note_id";
+
+        /**
+         * Created data for note or folder
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String CREATED_DATE = "created_date";
+
+        /**
+         * Latest modified date
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String MODIFIED_DATE = "modified_date";
+
+        /**
+         * Data's content
+         * <P> Type: TEXT </P>
+         */
+        public static final String CONTENT = "content";
+
+
+        /**
+         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+         * integer data type
+         * <P> Type: INTEGER </P>
+         */
+        public static final String DATA1 = "data1";
+
+        /**
+         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+         * integer data type
+         * <P> Type: INTEGER </P>
+         */
+        public static final String DATA2 = "data2";
+
+        /**
+         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+         * TEXT data type
+         * <P> Type: TEXT </P>
+         */
+        public static final String DATA3 = "data3";
+
+        /**
+         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+         * TEXT data type
+         * <P> Type: TEXT </P>
+         */
+        public static final String DATA4 = "data4";
+
+        /**
+         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+         * TEXT data type
+         * <P> Type: TEXT </P>
+         */
+        public static final String DATA5 = "data5";
     }
 
-    // 定义文本笔记类
     public static final class TextNote implements DataColumns {
-        public static final String MODE = DATA1;  // 模式字段：是否为检查列表模式
-        public static final int MODE_CHECK_LIST = 1;  // 检查列表模式
-        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";  // 内容类型：多个文本笔记
-        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";  // 内容类型：单个文本笔记
-        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");  // 文本笔记的访问Uri
+        /**
+         * Mode to indicate the text in check list mode or not
+         * <P> Type: Integer 1:check list mode 0: normal mode </P>
+         */
+        public static final String MODE = DATA1;
+
+        public static final int MODE_CHECK_LIST = 1;
+
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
+
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
+
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
     }
 
-    // 定义通话笔记类
     public static final class CallNote implements DataColumns {
-        public static final String CALL_DATE = DATA1;  // 通话日期字段
-        public static final String PHONE_NUMBER = DATA3;  // 电话号码字段
-        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";  // 内容类型：多个通话笔记
-        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";  // 内容类型：单个通话笔记
-        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");  // 通话笔记的访问Uri
+        /**
+         * Call date for this record
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String CALL_DATE = DATA1;
+
+        /**
+         * Phone number for this record
+         * <P> Type: TEXT </P>
+         */
+        public static final String PHONE_NUMBER = DATA3;
+
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
+
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
+
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
     }
 }

app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java

@@ -1,287 +1,362 @@
-package net.micode.notes.data;  // 包声明
+/*
+ * 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.
+ */
 
-import android.content.ContentValues;  // 导入ContentValues类
-import android.content.Context;  // 导入Context类
-import android.database.sqlite.SQLiteDatabase;  // 导入SQLiteDatabase类
-import android.database.sqlite.SQLiteOpenHelper;  // 导入SQLiteOpenHelper类
-import android.util.Log;  // 导入Log类
+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;
 
-import net.micode.notes.data.Notes.DataColumns;  // 导入DataColumns类
-import net.micode.notes.data.Notes.DataConstants;  // 导入DataConstants类
-import net.micode.notes.data.Notes.NoteColumns;  // 导入NoteColumns类
 
-// Notes数据库帮助类
 public class NotesDatabaseHelper extends SQLiteOpenHelper {
-    private static final String DB_NAME = "note.db";  // 定义数据库名称
-    private static final int DB_VERSION = 4;  // 定义数据库版本号
+    private static final String DB_NAME = "note.db";
+
+    private static final int DB_VERSION = 4;
 
-    // 表名接口
     public interface TABLE {
-        public static final String NOTE = "note";  // 笔记表名
-        public static final String DATA = "data";  // 数据表名
+        public static final String NOTE = "note";
+
+        public static final String DATA = "data";
     }
 
-    private static final String TAG = "NotesDatabaseHelper";  // 用于日志输出的TAG
+    private static final String TAG = "NotesDatabaseHelper";
 
-    private static NotesDatabaseHelper mInstance;  // 定义数据库帮助类的实例
+    private static NotesDatabaseHelper mInstance;
 
-    // 创建笔记表的SQL语句
     private static final String CREATE_NOTE_TABLE_SQL =
-            "CREATE TABLE " + TABLE.NOTE + "(" +  // 创建笔记表
-                    NoteColumns.ID + " INTEGER PRIMARY KEY," +  // 笔记ID，主键
-                    NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +  // 父级笔记ID，默认为0
-                    NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +  // 提醒日期，默认为0
-                    NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," +  // 背景色ID，默认为0
-                    NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +  // 创建日期，默认为当前时间戳
-                    NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," +  // 是否有附件，默认为0
-                    NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +  // 修改日期，默认为当前时间戳
-                    NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +  // 笔记数量，默认为0
-                    NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +  // 笔记摘要，默认为空字符串
-                    NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +  // 笔记类型，默认为0
-                    NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +  // 小部件ID，默认为0
-                    NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +  // 小部件类型，默认为-1
-                    NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," +  // 同步ID，默认为0
-                    NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +  // 本地修改标志，默认为0
-                    NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +  // 原父级ID，默认为0
-                    NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +  // GTASK ID，默认为空字符串
-                    NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +  // 笔记版本号，默认为0
-                    ")";  // 结束创建表的SQL语句
-    // 创建触发器SQL
-    // 创建数据表的SQL语句
-    private static final String CREATE_DATA_TABLE_SQL =// 创建触发器SQL
-            "CREATE TABLE " + TABLE.DATA + "(" +  // 创建数据表
-                    DataColumns.ID + " INTEGER PRIMARY KEY," +  // 数据ID，主键
-                    DataColumns.MIME_TYPE + " TEXT NOT NULL," +  // MIME类型
-                    DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," +  // 笔记ID，默认为0
-                    NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +  // 创建日期，默认为当前时间戳
-                    NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +  // 修改日期，默认为当前时间戳
-                    DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," +  // 内容，默认为空字符串
-                    DataColumns.DATA1 + " INTEGER," +  // 数据字段1
-                    DataColumns.DATA2 + " INTEGER," +  // 数据字段2
-                    DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +  // 数据字段3，默认为空字符串
-                    DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +  // 数据字段4，默认为空字符串
-                    DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +  // 数据字段5，默认为空字符串
-                    ")";  // 结束创建数据表的SQL语句// 创建触发器SQL
-    // 创建触发器SQL
-    // 创建数据表的NOTE_ID索引// 创建触发器SQL
-    private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =// 创建触发器SQL
-            "CREATE INDEX IF NOT EXISTS note_id_index ON " +// 创建触发器SQL
-                    TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";  // 创建数据表的NOTE_ID索引
-    // 创建触发器SQL
-    // 创建触发器：更新笔记的父级ID时增加父文件夹的笔记数// 创建触发器SQL
-    private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =// 创建触发器SQL
-            "CREATE TRIGGER increase_folder_count_on_update " +// 创建触发器SQL
-                    " AFTER UPDATE OF " + eColumns.PARENT_ID + " ON " + TABLE.NOTE +// 创建触发器SQL
-                    " BEGIN " +// 创建触发器SQL
-                    "  UPDATE " + TABLE.NOTE +// 创建触发器SQL// 创建触发器SQL// 创建触发器SQL
-                    "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +// 创建触发器SQL
-                    "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +// 创建触发器SQL// 创建触发器SQL
-                    " END";  // 创建触发器SQL
-    // 创建触发器SQL
-    // 创建触发器：更新笔记的父级ID时减少父文件夹的笔记数
-    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =// 创建触发器SQL
-            "CREATE TRIGGER decrease_folder_count_on_update " +// 创建触发器SQL
-                    " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +// 创建触发器SQL
-                    " BEGIN " +// 创建触发器SQL// 创建触发器SQL
-                    "  UPDATE " + TABLE.NOTE +// 创建触发器SQL
-                    "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +// 创建触发器SQL
-                    "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +// 创建触发器SQL
-                    "  AND " + NoteColumns.NOTES_COUNT + ">0" + ";" +// 创建触发器SQL
-                    " END";  // 创建触发器SQL
-
-    // 创建触发器：插入笔记时增加父文件夹的笔记数
-    private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =// 创建触发器SQL
-            "CREATE TRIGGER increase_folder_count_on_insert " +// 创建触发器SQL
-                    " AFTER INSERT ON " + TABLE.NOTE +// 创建触发器SQL
-                    " BEGIN " +// 创建触发器SQL
-                    "  UPDATE " + TABLE.NOTE +// 创建触发器SQL
-                    "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +// 创建触发器SQL
-                    "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +// 创建触发器SQL
-                    " END";  // 创建触发器SQL
-
-    // 创建触发器：删除笔记时减少父文件夹的笔记数
-    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =// 创建触发器SQL
-            "CREATE TRIGGER decrease_folder_count_on_delete " +// 创建触发器SQL
-                    " AFTER DELETE ON " + TABLE.NOTE +// 创建触发器SQL
-                    " BEGIN " +// 创建触发器SQL
-                    "  UPDATE " + TABLE.NOTE +// 创建触发器SQL
-                    "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +// 创建触发器SQL
-                    "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +// 创建触发器SQL
-                    "  AND " + NoteColumns.NOTES_COUNT + ">0;" +// 创建触发器SQL
-                    " END";  // 创建触发器SQL
-
-    // 创建触发器：插入数据时更新笔记的摘要
-    private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =// 创建触发器SQL
-            "CREATE TRIGGER update_note_content_on_insert " +// 创建触发器SQL
-                    " AFTER INSERT ON " + TABLE.DATA +// 创建触发器SQL
-                    " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +// 创建触发器SQL
-                    " BEGIN" +// 创建触发器SQL
-                    "  UPDATE " + TABLE.NOTE +// 创建触发器SQL
-                    "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +// 创建触发器SQL
-                    "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +// 创建触发器SQL
-                    " END";  // 创建触发器SQL
-
-    // 创建触发器：更新数据时更新笔记的摘要
-    private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =// 创建触发器SQL
-            "CREATE TRIGGER update_note_content_on_update " +// 创建触发器SQL// 创建触发器SQL
-                    " AFTER UPDATE ON " + TABLE.DATA +
-                    " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +// 创建触发器SQL
-                    " BEGIN" +// 创建触发器SQL
-                    "  UPDATE " + TABLE.NOTE +// 创建触发器SQL
-                    "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +// 创建触发器SQL
-                    "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +// 创建触发器SQL
-                    " END";  // 创建触发器SQL
-
-    // 创建触发器：删除数据时更新笔记的摘要
-    private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =// 创建触发器SQL
-            "CREATE TRIGGER update_note_content_on_delete " +// 创建触发器SQL
-                    " AFTER delete ON " + TABLE.DATA +// 创建触发器SQL
-                    " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +// 创建触发器SQL
-                    " BEGIN" +
-                    "  UPDATE " + TABLE.NOTE +// 创建触发器SQL
-                    "   SET " + NoteColumns.SNIPPET + "=''" +// 创建触发器SQL
-                    "  WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" +// 创建触发器SQL
-                    " END";  // 创建触发器SQL
-
-    // 创建触发器：删除笔记时删除相关的数据
-    private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =// 创建触发器SQL
-            "CREATE TRIGGER delete_data_on_delete " +// 创建触发器SQL
-                    " AFTER DELETE ON " + TABLE.NOTE +// 创建触发器SQL
-                    " BEGIN" +// 创建触发器SQL
-                    "  DELETE FROM " + TABLE.DATA +// 创建触发器SQL
-                    "   WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" +// 创建触发器SQL
-                    " END";  // 创建触发器SQL
-
-    // 创建触发器：删除文件夹时删除该文件夹中的所有笔记
-    private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =// 创建触发器SQL
-            "CREATE TRIGGER folder_delete_notes_on_delete " +// 创建触发器SQL
-                    " AFTER DELETE ON " + TABLE.NOTE +// 创建触发器SQL
-                    " BEGIN" +// 创建触发器SQL
-                    "  DELETE FROM " + TABLE.NOTE +// 创建触发器SQL
-                    "   WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +// 创建触发器SQL
-                    " END";  // 创建触发器SQL
-
-    // 创建触发器：移动文件夹到回收站时移动所有笔记到回收站
-    private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =// 创建触发器SQL
-            "CREATE TRIGGER folder_move_notes_on_trash " +// 创建触发器SQL
-                    " AFTER UPDATE ON " + TABLE.NOTE +// 创建触发器SQL
-                    " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +// 创建触发器SQL
-                    " BEGIN" +// 创建触发器SQL
-                    "  UPDATE " + TABLE.NOTE +// 创建触发器SQL
-                    "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +// 创建触发器SQL
-                    "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +// 创建触发器SQL
-                    " END";  // 创建触发器SQL
-
-    // 构造函数，初始化数据库帮助类
+        "CREATE TABLE " + TABLE.NOTE + "(" +
+            NoteColumns.ID + " INTEGER PRIMARY KEY," +
+            NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +
+            NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +
+            NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
+            NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
+        ")";
+
+    private static final String CREATE_DATA_TABLE_SQL =
+        "CREATE TABLE " + TABLE.DATA + "(" +
+            DataColumns.ID + " INTEGER PRIMARY KEY," +
+            DataColumns.MIME_TYPE + " TEXT NOT NULL," +
+            DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," +
+            DataColumns.DATA1 + " INTEGER," +
+            DataColumns.DATA2 + " INTEGER," +
+            DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +
+            DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
+            DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
+        ")";
+
+    private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
+        "CREATE INDEX IF NOT EXISTS note_id_index ON " +
+        TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
+
+    /**
+     * Increase folder's note count when move note to the folder
+     */
+    private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
+        "CREATE TRIGGER increase_folder_count_on_update "+
+        " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
+        " BEGIN " +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
+        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
+        " END";
+
+    /**
+     * Decrease folder's note count when move note from folder
+     */
+    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
+        "CREATE TRIGGER decrease_folder_count_on_update " +
+        " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
+        " BEGIN " +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
+        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
+        "  AND " + 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 =
+        "CREATE TRIGGER increase_folder_count_on_insert " +
+        " AFTER INSERT ON " + TABLE.NOTE +
+        " BEGIN " +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
+        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
+        " END";
+
+    /**
+     * Decrease folder's note count when delete note from the folder
+     */
+    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =
+        "CREATE TRIGGER decrease_folder_count_on_delete " +
+        " AFTER DELETE ON " + TABLE.NOTE +
+        " BEGIN " +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
+        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
+        "  AND " + NoteColumns.NOTES_COUNT + ">0;" +
+        " END";
+
+    /**
+     * Update note's content when insert data with type {@link DataConstants#NOTE}
+     */
+    private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
+        "CREATE TRIGGER update_note_content_on_insert " +
+        " AFTER INSERT ON " + TABLE.DATA +
+        " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
+        " BEGIN" +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
+        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
+        " END";
+
+    /**
+     * Update note's content when data with {@link DataConstants#NOTE} type has changed
+     */
+    private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
+        "CREATE TRIGGER update_note_content_on_update " +
+        " AFTER UPDATE ON " + TABLE.DATA +
+        " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
+        " BEGIN" +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
+        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
+        " END";
+
+    /**
+     * Update note's content when data with {@link DataConstants#NOTE} type has deleted
+     */
+    private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
+        "CREATE TRIGGER update_note_content_on_delete " +
+        " AFTER delete ON " + TABLE.DATA +
+        " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
+        " BEGIN" +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.SNIPPET + "=''" +
+        "  WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" +
+        " END";
+
+    /**
+     * Delete datas belong to note which has been deleted
+     */
+    private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =
+        "CREATE TRIGGER delete_data_on_delete " +
+        " AFTER DELETE ON " + TABLE.NOTE +
+        " BEGIN" +
+        "  DELETE FROM " + TABLE.DATA +
+        "   WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" +
+        " END";
+
+    /**
+     * Delete notes belong to folder which has been deleted
+     */
+    private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
+        "CREATE TRIGGER folder_delete_notes_on_delete " +
+        " AFTER DELETE ON " + TABLE.NOTE +
+        " BEGIN" +
+        "  DELETE FROM " + TABLE.NOTE +
+        "   WHERE " + NoteColumns.PARENT_ID + "=old." + 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 =
+        "CREATE TRIGGER folder_move_notes_on_trash " +
+        " AFTER UPDATE ON " + TABLE.NOTE +
+        " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
+        " BEGIN" +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
+        "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
+        " END";
+
     public NotesDatabaseHelper(Context context) {
-        super(context, DB_NAME, null, DB_VERSION);  // 调用父类的构造函数，指定数据库名称和版本
+        super(context, DB_NAME, null, DB_VERSION);
     }
 
-    // 创建笔记表
     public void createNoteTable(SQLiteDatabase db) {
-        db.execSQL(CREATE_NOTE_TABLE_SQL);  // 执行创建笔记表的SQL语句
-        reCreateNoteTableTriggers(db);  // 创建触发器
+        db.execSQL(CREATE_NOTE_TABLE_SQL);
+        reCreateNoteTableTriggers(db);
+        createSystemFolder(db);
+        Log.d(TAG, "note table has been created");
+    }
+
+    private void reCreateNoteTableTriggers(SQLiteDatabase db) {
+        db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
+        db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
+        db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
+        db.execSQL("DROP TRIGGER IF EXISTS delete_data_on_delete");
+        db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_insert");
+        db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
+        db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash");
+
+        db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
+        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
+        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);
+        db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER);
+        db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER);
+        db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
+        db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
+    }
+
+    private void createSystemFolder(SQLiteDatabase db) {
+        ContentValues values = new ContentValues();
+
+        /**
+         * call record foler for call notes
+         */
+        values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+        db.insert(TABLE.NOTE, null, 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.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+        db.insert(TABLE.NOTE, null, values);
+
+        /**
+         * create trash folder
+         */
+        values.clear();
+        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+        db.insert(TABLE.NOTE, null, values);
     }
 
-    // 创建数据表
     public void createDataTable(SQLiteDatabase db) {
-        db.execSQL(CREATE_DATA_TABLE_SQL);  // 执行创建数据表的SQL语句
-        db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);  // 创建数据表的索引
-        Log.d(TAG, "data table has been created");  // 打印日志
+        db.execSQL(CREATE_DATA_TABLE_SQL);
+        reCreateDataTableTriggers(db);
+        db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
+        Log.d(TAG, "data table has been created");
     }
 
-    // 执行数据库创建操作
-    @Override
-    public void onCreate(SQLiteDatabase db) {
-        createNoteTable(db);  // 创建笔记表
-        createDataTable(db);  // 创建数据表
+    private void reCreateDataTableTriggers(SQLiteDatabase db) {
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete");
+
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER);
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
     }
-    @Override
-    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
-        Log.d(TAG, "onUpgrade: " + oldVersion + " --> " + newVersion);  // 打印日志
 
-        // 根据版本号升级数据库
-        if (oldVersion == 1) {
-            db.execSQL(CREATE_DATA_TABLE_SQL);  // 创建数据表
-            db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);  // 创建索引
-            db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);  // 创建触发器
-            db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);  // 创建触发器
-        }
-        if (oldVersion <= 3) {
-            createNoteTable(db);  // 创建笔记表
-            reCreateNoteTableTriggers(db);  // 创建触发器
+    static synchronized NotesDatabaseHelper getInstance(Context context) {
+        if (mInstance == null) {
+            mInstance = new NotesDatabaseHelper(context);
         }
+        return mInstance;
     }
-    // 执行数据库升级操作
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+        createNoteTable(db);
+        createDataTable(db);
+    }
+
     @Override
     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
-        boolean reCreateTriggers = false;  // 是否需要重新创建触发器的标志
-        boolean skipV2 = false;  // 是否跳过V2升级的标志
+        boolean reCreateTriggers = false;
+        boolean skipV2 = false;
 
-        // 如果当前数据库版本是1，进行从V1升级到V2的操作
         if (oldVersion == 1) {
-            upgradeToV2(db);  // 执行V1到V2的升级
-            skipV2 = true;  // 跳过V2到V3的升级
-            oldVersion++;  // 更新数据库版本为2
+            upgradeToV2(db);
+            skipV2 = true; // this upgrade including the upgrade from v2 to v3
+            oldVersion++;
         }
 
-        // 如果当前数据库版本是2且没有跳过V2升级
         if (oldVersion == 2 && !skipV2) {
-            upgradeToV3(db);  // 执行V2到V3的升级
-            reCreateTriggers = true;  // 标记需要重新创建触发器
-            oldVersion++;  // 更新数据库版本为3
+            upgradeToV3(db);
+            reCreateTriggers = true;
+            oldVersion++;
         }
 
-        // 如果当前数据库版本是3，执行V3到V4的升级
         if (oldVersion == 3) {
-            upgradeToV4(db);  // 执行V3到V4的升级
-            oldVersion++;  // 更新数据库版本为4
-        }// 添加VERSION列，默认为0
+            upgradeToV4(db);
+            oldVersion++;
+        }
 
-        // 如果需要重新创建触发器，执行重新创建触发器的操作
         if (reCreateTriggers) {
-            reCreateNoteTableTriggers(db);  // 重新创建笔记表的触发器
-            reCreateDataTableTriggers(db);  // 重新创建数据表的触发器
+            reCreateNoteTableTriggers(db);
+            reCreateDataTableTriggers(db);
         }
 
-        // 如果升级后的版本不等于目标版本，抛出异常
         if (oldVersion != newVersion) {
-            throw new IllegalStateException("Upgrade notes database to version " + newVersion// 添加VERSION列，默认为0
-                    + " fails");  // 升级失败抛出异常
-        }// 添加VERSION列，默认为0
-    }// 添加VERSION列，默认为0
-    // 添加VERSION列，默认为0
-    // 从V1升级到V2
+            throw new IllegalStateException("Upgrade notes database to version " + newVersion
+                    + "fails");
+        }
+    }
+
     private void upgradeToV2(SQLiteDatabase db) {
-        db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);  // 删除笔记表（如果存在）
-        db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);  // 删除数据表（如果存在）
-        createNoteTable(db);  // 重新创建笔记表
-        createDataTable(db);  // 重新创建数据表
-    }// 添加VERSION列，默认为0
-    // 添加VERSION列，默认为0
-    // 从V2升级到V3
+        db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
+        db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
+        createNoteTable(db);
+        createDataTable(db);
+    }
+
     private void upgradeToV3(SQLiteDatabase db) {
-        // 删除不再使用的触发器
-        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");  // 删除插入时更新时间触发器
-        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete");  // 删除删除时更新时间触发器
-        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");  // 删除更新时更新时间触发器
-        // 在笔记表中添加一个新的列，用于存储gtask ID
+        // drop unused triggers
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete");
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");
+        // add a column for gtask id
         db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
-                + " TEXT NOT NULL DEFAULT ''");  // 添加GTASK_ID列，默认为空字符串
-        // 在笔记表中添加一个垃圾系统文件夹
-        ContentValues values = new ContentValues();  // 创建一个ContentValues对象
-        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);  // 设置垃圾文件夹ID
-        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);  // 设置文件夹类型为系统文件夹
-        db.insert(TABLE.NOTE, null, values);  // 插入新的垃圾文件夹记录
-    }// 添加VERSION列，默认为0
-    // 添加VERSION列，默认为0
-    // 从V3升级到V4
+                + " TEXT NOT NULL DEFAULT ''");
+        // add a trash system folder
+        ContentValues values = new ContentValues();
+        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+        db.insert(TABLE.NOTE, null, values);
+    }
+
     private void upgradeToV4(SQLiteDatabase db) {
-        // 在笔记表中添加一个新的列，用于存储版本号
         db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
-                + " INTEGER NOT NULL DEFAULT 0");  // 添加VERSION列，默认为0
-    }// 添加VERSION列，默认为0
-// 添加VERSION列，默认为0
-// 添加VERSION列，默认为0
-}// 添加VERSION列，默认为0
-// 添加VERSION列，默认为0
+                + " INTEGER NOT NULL DEFAULT 0");
+    }
+}

app/src/main/java/net/micode/notes/data/NotesProvider.java

@@ -1,229 +1,305 @@
 /*
  * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
- * See LICENSE file for full license details.
+ * 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.app.SearchManager;//导入
-import android.content.ContentProvider;//导入
-import android.content.ContentUris;//导入
-import android.content.ContentValues;//导入
-import android.content.Intent;//导入
-import android.content.UriMatcher;//导入
-import android.database.Cursor;//导入
-import android.database.sqlite.SQLiteDatabase;//导入
-import android.net.Uri;//导入
-import android.text.TextUtils;//导入
-import android.util.Log;//导入
-//导入
-import net.micode.notes.R;//导入
-import net.micode.notes.data.Notes.DataColumns;//导入
-import net.micode.notes.data.Notes.NoteColumns;//导入
-import net.micode.notes.data.NotesDatabaseHelper.TABLE;//导入
-
-public class NotesProvider extends ContentProvider {//导入
-
-    // 日志标签，用于日志输出
-    private static final String TAG = "NotesProvider";//导入
-
-    // Uri匹配器，负责匹配传入的Uri
-    private static final UriMatcher mMatcher;// 插入方法
-
-    // 数据库帮助类对象
-    private NotesDatabaseHelper mHelper;// 插入方法
-
-    // 常量定义：匹配不同Uri
-    private static final int URI_NOTE            = 1; // 匹配整个笔记表// 常量定义：匹配不同Uri
-    private static final int URI_NOTE_ITEM       = 2; // 匹配单个笔记项// 常量定义：匹配不同Uri
-    private static final int URI_DATA            = 3; // 匹配数据表// 常量定义：匹配不同Uri
-    private static final int URI_DATA_ITEM       = 4; // 匹配单个数据项// 常量定义：匹配不同Uri
-    private static final int URI_SEARCH          = 5; // 匹配搜索功能// 常量定义：匹配不同Uri
-    private static final int URI_SEARCH_SUGGEST  = 6; // 匹配搜索建议// 常量定义：匹配不同Uri
+package net.micode.notes.data;
+
+
+import android.app.SearchManager;
+import android.content.ContentProvider;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Intent;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.net.Uri;
+import android.text.TextUtils;
+import android.util.Log;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.NotesDatabaseHelper.TABLE;
+
+
+public class NotesProvider extends ContentProvider {
+    private static final UriMatcher mMatcher;
+
+    private NotesDatabaseHelper mHelper;
+
+    private static final String TAG = "NotesProvider";
+
+    private static final int URI_NOTE            = 1;
+    private static final int URI_NOTE_ITEM       = 2;
+    private static final int URI_DATA            = 3;
+    private static final int URI_DATA_ITEM       = 4;
+
+    private static final int URI_SEARCH          = 5;
+    private static final int URI_SEARCH_SUGGEST  = 6;
 
     static {
-        mMatcher = new UriMatcher(UriMatcher.NO_MATCH);// 常量定义：匹配不同Uri
-        mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE); // 匹配笔记表Uri
-        mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM); // 匹配单个笔记
-        mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA); // 匹配数据表Uri
-        mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM); // 匹配单个数据项
-        mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH); // 匹配搜索功能
-        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST); // 匹配搜索建议
-        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST); // 带参数的搜索建议
+        mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+        mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
+        mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
+        mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
+        mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
+        mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
+        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
+        mMatcher.addURI(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 + ","// 常量定义：匹配不同Uri
-            + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + ","// 常量定义：匹配不同Uri
-            + R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","// 常量定义：匹配不同Uri
-            + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","// 常量定义：匹配不同Uri
-            + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;// 常量定义：匹配不同Uri
-
-    // SQL查询：模糊搜索笔记内容
+        + 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;
+
     private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
-            + " FROM " + TABLE.NOTE // SQL查询：模糊搜索笔记内容
-            + " WHERE " + NoteColumns.SNIPPET + " LIKE ?" // SQL查询：模糊搜索笔记内容
-            + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER // SQL查询：模糊搜索笔记内容
-            + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE; // SQL查询：模糊搜索笔记内容
+        + " FROM " + TABLE.NOTE
+        + " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
+        + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
+        + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
 
-    // 初始化ContentProvider时调用
     @Override
-    public boolean onCreate() { // SQL查询：模糊搜索笔记内容
-        mHelper = NotesDatabaseHelper.getInstance(getContext()); // 获取数据库帮助类实例
-        return true; // SQL查询：模糊搜索笔记内容
-    } // SQL查询：模糊搜索笔记内容
+    public boolean onCreate() {
+        mHelper = NotesDatabaseHelper.getInstance(getContext());
+        return true;
+    }
 
-    /**
-     * 查询方法：根据Uri执行相应的查询操作
-     */
     @Override
-    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {// 插入方法
-        Cursor c = null;// 插入方法
-        SQLiteDatabase db = mHelper.getReadableDatabase(); // 获取可读数据库
-        String id = null;// 插入方法
+    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+            String sortOrder) {
+        Cursor c = null;
+        SQLiteDatabase db = mHelper.getReadableDatabase();
+        String id = null;
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
+                        sortOrder);
+                break;
+            case URI_NOTE_ITEM:
+                id = uri.getPathSegments().get(1);
+                c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
+                break;
+            case URI_DATA:
+                c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
+                        sortOrder);
+                break;
+            case URI_DATA_ITEM:
+                id = uri.getPathSegments().get(1);
+                c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
+                break;
+            case URI_SEARCH:
+            case URI_SEARCH_SUGGEST:
+                if (sortOrder != null || projection != null) {
+                    throw new IllegalArgumentException(
+                            "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
+                }
+
+                String searchString = null;
+                if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
+                    if (uri.getPathSegments().size() > 1) {
+                        searchString = uri.getPathSegments().get(1);
+                    }
+                } else {
+                    searchString = uri.getQueryParameter("pattern");
+                }
+
+                if (TextUtils.isEmpty(searchString)) {
+                    return null;
+                }
+
+                try {
+                    searchString = String.format("%%%s%%", searchString);
+                    c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
+                            new String[] { searchString });
+                } catch (IllegalStateException ex) {
+                    Log.e(TAG, "got exception: " + ex.toString());
+                }
+                break;
+            default:
+                throw new IllegalArgumentException("Unknown URI " + uri);
+        }
+        if (c != null) {
+            c.setNotificationUri(getContext().getContentResolver(), uri);
+        }
+        return c;
+    }
 
+    @Override
+    public Uri insert(Uri uri, ContentValues values) {
+        SQLiteDatabase db = mHelper.getWritableDatabase();
+        long dataId = 0, noteId = 0, insertedId = 0;
         switch (mMatcher.match(uri)) {
             case URI_NOTE:
-                // 查询笔记表
-                c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null, sortOrder);// 插入方法
-                break;// 插入方法
-            // SQL查询：模糊搜索笔记内容
-            case URI_NOTE_ITEM:// 插入方法
-                // 查询特定的笔记
-                id = uri.getPathSegments().get(1);// 插入方法
-                c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs, null, null, sortOrder);
-                break; // SQL查询：模糊搜索笔记内容
-            // SQL查询：模糊搜索笔记内容
-            case URI_DATA: // SQL查询：模糊搜索笔记内容
-                // 查询数据表
-                c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null, sortOrder);
-                break; // SQL查询：模糊搜索笔记内容
-
-            case URI_DATA_ITEM: // SQL查询：模糊搜索笔记内容
-                // 查询特定的数据项
-                id = uri.getPathSegments().get(1); // SQL查询：模糊搜索笔记内容
-                c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs, null, null, sortOrder);
-                break; // SQL查询：模糊搜索笔记内容
-
-            case URI_SEARCH: // SQL查询：模糊搜索笔记内容
-            case URI_SEARCH_SUGGEST: // SQL查询：模糊搜索笔记内容
-                // 执行搜索查询
-                if (sortOrder != null || projection != null) { // SQL查询：模糊搜索笔记内容
-                    throw new IllegalArgumentException("Invalid query parameters for search"); // SQL查询：模糊搜索笔记内容
-                } // SQL查询：模糊搜索笔记内容
-
-                String searchString = null; // SQL查询：模糊搜索笔记内容
-
-                if (mMatcher.match(uri) == URI_SEARCH_SUGGEST && uri.getPathSegments().size() > 1) { // SQL查询：模糊搜索笔记内容
-                    searchString = uri.getPathSegments().get(1); // SQL查询：模糊搜索笔记内容
-                } else { // SQL查询：模糊搜索笔记内容
-                    searchString = uri.getQueryParameter("pattern"); // SQL查询：模糊搜索笔记内容
-                } // SQL查询：模糊搜索笔记内容
-
-                if (TextUtils.isEmpty(searchString)) { // SQL查询：模糊搜索笔记内容
-                    return null; // SQL查询：模糊搜索笔记内容
-                } // SQL查询：模糊搜索笔记内容
-
-                try { // SQL查询：模糊搜索笔记内容
-                    searchString = String.format("%%%s%%", searchString); // SQL查询：模糊搜索笔记内容
-                    c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY, new String[] { searchString }); // SQL查询：模糊搜索笔记内容
-                } catch (IllegalStateException ex) { // SQL查询：模糊搜索笔记内容
-                    Log.e(TAG, "Exception during search query: " + ex.toString()); // SQL查询：模糊搜索笔记内容
-                } // SQL查询：模糊搜索笔记内容
-                break; // SQL查询：模糊搜索笔记内容
-
-            default: // SQL查询：模糊搜索笔记内容
-                throw new IllegalArgumentException("Unknown URI: " + uri); // SQL查询：模糊搜索笔记内容
-        } // SQL查询：模糊搜索笔记内容
-        // SQL查询：模糊搜索笔记内容
-        if (c != null) { // SQL查询：模糊搜索笔记内容
-            c.setNotificationUri(getContext().getContentResolver(), uri); // SQL查询：模糊搜索笔记内容
-        } // SQL查询：模糊搜索笔记内容
-
-        return c; // SQL查询：模糊搜索笔记内容
-    } // SQL查询：模糊搜索笔记内容
-
-    // 插入方法
+                insertedId = noteId = db.insert(TABLE.NOTE, null, values);
+                break;
+            case URI_DATA:
+                if (values.containsKey(DataColumns.NOTE_ID)) {
+                    noteId = values.getAsLong(DataColumns.NOTE_ID);
+                } else {
+                    Log.d(TAG, "Wrong data format without note id:" + values.toString());
+                }
+                insertedId = dataId = db.insert(TABLE.DATA, null, values);
+                break;
+            default:
+                throw new IllegalArgumentException("Unknown URI " + uri);
+        }
+        // Notify the note uri
+        if (noteId > 0) {
+            getContext().getContentResolver().notifyChange(
+                    ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
+        }
+
+        // Notify the data uri
+        if (dataId > 0) {
+            getContext().getContentResolver().notifyChange(
+                    ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
+        }
+
+        return ContentUris.withAppendedId(uri, insertedId);
+    }
+
     @Override
-    public Uri insert(Uri uri, ContentValues values) {// 插入方法
-        SQLiteDatabase db = mHelper.getWritableDatabase();// 插入方法
-        long insertedId = 0;// 插入方法
-        switch (mMatcher.match(uri)) {// 插入方法
-            case URI_NOTE:// 插入方法
-                insertedId = db.insert(TABLE.NOTE, null, values); // 插入到笔记表
-                break;// 插入方法
-
-            case URI_DATA:// 插入方法
-                insertedId = db.insert(TABLE.DATA, null, values); // 插入到数据表
-                break;// 插入方法
-
-            default:// 插入方法
-                throw new IllegalArgumentException("Unknown URI: " + uri);// 插入方法
-        }// 插入方法
-
-        getContext().getContentResolver().notifyChange(uri, null); // 通知数据变更
-        return ContentUris.withAppendedId(uri, insertedId);// 插入方法
-    } // SQL查询：模糊搜索笔记内容
-
-    // 删除方法
+    public int delete(Uri uri, String selection, String[] selectionArgs) {
+        int count = 0;
+        String id = null;
+        SQLiteDatabase db = mHelper.getWritableDatabase();
+        boolean deleteData = false;
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
+                count = db.delete(TABLE.NOTE, selection, selectionArgs);
+                break;
+            case URI_NOTE_ITEM:
+                id = uri.getPathSegments().get(1);
+                /**
+                 * ID that smaller than 0 is system folder which is not allowed to
+                 * trash
+                 */
+                long noteId = Long.valueOf(id);
+                if (noteId <= 0) {
+                    break;
+                }
+                count = db.delete(TABLE.NOTE,
+                        NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
+                break;
+            case URI_DATA:
+                count = db.delete(TABLE.DATA, selection, selectionArgs);
+                deleteData = true;
+                break;
+            case URI_DATA_ITEM:
+                id = uri.getPathSegments().get(1);
+                count = db.delete(TABLE.DATA,
+                        DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
+                deleteData = true;
+                break;
+            default:
+                throw new IllegalArgumentException("Unknown URI " + uri);
+        }
+        if (count > 0) {
+            if (deleteData) {
+                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
+            }
+            getContext().getContentResolver().notifyChange(uri, null);
+        }
+        return count;
+    }
+
     @Override
-    public int delete(Uri uri, String selection, String[] selectionArgs) { // SQL查询：模糊搜索笔记内容
-        SQLiteDatabase db = mHelper.getWritableDatabase(); // SQL查询：模糊搜索笔记内容
-        int count = 0; // SQL查询：模糊搜索笔记内容
-
-        switch (mMatcher.match(uri)) { // SQL查询：模糊搜索笔记内容
-            case URI_NOTE: // SQL查询：模糊搜索笔记内容
-                count = db.delete(TABLE.NOTE, selection, selectionArgs); // SQL查询：模糊搜索笔记内容
-                break; // SQL查询：模糊搜索笔记内容
-            // SQL查询：模糊搜索笔记内容
-            case URI_NOTE_ITEM: // SQL查询：模糊搜索笔记内容
-                count = db.delete(TABLE.NOTE, NoteColumns.ID  // SQL查询：模糊搜索笔记内容+ "=" + id + parseSelection(selection), selectionArgs);
-                String id = uri.getPathSegments().get(1);
-              //  count = db.delete(TABLE.NOTE, NoteColumns.ID  // SQL查询：模糊搜索笔记内容+ "=" + id + parseSelection(selection), selectionArgs);
-                count = db.delete(TABLE.NOTE, NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);// SQL查询：模糊搜索笔记内容
-                break;// SQL查询：模糊搜索笔记内容
-
-            default:// SQL查询：模糊搜索笔记内容
-                throw new IllegalArgumentException("Unknown URI: " + uri);// SQL查询：模糊搜索笔记内容
-        }// SQL查询：模糊搜索笔记内容
-
-        if (count > 0) {// SQL查询：模糊搜索笔记内容
-            getContext().getContentResolver().notifyChange(uri, null); // 数据变更通知
-        }// SQL查询：模糊搜索笔记内容
-        return count;// SQL查询：模糊搜索笔记内容
-    }// SQL查询：模糊搜索笔记内容
-
-    // 更新方法
-    @Override// SQL查询：模糊搜索笔记内容
-    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {// SQL查询：模糊搜索笔记内容
-        SQLiteDatabase db = mHelper.getWritableDatabase();// SQL查询：模糊搜索笔记内容
-        int count = 0;// SQL查询：模糊搜索笔记内容
-// SQL查询：模糊搜索笔记内容
-        switch (mMatcher.match(uri)) {// SQL查询：模糊搜索笔记内容
-            case URI_NOTE:// SQL查询：模糊搜索笔记内容
-                count = db.update(TABLE.NOTE, values, selection, selectionArgs);// SQL查询：模糊搜索笔记内容
-                break;// SQL查询：模糊搜索笔记内容
-
-            default:// SQL查询：模糊搜索笔记内容
-                throw new IllegalArgumentException("Unknown URI: " + uri);// SQL查询：模糊搜索笔记内容
-        }// SQL查询：模糊搜索笔记内容
-
-        if (count > 0) {// SQL查询：模糊搜索笔记内容
-            getContext().getContentResolver().notifyChange(uri, null);// SQL查询：模糊搜索笔记内容
-        }// SQL查询：模糊搜索笔记内容
-        return count;// SQL查询：模糊搜索笔记内容
-    }// SQL查询：模糊搜索笔记内容
-
-    // 辅助方法：解析selection条件
+    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+        int count = 0;
+        String id = null;
+        SQLiteDatabase db = mHelper.getWritableDatabase();
+        boolean updateData = false;
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                increaseNoteVersion(-1, selection, selectionArgs);
+                count = db.update(TABLE.NOTE, values, selection, selectionArgs);
+                break;
+            case URI_NOTE_ITEM:
+                id = uri.getPathSegments().get(1);
+                increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
+                count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs);
+                break;
+            case URI_DATA:
+                count = db.update(TABLE.DATA, values, selection, selectionArgs);
+                updateData = true;
+                break;
+            case URI_DATA_ITEM:
+                id = uri.getPathSegments().get(1);
+                count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs);
+                updateData = true;
+                break;
+            default:
+                throw new IllegalArgumentException("Unknown URI " + uri);
+        }
+
+        if (count > 0) {
+            if (updateData) {
+                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
+            }
+            getContext().getContentResolver().notifyChange(uri, null);
+        }
+        return count;
+    }
+
     private String parseSelection(String selection) {
-        return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");// SQL查询：模糊搜索笔记内容
-    }// SQL查询：模糊搜索笔记内容
-    // SQL查询：模糊搜索笔记内容
+        return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
+    }
+
+    private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
+        StringBuilder sql = new StringBuilder(120);
+        sql.append("UPDATE ");
+        sql.append(TABLE.NOTE);
+        sql.append(" SET ");
+        sql.append(NoteColumns.VERSION);
+        sql.append("=" + NoteColumns.VERSION + "+1 ");
+
+        if (id > 0 || !TextUtils.isEmpty(selection)) {
+            sql.append(" WHERE ");
+        }
+        if (id > 0) {
+            sql.append(NoteColumns.ID + "=" + String.valueOf(id));
+        }
+        if (!TextUtils.isEmpty(selection)) {
+            String selectString = id > 0 ? parseSelection(selection) : selection;
+            for (String args : selectionArgs) {
+                selectString = selectString.replaceFirst("\\?", args);
+            }
+            sql.append(selectString);
+        }
+
+        mHelper.getWritableDatabase().execSQL(sql.toString());
+    }
+
     @Override
-    public String getType(Uri uri) {// SQL查询：模糊搜索笔记内容
-        return null; // 不使用MIME类型// SQL查询：模糊搜索笔记内容
-    }// SQL查询：模糊搜索笔记内容
-}// SQL查询：模糊搜索笔记内容
+    public String getType(Uri uri) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+}

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

@@ -1,83 +1,82 @@
 /*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)// 定义包名
+ * 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// 定义包名
+ * 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// 定义包名
+ *        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.// 定义包名
- */// 定义包名
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-package net.micode.notes.gtask.data; // 定义包名
-// 定义包名
-import android.database.Cursor; // 导入Cursor类
-import android.util.Log; // 导入Log类
-// 定义包名
-import net.micode.notes.tool.GTaskStringUtils; // 导入GTaskStringUtils类
-// 定义包名
-import org.json.JSONException; // 导入JSONException类
-import org.json.JSONObject; // 导入JSONObject类
-// 定义包名
-public class MetaData extends Task { // 定义MetaData类，继承自Task类
-    private final static String TAG = MetaData.class.getSimpleName(); // 定义日志标签
-    // 定义包名
-    private String mRelatedGid = null; // 定义一个字符串变量用于存储相关的GID
-    // 定义包名
-    // 设置元数据的方法
-    public void setMeta(String gid, JSONObject metaInfo) {// 定义包名
-        try {// 定义包名
-            metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid); // 将GID放入metaInfo中// 定义包名
-        } catch (JSONException e) {// 定义包名
-            Log.e(TAG, "failed to put related gid"); // 捕获异常并记录错误日志// 定义包名
-        }// 定义包名
-        setNotes(metaInfo.toString()); // 将metaInfo转换为字符串并设置为笔记内容// 定义包名
-        setName(GTaskStringUtils.META_NOTE_NAME); // 设置笔记名称// 定义包名
-    }// 定义包名
-    // 定义包名
-    // 获取相关GID的方法
-    public String getRelatedGid() {// 定义包名
-        return mRelatedGid; // 返回相关GID// 定义包名
-    }// 定义包名
-    // 定义包名
-    @Override// 定义包名
-    public boolean isWorthSaving() {// 定义包名
-        return getNotes() != null; // 判断笔记内容是否不为空// 定义包名
-    }// 定义包名
-    // 定义包名
-    @Override// 定义包名
-    public void setContentByRemoteJSON(JSONObject js) {// 定义包名
-        super.setContentByRemoteJSON(js); // 调用父类方法设置内容// 定义包名
-        if (getNotes() != null) { // 如果笔记内容不为空// 定义包名
-            try {// 定义包名
-                JSONObject metaInfo = new JSONObject(getNotes().trim()); // 将笔记内容转换为JSONObject// 定义包名
-                mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID); // 获取相关GID// 定义包名
-            } catch (JSONException e) {// 定义包名
-                Log.w(TAG, "failed to get related gid"); // 捕获异常并记录警告日志// 定义包名
-                mRelatedGid = null; // 将相关GID设置为空// 定义包名
-            }// 定义包名
-        }// 定义包名
-    }// 定义包名
-    // 定义包名
-    @Override// 定义包名
-    public void setContentByLocalJSON(JSONObject js) {// 定义包名
-        // 这个方法不应该被调用
-        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");// 定义包名
-    }// 定义包名
-    // 定义包名
-    @Override// 定义包名
-    public JSONObject getLocalJSONFromContent() {// 定义包名
-        throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");// 定义包名
-    }// 定义包名
-    // 定义包名
-    @Override// 定义包名
-    public int getSyncAction(Cursor c) {// 定义包名
-        throw new IllegalAccessError("MetaData:getSyncAction should not be called");// 定义包名
-    }// 定义包名
-// 定义包名
-}// 定义包名
+package net.micode.notes.gtask.data;
+
+import android.database.Cursor;
+import android.util.Log;
+
+import net.micode.notes.tool.GTaskStringUtils;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+
+public class MetaData extends Task {
+    private final static String TAG = MetaData.class.getSimpleName();
+
+    private String mRelatedGid = null;
+
+    public void setMeta(String gid, JSONObject metaInfo) {
+        try {
+            metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
+        } catch (JSONException e) {
+            Log.e(TAG, "failed to put related gid");
+        }
+        setNotes(metaInfo.toString());
+        setName(GTaskStringUtils.META_NOTE_NAME);
+    }
+
+    public String getRelatedGid() {
+        return mRelatedGid;
+    }
+
+    @Override
+    public boolean isWorthSaving() {
+        return getNotes() != null;
+    }
+
+    @Override
+    public void setContentByRemoteJSON(JSONObject js) {
+        super.setContentByRemoteJSON(js);
+        if (getNotes() != null) {
+            try {
+                JSONObject metaInfo = new JSONObject(getNotes().trim());
+                mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
+            } catch (JSONException e) {
+                Log.w(TAG, "failed to get related gid");
+                mRelatedGid = null;
+            }
+        }
+    }
+
+    @Override
+    public void setContentByLocalJSON(JSONObject js) {
+        // this function should not be called
+        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
+    }
+
+    @Override
+    public JSONObject getLocalJSONFromContent() {
+        throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
+    }
+
+    @Override
+    public int getSyncAction(Cursor c) {
+        throw new IllegalAccessError("MetaData:getSyncAction should not be called");
+    }
+
+}

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

@@ -1,101 +1,101 @@
 /*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)//
+ * 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//
+ * 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//
+ *        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.//
+ * 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; // 定义包名
+package net.micode.notes.gtask.data;
 
-import android.database.Cursor; // 导入Cursor类
+import android.database.Cursor;
 
-import org.json.JSONObject; // 导入JSONObject类
+import org.json.JSONObject;
 
-public abstract class Node { // 定义抽象类Node
-    public static final int SYNC_ACTION_NONE = 0; // 定义常量，表示无同步操作
+public abstract class Node {
+    public static final int SYNC_ACTION_NONE = 0;
 
-    public static final int SYNC_ACTION_ADD_REMOTE = 1; // 定义常量，表示添加到远程
+    public static final int SYNC_ACTION_ADD_REMOTE = 1;
 
-    public static final int SYNC_ACTION_ADD_LOCAL = 2; // 定义常量，表示添加到本地
+    public static final int SYNC_ACTION_ADD_LOCAL = 2;
 
-    public static final int SYNC_ACTION_DEL_REMOTE = 3; // 定义常量，表示从远程删除
+    public static final int SYNC_ACTION_DEL_REMOTE = 3;
 
-    public static final int SYNC_ACTION_DEL_LOCAL = 4; // 定义常量，表示从本地删除
+    public static final int SYNC_ACTION_DEL_LOCAL = 4;
 
-    public static final int SYNC_ACTION_UPDATE_REMOTE = 5; // 定义常量，表示更新到远程
+    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
 
-    public static final int SYNC_ACTION_UPDATE_LOCAL = 6; // 定义常量，表示更新到本地
+    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
 
-    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; // 定义常量，表示更新冲突
+    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
 
-    public static final int SYNC_ACTION_ERROR = 8; // 定义常量，表示同步错误
+    public static final int SYNC_ACTION_ERROR = 8;
 
-    private String mGid; // 定义私有变量mGid，存储GID
+    private String mGid;
 
-    private String mName; // 定义私有变量mName，存储名称
+    private String mName;
 
-    private long mLastModified; // 定义私有变量mLastModified，存储最后修改时间
+    private long mLastModified;
 
-    private boolean mDeleted; // 定义私有变量mDeleted，存储删除状态
+    private boolean mDeleted;
 
-    public Node() { // 构造函数，初始化变量
-        mGid = null; // 初始化mGid为null
-        mName = ""; // 初始化mName为空字符串
-        mLastModified = 0; // 初始化mLastModified为0
-        mDeleted = false; // 初始化mDeleted为false
+    public Node() {
+        mGid = null;
+        mName = "";
+        mLastModified = 0;
+        mDeleted = false;
     }
 
-    public abstract JSONObject getCreateAction(int actionId); // 抽象方法，获取创建操作的JSON对象
+    public abstract JSONObject getCreateAction(int actionId);
 
-    public abstract JSONObject getUpdateAction(int actionId); // 抽象方法，获取更新操作的JSON对象
+    public abstract JSONObject getUpdateAction(int actionId);
 
-    public abstract void setContentByRemoteJSON(JSONObject js); // 抽象方法，通过远程JSON设置内容
+    public abstract void setContentByRemoteJSON(JSONObject js);
 
-    public abstract void setContentByLocalJSON(JSONObject js); // 抽象方法，通过本地JSON设置内容
+    public abstract void setContentByLocalJSON(JSONObject js);
 
-    public abstract JSONObject getLocalJSONFromContent(); // 抽象方法，从内容获取本地JSON对象
+    public abstract JSONObject getLocalJSONFromContent();
 
-    public abstract int getSyncAction(Cursor c); // 抽象方法，获取同步操作
+    public abstract int getSyncAction(Cursor c);
 
-    public void setGid(String gid) { // 设置GID的方法
+    public void setGid(String gid) {
         this.mGid = gid;
     }
 
-    public void setName(String name) { // 获取删除状态的方法
+    public void setName(String name) {
         this.mName = name;
-    }/ 获取删除状态的方法
-/ 获取删除状态的方法
-    public void setLastModified(long lastModified) { // 设置最后修改时间的方法
-        this.mLastModified = lastModified;/ 获取删除状态的方法
-    }/ 获取删除状态的方法
-/ 获取删除状态的方法
-    public void setDeleted(boolean deleted) { / 获取删除状态的方法
+    }
+
+    public void setLastModified(long lastModified) {
+        this.mLastModified = lastModified;
+    }
+
+    public void setDeleted(boolean deleted) {
         this.mDeleted = deleted;
-    }/ 获取删除状态的方法
-/ 获取删除状态的方法
-    public String getGid() { // 获取GID的方法
-        return this.mGid;/ 获取删除状态的方法
-    }/ 获取删除状态的方法
-/ 获取删除状态的方法
-    public String getName() { // 获取名称的方法
-        return this.mName;/ 获取删除状态的方法
-    }/ 获取删除状态的方法
-/ 获取删除状态的方法
-    public long getLastModified() { // 获取最后修改时间的方法
-        return this.mLastModified;/ 获取删除状态的方法
-    }/ 获取删除状态的方法/ 获取删除状态的方法
-/ 获取删除状态的方法
-    public boolean getDeleted() { // 获取删除状态的方法
-        return this.mDeleted;/ 获取删除状态的方法
-    }/ 获取删除状态的方法
-/ 获取删除状态的方法
-}/ 获取删除状态的方法
+    }
+
+    public String getGid() {
+        return this.mGid;
+    }
+
+    public String getName() {
+        return this.mName;
+    }
+
+    public long getLastModified() {
+        return this.mLastModified;
+    }
+
+    public boolean getDeleted() {
+        return this.mDeleted;
+    }
+
+}

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

@@ -1,186 +1,189 @@
 /*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)//
+ * 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//
+ * 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//
+ *        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.//
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 
-package net.micode.notes.gtask.data;//
-
-import android.content.ContentResolver;//
-import android.content.ContentUris;//
-import android.content.ContentValues;//
-import android.content.Context;//
-import android.database.Cursor;//
-import android.net.Uri;//
-import android.util.Log;//
-
-import net.micode.notes.data.Notes;//
-import net.micode.notes.data.Notes.DataColumns;//
-import net.micode.notes.data.Notes.DataConstants;//
-import net.micode.notes.data.Notes.NoteColumns;//
-import net.micode.notes.data.NotesDatabaseHelper.TABLE;//
-import net.micode.notes.gtask.exception.ActionFailureException;//
-//
-import org.json.JSONException;//
-import org.json.JSONObject;//
-//
+package net.micode.notes.gtask.data;
+
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.NotesDatabaseHelper.TABLE;
+import net.micode.notes.gtask.exception.ActionFailureException;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+
 public class SqlData {
-    private static final String TAG = SqlData.class.getSimpleName();  // 定义日志标签
-//
-    private static final int INVALID_ID = -99999;  // 无效ID常量
-//
-    // 定义查询数据库时所需要的字段
+    private static final String TAG = SqlData.class.getSimpleName();
+
+    private static final int INVALID_ID = -99999;
+
     public static final String[] PROJECTION_DATA = new String[] {
-            DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,//
-            DataColumns.DATA3//
-    };//
-//
-    // 数据库列的索引
-    public static final int DATA_ID_COLUMN = 0;//
-    public static final int DATA_MIME_TYPE_COLUMN = 1;//
-    public static final int DATA_CONTENT_COLUMN = 2;//
-    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;//
-    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;//
-//
-    private ContentResolver mContentResolver;  // 用于访问ContentProvider的ContentResolver
-    private boolean mIsCreate;  // 标记当前对象是否是新创建的
-    private long mDataId;  // 数据ID
-    private String mDataMimeType;  // 数据类型
-    private String mDataContent;  // 数据内容
-    private long mDataContentData1;  // 数据内容的附加信息1
-    private String mDataContentData3;  // 数据内容的附加信息3
-    private ContentValues mDiffDataValues;  // 用于存储更改的数据内容
-
-    // 构造函数，初始化SqlData对象
+            DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
+            DataColumns.DATA3
+    };
+
+    public static final int DATA_ID_COLUMN = 0;
+
+    public static final int DATA_MIME_TYPE_COLUMN = 1;
+
+    public static final int DATA_CONTENT_COLUMN = 2;
+
+    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
+
+    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
+
+    private ContentResolver mContentResolver;
+
+    private boolean mIsCreate;
+
+    private long mDataId;
+
+    private String mDataMimeType;
+
+    private String mDataContent;
+
+    private long mDataContentData1;
+
+    private String mDataContentData3;
+
+    private ContentValues mDiffDataValues;
+
     public SqlData(Context context) {
-        mContentResolver = context.getContentResolver();  // 获取ContentResolver
-        mIsCreate = true;  // 标记为新创建
-        mDataId = INVALID_ID;  // 初始化为无效ID
-        mDataMimeType = DataConstants.NOTE;  // 默认数据类型为NOTE
-        mDataContent = "";  // 默认内容为空
-        mDataContentData1 = 0;  // 默认附加信息1为0
-        mDataContentData3 = "";  // 默认附加信息3为空
-        mDiffDataValues = new ContentValues();  // 初始化更改数据的ContentValues
-    }//
-//
-    // 构造函数，通过Cur/sor加载数据
+        mContentResolver = context.getContentResolver();
+        mIsCreate = true;
+        mDataId = INVALID_ID;
+        mDataMimeType = DataConstants.NOTE;
+        mDataContent = "";
+        mDataContentData1 = 0;
+        mDataContentData3 = "";
+        mDiffDataValues = new ContentValues();
+    }
+
     public SqlData(Context context, Cursor c) {
-        mContentResolver = context.getContentResolver();  // 获取ContentResolver
-        mIsCreate = false;  // 标记为已存在数据
-        loadFromCursor(c);  // 从Cursor中加载数据
-        mDiffDataValues = new ContentValues();  // 初始化更改数据的ContentValues
-    }//
-//
-    // 从Cursor加载数据
-    private void loadFromCursor(Cursor c) {//
-        mDataId = c.getLong(DATA_ID_COLUMN);  // 获取数据ID
-        mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);  // 获取数据类型
-        mDataContent = c.getString(DATA_CONTENT_COLUMN);  // 获取数据内容
-        mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);  // 获取附加信息1
-        mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);  // 获取附加信息3
-    }//
-//
-    // 设置数据内容
+        mContentResolver = context.getContentResolver();
+        mIsCreate = false;
+        loadFromCursor(c);
+        mDiffDataValues = new ContentValues();
+    }
+
+    private void loadFromCursor(Cursor c) {
+        mDataId = c.getLong(DATA_ID_COLUMN);
+        mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
+        mDataContent = c.getString(DATA_CONTENT_COLUMN);
+        mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
+        mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
+    }
+
     public void setContent(JSONObject js) throws JSONException {
-        long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;  // 获取ID，如果没有则设置为无效ID
-        if (mIsCreate || mDataId != dataId) {  // 如果是新创建的或者ID不相同
-            mDiffDataValues.put(DataColumns.ID, dataId);  // 将ID放入更改数据中
-        }//
-        mDataId = dataId;  // 更新数据ID
-//
-        String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)//
-                : DataConstants.NOTE;  // 获取数据类型，默认是NOTE
-        if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {  // 如果是新创建的或者类型不相同
-            mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);  // 将数据类型放入更改数据中
-        }//
-        mDataMimeType = dataMimeType;  // 更新数据类型
-//
-        String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";  // 获取内容
-        if (mIsCreate || !mDataContent.equals(dataContent)) {  // 如果是新创建的或者内容不相同
-            mDiffDataValues.put(DataColumns.CONTENT, dataContent);  // 将内容放入更改数据中
-        }//
-        mDataContent = dataContent;  // 更新内容 // 清空更改的数据
-        // 清空更改的数据
-        long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;  // 获取附加信息1
-        if (mIsCreate || mDataContentData1 != dataContentData1) {  // 如果是新创建的或者附加信息1不同
-            mDiffDataValues.put(DataColumns.DATA1, dataContentData1);  // 将附加信息1放入更改数据中
-        } // 清空更改的数据
-        mDataContentData1 = dataContentData1;  // 更新附加信息1
-        // 清空更改的数据
-        String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";  // 获取附加信息3
-        if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {  // 如果是新创建的或者附加信息3不同
-            mDiffDataValues.put(DataColumns.DATA3, dataContentData3);  // 将附加信息3放入更改数据中
-        } // 清空更改的数据
-        mDataContentData3 = dataContentData3;  // 更新附加信息3
-    } // 清空更改的数据
-    // 清空更改的数据
-    // 获取数据内容
-    public JSONObject getContent() throws JSONException {//
-        if (mIsCreate) {  // 如果是新创建的
-            Log.e(TAG, "it seems that we haven't created this in database yet");  // 打印错误日志
-            return null;  // 返回null
-        }// 返回null
-        JSONObject js = new JSONObject();  // 创建一个新的JSONObject
-        js.put(DataColumns.ID, mDataId);  // 将ID放入JSONObject中
-        js.put(DataColumns.MIME_TYPE, mDataMimeType);  // 将数据类型放入JSONObject中
-        js.put(DataColumns.CONTENT, mDataContent);  // 将内容放入JSONObject中
-        js.put(DataColumns.DATA1, mDataContentData1);  // 将附加信息1放入JSONObject中
-        js.put(DataColumns.DATA3, mDataContentData3);  // 将附加信息3放入JSONObject中
-        return js;  // 返回JSONObject
-    } // 清空更改的数据
-    // 清空更改的数据
-    // 提交更改
-    public void commit(long noteId, boolean validateVersion, long version) {//
-        if (mIsCreate) {  // 如果是新创建的
-            if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {  // 如果ID无效并且有ID更改
-                mDiffDataValues.remove(DataColumns.ID);  // 移除ID字段
-            } // 清空更改的数据
-            // 清空更改的数据
-            mDiffDataValues.put(DataColumns.NOTE_ID, noteId);  // 将笔记ID放入更改数据中
-            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);  // 插入数据到ContentProvider
-            try { // 清空更改的数据
-                mDataId = Long.valueOf(uri.getPathSegments().get(1));  // 获取插入数据的ID
-            } catch (NumberFormatException e) { // 清空更改的数据
-                Log.e(TAG, "Get note id error :" + e.toString());  // 打印日志
-                throw new ActionFailureException("create note failed");  // 抛出异常
-            } // 清空更改的数据
-        } else {  // 如果不是新创建的
-            if (mDiffDataValues.size() > 0) {  // 如果有更改的数据
-                int result = 0; // 清空更改的数据
-                if (!validateVersion) {  // 如果不需要版本验证 // 清空更改的数据
-                    result = mContentResolver.update(ContentUris.withAppendedId( // 清空更改的数据
-                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);  // 更新数据
-                } else {  // 如果需要版本验证
-                    result = mContentResolver.update(ContentUris.withAppendedId( // 清空更改的数据
-                                    Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, // 清空更改的数据
-                            " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE // 清空更改的数据
-                                    + " WHERE " + NoteColumns.VERSION + "=?)", new String[] { // 清空更改的数据
-                                    String.valueOf(noteId), String.valueOf(version) // 清空更改的数据
-                            }); // 清空更改的数据
-                } // 清空更改的数据
-                if (result == 0) {  // 如果没有更新数据
-                    Log.w(TAG, "there is no update. maybe user updates note when syncing");  // 打印警告日志
-                } // 清空更改的数据
-            } // 清空更改的数据
-        } // 清空更改的数据
-        // 清空更改的数据
-        // 清空更改的数据
-        mDiffDataValues.clear();  // 清空更改的数据
-        mIsCreate = false;  // 标记为非新创建
-    } // 清空更改的数据
-    // 清空更改的数据
-    // 获取数据ID
-    public long getId() { // 清空更改的数据
-        return mDataId;  // 返回数据ID
-    } // 清空更改的数据
-} // 清空更改的数据
+        long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
+        if (mIsCreate || mDataId != dataId) {
+            mDiffDataValues.put(DataColumns.ID, dataId);
+        }
+        mDataId = dataId;
+
+        String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
+                : DataConstants.NOTE;
+        if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
+            mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
+        }
+        mDataMimeType = dataMimeType;
+
+        String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
+        if (mIsCreate || !mDataContent.equals(dataContent)) {
+            mDiffDataValues.put(DataColumns.CONTENT, dataContent);
+        }
+        mDataContent = dataContent;
+
+        long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
+        if (mIsCreate || mDataContentData1 != dataContentData1) {
+            mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
+        }
+        mDataContentData1 = dataContentData1;
+
+        String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
+        if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
+            mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
+        }
+        mDataContentData3 = dataContentData3;
+    }
+
+    public JSONObject getContent() throws JSONException {
+        if (mIsCreate) {
+            Log.e(TAG, "it seems that we haven't created this in database yet");
+            return null;
+        }
+        JSONObject js = new JSONObject();
+        js.put(DataColumns.ID, mDataId);
+        js.put(DataColumns.MIME_TYPE, mDataMimeType);
+        js.put(DataColumns.CONTENT, mDataContent);
+        js.put(DataColumns.DATA1, mDataContentData1);
+        js.put(DataColumns.DATA3, mDataContentData3);
+        return js;
+    }
+
+    public void commit(long noteId, boolean validateVersion, long version) {
+
+        if (mIsCreate) {
+            if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
+                mDiffDataValues.remove(DataColumns.ID);
+            }
+
+            mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
+            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
+            try {
+                mDataId = Long.valueOf(uri.getPathSegments().get(1));
+            } catch (NumberFormatException e) {
+                Log.e(TAG, "Get note id error :" + e.toString());
+                throw new ActionFailureException("create note failed");
+            }
+        } else {
+            if (mDiffDataValues.size() > 0) {
+                int result = 0;
+                if (!validateVersion) {
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
+                } else {
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
+                            " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+                                    + " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
+                                    String.valueOf(noteId), String.valueOf(version)
+                            });
+                }
+                if (result == 0) {
+                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
+                }
+            }
+        }
+
+        mDiffDataValues.clear();
+        mIsCreate = false;
+    }
+
+    public long getId() {
+        return mDataId;
+    }
+}

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

@@ -200,13 +200,6 @@ public class SqlNote {
         mVersion = c.getLong(VERSION_COLUMN);
     }
 
-
-
-
-
-
-
-    
     private void loadDataContent() {
         Cursor c = null;
         mDataList.clear();

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

@@ -33,357 +33,319 @@ import org.json.JSONObject;
 
 
 public class Task extends Node {
-    private static final String TAG = Task.class.getSimpleName();  // Tag for logging
+    private static final String TAG = Task.class.getSimpleName();
 
-    private boolean mCompleted;  // Flag indicating task completion status
+    private boolean mCompleted;
 
-    private String mNotes;  // Stores notes related to the task
+    private String mNotes;
 
-    private JSONObject mMetaInfo;  // Metadata for task
+    private JSONObject mMetaInfo;
 
-    private Task mPriorSibling;  // Reference to the previous task in the same list
+    private Task mPriorSibling;
 
-    private TaskList mParent;  // Reference to the parent task list
+    private TaskList mParent;
 
-    // Constructor
     public Task() {
         super();
-        mCompleted = false;  // Initialize task as not completed
-        mNotes = null;  // Initialize notes as null
-        mPriorSibling = null;  // Initialize prior sibling as null
-        mParent = null;  // Initialize parent as null
-        mMetaInfo = null;  // Initialize metadata as null
+        mCompleted = false;
+        mNotes = null;
+        mPriorSibling = null;
+        mParent = null;
+        mMetaInfo = null;
     }
 
-    // Creates a JSON object representing a task creation action
     public JSONObject getCreateAction(int actionId) {
-        JSONObject js = new JSONObject();  // Create a new JSONObject to hold the action details
+        JSONObject js = new JSONObject();
 
         try {
-            // Set action type to "create"
+            // action_type
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
 
-            // Set the action ID
+            // action_id
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
 
-            // Set the task index within its parent task list
+            // index
             js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
 
-            // Set the entity delta which holds the task details
+            // entity_delta
             JSONObject entity = new JSONObject();
-            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());  // Set the task name
-            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");  // Set the creator as null (default)
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
             entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
-                    GTaskStringUtils.GTASK_JSON_TYPE_TASK);  // Set entity type to task
+                    GTaskStringUtils.GTASK_JSON_TYPE_TASK);
             if (getNotes() != null) {
-                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());  // Add notes if present
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
             }
-            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);  // Add entity to the action
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
 
-            // Set parent ID (the ID of the parent task list)
+            // parent_id
             js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
 
-            // Set the destination parent type
+            // dest_parent_type
             js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
                     GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
 
-            // Set the list ID (the ID of the parent task list)
+            // list_id
             js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
 
-            // Set prior sibling ID if there's a prior sibling
+            // prior_sibling_id
             if (mPriorSibling != null) {
                 js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
             }
 
-        } catch (JSONException e) {  // Catch JSON exception if any occur
-            Log.e(TAG, e.toString());  // Log the error
-            e.printStackTrace();  // Print the stack trace
-            throw new ActionFailureException("fail to generate task-create jsonobject");  // Throw custom exception
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("fail to generate task-create jsonobject");
         }
 
-        return js;  // Return the JSON object representing the create action
+        return js;
     }
 
-    // Creates a JSON object representing a task update action
     public JSONObject getUpdateAction(int actionId) {
-        JSONObject js = new JSONObject();  // Create a new JSONObject for the update action
+        JSONObject js = new JSONObject();
 
         try {
-            // Set action type to "update"
+            // action_type
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
 
-            // Set action ID
+            // action_id
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
 
-            // Set task ID
+            // id
             js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
 
-            // Set the entity delta with task details
+            // entity_delta
             JSONObject entity = new JSONObject();
-            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());  // Set the task name
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
             if (getNotes() != null) {
-                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());  // Add notes if available
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
             }
-            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());  // Set deletion status
-            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);  // Add entity to the update action
+            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
 
-        } catch (JSONException e) {  // Catch JSON exception if any occur
-            Log.e(TAG, e.toString());  // Log the error
-            e.printStackTrace();  // Print the stack trace
-            throw new ActionFailureException("fail to generate task-update jsonobject");  // Throw custom exception
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("fail to generate task-update jsonobject");
         }
 
-        return js;  // Return the JSON object representing the update action
+        return js;
     }
 
-    // Sets the task content based on a remote JSON object
     public void setContentByRemoteJSON(JSONObject js) {
         if (js != null) {
             try {
-                // Set task ID if available
+                // id
                 if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
                     setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
                 }
 
-                // Set last modified timestamp if available
+                // last_modified
                 if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
                     setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
                 }
 
-                // Set task name if available
+                // name
                 if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
                     setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
                 }
 
-                // Set notes if available
+                // notes
                 if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
                     setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
                 }
 
-                // Set deletion status if available
+                // deleted
                 if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
                     setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
                 }
 
-                // Set completion status if available
+                // completed
                 if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
                     setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
                 }
-            } catch (JSONException e) {  // Catch JSON exception if any occur
-                Log.e(TAG, e.toString());  // Log the error
-                e.printStackTrace();  // Print the stack trace
-                throw new ActionFailureException("fail to get task content from jsonobject");  // Throw custom exception
+            } catch (JSONException e) {
+                Log.e(TAG, e.toString());
+                e.printStackTrace();
+                throw new ActionFailureException("fail to get task content from jsonobject");
             }
         }
     }
 
-    // Sets the task content based on a local JSON object
     public void setContentByLocalJSON(JSONObject js) {
         if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
                 || !js.has(GTaskStringUtils.META_HEAD_DATA)) {
-            Log.w(TAG, "setContentByLocalJSON: nothing is available");  // Log a warning if data is not available
+            Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
         }
 
         try {
-            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);  // Get the note object
-            JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);  // Get data array
+            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
 
-            // Check if the note type is valid
             if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
-                Log.e(TAG, "invalid type");  // Log an error if the type is invalid
-                return;  // Exit the method
+                Log.e(TAG, "invalid type");
+                return;
             }
 
-            // Iterate through data array and set the task name
             for (int i = 0; i < dataArray.length(); i++) {
                 JSONObject data = dataArray.getJSONObject(i);
                 if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
-                    setName(data.getString(DataColumns.CONTENT));  // Set the task name
+                    setName(data.getString(DataColumns.CONTENT));
                     break;
                 }
             }
 
-        } catch (JSONException e) {  // Catch JSON exception if any occur
-            Log.e(TAG, e.toString());  // Log the error
-            e.printStackTrace();  // Print the stack trace
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
         }
     }
 
-    // Returns a local JSON representation of the task content
     public JSONObject getLocalJSONFromContent() {
-        String name = getName();  // Get the task name
+        String name = getName();
         try {
-            if (mMetaInfo == null) {  // If metadata is null, create a new task
-                // New task created from the web
-                if (name == null) {  // If the task name is null, log a warning
+            if (mMetaInfo == null) {
+                // new task created from web
+                if (name == null) {
                     Log.w(TAG, "the note seems to be an empty one");
-                    return null;  // Return null if the task name is empty
+                    return null;
                 }
 
-                // Create a new JSON object for the task
                 JSONObject js = new JSONObject();
                 JSONObject note = new JSONObject();
                 JSONArray dataArray = new JSONArray();
                 JSONObject data = new JSONObject();
-                data.put(DataColumns.CONTENT, name);  // Set the task name in the data
-                dataArray.put(data);  // Add data to the array
-                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);  // Add data array to the JSON object
-                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);  // Set note type to "note"
-                js.put(GTaskStringUtils.META_HEAD_NOTE, note);  // Add note object to the JSON object
-                return js;  // Return the newly created JSON object
+                data.put(DataColumns.CONTENT, name);
+                dataArray.put(data);
+                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
+                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+                js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+                return js;
             } else {
-                // Synced task, retrieve data from metadata
-                JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);  // Get the note object
-                JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);  // Get data array
-
-                // Iterate through data array and update task name
-                for (int i = 0; i < dataArray.length(); i++) {// Return null if an error occurs
-                    JSONObject data = dataArray.getJSONObject(i);// Return null if an error occurs
-                    if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {// Return null if an error occurs
-                        data.put(DataColumns.CONTENT, getName());  // Set the task name in data
-                        break;// Return null if an error occurs
-                    }// Return null if an error occurs
-                }// Return null if an error occurs
-// Return null if an error occurs
-                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);  // Set note type to "note"
-                return mMetaInfo;  // Return the metadata as the JSON object
+                // synced task
+                JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+                JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+
+                for (int i = 0; i < dataArray.length(); i++) {
+                    JSONObject data = dataArray.getJSONObject(i);
+                    if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
+                        data.put(DataColumns.CONTENT, getName());
+                        break;
+                    }
+                }
+
+                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+                return mMetaInfo;
             }
-        } catch (JSONException e) {  // Catch JSON exception if any occur
-            Log.e(TAG, e.toString());  // Log the error
-            e.printStackTrace();  // Print the stack trace
-            return null;  // Return null if an error occurs
-        }// Return null if an error occurs
-    }// Return null if an error occurs
-}// Return null if an error occurs
-
-// Return null if an error occurs
-// Return null if an error occurs
-// Return null if an error occurs
-// Return null if an error occurs
-// Return null if an error occurs
-// Return null if an error occurs
-// Method to set meta information using a MetaData object
-public void setMetaInfo(MetaData metaData) {
-    // Check if the metaData is not null and contains notes
-    if (metaData != null && metaData.getNotes() != null) {
-        try {
-            // Convert the notes data into a JSONObject and assign it to mMetaInfo
-            mMetaInfo = new JSONObject(metaData.getNotes());
         } catch (JSONException e) {
-            // Log a warning if the conversion fails
-            Log.w(TAG, e.toString());
-            // Reset mMetaInfo to null in case of an error
-            mMetaInfo = null; // Reset mMetaInfo to null in case of an error
-        } // Reset mMetaInfo to null in case of an error
-    } // Reset mMetaInfo to null in case of an error
-} // Reset mMetaInfo to null in case of an error
-// Reset mMetaInfo to null in case of an error
-// Method to determine the sync action based on the data in the cursor
-public int getSyncAction(Cursor c) { // Reset mMetaInfo to null in case of an error
-    try { // Reset mMetaInfo to null in case of an error
-        JSONObject noteInfo = null; // Reset mMetaInfo to null in case of an error
-        // Reset mMetaInfo to null in case of an error
-        // Check if mMetaInfo is not null and contains the note info
-        if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) { // Reset mMetaInfo to null in case of an error
-            // Retrieve the note info from mMetaInfo
-            noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // Reset mMetaInfo to null in case of an error
-        } // Reset mMetaInfo to null in case of an error
-        // Reset mMetaInfo to null in case of an error
-        // If no note info is found, return SYNC_ACTION_UPDATE_REMOTE
-        if (noteInfo == null) { // Reset mMetaInfo to null in case of an error
-            Log.w(TAG, "it seems that note meta has been deleted"); // Reset mMetaInfo to null in case of an error
-            return SYNC_ACTION_UPDATE_REMOTE; // Reset mMetaInfo to null in case of an error
-        } // Reset mMetaInfo to null in case of an error
-        // Reset mMetaInfo to null in case of an error
-        // If no note ID is found in the note info, return SYNC_ACTION_UPDATE_LOCAL
-        if (!noteInfo.has(NoteColumns.ID)) {
-            Log.w(TAG, "remote note id seems to be deleted");
-            return SYNC_ACTION_UPDATE_LOCAL;
-        } // Reset mMetaInfo to null in case of an error
-        // Reset mMetaInfo to null in case of an error
-        // Validate the note ID with the value in the cursor
-        if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) { // Reset mMetaInfo to null in case of an error
-            Log.w(TAG, "note id doesn't match"); // Reset mMetaInfo to null in case of an error
-            return SYNC_ACTION_UPDATE_LOCAL; // Reset mMetaInfo to null in case of an error
-            // Reset mMetaInfo to null in case of an error
-        // Check if there are any local updates
-        if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
-            // If no local updates, check if the sync ID matches the last modified timestamp
-            if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                // No updates on either side // Reset mMetaInfo to null in case of an error
-                return SYNC_ACTION_NONE; // Reset mMetaInfo to null in case of an error
-            } else { // Reset mMetaInfo to null in case of an error
-                // Apply remote updates to local // Reset mMetaInfo to null in case of an error
-                return SYNC_ACTION_UPDATE_LOCAL; // Reset mMetaInfo to null in case of an error
-            } // Reset mMetaInfo to null in case of an error
-        } else { // Reset mMetaInfo to null in case of an error
-            // If there are local modifications,  // Reset mMetaInfo to null in case of an errorvalidate the gtask ID
-            if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { // Reset mMetaInfo to null in case of an error
-                Log.e(TAG, "gtask id doesn't match"); // Reset mMetaInfo to null in case of an error
-                return SYNC_ACTION_ERROR; // Reset mMetaInfo to null in case of an error
-            } // Reset mMetaInfo to null in case of an error
-            // Check if the sync ID matches the last modified timestamp for local modification
-            if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { // Reset mMetaInfo to null in case of an error
-                // Local modification only
-                return SYNC_ACTION_UPDATE_REMOTE; // Reset mMetaInfo to null in case of an error
-                // Conflict between local and remote modification
-                return SYNC_ACTION_UPDATE_CONFLICT; // Reset mMetaInfo to null in case of an error
-            } // Reset mMetaInfo to null in case of an error
-        } // Reset mMetaInfo to null in case of an error
-    } catch (Exception e) { // Reset mMetaInfo to null in case of an error
-        // Log the exception and return SYNC_ACTION_ERROR
-        Log.e(TAG, e.toString()); // Reset mMetaInfo to null in case of an error
-        e.printStackTrace(); // Reset mMetaInfo to null in case of an error
-    } // Reset mMetaInfo to null in case of an error
-        // Reset mMetaInfo to null in case of an error
-    return SYNC_ACTION_ERROR; // Reset mMetaInfo to null in case of an error
-} // Reset mMetaInfo to null in case of an error
-// Getter method to retrieve the parent task list
-// Method to check if the task is worth saving based on meta info or task content
-public boolean isWorthSaving() { // Reset mMetaInfo to null in case of an error
-    // If there is meta info or non-empty name or notes, return true
-    return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)// Getter method to retrieve the parent task list
-            || (getNotes() != null && getNotes().trim().length() > 0);// Getter method to retrieve the parent task list
-} // Reset mMetaInfo to null in case of an error
-    // Reset mMetaInfo to null in case of an error
-// Setter method to mark the task as completed
-public void setCompleted(boolean completed) { // Reset mMetaInfo to null in case of an error
-    this.mCompleted = completed;// Getter method to retrieve the parent task list
-}// Getter method to retrieve the parent task list
-// Getter method to retrieve the parent task list
-// Setter method to set the notes of the task
-public void setNotes(String notes) {// Getter method to retrieve the parent task list
-    this.mNotes = notes;// Getter method to retrieve the parent task list
-}// Getter method to retrieve the parent task list
-// Getter method to retrieve the parent task list
-// Setter method to set the prior sibling task
-public void setPriorSibling(Task priorSibling) {// Getter method to retrieve the parent task list
-    this.mPriorSibling = priorSibling;// Getter method to retrieve the parent task list
-}// Getter method to retrieve the parent task list
-// Getter method to retrieve the parent task list
-// Setter method to set the parent task list
-public void setParent(TaskList parent) {// Getter method to retrieve the parent task list
-    this.mParent = parent;// Getter method to retrieve the parent task list
-}// Getter method to retrieve the parent task list
-// Getter method to retrieve the parent task list
-// Getter method to retrieve the completed status of the task
-public boolean getCompleted() {// Getter method to retrieve the parent task list
-    return this.mCompleted;// Getter method to retrieve the parent task list
-}// Getter method to retrieve the parent task list
-// Getter method to retrieve the parent task list
-// Getter method to retrieve the notes of the task
-public String getNotes() {// Getter method to retrieve the parent task list
-    return this.mNotes;// Getter method to retrieve the parent task list
-}// Getter method to retrieve the parent task list
-// Getter method to retrieve the parent task list
-// Getter method to retrieve the prior sibling task
-public Task getPriorSibling() {// Getter method to retrieve the parent task list
-    return this.mPriorSibling;// Getter method to retrieve the parent task list
-}// Getter method to retrieve the parent task list
-// Getter method to retrieve the parent task list
-// Getter method to retrieve the parent task list
-public TaskList getParent() {// Getter method to retrieve the parent task list
-    return this.mParent;// Getter method to retrieve the parent task list
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public void setMetaInfo(MetaData metaData) {
+        if (metaData != null && metaData.getNotes() != null) {
+            try {
+                mMetaInfo = new JSONObject(metaData.getNotes());
+            } catch (JSONException e) {
+                Log.w(TAG, e.toString());
+                mMetaInfo = null;
+            }
+        }
+    }
+
+    public int getSyncAction(Cursor c) {
+        try {
+            JSONObject noteInfo = null;
+            if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
+                noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            }
+
+            if (noteInfo == null) {
+                Log.w(TAG, "it seems that note meta has been deleted");
+                return SYNC_ACTION_UPDATE_REMOTE;
+            }
+
+            if (!noteInfo.has(NoteColumns.ID)) {
+                Log.w(TAG, "remote note id seems to be deleted");
+                return SYNC_ACTION_UPDATE_LOCAL;
+            }
+
+            // validate the note id now
+            if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
+                Log.w(TAG, "note id doesn't match");
+                return SYNC_ACTION_UPDATE_LOCAL;
+            }
+
+            if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
+                // there is no local update
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                    // no update both side
+                    return SYNC_ACTION_NONE;
+                } else {
+                    // apply remote to local
+                    return SYNC_ACTION_UPDATE_LOCAL;
+                }
+            } else {
+                // validate gtask id
+                if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
+                    Log.e(TAG, "gtask id doesn't match");
+                    return SYNC_ACTION_ERROR;
+                }
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                    // local modification only
+                    return SYNC_ACTION_UPDATE_REMOTE;
+                } else {
+                    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);
+    }
+
+    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;
+    }
+
 }

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

@@ -1,11 +1,11 @@
 /*
- * Copyright (c) 2010 - 2011, The MiCode Open Source Community (www.micode.net)
+ * 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
+ *        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,
@@ -14,33 +14,20 @@
  * limitations under the License.
  */
 
-// 包声明，表明该类所在的包名为net.micode.notes.gtask.exception，通常用于存放自定义的异常相关类
 package net.micode.notes.gtask.exception;
 
-// ActionFailureException类继承自RuntimeException，意味着它是一个运行时异常，不需要在代码中显式地进行捕获处理（当然也可以捕获），
-// 一般用于表示在执行某个操作时发生了失败的情况，具体的失败原因可以通过构造函数传入相关信息来表示
 public class ActionFailureException extends RuntimeException {
-    // serialVersionUID是用于序列化和反序列化对象时的版本标识，用于确保在不同版本的类加载过程中对象的兼容性，
-    // 这里定义了一个固定的长整型值作为该异常类的版本标识
     private static final long serialVersionUID = 4425249765923293627L;
 
-    // 默认的无参构造函数，调用父类（RuntimeException）的无参构造函数，
-    // 通常在抛出异常时如果不需要传递特定的错误信息可以使用这个构造函数创建异常对象
     public ActionFailureException() {
         super();
     }
 
-    // 带有一个字符串参数的构造函数，用于创建异常对象并传递具体的错误信息描述，
-    // 这个字符串信息会在异常被捕获或者打印堆栈信息时展示出来，帮助定位和理解发生异常的原因，
-    // 它调用了父类（RuntimeException）的相应构造函数来传递错误信息字符串
     public ActionFailureException(String paramString) {
         super(paramString);
     }
 
-    // 带有一个字符串参数和一个Throwable参数的构造函数，用于创建异常对象，
-    // 字符串参数用于传递具体的错误信息描述，Throwable参数通常用于传递导致当前异常发生的底层异常（比如嵌套的其他异常），
-    // 这样可以更全面地展示异常的产生链，方便排查问题，它调用了父类（RuntimeException）的相应构造函数来传递这两个参数
     public ActionFailureException(String paramString, Throwable paramThrowable) {
         super(paramString, paramThrowable);
     }
-}
+}

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

@@ -1,11 +1,11 @@
 /*
- * Copyright (c) 2010 - 2011, The MiCode Open Source Community (www.micode.net)
+ * 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
+ *        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,
@@ -14,34 +14,20 @@
  * limitations under the License.
  */
 
-// 包声明，表明该类所在的包名为net.micode.notes.gtask.exception，通常这个包会用于存放和GTask相关的各类异常类定义
 package net.micode.notes.gtask.exception;
 
-// NetworkFailureException类继承自Exception，属于受检异常（Checked Exception），
-// 在使用可能抛出该异常的方法时，必须在方法签名中声明或者在调用处进行捕获处理，
-// 此类异常通常用于表示在网络相关操作过程中出现了故障或错误的情况
 public class NetworkFailureException extends Exception {
-    // serialVersionUID是一个用于在序列化和反序列化对象时进行版本控制的标识，
-    // 确保在不同版本的类加载过程中，对象的序列化和反序列化能够正确进行，这里给定了一个固定的长整型值作为该异常类的版本标识
     private static final long serialVersionUID = 2107610287180234136L;
 
-    // 无参构造函数，调用父类（Exception）的无参构造函数，
-    // 当需要抛出一个NetworkFailureException异常，但不需要提供具体的错误信息时，可以使用这个构造函数来创建异常对象
     public NetworkFailureException() {
         super();
     }
 
-    // 带有一个字符串参数的构造函数，用于创建异常对象并传递具体的错误信息描述，
-    // 这个字符串会作为异常的详细信息展示出来，方便在捕获异常时了解出现网络故障的具体原因等情况，
-    // 它调用了父类（Exception）的对应构造函数来传递这个错误信息字符串
     public NetworkFailureException(String paramString) {
         super(paramString);
     }
 
-    // 带有一个字符串参数和一个Throwable参数的构造函数，
-    // 其中字符串参数用于指定具体的错误信息描述，而Throwable参数通常用于传递导致当前网络故障异常的底层异常（例如底层网络库抛出的原始异常等），
-    // 这样可以更全面地展示异常产生的根源，便于排查和处理问题，它调用了父类（Exception）的相应构造函数来传递这两个参数
     public NetworkFailureException(String paramString, Throwable paramThrowable) {
         super(paramString, paramThrowable);
     }
-}
+}

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

@@ -1,11 +1,12 @@
+
 /*
- * Copyright (c) 2010 - 2011, The MiCode Open Source Community (www.micode.net)
+ * 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
+ *        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,
@@ -14,159 +15,110 @@
  * limitations under the License.
  */
 
-// 包声明，表明该类所在的包名，这里是net.micode.notes.gtask.remote包下
 package net.micode.notes.gtask.remote;
 
 import android.app.Notification;
-// 用于管理通知相关操作，比如创建、显示、取消通知等
 import android.app.NotificationManager;
-// 用于创建PendingIntent，它可以在未来某个时间点触发一个Intent操作
 import android.app.PendingIntent;
 import android.content.Context;
 import android.content.Intent;
-// 用于执行异步任务，避免在主线程执行耗时操作导致界面卡顿
 import android.os.AsyncTask;
 
 import net.micode.notes.R;
-// 笔记列表界面的Activity类，可能用于展示笔记列表等相关功能
 import net.micode.notes.ui.NotesListActivity;
-// 笔记相关的偏好设置Activity类，可能用于配置笔记应用的一些参数等功能
 import net.micode.notes.ui.NotesPreferenceActivity;
 
 
-// GTaskASyncTask继承自AsyncTask，用于在后台执行与GTask相关的异步操作，
-// 并在操作过程中更新进度、处理完成后的结果以及进行相应的通知展示等
 public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
 
-    // 定义一个静态的整型变量，用作GTask同步操作的通知ID，用于唯一标识一个通知
     private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
 
-    // 定义一个接口，用于在异步任务完成时回调通知外部，让外部可以执行相应的逻辑
     public interface OnCompleteListener {
         void onComplete();
     }
 
-    // 保存上下文对象，方便后续获取系统服务、资源等操作
     private Context mContext;
 
-    // 用于管理通知的显示、取消等操作，通过上下文获取系统的通知服务实例
     private NotificationManager mNotifiManager;
 
-    // GTaskManager实例，应该是用于管理GTask相关业务逻辑，比如同步操作等
     private GTaskManager mTaskManager;
 
-    // 完成监听器，外部可以传入实现了OnCompleteListener接口的对象，以便在任务完成时得到通知
     private OnCompleteListener mOnCompleteListener;
 
-    // 构造函数，用于初始化GTaskASyncTask实例
-    // 参数context是当前上下文，listener是任务完成时的监听器
     public GTaskASyncTask(Context context, OnCompleteListener listener) {
         mContext = context;
         mOnCompleteListener = listener;
-        // 获取系统的通知服务，用于后续管理通知的显示等操作
         mNotifiManager = (NotificationManager) mContext
                 .getSystemService(Context.NOTIFICATION_SERVICE);
-        // 获取GTaskManager的单例实例，用于执行具体的GTask相关任务
         mTaskManager = GTaskManager.getInstance();
     }
 
-    // 用于取消正在进行的GTask同步操作，调用GTaskManager中的取消同步方法
     public void cancelSync() {
         mTaskManager.cancelSync();
     }
 
-    // 对外提供的方法，用于发布任务进度消息，实际上是调用了publishProgress方法传递消息数组
     public void publishProgess(String message) {
         publishProgress(new String[] {
-                message
+            message
         });
     }
 
-    // 私有方法，用于显示通知
-    // 参数tickerId是通知在状态栏显示的简短提示文本的资源ID，content是通知详细内容
     private void showNotification(int tickerId, String content) {
-        // 创建一个Notification实例，设置图标、标题（通过资源ID获取对应字符串）以及显示时间
         Notification notification = new Notification(R.drawable.notification, mContext
                 .getString(tickerId), System.currentTimeMillis());
-        // 设置通知的默认灯光效果，当有通知时会亮起相应的灯光提示
         notification.defaults = Notification.DEFAULT_LIGHTS;
-        // 设置通知为自动取消，当用户点击通知后，该通知自动消失
         notification.flags = Notification.FLAG_AUTO_CANCEL;
         PendingIntent pendingIntent;
-        // 根据不同的tickerId来决定点击通知后跳转到不同的Activity
-        if (tickerId!= R.string.ticker_success) {
-            // 如果不是成功提示的tickerId，则点击通知跳转到NotesPreferenceActivity
+        if (tickerId != R.string.ticker_success) {
             pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
                     NotesPreferenceActivity.class), 0);
 
         } else {
-            // 如果是成功提示的tickerId，则点击通知跳转到NotesListActivity
             pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
                     NotesListActivity.class), 0);
         }
 //        notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
 //                pendingIntent);
-        // 设置通知的点击意图，即用户点击通知后会触发的操作
         notification.contentIntent = pendingIntent;
-        // 通过通知管理器显示通知，使用之前定义的通知ID来标识这个通知
         mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
     }
 
-    // 在后台线程执行的方法，是AsyncTask抽象方法，执行实际的耗时任务
-    // 参数unused在这里未被使用，一般用于传递执行任务需要的参数
     @Override
     protected Integer doInBackground(Void... unused) {
-        // 发布任务进度消息，消息内容是正在登录进行同步的提示，包含同步账号名称（通过NotesPreferenceActivity获取）
         publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
                 .getSyncAccountName(mContext)));
-        // 调用GTaskManager的sync方法进行同步操作，并返回同步结果，同步过程中可以通过publishProgess方法更新进度
         return mTaskManager.sync(mContext, this);
     }
 
-    // 在主线程执行的方法，用于更新任务进度，是AsyncTask抽象方法
-    // 参数progress是传递过来的进度消息数组，这里只取第一个元素作为进度消息展示
     @Override
     protected void onProgressUpdate(String... progress) {
-        // 根据同步中的进度消息显示相应的通知，通知标题为正在同步的提示文本
         showNotification(R.string.ticker_syncing, progress[0]);
-        // 如果当前上下文是GTaskSyncService类型（可能是在特定的服务中使用该异步任务）
         if (mContext instanceof GTaskSyncService) {
-            // 发送广播，传递进度消息，可能用于通知其他组件当前同步进度情况
             ((GTaskSyncService) mContext).sendBroadcast(progress[0]);
         }
     }
 
-    // 在主线程执行的方法，在异步任务完成后调用，是AsyncTask抽象方法
-    // 参数result是异步任务执行的最终结果，根据不同的结果值进行不同的处理
     @Override
     protected void onPostExecute(Integer result) {
-        // 如果同步结果是成功状态
         if (result == GTaskManager.STATE_SUCCESS) {
-            // 显示成功通知，通知标题为成功提示文本，内容包含同步成功的账号信息（通过GTaskManager获取）
             showNotification(R.string.ticker_success, mContext.getString(
                     R.string.success_sync_account, mTaskManager.getSyncAccount()));
-            // 设置最后同步时间，记录到NotesPreferenceActivity中，参数为当前时间戳
             NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis());
         } else if (result == GTaskManager.STATE_NETWORK_ERROR) {
-            // 如果是网络错误状态，显示网络错误通知，通知标题为失败提示文本，内容为网络错误提示信息
             showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network));
         } else if (result == GTaskManager.STATE_INTERNAL_ERROR) {
-            // 如果是内部错误状态，显示内部错误通知，通知标题为失败提示文本，内容为内部错误提示信息
             showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal));
         } else if (result == GTaskManager.STATE_SYNC_CANCELLED) {
-            // 如果是同步被取消状态，显示取消通知，通知标题为取消提示文本，内容为同步取消提示信息
             showNotification(R.string.ticker_cancel, mContext
                     .getString(R.string.error_sync_cancelled));
         }
-        // 如果设置了任务完成监听器
-        if (mOnCompleteListener!= null) {
+        if (mOnCompleteListener != null) {
             new Thread(new Runnable() {
 
                 public void run() {
-                    // 在新线程中调用监听器的onComplete方法，通知外部任务已完成
                     mOnCompleteListener.onComplete();
                 }
             }).start();
         }
     }
-}
+}

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

@@ -13,81 +13,80 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package net.micode.notes.gtask.remote;
 
-// 导入所需的Android类和自定义类
-import android.app.Activity;// 导入所需的Android类和自定义类
-import android.content.ContentResolver;// 导入所需的Android类和自定义类
-import android.content.ContentUris;// 导入所需的Android类和自定义类
-import android.content.ContentValues;// 导入所需的Android类和自定义类
-import android.content.Context;// 导入所需的Android类和自定义类
-import android.database.Cursor;// 导入所需的Android类和自定义类
-import android.util.Log;// 导入所需的Android类和自定义类
-// 导入所需的Android类和自定义类
-import net.micode.notes.R;// 导入所需的Android类和自定义类
-import net.micode.notes.data.Notes;// 导入所需的Android类和自定义类
-import net.micode.notes.data.Notes.DataColumns;// 导入所需的Android类和自定义类
-import net.micode.notes.data.Notes.NoteColumns;// 导入所需的Android类和自定义类
-import net.micode.notes.gtask.data.MetaData;// 导入所需的Android类和自定义类
-import net.micode.notes.gtask.data.Node;// 导入所需的Android类和自定义类
-import net.micode.notes.gtask.data.SqlNote;// 导入所需的Android类和自定义类
-import net.micode.notes.gtask.data.Task;// 导入所需的Android类和自定义类
-import net.micode.notes.gtask.data.TaskList;// 导入所需的Android类和自定义类
-import net.micode.notes.gtask.exception.ActionFailureException;// 导入所需的Android类和自定义类
-import net.micode.notes.gtask.exception.NetworkFailureException;// 导入所需的Android类和自定义类
-import net.micode.notes.tool.DataUtils;// 导入所需的Android类和自定义类
-import net.micode.notes.tool.GTaskStringUtils;// 导入所需的Android类和自定义类
-
-import org.json.JSONArray;// 导入所需的Android类和自定义类
-import org.json.JSONException;// 导入所需的Android类和自定义类
-import org.json.JSONObject;// 导入所需的Android类和自定义类
-
-import java.util.HashMap;// 导入所需的Android类和自定义类// 导入所需的Android类和自定义类
-import java.util.HashSet;// 导入所需的Android类和自定义类
-import java.util.Iterator;// 导入所需的Android类和自定义类
+import android.app.Activity;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.util.Log;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.data.MetaData;
+import net.micode.notes.gtask.data.Node;
+import net.micode.notes.gtask.data.SqlNote;
+import net.micode.notes.gtask.data.Task;
+import net.micode.notes.gtask.data.TaskList;
+import net.micode.notes.gtask.exception.ActionFailureException;
+import net.micode.notes.gtask.exception.NetworkFailureException;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.GTaskStringUtils;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.Map;
 
-// GTaskManager类是管理Google任务同步的核心类
+
 public class GTaskManager {
-    // 日志标签，用于Logcat中过滤日志
     private static final String TAG = GTaskManager.class.getSimpleName();
 
-    // 定义同步状态常量
     public static final int STATE_SUCCESS = 0;
+
     public static final int STATE_NETWORK_ERROR = 1;
+
     public static final int STATE_INTERNAL_ERROR = 2;
+
     public static final int STATE_SYNC_IN_PROGRESS = 3;
+
     public static final int STATE_SYNC_CANCELLED = 4;
 
-    // 单例对象
     private static GTaskManager mInstance = null;
 
-    // Activity上下文，用于获取认证token
     private Activity mActivity;
-    // 应用程序上下文
+
     private Context mContext;
-    // 内容解析器，用于访问和修改数据库
+
     private ContentResolver mContentResolver;
-    // 同步状态标志
+
     private boolean mSyncing;
-    // 取消同步标志
+
     private boolean mCancelled;
-    // 存储任务列表的哈希映射
+
     private HashMap<String, TaskList> mGTaskListHashMap;
-    // 存储任务节点的哈希映射
+
     private HashMap<String, Node> mGTaskHashMap;
-    // 存储元数据的哈希映射
+
     private HashMap<String, MetaData> mMetaHashMap;
-    // 元数据列表
+
     private TaskList mMetaList;
-    // 本地删除ID集合
+
     private HashSet<Long> mLocalDeleteIdMap;
-    // 任务ID到笔记ID的映射
+
     private HashMap<String, Long> mGidToNid;
-    // 笔记ID到任务ID的映射
+
     private HashMap<Long, String> mNidToGid;
 
-    // 私有构造函数，确保单例
     private GTaskManager() {
         mSyncing = false;
         mCancelled = false;
@@ -100,7 +99,6 @@ public class GTaskManager {
         mNidToGid = new HashMap<Long, String>();
     }
 
-    // 获取GTaskManager单例
     public static synchronized GTaskManager getInstance() {
         if (mInstance == null) {
             mInstance = new GTaskManager();
@@ -108,15 +106,12 @@ public class GTaskManager {
         return mInstance;
     }
 
-    // 设置Activity上下文
     public synchronized void setActivityContext(Activity activity) {
-        // 用于获取认证token
+        // used for getting authtoken
         mActivity = activity;
     }
 
-    // 同步方法，接受上下文和异步任务参数
     public int sync(Context context, GTaskASyncTask asyncTask) {
-        // 如果正在同步中，则返回同步进行中状态
         if (mSyncing) {
             Log.d(TAG, "Sync is in progress");
             return STATE_SYNC_IN_PROGRESS;
@@ -133,22 +128,21 @@ public class GTaskManager {
         mNidToGid.clear();
 
         try {
-            // 获取GTaskClient单例
             GTaskClient client = GTaskClient.getInstance();
             client.resetUpdateArray();
 
-            // 登录Google任务
+            // login google task
             if (!mCancelled) {
                 if (!client.login(mActivity)) {
                     throw new NetworkFailureException("login google task failed");
                 }
             }
 
-            // 从Google获取任务列表
+            // get the task list from google
             asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
             initGTaskList();
 
-            // 执行内容同步工作
+            // do content sync work
             asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
             syncContent();
         } catch (NetworkFailureException e) {
@@ -174,27 +168,26 @@ public class GTaskManager {
         return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
     }
 
-    // 初始化Google任务列表
     private void initGTaskList() throws NetworkFailureException {
-        if (mCancelled) // 初始化Google任务列表
-            return; // 初始化Google任务列表
-        GTaskClient client = GTaskClient.getInstance(); // 初始化Google任务列表
-        try { // 初始化Google任务列表
-            JSONArray jsTaskLists = client.getTaskLists(); // 初始化Google任务列表
-            // 初始化Google任务列表
-            // 首先初始化元数据列表
+        if (mCancelled)
+            return;
+        GTaskClient client = GTaskClient.getInstance();
+        try {
+            JSONArray jsTaskLists = client.getTaskLists();
+
+            // init meta list first
             mMetaList = null;
             for (int i = 0; i < jsTaskLists.length(); i++) {
                 JSONObject object = jsTaskLists.getJSONObject(i);
                 String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
                 String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
 
-                // 检查是否是元数据文件夹
-                if (name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
+                if (name
+                        .equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
                     mMetaList = new TaskList();
                     mMetaList.setContentByRemoteJSON(object);
 
-                    // 加载元数据
+                    // load meta data
                     JSONArray jsMetas = client.getTaskList(gid);
                     for (int j = 0; j < jsMetas.length(); j++) {
                         object = (JSONObject) jsMetas.getJSONObject(j);
@@ -209,17 +202,6 @@ public class GTaskManager {
                     }
                 }
             }
-        }
-        // 处理JSON异常
-        catch (JSONException e) {
-            throw new NetworkFailureException("JSONException in initGTaskList");
-        }
-    }
-}                            }
-                        }
-                    }
-                }
-            }
 
             // create meta list if not existed
             if (mMetaList == null) {

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

@@ -1,11 +1,11 @@
 /*
- * Copyright (c) 2010 - 2011, The MiCode Open Source Community (www.micode.net)
+ * 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
+ *        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,
@@ -14,151 +14,97 @@
  * limitations under the License.
  */
 
-// 包声明，表明该类所在的包名为net.micode.notes.gtask.remote
 package net.micode.notes.gtask.remote;
 
 import android.app.Activity;
 import android.app.Service;
-// 用于创建和管理Android中的服务，服务可以在后台执行长时间运行的操作，不提供用户界面
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
-// 用于在组件间传递数据，例如在Activity、Service之间传递参数等，以键值对的形式存储数据
 import android.os.IBinder;
 
-// GTaskSyncService继承自Service类，是一个用于处理与GTask相关的同步操作的服务类，
-// 比如启动同步、取消同步以及发送同步相关广播等功能
 public class GTaskSyncService extends Service {
-    // 定义一个字符串常量，作为在Intent中传递同步操作类型的键，用于区分不同的同步相关动作
     public final static String ACTION_STRING_NAME = "sync_action_type";
 
-    // 定义一个整型常量，表示启动同步的操作类型，对应的值为0，用于在传递操作类型时使用
     public final static int ACTION_START_SYNC = 0;
 
-    // 定义一个整型常量，表示取消同步的操作类型，对应的值为1，用于在传递操作类型时使用
     public final static int ACTION_CANCEL_SYNC = 1;
 
-    // 定义一个整型常量，表示无效的操作类型，对应的值为2，用于在一些不符合预期的情况判断中使用
     public final static int ACTION_INVALID = 2;
 
-    // 定义一个字符串常量，作为广播的Action名称，用于标识该服务发送的广播，其他组件可以通过监听这个Action来接收广播
     public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
 
-    // 定义一个字符串常量，作为广播中传递是否正在同步状态的键，用于在广播Intent中传递同步状态信息
     public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
 
-    // 定义一个字符串常量，作为广播中传递同步进度消息的键，用于在广播Intent中传递同步进度相关的文本信息
     public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
 
-    // 静态变量，用于保存当前正在执行的GTaskASyncTask实例，初始化为null，表示当前没有正在进行的同步任务
     private static GTaskASyncTask mSyncTask = null;
 
-    // 静态变量，用于保存同步进度相关的消息内容，初始化为空字符串，后续会根据同步情况更新该内容并通过广播发送出去
     private static String mSyncProgress = "";
 
-    // 私有方法，用于启动同步任务
     private void startSync() {
-        // 判断当前是否没有正在执行的同步任务（mSyncTask为null），如果是则创建一个新的GTaskASyncTask实例来执行同步操作
         if (mSyncTask == null) {
-            // 创建GTaskASyncTask实例，传入当前服务的上下文（this）以及一个实现了OnCompleteListener接口的匿名内部类对象
             mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
-                // 实现OnCompleteListener接口的onComplete方法，当同步任务完成时会被调用
                 public void onComplete() {
-                    // 将mSyncTask置为null，表示同步任务已结束
                     mSyncTask = null;
-                    // 发送一个空消息的广播，可能用于通知其他组件同步已完成等情况
                     sendBroadcast("");
-                    // 停止当前服务，因为同步任务已经完成，服务不再需要继续运行
                     stopSelf();
                 }
             });
-            // 发送一个空消息的广播，可能用于通知其他组件即将开始同步等情况
             sendBroadcast("");
-            // 执行GTaskASyncTask实例的execute方法，启动异步任务开始执行同步操作
             mSyncTask.execute();
         }
     }
 
-    // 私有方法，用于取消正在进行的同步任务
     private void cancelSync() {
-        // 判断如果当前存在正在执行的同步任务（mSyncTask不为null），则调用GTaskASyncTask的cancelSync方法取消同步
-        if (mSyncTask!= null) {
+        if (mSyncTask != null) {
             mSyncTask.cancelSync();
         }
     }
 
-    // 重写Service的onCreate方法，该方法在服务创建时被调用，这里将mSyncTask初始化为null，
-    // 确保每次服务启动时都处于没有正在执行同步任务的初始状态
     @Override
     public void onCreate() {
         mSyncTask = null;
     }
 
-    // 重写Service的onStartCommand方法，该方法在每次服务接收到启动请求（通过startService方法启动服务时）被调用，
-    // 在这里根据传入的Intent中的参数来决定执行启动同步还是取消同步等操作，并返回服务的启动模式相关标识
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
-        // 从传入的Intent中获取携带的额外数据（以Bundle形式存储），这些数据可能包含了同步操作类型等信息
         Bundle bundle = intent.getExtras();
-        // 判断获取到的Bundle不为null并且其中包含了用于标识同步操作类型的键（ACTION_STRING_NAME）
-        if (bundle!= null && bundle.containsKey(ACTION_STRING_NAME)) {
-            // 根据获取到的同步操作类型的值进行不同的操作，通过switch语句进行判断
+        if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
             switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
-                // 如果操作类型是启动同步（ACTION_START_SYNC）
                 case ACTION_START_SYNC:
-                    // 调用startSync方法启动同步任务
                     startSync();
                     break;
-                // 如果操作类型是取消同步（ACTION_CANCEL_SYNC）
                 case ACTION_CANCEL_SYNC:
-                    // 调用cancelSync方法取消正在进行的同步任务
                     cancelSync();
                     break;
                 default:
-                    // 如果是其他未定义的操作类型，不做任何处理，直接跳出switch语句
                     break;
             }
-            // 返回START_STICKY，表示服务在被系统强制关闭后（例如内存不足等情况），会尝试重新创建并启动，
-            // 但不会重新传递上次的Intent，而是以空Intent启动，服务需要自行处理这种情况来恢复到合适的状态
             return START_STICKY;
         }
-        // 如果传入的Intent不符合预期（没有包含操作类型相关参数等情况），则调用父类的onStartCommand方法进行默认处理
         return super.onStartCommand(intent, flags, startId);
     }
 
-    // 重写Service的onLowMemory方法，该方法在系统内存不足时被调用，在这里用于取消正在进行的同步任务，
-    // 以释放内存资源，避免服务占用过多内存导致系统出现问题
     @Override
     public void onLowMemory() {
-        if (mSyncTask!= null) {
+        if (mSyncTask != null) {
             mSyncTask.cancelSync();
         }
     }
 
-    // 重写Service的onBind方法，用于处理服务的绑定操作，这里返回null，表示该服务不支持绑定操作，
-    // 即其他组件不能通过bindService方法来绑定这个服务获取IBinder对象进行交互
     public IBinder onBind(Intent intent) {
         return null;
     }
 
-    // 用于发送同步相关的广播，广播中包含了是否正在同步的状态以及同步进度消息等信息
     public void sendBroadcast(String msg) {
-        // 更新同步进度消息内容，将传入的msg赋值给mSyncProgress变量
         mSyncProgress = msg;
-        // 创建一个Intent对象，设置其Action为之前定义的广播Action名称（GTASK_SERVICE_BROADCAST_NAME），
-        // 用于标识这个广播是由该服务发出的同步相关广播
         Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
-        // 在Intent中添加额外数据，通过键（GTASK_SERVICE_BROADCAST_IS_SYNCING）来传递当前是否正在同步的状态，
-        // 根据mSyncTask是否为null来判断，null表示没有正在进行的同步任务，非null则表示正在同步
-        intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask!= null);
-        // 在Intent中添加额外数据，通过键（GTASK_SERVICE_BROADCAST_PROGRESS_MSG）来传递同步进度消息内容
+        intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null);
         intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg);
-        // 使用服务的上下文发送广播，将包含同步相关信息的Intent广播出去，其他组件可以通过注册监听相应Action来接收广播
         sendBroadcast(intent);
     }
 
-    // 静态方法，用于在Activity中启动同步服务来执行同步操作，
-    // 首先设置GTaskManager中的Activity上下文，然后构建启动服务的Intent并传递启动同步的操作类型参数，最后启动服务
     public static void startSync(Activity activity) {
         GTaskManager.getInstance().setActivityContext(activity);
         Intent intent = new Intent(activity, GTaskSyncService.class);
@@ -166,21 +112,17 @@ public class GTaskSyncService extends Service {
         activity.startService(intent);
     }
 
-    // 静态方法，用于在给定的上下文（Context）中启动服务来取消同步操作，
-    // 构建启动服务的Intent并传递取消同步的操作类型参数，最后启动服务
     public static void cancelSync(Context context) {
         Intent intent = new Intent(context, GTaskSyncService.class);
         intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC);
         context.startService(intent);
     }
 
-    // 静态方法，用于判断当前是否正在进行同步操作，通过判断mSyncTask是否为null来返回相应的布尔值结果
     public static boolean isSyncing() {
-        return mSyncTask!= null;
+        return mSyncTask != null;
     }
 
-    // 静态方法，用于获取当前的同步进度消息内容，直接返回保存同步进度消息的mSyncProgress变量的值
     public static String getProgressString() {
         return mSyncProgress;
     }
-}
+}

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

@@ -1,11 +1,11 @@
 /*
- * Copyright (c) 2010 - 2011, The MiCode Open Source Community (www.micode.net)
+ * 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
+ *        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,
@@ -14,141 +14,98 @@
  * limitations under the License.
  */
 
-// 包声明，表明该类所在的包名为net.micode.notes.model，通常用于存放笔记相关的数据模型等相关类定义
 package net.micode.notes.model;
-
-// 用于构建ContentProvider操作相关的数据结构，比如插入、更新、删除等操作的数据封装，以便批量应用到ContentResolver上
 import android.content.ContentProviderOperation;
-// 用于获取ContentProvider操作执行后的结果集，比如批量更新、插入等操作完成后返回的结果信息
 import android.content.ContentProviderResult;
-// 用于根据给定的基础Uri和一个ID值构建一个新的Uri，方便对特定资源进行操作（比如对某个具体笔记的相关操作对应的Uri）
 import android.content.ContentUris;
-// 用于存储键值对形式的数据，通常用于向ContentProvider插入、更新数据时传递具体的数据内容
 import android.content.ContentValues;
 import android.content.Context;
-// 用于处理ContentProvider操作应用时可能出现的异常情况，比如批量操作部分失败等异常处理
 import android.content.OperationApplicationException;
-// 用于表示一个资源的统一资源标识符（Uri），在Android中常用于定位ContentProvider中的数据资源等操作
 import android.net.Uri;
-// 用于处理在跨进程调用ContentProvider等操作时可能出现的远程异常情况
 import android.os.RemoteException;
 import android.util.Log;
 
-// 导入笔记相关的数据类，可能包含了笔记的各种属性、类型等定义以及不同类型笔记的数据结构相关类
 import net.micode.notes.data.Notes;
-// 导入笔记中呼叫记录相关的内部类，可能用于处理特定类型笔记（呼叫记录类型笔记）的数据结构和操作
 import net.micode.notes.data.Notes.CallNote;
-// 导入笔记中数据列相关的内部类，可能定义了笔记数据在存储时各个列的名称、类型等相关常量
 import net.micode.notes.data.Notes.DataColumns;
-// 导入笔记中普通笔记相关的列定义的内部类，可能定义了普通笔记在数据库存储时各个字段对应的列名等信息
 import net.micode.notes.data.Notes.NoteColumns;
-// 导入笔记中文本笔记相关的内部类，可能用于处理文本类型笔记的数据结构和操作
 import net.micode.notes.data.Notes.TextNote;
 
-// 导入用于存储列表等数据结构的集合类，这里主要用于存储ContentProviderOperation对象列表，以便批量操作
 import java.util.ArrayList;
 
-// Note类，应该是代表笔记的数据模型类，用于处理笔记相关的数据操作，比如创建笔记、更新笔记以及与ContentProvider交互等操作
+
 public class Note {
-    // 用于存储笔记的差异数据（可能是自上次同步或修改后发生变化的数据），以ContentValues形式存储，方便后续更新操作
     private ContentValues mNoteDiffValues;
-    // 用于存储笔记的详细数据（包含文本数据、呼叫数据等不同类型的数据），是一个自定义的NoteData类型对象
     private NoteData mNoteData;
-    // 定义一个日志标签，用于在Log输出时标识是该类中的相关日志信息，方便调试和查看日志记录
     private static final String TAG = "Note";
-
     /**
      * Create a new note id for adding a new note to databases
-     * 创建一个新的笔记ID，用于向数据库中添加新笔记，通过向ContentProvider插入一条新的笔记记录来获取新生成的笔记ID
      */
     public static synchronized long getNewNoteId(Context context, long folderId) {
-        // 创建一个新的ContentValues对象，用于存储要插入到数据库中的笔记初始数据
+        // Create a new note in the database
         ContentValues values = new ContentValues();
-        // 获取当前系统时间的时间戳，作为笔记的创建时间，单位为毫秒
         long createdTime = System.currentTimeMillis();
-        // 将创建时间设置到ContentValues中，对应笔记记录的创建日期字段（NoteColumns.CREATED_DATE）
         values.put(NoteColumns.CREATED_DATE, createdTime);
-        // 将创建时间也设置为修改时间，因为新创建的笔记初始时修改时间和创建时间相同，对应修改日期字段（NoteColumns.MODIFIED_DATE）
         values.put(NoteColumns.MODIFIED_DATE, createdTime);
-        // 设置笔记的类型，这里设置为普通笔记类型（Notes.TYPE_NOTE），可能有不同类型的笔记区分
         values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
-        // 将本地修改标志设置为1，表示该笔记在本地有过修改（初始创建也算一种本地修改情况），对应本地修改字段（NoteColumns.LOCAL_MODIFIED）
         values.put(NoteColumns.LOCAL_MODIFIED, 1);
-        // 设置笔记的父文件夹ID，用于表示笔记所属的文件夹，对应父ID字段（NoteColumns.PARENT_ID）
         values.put(NoteColumns.PARENT_ID, folderId);
-        // 通过ContentResolver向指定的笔记内容Uri（Notes.CONTENT_NOTE_URI）插入新的笔记记录，返回插入后生成的Uri
         Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
 
         long noteId = 0;
         try {
-            // 从插入后生成的Uri中获取路径段（通常Uri的路径部分可以按段分割，比如最后一段可能是新生成的资源ID），获取第二个路径段（索引为1）作为笔记ID
             noteId = Long.valueOf(uri.getPathSegments().get(1));
         } catch (NumberFormatException e) {
-            // 如果在转换为长整型笔记ID时出现格式异常（比如路径段内容不是合法的数字格式），记录错误日志并将笔记ID设置为0
             Log.e(TAG, "Get note id error :" + e.toString());
             noteId = 0;
         }
         if (noteId == -1) {
-            // 如果获取到的笔记ID为 -1，说明出现了不合理的情况，抛出IllegalStateException异常，表示笔记ID错误
             throw new IllegalStateException("Wrong note id:" + noteId);
         }
         return noteId;
     }
 
-    // 无参构造函数，用于初始化Note对象，创建一个新的ContentValues用于存储笔记差异数据，以及一个新的NoteData对象用于存储详细笔记数据
     public Note() {
         mNoteDiffValues = new ContentValues();
         mNoteData = new NoteData();
     }
 
-    // 设置笔记的某个值（可能是笔记的属性值等），将给定的键值对添加到笔记差异数据ContentValues中，
-    // 同时更新本地修改标志和修改日期，以记录笔记数据的变化情况
     public void setNoteValue(String key, String value) {
         mNoteDiffValues.put(key, value);
         mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
         mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
     }
 
-    // 设置笔记的文本数据，调用NoteData对象的相应方法来设置文本数据，将键值对存储到NoteData中的文本数据相关ContentValues中
     public void setTextData(String key, String value) {
         mNoteData.setTextData(key, value);
     }
 
-    // 设置笔记的文本数据ID，调用NoteData对象的相应方法来设置文本数据ID，传入的ID值会被存储到NoteData对象中
     public void setTextDataId(long id) {
         mNoteData.setTextDataId(id);
     }
 
-    // 获取笔记的文本数据ID，通过访问NoteData对象中的相应属性来返回文本数据ID
     public long getTextDataId() {
         return mNoteData.mTextDataId;
     }
 
-    // 设置笔记的呼叫数据ID，调用NoteData对象的相应方法来设置呼叫数据ID，传入的ID值会被存储到NoteData对象中，同时会进行参数合法性检查
     public void setCallDataId(long id) {
         mNoteData.setCallDataId(id);
     }
 
-    // 设置笔记的呼叫数据，调用NoteData对象的相应方法来设置呼叫数据，将键值对存储到NoteData中的呼叫数据相关ContentValues中，
-    // 同时更新本地修改标志和修改日期，以记录笔记数据的变化情况
     public void setCallData(String key, String value) {
         mNoteData.setCallData(key, value);
     }
 
-    // 判断笔记是否在本地有过修改，通过检查笔记差异数据ContentValues的大小（即是否有数据变化）以及NoteData对象是否有本地修改来综合判断
     public boolean isLocalModified() {
         return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
     }
 
-    // 同步笔记数据到ContentProvider（比如更新到数据库等存储介质中），根据笔记是否有本地修改以及更新操作的结果来返回同步是否成功
     public boolean syncNote(Context context, long noteId) {
         if (noteId <= 0) {
-            // 如果传入的笔记ID小于等于0，说明是不合理的笔记ID，抛出IllegalArgumentException异常，表示笔记ID错误
             throw new IllegalArgumentException("Wrong note id:" + noteId);
         }
 
         if (!isLocalModified()) {
-            // 如果笔记没有本地修改，说明不需要进行同步操作，直接返回true表示同步成功（实际上没有进行实际的更新操作）
             return true;
         }
 
@@ -156,21 +113,15 @@ public class Note {
          * In theory, once data changed, the note should be updated on {@link NoteColumns#LOCAL_MODIFIED} and
          * {@link NoteColumns#MODIFIED_DATE}. For data safety, though update note fails, we also update the
          * note data info
-         * 理论上，一旦数据发生变化，笔记应该在{@link NoteColumns#LOCAL_MODIFIED}和{@link NoteColumns#MODIFIED_DATE}字段上进行更新。
-         * 为了数据安全，即使更新笔记失败，我们也要更新笔记数据信息。
          */
-        // 通过ContentResolver尝试更新指定笔记ID对应的笔记记录，传入笔记差异数据ContentValues进行更新操作，
-        // 如果更新操作影响的行数为0（即没有实际更新到任何数据，可能更新失败），记录错误日志，但不立即返回，继续执行后续操作
         if (context.getContentResolver().update(
                 ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
                 null) == 0) {
             Log.e(TAG, "Update note error, should not happen");
             // Do not return, fall through
         }
-        // 清除笔记差异数据ContentValues中的内容，因为已经尝试进行了更新操作，无论成功与否都先清空，准备下次记录新的差异数据
         mNoteDiffValues.clear();
 
-        // 如果NoteData对象有本地修改，并且将NoteData中的数据推送到ContentResolver（即更新相关数据到存储介质）操作返回null（可能推送失败），则返回false表示同步失败
         if (mNoteData.isLocalModified()
                 && (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
             return false;
@@ -179,21 +130,17 @@ public class Note {
         return true;
     }
 
-    // NoteData内部类，用于封装笔记的详细数据（包含文本数据和呼叫数据相关的ContentValues以及对应的ID等信息），
-    // 处理与这些详细数据相关的操作，比如设置数据、判断是否有本地修改以及将数据推送到ContentResolver等操作
     private class NoteData {
-        // 存储文本数据的唯一标识符（ID），初始化为0
         private long mTextDataId;
-        // 用于存储文本数据相关的ContentValues，以键值对形式存储文本数据的具体内容等信息，初始化为一个新的ContentValues对象
+
         private ContentValues mTextDataValues;
-        // 存储呼叫数据的唯一标识符（ID），初始化为0
+
         private long mCallDataId;
-        // 用于存储呼叫数据相关的ContentValues，以键值对形式存储呼叫数据的具体内容等信息，初始化为一个新的ContentValues对象
+
         private ContentValues mCallDataValues;
-        // 定义一个日志标签，用于在Log输出时标识是该内部类中的相关日志信息，方便调试和查看日志记录
+
         private static final String TAG = "NoteData";
 
-        // 构造函数，用于初始化NoteData对象，创建新的文本数据和呼叫数据相关的ContentValues对象，并将文本数据和呼叫数据的ID初始化为0
         public NoteData() {
             mTextDataValues = new ContentValues();
             mCallDataValues = new ContentValues();
@@ -201,20 +148,17 @@ public class Note {
             mCallDataId = 0;
         }
 
-        // 判断NoteData对象中的文本数据或呼叫数据是否有本地修改，通过检查对应的ContentValues的大小（即是否有数据变化）来判断
         boolean isLocalModified() {
             return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
         }
 
-        // 设置文本数据ID，进行参数合法性检查，如果传入的ID小于等于0，则抛出IllegalArgumentException异常，否则更新文本数据ID
         void setTextDataId(long id) {
-            if (id <= 0) {
+            if(id <= 0) {
                 throw new IllegalArgumentException("Text data id should larger than 0");
             }
             mTextDataId = id;
         }
 
-        // 设置呼叫数据ID，进行参数合法性检查，如果传入的ID小于等于0，则抛出IllegalArgumentException异常，否则更新呼叫数据ID
         void setCallDataId(long id) {
             if (id <= 0) {
                 throw new IllegalArgumentException("Call data id should larger than 0");
@@ -222,54 +166,88 @@ public class Note {
             mCallDataId = id;
         }
 
-        // 设置呼叫数据，将给定的键值对添加到呼叫数据相关的ContentValues中，同时更新笔记的本地修改标志和修改日期（通过外部的Note对象相关字段来更新）
         void setCallData(String key, String value) {
             mCallDataValues.put(key, value);
             mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
             mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
         }
 
-        // 设置文本数据，将给定的键值对添加到文本数据相关的ContentValues中，同时更新笔记的本地修改标志和修改日期（通过外部的Note对象相关字段来更新）
         void setTextData(String key, String value) {
             mTextDataValues.put(key, value);
             mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
             mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
         }
 
-        // 将NoteData中的数据推送到ContentResolver（比如更新到数据库等存储介质中），根据文本数据和呼叫数据的情况进行相应的插入、更新操作，
-        // 并处理操作过程中可能出现的异常情况，返回操作结果对应的Uri（如果成功）或null（如果失败）
         Uri pushIntoContentResolver(Context context, long noteId) {
             /**
              * Check for safety
              */
             if (noteId <= 0) {
-                // 如果传入的笔记ID小于等于0，进行参数合法性检查，抛出IllegalArgumentException异常，表示笔记ID错误
                 throw new IllegalArgumentException("Wrong note id:" + noteId);
             }
 
-            // 创建一个ArrayList，用于存储ContentProviderOperation对象，以便后续批量应用到ContentResolver上进行操作
             ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
-            // 创建一个ContentProviderOperation的构建器对象，初始化为null，后续根据具体情况创建相应的更新或插入操作构建器
             ContentProviderOperation.Builder builder = null;
 
-            if (mTextDataValues.size() > 0) {
-                // 如果文本数据相关的ContentValues中有数据（即有文本数据需要处理），将笔记ID设置到文本数据的ContentValues中，对应笔记ID字段（DataColumns.NOTE_ID）
+            if(mTextDataValues.size() > 0) {
                 mTextDataValues.put(DataColumns.NOTE_ID, noteId);
                 if (mTextDataId == 0) {
-                    // 如果文本数据ID为0，说明是新的文本数据，需要进行插入操作，设置文本数据的MIME类型为文本笔记的内容类型（TextNote.CONTENT_ITEM_TYPE）
                     mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
-                    // 通过ContentResolver向指定的笔记数据内容Uri（Notes.CONTENT_DATA_URI）插入新的文本数据记录，返回插入后生成的Uri
                     Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
                             mTextDataValues);
                     try {
-                        // 尝试从插入后生成的Uri中获取路径段，获取第二个路径段（索引为1）作为新生成的文本数据ID，并设置到文本数据ID属性中
                         setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));
                     } catch (NumberFormatException e) {
-                        // 如果在转换为长整型文本数据ID时出现格式异常，记录错误日志，清除文本数据相关的ContentValues内容，并返回null表示插入失败
                         Log.e(TAG, "Insert new text data fail with noteId" + noteId);
                         mTextDataValues.clear();
                         return null;
                     }
                 } else {
-                    // 如果文本数据ID不为0，说明是已有文本数据的更新操作，创建一个ContentProviderOperation的更新操作构建器，
-                    // 根据文本数据ID对应的Uri（通过ContentUris.withAppendedId构建）来指定要更新的
+                    builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mTextDataId));
+                    builder.withValues(mTextDataValues);
+                    operationList.add(builder.build());
+                }
+                mTextDataValues.clear();
+            }
+
+            if(mCallDataValues.size() > 0) {
+                mCallDataValues.put(DataColumns.NOTE_ID, noteId);
+                if (mCallDataId == 0) {
+                    mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
+                    Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
+                            mCallDataValues);
+                    try {
+                        setCallDataId(Long.valueOf(uri.getPathSegments().get(1)));
+                    } catch (NumberFormatException e) {
+                        Log.e(TAG, "Insert new call data fail with noteId" + noteId);
+                        mCallDataValues.clear();
+                        return null;
+                    }
+                } else {
+                    builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mCallDataId));
+                    builder.withValues(mCallDataValues);
+                    operationList.add(builder.build());
+                }
+                mCallDataValues.clear();
+            }
+
+            if (operationList.size() > 0) {
+                try {
+                    ContentProviderResult[] results = context.getContentResolver().applyBatch(
+                            Notes.AUTHORITY, operationList);
+                    return (results == null || results.length == 0 || results[0] == null) ? null
+                            : ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId);
+                } catch (RemoteException e) {
+                    Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+                    return null;
+                } catch (OperationApplicationException e) {
+                    Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+                    return null;
+                }
+            }
+            return null;
+        }
+    }
+}

app/src/main/java/net/micode/notes/model/WorkingNote.java

@@ -1,11 +1,11 @@
 /*
- * Copyright (c) 2010 - 2011, The MiCode Open Source Community (www.micode.net)
+ * 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
+ *        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,
@@ -14,73 +14,54 @@
  * limitations under the License.
  */
 
-// 包声明，表明该类所在的包名为net.micode.notes.model，通常用于存放和笔记相关的数据模型及操作逻辑等相关类
 package net.micode.notes.model;
 
-// 用于管理桌面小部件相关操作，例如获取小部件ID、更新小部件等操作，和Android桌面小部件功能交互相关
 import android.appwidget.AppWidgetManager;
-// 用于根据给定的基础Uri和一个ID值构建一个新的Uri，方便对特定资源进行操作（比如对某个具体笔记的相关操作对应的Uri）
 import android.content.ContentUris;
-// 提供对Android设备上各种数据存储（如数据库等）进行查询、插入、更新、删除等操作的接口，通过它与Content Provider进行交互
 import android.content.Context;
-// 用于在数据库查询操作后获取结果集，以游标形式遍历查询返回的数据行，可从中获取具体的列数据
 import android.database.Cursor;
-// 用于处理字符串相关的工具方法，比如判断字符串是否为空、比较字符串内容是否相等之类的操作
 import android.text.TextUtils;
 import android.util.Log;
 
-// 导入笔记相关的数据类，可能包含了笔记的各种属性、类型等定义以及不同类型笔记的数据结构相关类
 import net.micode.notes.data.Notes;
-// 导入笔记中呼叫记录相关的内部类，可能用于处理特定类型笔记（呼叫记录类型笔记）的数据结构和操作
 import net.micode.notes.data.Notes.CallNote;
-// 导入笔记中数据列相关的内部类，可能定义了笔记数据在存储时各个列的名称、类型等相关常量
 import net.micode.notes.data.Notes.DataColumns;
-// 导入笔记中数据相关的常量定义，可能包含了一些预定义的笔记数据类型等常量值
 import net.micode.notes.data.Notes.DataConstants;
-// 导入笔记中普通笔记相关的列定义的内部类，可能定义了普通笔记在数据库存储时各个字段对应的列名等信息
 import net.micode.notes.data.Notes.NoteColumns;
-// 导入笔记中文本笔记相关的内部类，可能用于处理文本类型笔记的数据结构和操作
 import net.micode.notes.data.Notes.TextNote;
-// 导入用于解析资源相关的工具类中的笔记背景资源相关的内部类，可能用于获取笔记背景相关的资源ID等操作
 import net.micode.notes.tool.ResourceParser.NoteBgResources;
 
-// WorkingNote类，应该是代表正在操作（编辑、修改等）的笔记的数据模型类，封装了笔记的各种属性以及相关操作方法
+
 public class WorkingNote {
-    // 用于存储关联的Note对象，Note类可能是更基础的笔记数据模型类，这里的WorkingNote可能是在其基础上进行更多业务相关操作的封装
     // Note for the working note
     private Note mNote;
-    // 用于存储笔记的唯一标识符（ID），代表当前正在操作的笔记在数据库等存储介质中的标识
     // Note Id
     private long mNoteId;
-    // 用于存储笔记的内容文本，比如用户输入的具体笔记文字内容等
     // Note content
     private String mContent;
-    // 用于存储笔记的模式相关信息，具体含义可能根据业务逻辑而定，例如可能是不同的编辑模式等情况
     // Note mode
     private int mMode;
 
-    // 用于存储笔记设置的提醒日期时间戳，以毫秒为单位，用于表示笔记的提醒时间相关设置
     private long mAlertDate;
-    // 用于存储笔记最后修改的日期时间戳，以毫秒为单位，用于记录笔记最近一次被修改的时间
+
     private long mModifiedDate;
-    // 用于存储笔记背景颜色的资源ID，通过这个ID可以获取到对应的背景颜色资源，用于设置笔记的显示背景等
+
     private int mBgColorId;
-    // 用于存储笔记关联的桌面小部件的ID，用于标识该笔记与哪个桌面小部件相关联（如果有的话）
+
     private int mWidgetId;
-    // 用于存储笔记关联的桌面小部件的类型，可能有不同类型的小部件对应不同的展示或功能，具体类型由业务定义
+
     private int mWidgetType;
-    // 用于存储笔记所属的文件夹的ID，用于表示笔记在文件系统中的分类归属，方便管理和查找笔记
+
     private long mFolderId;
-    // 用于存储当前的上下文环境（Context），通过它可以访问Android系统的各种资源、服务等，方便与系统进行交互操作
+
     private Context mContext;
-    // 定义一个日志标签，用于在Log输出时标识是该类中的相关日志信息，方便调试和查看日志记录
+
     private static final String TAG = "WorkingNote";
-    // 用于标记当前笔记是否已被删除，true表示已删除，false表示未删除，方便在业务逻辑中判断笔记的删除状态
+
     private boolean mIsDeleted;
-    // 用于存储一个实现了NoteSettingChangedListener接口的对象，以便在笔记相关设置发生变化时通知对应的监听器进行相应处理
+
     private NoteSettingChangedListener mNoteSettingStatusListener;
 
-    // 定义一个字符串数组常量，用于指定查询笔记数据时要获取的列名列表，主要涉及笔记数据相关的一些通用列信息，用于后续数据库查询操作
     public static final String[] DATA_PROJECTION = new String[] {
             DataColumns.ID,
             DataColumns.CONTENT,
@@ -91,7 +72,6 @@ public class WorkingNote {
             DataColumns.DATA4,
     };
 
-    // 定义一个字符串数组常量，用于指定查询笔记基本信息时要获取的列名列表，主要涉及笔记自身属性相关的一些列信息，用于后续数据库查询操作
     public static final String[] NOTE_PROJECTION = new String[] {
             NoteColumns.PARENT_ID,
             NoteColumns.ALERTED_DATE,
@@ -101,28 +81,26 @@ public class WorkingNote {
             NoteColumns.MODIFIED_DATE
     };
 
-    // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记数据ID列的索引位置，方便从游标中获取对应的数据
     private static final int DATA_ID_COLUMN = 0;
-    // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记内容列的索引位置，方便从游标中获取对应的数据
+
     private static final int DATA_CONTENT_COLUMN = 1;
-    // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记MIME类型列的索引位置，方便从游标中获取对应的数据
+
     private static final int DATA_MIME_TYPE_COLUMN = 2;
-    // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记模式相关列的索引位置，方便从游标中获取对应的数据
+
     private static final int DATA_MODE_COLUMN = 3;
-    // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记父文件夹ID列的索引位置，方便从游标中获取对应的数据
+
     private static final int NOTE_PARENT_ID_COLUMN = 0;
-    // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记提醒日期列的索引位置，方便从游标中获取对应的数据
+
     private static final int NOTE_ALERTED_DATE_COLUMN = 1;
-    // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记背景颜色ID列的索引位置，方便从游标中获取对应的数据
+
     private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
-    // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记小部件ID列的索引位置，方便从游标中获取对应的数据
+
     private static final int NOTE_WIDGET_ID_COLUMN = 3;
-    // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记小部件类型列的索引位置，方便从游标中获取对应的数据
+
     private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
-    // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记修改日期列的索引位置，方便从游标中获取对应的数据
+
     private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
 
-    // 私有构造函数，用于创建一个新的空白笔记（尚未保存到数据库等存储介质中），初始化一些基本属性，如创建时间、所属文件夹等信息
     // New note construct
     private WorkingNote(Context context, long folderId) {
         mContext = context;
@@ -136,7 +114,6 @@ public class WorkingNote {
         mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
     }
 
-    // 私有构造函数，用于创建一个基于已有笔记ID的WorkingNote对象，通过从数据库等存储介质中加载已有笔记的信息来初始化对象属性
     // Existing note construct
     private WorkingNote(Context context, long noteId, long folderId) {
         mContext = context;
@@ -147,15 +124,12 @@ public class WorkingNote {
         loadNote();
     }
 
-    // 私有方法，用于从数据库等存储介质中加载笔记的基本信息（如文件夹ID、背景颜色ID、小部件相关信息等），通过ContentResolver进行查询操作获取数据
     private void loadNote() {
-        // 使用ContentResolver查询指定笔记ID对应的笔记基本信息，传入构建好的笔记内容Uri（通过ContentUris.withAppendedId根据笔记ID生成）以及要查询的列名列表（NOTE_PROJECTION）等参数
         Cursor cursor = mContext.getContentResolver().query(
                 ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
                 null, null);
 
-        if (cursor!= null) {
-            // 判断游标是否有数据，如果游标可以移动到第一条数据（即有查询到的数据），则从游标中获取相应列的数据并赋值给对应的对象属性
+        if (cursor != null) {
             if (cursor.moveToFirst()) {
                 mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
                 mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
@@ -164,59 +138,44 @@ public class WorkingNote {
                 mAlertDate = cursor.getLong(NOTE_ALERTED_DATE_COLUMN);
                 mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN);
             }
-            // 关闭游标，释放相关资源，因为已经获取完需要的数据了
             cursor.close();
         } else {
-            // 如果游标为null，说明查询出现问题，没有找到对应的笔记，记录错误日志并抛出IllegalArgumentException异常，表示无法找到指定ID的笔记
             Log.e(TAG, "No note with id:" + mNoteId);
             throw new IllegalArgumentException("Unable to find note with id " + mNoteId);
         }
-        // 调用loadNoteData方法加载笔记的详细数据（如内容、类型等信息）
         loadNoteData();
     }
 
-    // 私有方法，用于从数据库等存储介质中加载笔记的详细数据（如内容、类型等信息），通过ContentResolver进行查询操作获取数据，并根据数据类型进行相应的处理
     private void loadNoteData() {
-        // 使用ContentResolver查询指定笔记ID对应的笔记数据信息，传入笔记数据内容的Uri（Notes.CONTENT_DATA_URI）以及要查询的列名列表（DATA_PROJECTION）等参数，
-        // 同时通过条件筛选只获取当前笔记ID对应的笔记数据（DataColumns.NOTE_ID + "=?" 及对应的笔记ID参数）
         Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
                 DataColumns.NOTE_ID + "=?", new String[] {
-                        String.valueOf(mNoteId)
+                    String.valueOf(mNoteId)
                 }, null);
 
-        if (cursor!= null) {
-            // 判断游标是否有数据，如果游标可以移动到第一条数据（即有查询到的数据），则进入循环遍历游标中的每一行数据
+        if (cursor != null) {
             if (cursor.moveToFirst()) {
                 do {
-                    // 从游标中获取笔记数据的MIME类型列的数据（表示数据的格式类型，比如文本、呼叫记录等类型）
                     String type = cursor.getString(DATA_MIME_TYPE_COLUMN);
                     if (DataConstants.NOTE.equals(type)) {
-                        // 如果类型是普通笔记类型（DataConstants.NOTE），则从游标中获取笔记内容列的数据赋值给mContent属性，
-                        // 获取笔记模式列的数据赋值给mMode属性，并将笔记数据ID设置到关联的Note对象中（通过调用Note对象的setTextDataId方法）
                         mContent = cursor.getString(DATA_CONTENT_COLUMN);
                         mMode = cursor.getInt(DATA_MODE_COLUMN);
                         mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN));
                     } else if (DataConstants.CALL_NOTE.equals(type)) {
-                        // 如果类型是呼叫记录笔记类型（DataConstants.CALL_NOTE），则将笔记数据ID设置到关联的Note对象的呼叫数据相关属性中（通过调用Note对象的setCallDataId方法）
                         mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN));
                     } else {
-                        // 如果是其他未知的类型，则记录调试日志，提示出现了错误的笔记类型
                         Log.d(TAG, "Wrong note type with type:" + type);
                     }
                 } while (cursor.moveToNext());
             }
-            // 关闭游标，释放相关资源，因为已经获取完需要的数据了
             cursor.close();
         } else {
-            // 如果游标为null，说明查询出现问题，没有找到对应的笔记数据，记录错误日志并抛出IllegalArgumentException异常，表示无法找到指定ID的笔记数据
             Log.e(TAG, "No data with id:" + mNoteId);
             throw new IllegalArgumentException("Unable to find note's data with id " + mNoteId);
         }
     }
 
-    // 静态工厂方法，用于创建一个新的空白笔记对象，并设置一些初始属性（如背景颜色ID、小部件ID、小部件类型等），方便后续编辑等操作
     public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
-                                              int widgetType, int defaultBgColorId) {
+            int widgetType, int defaultBgColorId) {
         WorkingNote note = new WorkingNote(context, folderId);
         note.setBgColorId(defaultBgColorId);
         note.setWidgetId(widgetId);
@@ -224,34 +183,27 @@ public class WorkingNote {
         return note;
     }
 
-    // 静态工厂方法，用于根据给定的笔记ID从数据库等存储介质中加载已有笔记信息并创建对应的WorkingNote对象，方便后续操作
     public static WorkingNote load(Context context, long id) {
         return new WorkingNote(context, id, 0);
     }
 
-    // 同步方法，用于保存当前笔记的信息到数据库等存储介质中，如果笔记值得保存（根据一定的业务规则判断），则进行保存操作并返回保存结果（成功或失败）
     public synchronized boolean saveNote() {
         if (isWorthSaving()) {
-            // 判断笔记是否已经存在于数据库中，如果不存在
             if (!existInDatabase()) {
-                // 通过调用Note类的静态方法获取一个新的笔记ID，如果获取失败（返回0），记录错误日志并返回false表示保存失败
                 if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
                     Log.e(TAG, "Create new note fail with id:" + mNoteId);
                     return false;
                 }
             }
 
-            // 调用关联的Note对象的syncNote方法将笔记数据同步到数据库等存储介质中，进行实际的保存操作
             mNote.syncNote(mContext, mNoteId);
 
             /**
              * Update widget content if there exist any widget of this note
-             * 如果当前笔记关联了桌面小部件（小部件ID有效且小部件类型有效）并且设置了NoteSettingChangedListener监听器，
-             * 则调用监听器的onWidgetChanged方法通知小部件内容需要更新（可能是笔记内容变化后小部件展示也需要相应更新等情况）
              */
-            if (mWidgetId!= AppWidgetManager.INVALID_APPWIDGET_ID
-                    && mWidgetType!= Notes.TYPE_WIDGET_INVALIDE
-                    && mNoteSettingStatusListener!= null) {
+            if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                    && mWidgetType != Notes.TYPE_WIDGET_INVALIDE
+                    && mNoteSettingStatusListener != null) {
                 mNoteSettingStatusListener.onWidgetChanged();
             }
             return true;
@@ -260,11 +212,157 @@ public class WorkingNote {
         }
     }
 
-    // 用于判断笔记是否已经存在于数据库等存储介质中，通过检查笔记ID是否大于0来判断（通常大于0表示已经有对应的存储记录）
     public boolean existInDatabase() {
         return mNoteId > 0;
     }
 
-    // 私有方法，用于根据一定的业务规则判断笔记是否值得保存，比如笔记已被删除、不存在且内容为空、存在但没有本地修改等情况则不值得保存，返回相应的布尔值结果
     private boolean isWorthSaving() {
-        if (mIsDeleted
+        if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
+                || (existInDatabase() && !mNote.isLocalModified())) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
+        mNoteSettingStatusListener = l;
+    }
+
+    public void setAlertDate(long date, boolean set) {
+        if (date != mAlertDate) {
+            mAlertDate = date;
+            mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));
+        }
+        if (mNoteSettingStatusListener != null) {
+            mNoteSettingStatusListener.onClockAlertChanged(date, set);
+        }
+    }
+
+    public void markDeleted(boolean mark) {
+        mIsDeleted = mark;
+        if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                && mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) {
+                mNoteSettingStatusListener.onWidgetChanged();
+        }
+    }
+
+    public void setBgColorId(int id) {
+        if (id != mBgColorId) {
+            mBgColorId = id;
+            if (mNoteSettingStatusListener != null) {
+                mNoteSettingStatusListener.onBackgroundColorChanged();
+            }
+            mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id));
+        }
+    }
+
+    public void setCheckListMode(int mode) {
+        if (mMode != mode) {
+            if (mNoteSettingStatusListener != null) {
+                mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode);
+            }
+            mMode = mode;
+            mNote.setTextData(TextNote.MODE, String.valueOf(mMode));
+        }
+    }
+
+    public void setWidgetType(int type) {
+        if (type != mWidgetType) {
+            mWidgetType = type;
+            mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
+        }
+    }
+
+    public void setWidgetId(int id) {
+        if (id != mWidgetId) {
+            mWidgetId = id;
+            mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
+        }
+    }
+
+    public void setWorkingText(String text) {
+        if (!TextUtils.equals(mContent, text)) {
+            mContent = text;
+            mNote.setTextData(DataColumns.CONTENT, mContent);
+        }
+    }
+
+    public void convertToCallNote(String phoneNumber, long callDate) {
+        mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
+        mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
+        mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
+    }
+
+    public boolean hasClockAlert() {
+        return (mAlertDate > 0 ? true : false);
+    }
+
+    public String getContent() {
+        return mContent;
+    }
+
+    public long getAlertDate() {
+        return mAlertDate;
+    }
+
+    public long getModifiedDate() {
+        return mModifiedDate;
+    }
+
+    public int getBgColorResId() {
+        return NoteBgResources.getNoteBgResource(mBgColorId);
+    }
+
+    public int getBgColorId() {
+        return mBgColorId;
+    }
+
+    public int getTitleBgResId() {
+        return NoteBgResources.getNoteTitleBgResource(mBgColorId);
+    }
+
+    public int getCheckListMode() {
+        return mMode;
+    }
+
+    public long getNoteId() {
+        return mNoteId;
+    }
+
+    public long getFolderId() {
+        return mFolderId;
+    }
+
+    public int getWidgetId() {
+        return mWidgetId;
+    }
+
+    public int getWidgetType() {
+        return mWidgetType;
+    }
+
+    public interface NoteSettingChangedListener {
+        /**
+         * Called when the background color of current note has just changed
+         */
+        void onBackgroundColorChanged();
+
+        /**
+         * Called when user set clock
+         */
+        void onClockAlertChanged(long date, boolean set);
+
+        /**
+         * Call when user create note from widget
+         */
+        void onWidgetChanged();
+
+        /**
+         * Call when switch between check list mode and normal mode
+         * @param oldMode is previous mode before change
+         * @param newMode is new mode
+         */
+        void onCheckListModeChanged(int oldMode, int newMode);
+    }
+}

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

@@ -1,65 +1,46 @@
-//*
-* 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.
-        */
-
-// 包声明，表明该类所在的包名为net.micode.notes.tool，通常用于存放和笔记应用相关的工具类，这里的BackupUtils应该是和备份相关的工具类
-        package net.micode.notes.tool;
-
-// 用于获取Android应用的上下文环境，通过它可以访问系统资源、服务等，是Android开发中很多操作的基础入口
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.tool;
+
 import android.content.Context;
-// 用于在数据库查询操作后获取结果集，以游标形式遍历查询返回的数据行，可从中获取具体的列数据
 import android.database.Cursor;
-// 用于获取Android设备外部存储（如SD卡等）的状态信息，判断是否可读写等情况
 import android.os.Environment;
-// 用于处理字符串相关的工具方法，比如判断字符串是否为空、格式化字符串等操作
 import android.text.TextUtils;
-// 用于格式化日期、时间相关的文本展示格式，方便将时间戳等数据转换为符合特定格式的字符串
 import android.text.format.DateFormat;
 import android.util.Log;
 
-// 导入应用资源相关的R类，通过它可以获取到应用中定义的各种资源（如字符串、布局、图片资源等）的ID，用于在代码中使用这些资源
 import net.micode.notes.R;
-// 导入笔记相关的数据类，可能包含了笔记的各种属性、类型等定义以及不同类型笔记的数据结构相关类
 import net.micode.notes.data.Notes;
-// 导入笔记中数据列相关的内部类，可能定义了笔记数据在存储时各个列的名称、类型等相关常量
 import net.micode.notes.data.Notes.DataColumns;
-// 导入笔记中数据相关的常量定义，可能包含了一些预定义的笔记数据类型等常量值
 import net.micode.notes.data.Notes.DataConstants;
-// 导入笔记中普通笔记相关的列定义的内部类，可能定义了普通笔记在数据库存储时各个字段对应的列名等信息
 import net.micode.notes.data.Notes.NoteColumns;
 
-// 导入Java中文件操作相关的类，用于创建、读取、写入文件等操作
 import java.io.File;
-// 用于在文件操作中表示找不到指定文件的异常情况，当尝试访问不存在的文件时会抛出该异常
 import java.io.FileNotFoundException;
-// 用于创建文件输出流，将数据写入到文件中，是进行文件写入操作的关键类之一
 import java.io.FileOutputStream;
-// 用于处理文件读写过程中出现的一般性IO异常情况，比如读写文件出错、权限不足等问题时抛出该异常
 import java.io.IOException;
-// 用于将格式化后的文本数据输出到指定的输出流（比如文件输出流、控制台输出流等），方便进行文本内容的输出操作
 import java.io.PrintStream;
 
-// BackupUtils类，是一个用于备份相关功能的工具类，可能涉及将笔记数据备份到文件等操作，采用了单例模式设计
+
 public class BackupUtils {
-    // 定义一个日志标签，用于在Log输出时标识是该类中的相关日志信息，方便调试和查看日志记录
     private static final String TAG = "BackupUtils";
-    // 单例模式相关，用于保存唯一的BackupUtils实例对象，初始化为null，后续通过单例方法获取实例时进行初始化
     // Singleton stuff
     private static BackupUtils sInstance;
 
-    // 静态同步方法，用于获取BackupUtils的单例实例，如果实例还未创建，则创建一个新的实例并返回，保证整个应用中只有一个该类的实例存在
     public static synchronized BackupUtils getInstance(Context context) {
         if (sInstance == null) {
             sInstance = new BackupUtils(context);
@@ -70,55 +51,41 @@ public class BackupUtils {
     /**
      * Following states are signs to represents backup or restore
      * status
-     * 以下这些状态常量用于表示备份或恢复操作的状态情况
      */
-    // 表示当前SD卡（外部存储设备）未挂载，不可进行读写操作，对应备份或恢复操作可能无法进行的一种状态
     // Currently, the sdcard is not mounted
-    public static final int STATE_SD_CARD_UNMOUONTED = 0;
-    // 表示备份文件不存在，可能是还未进行过备份或者备份文件被误删除等情况，用于在检查备份相关情况时判断
+    public static final int STATE_SD_CARD_UNMOUONTED           = 0;
     // The backup file not exist
-    public static final int STATE_BACKUP_FILE_NOT_EXIST = 1;
-    // 表示数据格式不正确，可能被其他程序修改导致不符合预期的格式，影响备份或恢复操作的正常进行，用于异常情况判断
+    public static final int STATE_BACKUP_FILE_NOT_EXIST        = 1;
     // The data is not well formated, may be changed by other programs
-    public static final int STATE_DATA_DESTROIED = 2;
-    // 表示出现了一些运行时异常，导致备份或恢复操作失败，比如内存不足、程序崩溃等异常情况，用于捕获和标识异常状态
+    public static final int STATE_DATA_DESTROIED               = 2;
     // Some run-time exception which causes restore or backup fails
-    public static final int STATE_SYSTEM_ERROR = 3;
-    // 表示备份或恢复操作成功完成，用于标识操作正常结束的状态情况
+    public static final int STATE_SYSTEM_ERROR                 = 3;
     // Backup or restore success
-    public static final int STATE_SUCCESS = 4;
+    public static final int STATE_SUCCESS                      = 4;
 
-    // 用于文本导出相关操作的对象，可能负责将笔记数据转换为文本格式并进行导出等具体功能，通过构造函数初始化
     private TextExport mTextExport;
 
-    // 私有构造函数，用于初始化BackupUtils对象，创建一个TextExport对象用于后续的文本导出相关操作，保证外部不能随意创建该类实例，符合单例模式要求
     private BackupUtils(Context context) {
         mTextExport = new TextExport(context);
     }
 
-    // 静态方法，用于判断外部存储（如SD卡等）是否可用，通过检查外部存储的挂载状态是否为已挂载（MEDIA_MOUNTED）来返回相应的布尔值结果
     private static boolean externalStorageAvailable() {
         return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
     }
 
-    // 调用TextExport对象的exportToText方法进行文本导出操作，并返回相应的结果（可能是表示导出操作状态的状态码等）
     public int exportToText() {
         return mTextExport.exportToText();
     }
 
-    // 获取通过TextExport对象导出的文本文件的文件名，实际是调用TextExport对象的相应属性来返回文件名
     public String getExportedTextFileName() {
         return mTextExport.mFileName;
     }
 
-    // 获取通过TextExport对象导出的文本文件所在的目录路径，实际是调用TextExport对象的相应属性来返回文件目录路径
     public String getExportedTextFileDir() {
         return mTextExport.mFileDirectory;
     }
 
-    // TextExport内部类，主要负责将笔记相关数据转换为文本格式并输出到指定位置（如文件）的具体操作，封装了相关的数据查询、格式转换等逻辑
     private static class TextExport {
-        // 定义一个字符串数组常量，用于指定查询笔记基本信息时要获取的列名列表，主要涉及笔记自身属性相关的一些列信息，用于后续数据库查询操作
         private static final String[] NOTE_PROJECTION = {
                 NoteColumns.ID,
                 NoteColumns.MODIFIED_DATE,
@@ -126,14 +93,12 @@ public class BackupUtils {
                 NoteColumns.TYPE
         };
 
-        // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记ID列的索引位置，方便从游标中获取对应的数据
         private static final int NOTE_COLUMN_ID = 0;
-        // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记修改日期列的索引位置，方便从游标中获取对应的数据
+
         private static final int NOTE_COLUMN_MODIFIED_DATE = 1;
-        // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记摘要列的索引位置，方便从游标中获取对应的数据
+
         private static final int NOTE_COLUMN_SNIPPET = 2;
 
-        // 定义一个字符串数组常量，用于指定查询笔记数据时要获取的列名列表，主要涉及笔记数据相关的一些通用列信息，用于后续数据库查询操作
         private static final String[] DATA_PROJECTION = {
                 DataColumns.CONTENT,
                 DataColumns.MIME_TYPE,
@@ -143,32 +108,23 @@ public class BackupUtils {
                 DataColumns.DATA4,
         };
 
-        // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记数据内容列的索引位置，方便从游标中获取对应的数据
         private static final int DATA_COLUMN_CONTENT = 0;
-        // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记数据MIME类型列的索引位置，方便从游标中获取对应的数据
+
         private static final int DATA_COLUMN_MIME_TYPE = 1;
-        // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记数据呼叫日期列的索引位置，方便从游标中获取对应的数据
+
         private static final int DATA_COLUMN_CALL_DATE = 2;
-        // 定义一个整型常量，用于表示在查询结果游标（Cursor）中笔记数据电话号码列的索引位置，方便从游标中获取对应的数据
+
         private static final int DATA_COLUMN_PHONE_NUMBER = 4;
 
-        // 定义一个字符串数组，用于存储文本格式相关的模板字符串，不同索引位置对应不同用途的格式模板，后续会根据索引获取相应格式来格式化输出文本内容
         private final String [] TEXT_FORMAT;
-        // 定义一个整型常量，用于表示在TEXT_FORMAT数组中文件夹名称格式模板的索引位置，方便获取对应格式字符串
-        private static final int FORMAT_FOLDER_NAME = 0;
-        // 定义一个整型常量，用于表示在TEXT_FORMAT数组中笔记日期格式模板的索引位置，方便获取对应格式字符串
-        private static final int FORMAT_NOTE_DATE = 1;
-        // 定义一个整型常量，用于表示在TEXT_FORMAT数组中笔记内容格式模板的索引位置，方便获取对应格式字符串
-        private static final int FORMAT_NOTE_CONTENT = 2;
-
-        // 用于存储当前的上下文环境（Context），通过它可以访问Android系统的各种资源、服务等，方便与系统进行交互操作，在构造函数中初始化
+        private static final int FORMAT_FOLDER_NAME          = 0;
+        private static final int FORMAT_NOTE_DATE            = 1;
+        private static final int FORMAT_NOTE_CONTENT         = 2;
+
         private Context mContext;
-        // 用于存储导出的文本文件的文件名，初始化为空字符串，后续会根据实际情况赋值
         private String mFileName;
-        // 用于存储导出的文本文件所在的目录路径，初始化为空字符串，后续会根据实际情况赋值
         private String mFileDirectory;
 
-        // 构造函数，用于初始化TextExport对象，从资源中获取文本格式模板字符串数组，同时初始化上下文、文件名和文件目录等属性
         public TextExport(Context context) {
             TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
             mContext = context;
@@ -176,61 +132,51 @@ public class BackupUtils {
             mFileDirectory = "";
         }
 
-        // 根据给定的索引ID获取对应的文本格式模板字符串，用于后续格式化输出文本内容，实际就是从TEXT_FORMAT数组中根据索引获取相应元素
         private String getFormat(int id) {
             return TEXT_FORMAT[id];
         }
 
         /**
          * Export the folder identified by folder id to text
-         * 将由文件夹ID标识的文件夹中的笔记数据导出为文本格式，通过查询该文件夹下的笔记及对应的数据，然后按照一定格式输出到指定的输出流（PrintStream）中
          */
         private void exportFolderToText(String folderId, PrintStream ps) {
-            // 使用ContentResolver查询属于该文件夹的所有笔记信息，传入笔记内容的Uri（Notes.CONTENT_NOTE_URI）、要查询的列名列表（NOTE_PROJECTION）以及通过文件夹ID筛选的条件（NoteColumns.PARENT_ID + "=?" 及对应的文件夹ID参数）等参数
+            // Query notes belong to this folder
             Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                     NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] {
-                            folderId
+                        folderId
                     }, null);
 
-            if (notesCursor!= null) {
-                // 判断游标是否有数据，如果游标可以移动到第一条数据（即有查询到的数据），则进入循环遍历游标中的每一行数据
+            if (notesCursor != null) {
                 if (notesCursor.moveToFirst()) {
                     do {
-                        // 使用指定的日期格式模板格式化笔记的最后修改日期，并输出到指定的输出流（PrintStream）中，通过String.format方法结合获取到的格式模板和格式化后的日期数据进行输出
+                        // Print note's last modified date
                         ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
                                 mContext.getString(R.string.format_datetime_mdhm),
                                 notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
-                        // 获取当前笔记的ID，用于后续查询该笔记对应的详细数据信息
+                        // Query data belong to this note
                         String noteId = notesCursor.getString(NOTE_COLUMN_ID);
-                        // 调用exportNoteToText方法将该笔记的详细数据信息导出为文本格式并输出到指定的输出流（PrintStream）中
                         exportNoteToText(noteId, ps);
                     } while (notesCursor.moveToNext());
                 }
-                // 关闭游标，释放相关资源，因为已经获取完需要的数据了
                 notesCursor.close();
             }
         }
 
         /**
          * Export note identified by id to a print stream
-         * 将由笔记ID标识的笔记数据导出为文本格式，并输出到指定的输出流（PrintStream）中，通过查询该笔记对应的详细数据信息，然后按照一定格式进行输出
          */
         private void exportNoteToText(String noteId, PrintStream ps) {
-            // 使用ContentResolver查询属于该笔记的所有数据信息，传入笔记数据内容的Uri（Notes.CONTENT_DATA_URI）、要查询的列名列表（DATA_PROJECTION）以及通过笔记ID筛选的条件（DataColumns.NOTE_ID + "=?" 及对应的笔记ID参数）等参数
             Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
                     DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
-                            noteId
+                        noteId
                     }, null);
 
-            if (dataCursor!= null) {
-                // 判断游标是否有数据，如果游标可以移动到第一条数据（即有查询到的数据），则进入循环遍历游标中的每一行数据
+            if (dataCursor != null) {
                 if (dataCursor.moveToFirst()) {
                     do {
-                        // 从游标中获取笔记数据的MIME类型列的数据（表示数据的格式类型，比如文本、呼叫记录等类型）
                         String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
                         if (DataConstants.CALL_NOTE.equals(mimeType)) {
-                            // 如果类型是呼叫记录笔记类型（DataConstants.CALL_NOTE），则从游标中获取电话号码列的数据，并输出到指定的输出流（PrintStream）中，
-                            // 使用指定的笔记内容格式模板进行格式化输出，前提是电话号码不为空
+                            // Print phone number
                             String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER);
                             long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE);
                             String location = dataCursor.getString(DATA_COLUMN_CONTENT);
@@ -239,20 +185,16 @@ public class BackupUtils {
                                 ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
                                         phoneNumber));
                             }
-                            // 从游标中获取呼叫日期列的数据，并输出到指定的输出流（PrintStream）中，
-                            // 使用指定的笔记内容格式模板进行格式化输出
+                            // Print call date
                             ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
                                     .format(mContext.getString(R.string.format_datetime_mdhm),
                                             callDate)));
-                            // 从游标中获取呼叫附件位置列的数据（如果有），并输出到指定的输出流（PrintStream）中，
-                            // 使用指定的笔记内容格式模板进行格式化输出，前提是该位置信息不为空
+                            // Print call attachment location
                             if (!TextUtils.isEmpty(location)) {
                                 ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
                                         location));
                             }
                         } else if (DataConstants.NOTE.equals(mimeType)) {
-                            // 如果类型是普通笔记类型（DataConstants.NOTE），则从游标中获取笔记内容列的数据，并输出到指定的输出流（PrintStream）中，
-                            // 使用指定的笔记内容格式模板进行格式化输出，前提是笔记内容不为空
                             String content = dataCursor.getString(DATA_COLUMN_CONTENT);
                             if (!TextUtils.isEmpty(content)) {
                                 ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
@@ -261,183 +203,134 @@ public class BackupUtils {
                         }
                     } while (dataCursor.moveToNext());
                 }
-                // 关闭游标，释放相关资源，因为已经获取完需要的数据了
                 dataCursor.close();
             }
-        }
-    }
-}
-                   } while (dataCursor.moveToNext());
-        }
-        // 关闭游标，释放相关资源，因为已经获取完当前笔记对应的数据信息了
-        dataCursor.close();
+            // print a line separator between note
+            try {
+                ps.write(new byte[] {
+                        Character.LINE_SEPARATOR, Character.LETTER_NUMBER
+                });
+            } catch (IOException e) {
+                Log.e(TAG, e.toString());
             }
-                    // print a line separator between note
-                    // 尝试向输出流（PrintStream）中写入换行分隔符（通过写入对应字符的字节形式），用于在不同笔记内容之间进行分隔，使导出的文本更易读
-                    try {
-                    ps.write(new byte[] {
-    Character.LINE_SEPARATOR, Character.LETTER_NUMBER
-});
-        } catch (IOException e) {
-        // 如果在写入换行分隔符时出现IO异常，记录错误日志（将异常信息输出到日志中，方便排查问题）
-        Log.e(TAG, e.toString());
-        }
         }
 
-/**
- * Note will be exported as text which is user readable
- * 将笔记导出为用户可读的文本格式，在这个方法中完成整个导出流程，包括检查外部存储是否可用、获取输出流、查询并导出不同类型笔记等操作，并返回导出操作的状态码
- */
-public int exportToText() {
-    // 调用externalStorageAvailable方法判断外部存储（如SD卡等）是否可用，如果不可用
-    if (!externalStorageAvailable()) {
-        // 记录调试日志，提示媒体（外部存储设备）未挂载情况
-        Log.d(TAG, "Media was not mounted");
-        // 返回表示外部存储未挂载的状态码，表明当前无法进行导出操作，因为没有可用的存储位置
-        return STATE_SD_CARD_UNMOUONTED;
-    }
+        /**
+         * Note will be exported as text which is user readable
+         */
+        public int exportToText() {
+            if (!externalStorageAvailable()) {
+                Log.d(TAG, "Media was not mounted");
+                return STATE_SD_CARD_UNMOUONTED;
+            }
 
-    // 调用getExportToTextPrintStream方法获取用于将笔记数据输出为文本的打印流（PrintStream）对象，如果获取失败（返回null）
-    PrintStream ps = getExportToTextPrintStream();
-    if (ps == null) {
-        // 记录错误日志，提示获取打印流出现错误情况
-        Log.e(TAG, "get print stream error");
-        // 返回表示系统错误的状态码，说明在获取输出流这个环节出现问题，导致导出操作无法正常进行
-        return STATE_SYSTEM_ERROR;
-    }
-    // First export folder and its notes
-    // 使用ContentResolver查询需要导出的文件夹及其中笔记的信息，筛选条件比较复杂，主要是获取特定类型的文件夹（普通文件夹且非回收站文件夹，以及呼叫记录文件夹）及其包含的笔记信息
-    Cursor folderCursor = mContext.getContentResolver().query(
-            Notes.CONTENT_NOTE_URI,
-            NOTE_PROJECTION,
-            "(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND "
-                    + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
-                    + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null);
-
-    if (folderCursor!= null) {
-        // 判断游标是否有数据，如果游标可以移动到第一条数据（即有查询到的数据），则进入循环遍历游标中的每一行数据
-        if (folderCursor.moveToFirst()) {
-            do {
-                // 初始化文件夹名称为空字符串，后续根据不同情况获取并赋值实际的文件夹名称
-                String folderName = "";
-                // 如果当前文件夹的ID等于呼叫记录文件夹的ID（Notes.ID_CALL_RECORD_FOLDER），则从资源中获取对应的字符串资源（呼叫记录文件夹名称）赋值给folderName变量
-                if (folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {
-                    folderName = mContext.getString(R.string.call_record_folder_name);
-                } else {
-                    // 否则，从游标中获取文件夹摘要列的数据作为文件夹名称（一般情况的文件夹名称获取方式）
-                    folderName = folderCursor.getString(NOTE_COLUMN_SNIPPET);
+            PrintStream ps = getExportToTextPrintStream();
+            if (ps == null) {
+                Log.e(TAG, "get print stream error");
+                return STATE_SYSTEM_ERROR;
+            }
+            // First export folder and its notes
+            Cursor folderCursor = mContext.getContentResolver().query(
+                    Notes.CONTENT_NOTE_URI,
+                    NOTE_PROJECTION,
+                    "(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND "
+                            + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
+                            + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null);
+
+            if (folderCursor != null) {
+                if (folderCursor.moveToFirst()) {
+                    do {
+                        // Print folder's name
+                        String folderName = "";
+                        if(folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {
+                            folderName = mContext.getString(R.string.call_record_folder_name);
+                        } else {
+                            folderName = folderCursor.getString(NOTE_COLUMN_SNIPPET);
+                        }
+                        if (!TextUtils.isEmpty(folderName)) {
+                            ps.println(String.format(getFormat(FORMAT_FOLDER_NAME), folderName));
+                        }
+                        String folderId = folderCursor.getString(NOTE_COLUMN_ID);
+                        exportFolderToText(folderId, ps);
+                    } while (folderCursor.moveToNext());
                 }
-                // 判断文件夹名称不为空字符串时，使用指定的文件夹名称格式模板格式化文件夹名称，并输出到打印流（PrintStream）中
-                if (!TextUtils.isEmpty(folderName)) {
-                    ps.println(String.format(getFormat(FORMAT_FOLDER_NAME), folderName));
+                folderCursor.close();
+            }
+
+            // Export notes in root's folder
+            Cursor noteCursor = mContext.getContentResolver().query(
+                    Notes.CONTENT_NOTE_URI,
+                    NOTE_PROJECTION,
+                    NoteColumns.TYPE + "=" + +Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID
+                            + "=0", null, null);
+
+            if (noteCursor != null) {
+                if (noteCursor.moveToFirst()) {
+                    do {
+                        ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
+                                mContext.getString(R.string.format_datetime_mdhm),
+                                noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
+                        // Query data belong to this note
+                        String noteId = noteCursor.getString(NOTE_COLUMN_ID);
+                        exportNoteToText(noteId, ps);
+                    } while (noteCursor.moveToNext());
                 }
-                // 获取当前文件夹的ID，用于后续调用exportFolderToText方法导出该文件夹下的笔记数据
-                String folderId = folderCursor.getString(NOTE_COLUMN_ID);
-                exportFolderToText(folderId, ps);
-            } while (folderCursor.moveToNext());
-        }
-        // 关闭游标，释放相关资源，因为已经获取完需要的文件夹及笔记相关数据了
-        folderCursor.close();
-    }
+                noteCursor.close();
+            }
+            ps.close();
 
-    // Export notes in root's folder
-    // 使用ContentResolver查询根文件夹下的笔记信息，筛选条件是类型为普通笔记（Notes.TYPE_NOTE）且父文件夹ID为0（表示根文件夹下）的笔记
-    Cursor noteCursor = mContext.getContentResolver().query(
-            Notes.CONTENT_NOTE_URI,
-            NOTE_PROJECTION,
-            NoteColumns.TYPE + "=" + +Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID
-                    + "=0", null, null);
-
-    if (noteCursor!= null) {
-        // 判断游标是否有数据，如果游标可以移动到第一条数据（即有查询到的数据），则进入循环遍历游标中的每一行数据
-        if (noteCursor.moveToFirst()) {
-            do {
-                // 使用指定的笔记日期格式模板格式化笔记的最后修改日期，并输出到打印流（PrintStream）中
-                ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
-                        mContext.getString(R.string.format_datetime_mdhm),
-                        noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
-                // 获取当前笔记的ID，用于后续调用exportNoteToText方法导出该笔记的详细数据信息
-                String noteId = noteCursor.getString(NOTE_COLUMN_ID);
-                exportNoteToText(noteId, ps);
-            } while (noteCursor.moveToNext());
+            return STATE_SUCCESS;
         }
-        // 关闭游标，释放相关资源，因为已经获取完需要的根文件夹下笔记相关数据了
-        noteCursor.close();
-    }
-    // 关闭打印流，释放相关资源，完成整个笔记数据导出到文本文件的操作
-    ps.close();
 
-    // 返回表示导出操作成功的状态码，说明整个导出流程顺利完成，笔记数据已成功导出为文本格式
-    return STATE_SUCCESS;
-}
-
-/**
- * Get a print stream pointed to the file {@generateExportedTextFile}
- * 获取一个指向由{@generateExportedTextFile}方法生成的文件的打印流（PrintStream）对象，用于后续向该文件中写入导出的笔记文本数据，如果获取失败则返回null
- */
-private PrintStream getExportToTextPrintStream() {
-    // 调用generateFileMountedOnSDcard方法在外部存储（SD卡等）上生成用于存储导出文本数据的文件对象，如果生成失败（返回null）
-    File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
-            R.string.file_name_txt_format);
-    if (file == null) {
-        // 记录错误日志，提示创建用于导出的文件失败情况
-        Log.e(TAG, "create file to exported failed");
-        return null;
-    }
-    // 将生成的文件的名称赋值给mFileName属性，用于后续可能的获取文件名相关操作
-    mFileName = file.getName();
-    // 将文件所在的目录路径（从资源中获取的固定路径字符串）赋值给mFileDirectory属性，用于后续可能的获取文件目录相关操作
-    mFileDirectory = mContext.getString(R.string.file_path);
-    PrintStream ps = null;
-    try {
-        // 创建一个基于生成的文件对象的文件输出流（FileOutputStream），用于后续向文件中写入数据
-        FileOutputStream fos = new FileOutputStream(file);
-        // 使用文件输出流创建一个打印流（PrintStream）对象，通过这个对象可以方便地将格式化后的文本数据写入到文件中
-        ps = new PrintStream(fos);
-    } catch (FileNotFoundException e) {
-        // 如果在创建文件输出流时出现文件不存在的异常（比如文件路径不可写、文件不存在且无法创建等原因），打印异常堆栈信息，方便排查问题，并返回null表示获取打印流失败
-        e.printStackTrace();
-        return null;
-    } catch (NullPointerException e) {
-        // 如果出现空指针异常（比如传入的文件对象为null等情况），打印异常堆栈信息，方便排查问题，并返回null表示获取打印流失败
-        e.printStackTrace();
-        return null;
-    }
-    return ps;
-}
+        /**
+         * Get a print stream pointed to the file {@generateExportedTextFile}
+         */
+        private PrintStream getExportToTextPrintStream() {
+            File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
+                    R.string.file_name_txt_format);
+            if (file == null) {
+                Log.e(TAG, "create file to exported failed");
+                return null;
+            }
+            mFileName = file.getName();
+            mFileDirectory = mContext.getString(R.string.file_path);
+            PrintStream ps = null;
+            try {
+                FileOutputStream fos = new FileOutputStream(file);
+                ps = new PrintStream(fos);
+            } catch (FileNotFoundException e) {
+                e.printStackTrace();
+                return null;
+            } catch (NullPointerException e) {
+                e.printStackTrace();
+                return null;
+            }
+            return ps;
+        }
     }
 
-/**
- * Generate the text file to store imported data
- * 在外部存储（SD卡等）上生成用于存储导入数据的文本文件，包括创建文件所在的目录（如果不存在）以及文件本身（如果不存在），并返回生成的文件对象，如果生成失败则返回null
- */
-private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
-    StringBuilder sb = new StringBuilder();
-    // 在StringBuilder中添加外部存储的根目录路径（通过Environment.getExternalStorageDirectory获取）
-    sb.append(Environment.getExternalStorageDirectory());
-    // 接着添加从资源中获取的文件路径字符串，拼接出完整的文件目录路径
-    sb.append(context.getString(filePathResId));
-    // 根据拼接好的路径字符串创建一个File对象，表示文件所在的目录对象
-    File filedir = new File(sb.toString());
-    // 在StringBuilder中继续添加文件名相关内容，文件名通过资源中获取的格式化字符串结合当前系统时间进行格式化生成（使用DateFormat.format按照指定格式生成包含日期的文件名部分）
-    sb.append(context.getString(
-            fileNameFormatResId,
-            DateFormat.format(context.getString(R.string.format_date_ymd),
-                    System.currentTimeMillis())));
-    // 根据最终拼接好的完整路径字符串创建一个File对象，表示要生成的文件对象
-    File file = new File(sb.toString());
-
-    try {
-        // 判断文件所在的目录是否不存在，如果不存在则创建该目录
-        if (!filedir.exists()) {
-            filedir.mkdir();
-        }
-        // 判断文件是否不存在，如果不存在则创建新的文件
-        if (!file.exists()) {
-            file.createNewFile();
-        }
-        // 返回生成的文件对象，用于后续操作（如获取输出流向文件中写入数据等）
-        return file;
+    /**
+     * Generate the text file to store imported data
+     */
+    private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(Environment.getExternalStorageDirectory());
+        sb.append(context.getString(filePathResId));
+        File filedir = new File(sb.toString());
+        sb.append(context.getString(
+                fileNameFormatResId,
+                DateFormat.format(context.getString(R.string.format_date_ymd),
+                        System.currentTimeMillis())));
+        File file = new File(sb.toString());
+
+        try {
+            if (!filedir.exists()) {
+                filedir.mkdir();
+            }
+            if (!file.exists()) {
+                file.createNewFile();
+            }
+            return file;
         } catch (SecurityException e) {
             e.printStackTrace();
         } catch (IOException e) {

build.gradle

@@ -2,14 +2,19 @@
 buildscript {
     repositories {
         jcenter()
+        google()
+        mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:2.3.2'
+        //classpath 'com.android.tools.build:gradle:2.3.2'
+        classpath 'com.android.tools.build:gradle:7.4.2'
     }
 }
 
 allprojects {
     repositories {
         jcenter()
+        google()
+        mavenCentral()
     }
 }

gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-3.3-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11-rc-1-bin.zip