diff --git a/doc/readme.md b/doc/readme.md
deleted file mode 100644
index e69de29..0000000
diff --git a/doc/李豪杰显示结果.jpg b/doc/李豪杰显示结果.jpg
new file mode 100644
index 0000000..c146057
Binary files /dev/null and b/doc/李豪杰显示结果.jpg differ
diff --git a/doc/李豪杰的泛读报告.docx b/doc/李豪杰的泛读报告.docx
new file mode 100644
index 0000000..dc2ba68
Binary files /dev/null and b/doc/李豪杰的泛读报告.docx differ
diff --git a/src/Notesmaster/app/src/main/java/net/micode/notes/data/Contact.java b/src/Notesmaster/app/src/main/java/net/micode/notes/data/Contact.java
index d97ac5d..e219f67 100644
--- a/src/Notesmaster/app/src/main/java/net/micode/notes/data/Contact.java
+++ b/src/Notesmaster/app/src/main/java/net/micode/notes/data/Contact.java
@@ -26,9 +26,12 @@ import android.util.Log;
 import java.util.HashMap;
 
 public class Contact {
+    // ����һ����̬��HashMap�����ڻ�����ϵ����Ϣ
     private static HashMap<String, String> sContactCache;
+    // ����һ����̬���ַ��������ڱ����־��Ϣ
     private static final String TAG = "Contact";
 
+    // ����һ����̬���ַ��������ڲ�ѯ��ϵ����Ϣ��SQL���
     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 "
@@ -36,38 +39,65 @@ public class Contact {
             + " FROM phone_lookup"
             + " WHERE min_match = '+')";
 
+    // ���ݵ绰�����ȡ��ϵ����Ϣ
     public static String getContact(Context context, String phoneNumber) {
+        // �������Ϊ�գ��򴴽�һ���µ�HashMap
+public class Contact {
+ 
+// ���ݵ绰�����ȡ��ϵ������
+    public String getContactName(String phoneNumber) {
+        // �����ϵ�˻���Ϊ�գ��򴴽�һ���µ�HashMap
         if(sContactCache == null) {
             sContactCache = new HashMap<String, String>();
         }
-
+ 
+        // ����������Ѿ����ڸõ绰�������ϵ����Ϣ����ֱ�ӷ���
         if(sContactCache.containsKey(phoneNumber)) {
             return sContactCache.get(phoneNumber);
         }
-
+ 
+        
+// ��phoneNumberת��ΪCallerIDMinMatch��ʽ���������滻��CALLER_ID_SELECTION�ַ�����
         String selection = CALLER_ID_SELECTION.replace("+",
                 PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
+        // ִ�в�ѯ����
+// ���ݵ绰�����ѯ��ϵ��
+// ��ȡContentResolver����
         Cursor cursor = context.getContentResolver().query(
+                // ��ѯ��URI
                 Data.CONTENT_URI,
+                // ��ѯ����
                 new String [] { Phone.DISPLAY_NAME },
+                // ��ѯ������
                 selection,
+                // ��ѯ�IJ���
                 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());
+                // ����null
                 return null;
             } finally {
+                // �ر��α�
                 cursor.close();
             }
         } else {
+            // ���û��ƥ�����ϵ�ˣ���ӡ��־
             Log.d(TAG, "No contact matched with number:" + phoneNumber);
+            // ����null
             return null;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Notesmaster/app/src/main/java/net/micode/notes/data/Notes.java b/src/Notesmaster/app/src/main/java/net/micode/notes/data/Notes.java
index f240604..f28f07a 100644
--- a/src/Notesmaster/app/src/main/java/net/micode/notes/data/Notes.java
+++ b/src/Notesmaster/app/src/main/java/net/micode/notes/data/Notes.java
@@ -18,262 +18,242 @@ package net.micode.notes.data;
 
 import android.net.Uri;
 public class Notes {
+    // ����Notes��ij���
+ // ����һ����������ʾNotes��Ȩ��
     public static final String AUTHORITY = "micode_notes";
+ // ����һ����������ʾNotes�ı�ǩ
     public static final String TAG = "Notes";
+ // ����һ����������ʾNotes������ΪNote
     public static final int TYPE_NOTE     = 0;
+ // ����һ����������ʾNotes������ΪFolder
     public static final int TYPE_FOLDER   = 1;
+ // ����һ����������ʾNotes������ΪSystem
     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
-     */
+    
+    // ������ļ��е�ID
     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;
 
+    // ����Intent�Ķ������
+// ����һ����������ʾ�������ڵ���ͼ
     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";
+// ����һ����������ʾС�������͵���ͼ
     public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
+// ����һ����������ʾ�ļ��е���ͼ
     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";
 
-    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 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 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; // �ı��ʼǵ�content type
+        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE; // ���бʼǵ�content type
     }
 
-    /**
-     * Uri to query all notes and folders
-     */
-    public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
+    
+// ����һ����������ʾnote��Uri
+    public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note"); 
 
-    /**
-     * Uri to query data
-     */
-    public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
+   
+ // ����һ����������ʾ�������ݵ�URI
+    public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data"); 
 
+ // ����һ���ӿڣ����ڶ���Note����
     public interface NoteColumns {
-        /**
-         * The unique ID for a row
-         * <P> Type: INTEGER (long) </P>
-         */
+       
+ // ����һ����������ʾID
         public static final String ID = "_id";
 
-        /**
-         * The parent's id for note or folder
-         * <P> Type: INTEGER (long) </P>
-         */
+        
+       
+ // ����һ����������ʾ���ڵ��ID
         public static final String PARENT_ID = "parent_id";
 
-        /**
-         * 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>
-         */
+        
+        
+// ����һ����������ʾС������ID
         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>
-         */
+        
+        
+ // ����һ����������ʾ������ɫID
         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>
-         */
+        
+        // Note���е��Ƿ��и����ֶ�
+ // ����һ����������ʾ�Ƿ��и���
         public static final String HAS_ATTACHMENT = "has_attachment";
 
-        /**
-         * Folder's count of notes
-         * <P> Type: INTEGER (long) </P>
-         */
+        
+        // Note���еıʼ������ֶ�
+// ����һ�����������ڴ洢�ʼ�����
         public static final String NOTES_COUNT = "notes_count";
 
-        /**
-         * The file type: folder or note
-         * <P> Type: INTEGER </P>
-         */
+        
+        // Note���е������ֶ�
+ // ����һ����������ʾ����
         public static final String TYPE = "type";
 
-        /**
-         * The last sync id
-         * <P> Type: INTEGER (long) </P>
-         */
+        
+        // Note���е�ͬ��ID�ֶ�
+// ����һ������������ͬ����ID
         public static final String SYNC_ID = "sync_id";
 
-        /**
-         * Sign to indicate local modified or not
-         * <P> Type: INTEGER </P>
-         */
+        
+        // Note���еı����޸��ֶ�
+// ����һ����������ʾ�����޸�
         public static final String LOCAL_MODIFIED = "local_modified";
 
-        /**
-         * Original parent id before moving into temporary folder
-         * <P> Type : INTEGER </P>
-         */
+        
+        // Note���е�ԭʼ��ID�ֶ�
+// ����һ����������ʾԭʼ����ID
         public static final String ORIGIN_PARENT_ID = "origin_parent_id";
 
-        /**
-         * The gtask id
-         * <P> Type : TEXT </P>
-         */
+        
+        // Note���е�GTask ID�ֶ�
+// ����һ�����������ڴ洢����ID
         public static final String GTASK_ID = "gtask_id";
 
-        /**
-         * The version code
-         * <P> Type : INTEGER (long) </P>
-         */
+        
+        // Note���еİ汾�ֶ�
+ // ����һ����������ʾ�汾��
         public static final String VERSION = "version";
     }
 
     public interface DataColumns {
-        /**
-         * The unique ID for a row
-         * <P> Type: INTEGER (long) </P>
-         */
+       
+        // Data���е�ID�ֶ�
+ // ����һ����������ʾID
         public static final String ID = "_id";
 
-        /**
-         * The MIME type of the item represented by this row.
-         * <P> Type: Text </P>
-         */
+        
+        // Data���е�MIME�����ֶ�
+// ����һ����������ʾMIME����
         public static final String MIME_TYPE = "mime_type";
 
-        /**
-         * The reference id to note that this data belongs to
-         * <P> Type: INTEGER (long) </P>
-         */
+        
+        // Data���е�Note ID�ֶ�
+// ����һ�����������ڱ�ʾ�ʼǵ�ID
         public static final String NOTE_ID = "note_id";
 
-        /**
-         * Created data for note or folder
-         * <P> Type: INTEGER (long) </P>
-         */
+        
+        // Data���еĴ��������ֶ�
+// ����һ����������ʾ��������
         public static final String CREATED_DATE = "created_date";
 
-        /**
-         * Latest modified date
-         * <P> Type: INTEGER (long) </P>
-         */
+        
+        // Data���е��޸������ֶ�
+// ����һ����������ʾ�޸�����
         public static final String MODIFIED_DATE = "modified_date";
 
-        /**
-         * Data's content
-         * <P> Type: TEXT </P>
-         */
+       
+        // Data���е������ֶ�
+// ����һ������CONTENT��ֵΪ"content"
         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";
+        
+// ����һ������DATA1��ֵΪ"data1"
+        public static final String DATA1 = "data1"; 
+
+        
+        public static final String DATA2 = "data2"; // ����һ������DATA2��ֵΪ"data2"
+
+        
+        public static final String DATA3 = "data3"; // ����һ������DATA3��ֵΪ"data3"
+
+        
+        public static final String DATA4 = "data4"; // ����һ������DATA4��ֵΪ"data4"
+
+        
+        public static final String DATA5 = "data5"; // ����һ������DATA5��ֵΪ"data5"
     }
 
+// ����һ����ΪTextNote�Ĺ�����̬�����࣬ʵ��DataColumns�ӿ�
     public static final class TextNote implements DataColumns {
-        /**
-         * Mode to indicate the text in check list mode or not
-         * <P> Type: Integer 1:check list mode 0: normal mode </P>
-         */
+       
+        // �ı��ʼ�ģʽ
+// ����һ������MODE����ֵΪDATA1
         public static final String MODE = DATA1;
 
+        // ����б�ģʽ
+// ����һ����������ʾ����б���ģʽ
         public static final int MODE_CHECK_LIST = 1;
 
+        // �ı��ʼ���������
+// ����һ����������ʾ��������Ϊ"text_note"
         public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
 
+        // �ı��ʼ�����������
+ // ����һ����������ʾ�ı��ʼǵ�ContentItemType
         public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
 
+        // �ı��ʼ�����URI
+ // ����һ������Uri�����ڷ���text_note��
         public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
     }
 
+// ����һ����ΪCallNote�Ĺ�����̬�����࣬ʵ��DataColumns�ӿ�
     public static final class CallNote implements DataColumns {
-        /**
-         * Call date for this record
-         * <P> Type: INTEGER (long) </P>
-         */
+       
+        // ͨ������
+ // ����һ������CALL_DATE����ֵΪDATA1
         public static final String CALL_DATE = DATA1;
 
-        /**
-         * Phone number for this record
-         * <P> Type: TEXT </P>
-         */
+       
+        // �绰����
+// ����һ������PHONE_NUMBER����ֵΪDATA3
         public static final String PHONE_NUMBER = DATA3;
 
+        // ͨ���ʼ���������
+ // ����һ����������ʾ��������Ϊcall_note
         public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
 
+        // ͨ���ʼ�����������
+// ����һ����������ʾ����������Ϊcall_note
         public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
 
+        // ͨ���ʼ�����URI
+// ����һ������Uri�����ڷ���CallNoteProvider�е�����
         public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
     }
 }
diff --git a/src/Notesmaster/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java b/src/Notesmaster/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java
index ffe5d57..b5fb389 100644
--- a/src/Notesmaster/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java
+++ b/src/Notesmaster/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java
@@ -28,75 +28,117 @@ import net.micode.notes.data.Notes.NoteColumns;
 
 
 public class NotesDatabaseHelper extends SQLiteOpenHelper {
+    
+// �������ݿ������
     private static final String DB_NAME = "note.db";
 
+// �������ݿ�汾��
     private static final int DB_VERSION = 4;
 
     public interface TABLE {
+// ����һ������NOTE��ֵΪ"note"
         public static final String NOTE = "note";
 
+// ����һ������DATA��ֵΪ"data"
         public static final String DATA = "data";
     }
 
+// ����һ�����������ڱ�ʶNotesDatabaseHelper��
     private static final String TAG = "NotesDatabaseHelper";
 
+// ����һ����̬��NotesDatabaseHelper���͵ı���mInstance
     private static NotesDatabaseHelper mInstance;
 
+ // ���崴���ʼDZ���SQL���
     private static final String CREATE_NOTE_TABLE_SQL =
         "CREATE TABLE " + TABLE.NOTE + "(" +
+            // ����һ����ΪNote�ı�
             NoteColumns.ID + " INTEGER PRIMARY KEY," +
+            // ����һ����ΪID���У�����ΪINTEGER��Ϊ����
             NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+            // ����һ����ΪPARENT_ID���У�����ΪINTEGER��Ĭ��ֵΪ0
             NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +
+            // ����һ����ΪALERTED_DATE���У�����ΪINTEGER��Ĭ��ֵΪ0
             NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," +
+            // ����һ����ΪBG_COLOR_ID���У�����ΪINTEGER��Ĭ��ֵΪ0
             NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            // ����һ����ΪCREATED_DATE���У�����ΪINTEGER��Ĭ��ֵΪ��ǰʱ���
             NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," +
+            // ����һ����ΪHAS_ATTACHMENT���У�����ΪINTEGER��Ĭ��ֵΪ0
             NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            // ����һ����ΪMODIFIED_DATE���У�����ΪINTEGER��Ĭ��ֵΪ��ǰʱ���
             NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +
+            // ����һ����ΪNOTES_COUNT���У�����ΪINTEGER��Ĭ��ֵΪ0
             NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +
+            // ����һ����ΪSNIPPET���У�����ΪTEXT��Ĭ��ֵΪ���ַ���
             NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +
+            // ����һ����ΪTYPE���У�����ΪINTEGER��Ĭ��ֵΪ0
             NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +
+            // ����һ����ΪWIDGET_ID���У�����ΪINTEGER��Ĭ��ֵΪ0
             NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +
+            // ����һ����ΪWIDGET_TYPE���У�����ΪINTEGER��Ĭ��ֵΪ-1
             NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," +
+            // ����һ����ΪSYNC_ID���У�����ΪINTEGER��Ĭ��ֵΪ0
             NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +
+            // ����һ����ΪLOCAL_MODIFIED���У�����ΪINTEGER��Ĭ��ֵΪ0
             NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+            // ����һ����ΪORIGIN_PARENT_ID���У�����ΪINTEGER��Ĭ��ֵΪ0
             NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
+            // ����һ����ΪGTASK_ID���У�����ΪTEXT��Ĭ��ֵΪ���ַ���
             NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
+        // ����һ����ΪVERSION���У�����ΪINTEGER��Ĭ��ֵΪ0
         ")";
 
+// ����һ�����������ڴ������ݱ���SQL���
     private static final String CREATE_DATA_TABLE_SQL =
+// ����һ����ΪTABLE.DATA�ı������������У�
         "CREATE TABLE " + TABLE.DATA + "(" +
+            // ID�У�����ΪINTEGER��Ϊ����
             DataColumns.ID + " INTEGER PRIMARY KEY," +
+            // MIME_TYPE�У�����ΪTEXT������Ϊ��
             DataColumns.MIME_TYPE + " TEXT NOT NULL," +
+            // NOTE_ID�У�����ΪINTEGER������Ϊ�գ�Ĭ��ֵΪ0
             DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," +
+            // CREATED_DATE�У�����ΪINTEGER������Ϊ�գ�Ĭ��ֵΪ��ǰʱ���
             NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            // MODIFIED_DATE�У�����ΪINTEGER������Ϊ�գ�Ĭ��ֵΪ��ǰʱ���
             NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            // CONTENT�У�����ΪTEXT������Ϊ�գ�Ĭ��ֵΪ���ַ���
             DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," +
+            // DATA1�У�����ΪINTEGER
             DataColumns.DATA1 + " INTEGER," +
+            // DATA2�У�����ΪINTEGER
             DataColumns.DATA2 + " INTEGER," +
+            // DATA3�У�����ΪTEXT������Ϊ�գ�Ĭ��ֵΪ���ַ���
             DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +
+            // DATA4�У�����ΪTEXT������Ϊ�գ�Ĭ��ֵΪ���ַ���
             DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
+            // DATA5�У�����ΪTEXT������Ϊ�գ�Ĭ��ֵΪ���ַ���
             DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
+        // ����������
         ")";
 
+// ����һ�����������ڴ���������SQL���
     private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
+// ����һ����Ϊnote_id_index�����������������
         "CREATE INDEX IF NOT EXISTS note_id_index ON " +
+// ��ѯ��TABLE��NOTE_ID�е�����
         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
-     */
+        "CREATE TRIGGER increase_folder_count_on_update "+ // ����һ�����������ڸ���Note����PARENT_ID�ֶκ����Ӷ�Ӧ�ļ��е�NOTES_COUNT�ֶ�
+        " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + // ��Note����PARENT_ID�ֶθ��º󴥷�
+        " BEGIN " + // ��ʼ
+        "  UPDATE " + TABLE.NOTE + // ����Note��
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + // ��NOTES_COUNT�ֶμ�1
+        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + // ��ID�ֶε�����ֵ�������
+        " END"; // ����
+
+    
+// ����һ�����������ڱ�ʾ�ڸ��´������м����ļ��������IJ���
+// ����һ����Ϊdecrease_folder_count_on_update�Ĵ��������ڸ���Note����parent_id�ֶκ�ִ��
     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 +
@@ -107,255 +149,327 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         "  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
-     */
+        "CREATE TRIGGER increase_folder_count_on_insert " + // ����һ��������������Ϊincrease_folder_count_on_insert
+        " AFTER INSERT ON " + TABLE.NOTE + // ��NOTE���ϲ������ݺ󴥷�
+        " BEGIN " + // ��ʼ
+        "  UPDATE " + TABLE.NOTE + // ����NOTE��
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + // ��NOTES_COUNT�ֶμ�1
+        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + // ����ΪID�����²������ݵ�PARENT_ID
+        " END"; // ����
+
+    
+ // ����һ��������������ɾ���ļ���ʱ�����ļ��������Ĵ�����
     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}
-     */
+        "CREATE TRIGGER decrease_folder_count_on_delete " + // ����һ������������ɾ���ʼǺ�����ļ����еıʼ�����
+        " AFTER DELETE ON " + TABLE.NOTE + // ��ɾ���ʼǺ󴥷�
+        " BEGIN " + // ��ʼ
+        "  UPDATE " + TABLE.NOTE + // ���±ʼDZ�
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + // ���ʼ�������1
+        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + // �ڸ��ļ���ID���ڱ�ɾ���ʼǵĸ��ļ���ID��������
+        "  AND " + NoteColumns.NOTES_COUNT + ">0;" + // �ʼ���������0
+        " END"; // ����
+
+    
+ // ����һ�����������ڴ洢�ڲ�������ʱ���±�ע���ݵĴ�����
     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
-     */
+        "CREATE TRIGGER update_note_content_on_insert " + // ����һ��������������Ϊupdate_note_content_on_insert
+        " AFTER INSERT ON " + TABLE.DATA + // �ڲ������ݱ��󴥷�
+        " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + // ���²�������ݵ�MIME_TYPEΪNOTEʱ
+        " BEGIN" + // ��ʼ
+        "  UPDATE " + TABLE.NOTE + // ����NOTE��
+        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + // ���²�������ݵ�CONTENT��ֵ��NOTE����SNIPPET
+        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + // ����NOTE����ID���²�������ݵ�NOTE_ID����ƥ��
+        " END"; // ����
+
+    
+// ����һ�����������ڸ��´�����ʱ��������ע�͵�����
     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 + "'" +
+        " AFTER UPDATE ON " + TABLE.DATA + // ����һ�����������ڸ���DATA����ִ��
+        " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + // �������ݵ�MIME_TYPEΪNOTEʱ
         " BEGIN" +
-        "  UPDATE " + TABLE.NOTE +
-        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
-        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
+        "  UPDATE " + TABLE.NOTE + // ����NOTE��
+        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + // �������ݵ�CONTENT��ֵ��NOTE����SNIPPET
+        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + // ��NOTE���У�ID���������ݵ�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
-     */
+        "CREATE TRIGGER update_note_content_on_delete " + // ����һ��������������Ϊupdate_note_content_on_delete
+        " AFTER delete ON " + TABLE.DATA + // ��ɾ�����ݱ��󴥷�
+        " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + // ��ɾ�������ݵ�MIME_TYPEΪNOTEʱ
+        " BEGIN" + // ��ʼ
+        "  UPDATE " + TABLE.NOTE + // ����NOTE��
+        "   SET " + NoteColumns.SNIPPET + "=''" + // ��SNIPPET�ֶ�����Ϊ���ַ���
+        "  WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" + // ��NOTE���У�ID����ɾ�������ݵ�NOTE_ID
+        " END"; // ����
+
+    
+// ����һ������������ɾ��������ʱɾ������
     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
-     */
+        "CREATE TRIGGER delete_data_on_delete " + // ����һ��������������Ϊdelete_data_on_delete
+        " AFTER DELETE ON " + TABLE.NOTE + // ��ɾ��NOTE���е����ݺ󴥷�
+        " BEGIN" + // ��ʼ
+        "  DELETE FROM " + TABLE.DATA + // ��DATA����ɾ������
+        "   WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" + // ����ΪNOTE_ID���ڱ�ɾ����NOTE��ID
+        " END"; // ����
+
+    
+ // ����һ������������ɾ���ļ���ʱ����ɾ���ʼǵĴ�����
     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
-     */
+        "CREATE TRIGGER folder_delete_notes_on_delete " + // ����һ��������������Ϊfolder_delete_notes_on_delete
+        " AFTER DELETE ON " + TABLE.NOTE + // ��ɾ��NOTE���е����ݺ󴥷�
+        " BEGIN" + // ��ʼ
+        "  DELETE FROM " + TABLE.NOTE + // ��NOTE����ɾ������
+        "   WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" + // ɾ������ΪPARENT_ID���ڱ�ɾ�����ݵ�ID
+        " END"; // ����
+
+    
+// ����һ�����������ڱ�ʾ�ڻ���վ���ƶ��ļ����ļ���ʱ��������ʾ��Ϣ
     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";
-
+        "CREATE TRIGGER folder_move_notes_on_trash " + // ����һ����Ϊfolder_move_notes_on_trash�Ĵ�����
+        " AFTER UPDATE ON " + TABLE.NOTE + // ��NOTE����ִ�и��²����󴥷�
+        " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + // ���¼�¼�ĸ�ID��������Ͱ�ļ���IDʱ����
+        " BEGIN" + // ��ʼִ�д�����
+        "  UPDATE " + TABLE.NOTE + // ����NOTE��
+        "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + // ����ID����Ϊ����Ͱ�ļ���ID
+        "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" + // �ڸ�ID���ھɼ�¼ID��������
+        " END"; // ����������
+
+// ���캯�������ڳ�ʼ��NotesDatabaseHelper����
     public NotesDatabaseHelper(Context context) {
+        // ���ø���Ĺ��캯�������������ġ����ݿ����ơ��α깤�������ݿ�汾��
         super(context, DB_NAME, null, DB_VERSION);
     }
 
     public void createNoteTable(SQLiteDatabase db) {
+        // ִ�д���note����SQL���
         db.execSQL(CREATE_NOTE_TABLE_SQL);
+        // ���´���note���Ĵ�����
         reCreateNoteTableTriggers(db);
+        // ����ϵͳ�ļ���
         createSystemFolder(db);
+        // ��ӡ��־��note���Ѵ���
         Log.d(TAG, "note table has been created");
     }
 
+// ���´����ʼDZ�������
     private void reCreateNoteTableTriggers(SQLiteDatabase db) {
+ // ɾ�����д�����
+// ɾ����Ϊincrease_folder_count_on_update�Ĵ�����
         db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
+// ɾ����Ϊdecrease_folder_count_on_update�Ĵ�����
         db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
+// ɾ����Ϊdecrease_folder_count_on_delete�Ĵ�����
         db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
+// ɾ����Ϊdelete_data_on_delete�Ĵ�����
         db.execSQL("DROP TRIGGER IF EXISTS delete_data_on_delete");
+// ɾ����Ϊincrease_folder_count_on_insert�Ĵ�����
         db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_insert");
+// ɾ����Ϊfolder_delete_notes_on_delete�Ĵ�����
         db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
+// ɾ����Ϊfolder_move_notes_on_trash�Ĵ�����
         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�������ڴ洢����
         ContentValues values = new ContentValues();
 
-        /**
-         * call record foler for call notes
-         */
+        
+// ��NoteColumns.ID��ֵ����ΪNotes.ID_CALL_RECORD_FOLDER
         values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
+// ��NoteColumns.TYPE��ֵ����ΪNotes.TYPE_SYSTEM
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// ��values���뵽TABLE.NOTE����
         db.insert(TABLE.NOTE, null, values);
 
-        /**
-         * root folder which is default folder
-         */
+        
+// ���values
         values.clear();
+// ��Notes.ID_ROOT_FOLDER����values��
         values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
+// ��Notes.TYPE_SYSTEM����values��
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// ��values���뵽TABLE.NOTE����
         db.insert(TABLE.NOTE, null, values);
 
-        /**
-         * temporary folder which is used for moving note
-         */
+        
+ // ���values
         values.clear();
+ // ��NoteColumns.ID��ֵ��ΪNotes.ID_TEMPARAY_FOLDER
         values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
+ // ��NoteColumns.TYPE��ֵ��ΪNotes.TYPE_SYSTEM
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+ // ��values���뵽TABLE.NOTE����
         db.insert(TABLE.NOTE, null, values);
 
-        /**
-         * create trash folder
-         */
+        
+// ���values
         values.clear();
+// ��NoteColumns.ID��ֵ��ΪNotes.ID_TRASH_FOLER
         values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+// ��NoteColumns.TYPE��ֵ��ΪNotes.TYPE_SYSTEM
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// ��values���뵽TABLE.NOTE����
         db.insert(TABLE.NOTE, null, values);
     }
 
     public void createDataTable(SQLiteDatabase db) {
+        // ִ�д������ݱ���SQL���
         db.execSQL(CREATE_DATA_TABLE_SQL);
+        // ���´������ݱ�������
         reCreateDataTableTriggers(db);
+        // ִ�д������ݱ�������SQL���
         db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
+        // ��ӡ��־����ʾ���ݱ��Ѿ�����
         Log.d(TAG, "data table has been created");
     }
 
+// ���´������ݱ�������
     private void reCreateDataTableTriggers(SQLiteDatabase db) {
+// ɾ����Ϊupdate_note_content_on_insert�Ĵ�����
         db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");
+// ɾ����Ϊupdate_note_content_on_update�Ĵ�����
         db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
+// ɾ����Ϊupdate_note_content_on_delete�Ĵ�����
         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);
     }
 
+ // ��ȡNotesDatabaseHelperʵ��
     static synchronized NotesDatabaseHelper getInstance(Context context) {
+ // ���mInstanceΪ�գ��򴴽�һ���µ�NotesDatabaseHelper����
         if (mInstance == null) {
             mInstance = new NotesDatabaseHelper(context);
         }
+ // ����mInstance����
         return mInstance;
     }
 
     @Override
+    // ��дonCreate���������ڴ������ݿ�
     public void onCreate(SQLiteDatabase db) {
+        // ����createNoteTable����������Note��
         createNoteTable(db);
+        // ����createDataTable����������Data��
         createDataTable(db);
     }
 
+ // ��дonUpgrade�����������ݿ�汾����ʱ����
     @Override
     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        // �Ƿ����´���������
         boolean reCreateTriggers = false;
+        // �Ƿ�����V2�汾
         boolean skipV2 = false;
 
+// ����ɰ汾��Ϊ1
         if (oldVersion == 1) {
+            // �������汾2
             upgradeToV2(db);
-            skipV2 = true; // this upgrade including the upgrade from v2 to v3
+            // �����汾2
+            skipV2 = true; 
+            // �ɰ汾�ż�1
             oldVersion++;
         }
 
+ // ����ɰ汾Ϊ2�Ҳ�����V2�汾����������V3�汾�������´�����������ͬʱ�ɰ汾��1
         if (oldVersion == 2 && !skipV2) {
             upgradeToV3(db);
             reCreateTriggers = true;
             oldVersion++;
         }
 
+// ����ɰ汾��Ϊ3
         if (oldVersion == 3) {
+            // �������汾4
             upgradeToV4(db);
+            // �汾�ż�1
             oldVersion++;
         }
 
+// �����Ҫ���´�������������ִ�����´���
         if (reCreateTriggers) {
+            // ���´���NoteTable������
             reCreateNoteTableTriggers(db);
+            // ���´���DataTable������
             reCreateDataTableTriggers(db);
         }
 
+ // ����ɰ汾�������°汾�����׳��쳣
         if (oldVersion != newVersion) {
             throw new IllegalStateException("Upgrade notes database to version " + newVersion
                     + "fails");
         }
     }
 
+ // �����ݿ�������V2�汾
     private void upgradeToV2(SQLiteDatabase db) {
+ // ɾ����ΪNOTE�ı�
         db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
+ // ɾ����ΪDATA�ı�
         db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
+ // ������ΪNOTE�ı�
         createNoteTable(db);
+ // ������ΪDATA�ı�
         createDataTable(db);
     }
 
+  // �������ݿ⵽V3�汾
     private void upgradeToV3(SQLiteDatabase db) {
-        // drop unused triggers
+        
+// ɾ����Ϊupdate_note_modified_date_on_insert�Ĵ�����
         db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
+// ɾ����Ϊupdate_note_modified_date_on_delete�Ĵ�����
         db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete");
+// ɾ����Ϊupdate_note_modified_date_on_update�Ĵ�����
         db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");
-        // add a column for gtask id
+        
+// ��NOTE����������ΪGTASK_ID��TEXT�����У�Ĭ��ֵΪ���ַ���
         db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
                 + " TEXT NOT NULL DEFAULT ''");
-        // add a trash system folder
+       
+        // ����һ��ContentValues�������ڴ洢Ҫ���������
         ContentValues values = new ContentValues();
+        // ��ID_TRASH_FOLER��ֵ����ID�ֶ�
         values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+        // ��TYPE_SYSTEM��ֵ����TYPE�ֶ�
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+        // �����ݲ��뵽NOTE����
         db.insert(TABLE.NOTE, null, values);
     }
 
+ // �����ݿ�������V4�汾
     private void upgradeToV4(SQLiteDatabase db) {
+        // ִ��SQL��䣬��NOTE��������VERSION�У�����ΪINTEGER��Ĭ��ֵΪ0
         db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
                 + " INTEGER NOT NULL DEFAULT 0");
     }
diff --git a/src/Notesmaster/app/src/main/java/net/micode/notes/data/NotesProvider.java b/src/Notesmaster/app/src/main/java/net/micode/notes/data/NotesProvider.java
index edb0a60..67bd6d6 100644
--- a/src/Notesmaster/app/src/main/java/net/micode/notes/data/NotesProvider.java
+++ b/src/Notesmaster/app/src/main/java/net/micode/notes/data/NotesProvider.java
@@ -35,78 +35,118 @@ import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.NotesDatabaseHelper.TABLE;
 
 
+// ����һ��NotesProvider�࣬�̳���ContentProvider��
 public class NotesProvider extends ContentProvider {
+ // ����һ��UriMatcher����
     private static final UriMatcher mMatcher;
 
+ // ����һ��NotesDatabaseHelper����
     private NotesDatabaseHelper mHelper;
 
+ // ����һ�����������ڱ�ʶNotesProvider
     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;
+ // ����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
 
+// ����URI_SEARCH������ֵΪ5
     private static final int URI_SEARCH          = 5;
+// ����URI_SEARCH_SUGGEST������ֵΪ6
     private static final int URI_SEARCH_SUGGEST  = 6;
 
     static {
+// ����һ��UriMatcher��������ƥ��Uri
         mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+// ����ƥ�����ƥ��"note"·��������URI_NOTE
         mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
+// ����ƥ�����ƥ��"note/#"·��������URI_NOTE_ITEM
         mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
+// ����ƥ�����ƥ��"data"·��������URI_DATA
         mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
+// ����ƥ�����ƥ��"data/#"·��������URI_DATA_ITEM
         mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
+// ����ƥ�����ƥ��"search"·��������URI_SEARCH
         mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
+// ����ƥ�����ƥ��"search/*"·��������URI_SEARCH_SUGGEST
         mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
+// ����ƥ�����ƥ��"search/*"·��������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 + ","
+        // ��NoteColumns.SNIPPET�еĻ��з��滻Ϊ���ַ�������ȥ����β�ո���ΪSearchManager.SUGGEST_COLUMN_TEXT_1��ֵ
         + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + ","
+        // ��NoteColumns.SNIPPET�еĻ��з��滻Ϊ���ַ�������ȥ����β�ո���ΪSearchManager.SUGGEST_COLUMN_TEXT_2��ֵ
         + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + ","
+        // ��R.drawable.search_result��ΪSearchManager.SUGGEST_COLUMN_ICON_1��ֵ
         + R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","
+        // ��Intent.ACTION_VIEW��ΪSearchManager.SUGGEST_COLUMN_INTENT_ACTION��ֵ
         + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
+        // ��Notes.TextNote.CONTENT_TYPE��ΪSearchManager.SUGGEST_COLUMN_INTENT_DATA��ֵ
         + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
 
+ // ����һ����̬�ַ������������ڴ洢��ѯ���
     private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
-        + " FROM " + TABLE.NOTE
-        + " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
-        + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
-        + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
+// ƴ��SQL��䣬��ѯnote����snippet�ֶΰ���ָ���ַ�������parent_id������ID_TRASH_FOLER����type����TYPE_NOTE�ļ�¼
+        + " FROM " + TABLE.NOTE // ���Ӳ�ѯ����
+        + " WHERE " + NoteColumns.SNIPPET + " LIKE ?" // ���Ӳ�ѯ������ƥ��Ƭ��
+        + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER // ���Ӳ�ѯ�������ų�����վ
+        + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE; // ���Ӳ�ѯ������ƥ��ʼ�����
 
     @Override
+    // ��дonCreate����
     public boolean onCreate() {
+        // ��ȡNotesDatabaseHelperʵ��
+ // ��ȡNotesDatabaseHelper��ʵ��
         mHelper = NotesDatabaseHelper.getInstance(getContext());
+ // ����true
         return true;
     }
 
     @Override
+    // ��дquery���������ڲ�ѯ����
+// ���ݸ�����Uri��ͶӰ��ѡ������������˳���ѯ����
     public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
             String sortOrder) {
+// ����һ���α����
         Cursor c = null;
+// ��ȡһ��ֻ�������ݿ����
         SQLiteDatabase db = mHelper.getReadableDatabase();
+// ����һ���ַ������͵ı���id������ʼ��Ϊnull
         String id = null;
+// ���ݴ����uri��ƥ���Ӧ��URI_NOTE��Ȼ��ִ����Ӧ�IJ���
         switch (mMatcher.match(uri)) {
+    // ���ƥ�䵽URI_NOTE����ִ�����²���
             case URI_NOTE:
+        // ��ѯ���ݿ⣬��ȡָ�����е�����
+// ��ѯ���ݿ��е�NOTE��������ָ���е�����
                 c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
                         sortOrder);
+// ����selection��selectionArgs����ɸѡ�����ؽ����
                 break;
+// ����URI_NOTE_ITEM��ֵ����ȡ·���еĵڶ���������Ϊid
             case URI_NOTE_ITEM:
                 id = uri.getPathSegments().get(1);
+// ʹ��id��Ϊ��ѯ��������ѯ���ݿ��е�NOTE�������ؽ����
                 c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs, null, null, sortOrder);
                 break;
+// ����URI_DATA
             case URI_DATA:
+ // �����ݿ��в�ѯ���ݣ�����һ��Cursor����
                 c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
                         sortOrder);
                 break;
+// ����URI_DATA_ITEM��ֵ����ȡ·���еĵڶ���������Ϊid
             case URI_DATA_ITEM:
                 id = uri.getPathSegments().get(1);
+// ��ѯ���ݿ⣬��ȡָ��id�����ݣ�projectionΪ��ѯ���У�selectionΪ��ѯ��������selectionArgsΪ��ѯ�����IJ���
                 c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs, null, null, sortOrder);
                 break;
@@ -166,13 +206,13 @@ public class NotesProvider extends ContentProvider {
             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);
@@ -194,10 +234,7 @@ public class NotesProvider extends ContentProvider {
                 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;
@@ -298,7 +335,7 @@ public class NotesProvider extends ContentProvider {
 
     @Override
     public String getType(Uri uri) {
-        // TODO Auto-generated method stub
+       
         return null;
     }
 
diff --git a/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/MetaData.java b/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/MetaData.java
index 3a2050b..9a1e5a4 100644
--- a/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/MetaData.java
+++ b/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/MetaData.java
@@ -16,48 +16,68 @@
 
 package net.micode.notes.gtask.data;
 
+// ����Cursor��Log��
 import android.database.Cursor;
 import android.util.Log;
 
+// ����GTaskStringUtils��
 import net.micode.notes.tool.GTaskStringUtils;
 
+// ����JSONException��JSONObject��
 import org.json.JSONException;
 import org.json.JSONObject;
 
 
 public class MetaData extends Task {
+// ����һ�����������ڱ�ʶMetaData�������
     private final static String TAG = MetaData.class.getSimpleName();
 
+// ����һ����ΪmRelatedGid���ַ�����������ʼֵΪnull
     private String mRelatedGid = null;
 
+ // ����Ԫ����
     public void setMeta(String gid, JSONObject metaInfo) {
         try {
+            // ��gid����metaInfo��
             metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
         } catch (JSONException e) {
+            // �������JSONException�쳣�����ӡ������־
             Log.e(TAG, "failed to put related gid");
         }
+// ���ñʼ�
         setNotes(metaInfo.toString());
+// ��������
         setName(GTaskStringUtils.META_NOTE_NAME);
     }
 
+ // ��ȡ���GID
     public String getRelatedGid() {
         return mRelatedGid;
     }
 
     @Override
+    // ��дisWorthSaving()����
     public boolean isWorthSaving() {
+        // ���getNotes()�������ص�ֵ��Ϊnull���򷵻�true�����򷵻�false
         return getNotes() != null;
     }
 
     @Override
+    // ��дsetContentByRemoteJSON����
     public void setContentByRemoteJSON(JSONObject js) {
+        // ���ø����setContentByRemoteJSON����
         super.setContentByRemoteJSON(js);
+        // ���getNotes()����
         if (getNotes() != null) {
             try {
+                // ��getNotes()��ֵת��ΪJSONObject
                 JSONObject metaInfo = new JSONObject(getNotes().trim());
+                // ��ȡmetaInfo�е�GTaskStringUtils.META_HEAD_GTASK_ID��ֵ
                 mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
             } catch (JSONException e) {
+                // ��ӡ��־
                 Log.w(TAG, "failed to get related gid");
+                // ��mRelatedGid����Ϊnull
                 mRelatedGid = null;
             }
         }
@@ -65,17 +85,22 @@ public class MetaData extends Task {
 
     @Override
     public void setContentByLocalJSON(JSONObject js) {
-        // this function should not be called
+       
+        // ���ݱ���JSON��������
         throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
     }
 
     @Override
+    // ��д���෽������ȡ����JSON����
     public JSONObject getLocalJSONFromContent() {
+        // �׳��Ƿ����ʴ�����ʾMetaData:getLocalJSONFromContent������Ӧ�ñ�����
         throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
     }
 
     @Override
+    // ��дgetSyncAction����
     public int getSyncAction(Cursor c) {
+        // ��ȡCursor����
         throw new IllegalAccessError("MetaData:getSyncAction should not be called");
     }
 
diff --git a/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/Node.java b/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/Node.java
index 63950e0..7aa74b1 100644
--- a/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/Node.java
+++ b/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/Node.java
@@ -21,80 +21,114 @@ import android.database.Cursor;
 import org.json.JSONObject;
 
 public abstract class Node {
+  // ����ͬ����������
     public static final int SYNC_ACTION_NONE = 0;
 
+    // ����Զ�̽ڵ�
     public static final int SYNC_ACTION_ADD_REMOTE = 1;
 
+    // ���ӱ��ؽڵ�
     public static final int SYNC_ACTION_ADD_LOCAL = 2;
 
+    // ɾ��Զ�̽ڵ�
     public static final int SYNC_ACTION_DEL_REMOTE = 3;
 
+    // ɾ�����ؽڵ�
     public static final int SYNC_ACTION_DEL_LOCAL = 4;
 
+    // ����Զ�̽ڵ�
     public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
 
+    // ���±��ؽڵ�
     public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
 
+    // ���³�ͻ�ڵ�
     public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
 
+    // ����
     public static final int SYNC_ACTION_ERROR = 8;
 
+    // �ڵ�ID
     private String mGid;
 
+    // �ڵ�����
     private String mName;
 
+    // ����޸�ʱ��
     private long mLastModified;
 
+    // �Ƿ���ɾ��
     private boolean mDeleted;
 
+    // ���캯��
+ // ���캯������ʼ��Node����
     public Node() {
+        // ��ʼ��mGidΪnull
         mGid = null;
+        // ��ʼ��mNameΪ���ַ���
         mName = "";
+        // ��ʼ��mLastModifiedΪ0
         mLastModified = 0;
+        // ��ʼ��mDeletedΪfalse
         mDeleted = false;
     }
 
+// ��ȡ��������
     public abstract JSONObject getCreateAction(int actionId);
 
+// ��ȡ���¶���
     public abstract JSONObject getUpdateAction(int actionId);
 
+// ����Զ��JSON��������
     public abstract void setContentByRemoteJSON(JSONObject js);
 
+// ���ݱ���JSON��������
     public abstract void setContentByLocalJSON(JSONObject js);
 
+// �������л�ȡ����JSON
     public abstract JSONObject getLocalJSONFromContent();
 
+// �����α��ȡͬ������
     public abstract int getSyncAction(Cursor c);
 
+ // ����GID
     public void setGid(String gid) {
         this.mGid = gid;
     }
 
+ // �������ֵķ���
     public void setName(String name) {
+        // �������name������ֵ����Ա����mName
         this.mName = name;
     }
 
+ // ��������޸�ʱ��
     public void setLastModified(long lastModified) {
         this.mLastModified = lastModified;
     }
 
+// �����Ƿ�ɾ���ı�־
     public void setDeleted(boolean deleted) {
         this.mDeleted = deleted;
     }
 
+ // ��ȡGid
     public String getGid() {
         return this.mGid;
     }
 
+ // ��ȡ����
     public String getName() {
         return this.mName;
     }
 
+ // ��ȡ����޸�ʱ��
     public long getLastModified() {
         return this.mLastModified;
     }
 
     public boolean getDeleted() {
+        // ����mDeleted��ֵ
         return this.mDeleted;
     }
 
diff --git a/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/SqlData.java b/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/SqlData.java
index d3ec3be..430e823 100644
--- a/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/SqlData.java
+++ b/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/SqlData.java
@@ -24,148 +24,209 @@ import android.database.Cursor;
 import android.net.Uri;
 import android.util.Log;
 
+// ����Notes�࣬����Notes���к����ݳ���
 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;
+// ����NotesDatabaseHelper�࣬����Notes�ı�
 import net.micode.notes.data.NotesDatabaseHelper.TABLE;
+// ����ActionFailureException�࣬���ڴ�������ʧ���쳣
 import net.micode.notes.gtask.exception.ActionFailureException;
 
+// ����JSON��ص��࣬���ڴ���JSON����
 import org.json.JSONException;
 import org.json.JSONObject;
 
 
 public class SqlData {
+    // ����һ�����������ڱ�ʶ��Ч��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_ID_COLUMN = 0; // ����ID��
 
-    public static final int DATA_MIME_TYPE_COLUMN = 1;
+    public static final int DATA_MIME_TYPE_COLUMN = 1; // ����MIME������
 
-    public static final int DATA_CONTENT_COLUMN = 2;
+    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_1_COLUMN = 3; // ������������1��
 
-    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
+    public static final int DATA_CONTENT_DATA_3_COLUMN = 4; // ������������3��
 
-    private ContentResolver mContentResolver;
+    private ContentResolver mContentResolver; // ���ݽ�����
 
-    private boolean mIsCreate;
+    private boolean mIsCreate; // �Ƿ񴴽�
 
-    private long mDataId;
+    private long mDataId; // ����ID
 
-    private String mDataMimeType;
+    private String mDataMimeType; // ����MIME����
 
-    private String mDataContent;
+    private String mDataContent; // ��������
 
-    private long mDataContentData1;
+    private long mDataContentData1; // ������������1
 
-    private String mDataContentData3;
+    private String mDataContentData3; // ������������3
 
-    private ContentValues mDiffDataValues;
+    private ContentValues mDiffDataValues; // ����ֵ
 
+// ���캯������ʼ��SqlData����
     public SqlData(Context context) {
+        // ��ȡContentResolver����
         mContentResolver = context.getContentResolver();
+        // ���Ϊ����״̬
         mIsCreate = true;
+        // ��ʼ������IDΪ��ЧID
         mDataId = INVALID_ID;
+        // ��ʼ����������ΪNOTE
         mDataMimeType = DataConstants.NOTE;
+        // ��ʼ����������Ϊ���ַ���
         mDataContent = "";
+        // ��ʼ��������������1Ϊ0
         mDataContentData1 = 0;
+        // ��ʼ��������������3Ϊ���ַ���
         mDataContentData3 = "";
+        // ��ʼ��ContentValues����
         mDiffDataValues = new ContentValues();
     }
 
+    // ���캯�������ڴ�Cursor�м�������
     public SqlData(Context context, Cursor c) {
+        // ��ȡContentResolver
         mContentResolver = context.getContentResolver();
+        // ����mIsCreateΪfalse
         mIsCreate = false;
+        // ��Cursor�������
         loadFromCursor(c);
+        // ��ʼ��mDiffDataValues
         mDiffDataValues = new ContentValues();
     }
 
+// ���α��м�������
     private void loadFromCursor(Cursor c) {
+        // ���α��л�ȡ����ID
         mDataId = c.getLong(DATA_ID_COLUMN);
+        // ���α��л�ȡ����MIME����
         mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
+        // ���α��л�ȡ��������
         mDataContent = c.getString(DATA_CONTENT_COLUMN);
+        // ���α��л�ȡ������������1
         mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
+        // ���α��л�ȡ������������3
         mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
     }
 
+  // ��������
     public void setContent(JSONObject js) throws JSONException {
+        // ��ȡ����ID
         long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
+        // ����Ǵ���״̬��������ID��һ�£�������ID�������������
         if (mIsCreate || mDataId != dataId) {
             mDiffDataValues.put(DataColumns.ID, dataId);
         }
+        // ��������ID
         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;
 
+        // ��ȡjs��DATA1�ֶε�ֵ�����û����ֵΪ0
         long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
+        // ����Ǵ�������mDataContentData1��ֵ��dataContentData1��ֵ����ȣ���dataContentData1��ֵ����mDiffDataValues��
         if (mIsCreate || mDataContentData1 != dataContentData1) {
             mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
         }
+        // ��dataContentData1��ֵ����mDataContentData1
         mDataContentData1 = dataContentData1;
 
+        // ��ȡjs��DATA3�ֶε�ֵ�����û����ֵΪ���ַ���
         String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
+        // ����Ǵ�������mDataContentData3��ֵ��dataContentData3��ֵ����ȣ���dataContentData3��ֵ����mDiffDataValues��
         if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
             mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
         }
+        // ��dataContentData3��ֵ����mDataContentData3
         mDataContentData3 = dataContentData3;
     }
 
     public JSONObject getContent() throws JSONException {
+        // ���mIsCreateΪtrue��˵����û�������ݿ��д���
         if (mIsCreate) {
             Log.e(TAG, "it seems that we haven't created this in database yet");
             return null;
         }
+        // ����һ��JSONObject����
         JSONObject js = new JSONObject();
+        // ��mDataId����JSONObject��
         js.put(DataColumns.ID, mDataId);
+        // ��mDataMimeType����JSONObject��
         js.put(DataColumns.MIME_TYPE, mDataMimeType);
+        // ��mDataContent����JSONObject��
         js.put(DataColumns.CONTENT, mDataContent);
+        // ��mDataContentData1����JSONObject��
         js.put(DataColumns.DATA1, mDataContentData1);
+        // ��mDataContentData3����JSONObject��
         js.put(DataColumns.DATA3, mDataContentData3);
+        // ����JSONObject����
         return js;
     }
 
     public void commit(long noteId, boolean validateVersion, long version) {
 
+        // ����Ǵ�������
         if (mIsCreate) {
+            // �������ID��Ч������ֵ�а���ID��
             if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
+                // �Ƴ�ID��
                 mDiffDataValues.remove(DataColumns.ID);
             }
 
+            // ��noteId��������ֵ��
             mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
+            // ��������
             Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
             try {
+                // ��ȡ�������ݵ�ID
                 mDataId = Long.valueOf(uri.getPathSegments().get(1));
             } catch (NumberFormatException e) {
+                // �����ȡIDʧ�ܣ���ӡ������־���׳��쳣
                 Log.e(TAG, "Get note id error :" + e.toString());
                 throw new ActionFailureException("create note failed");
             }
         } else {
+            // ���mDiffDataValues�Ĵ�С����0
             if (mDiffDataValues.size() > 0) {
                 int result = 0;
+                // ���validateVersionΪfalse
                 if (!validateVersion) {
+                    // ����mContentResolver�����
                     result = mContentResolver.update(ContentUris.withAppendedId(
                             Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
                 } else {
+                    // ����mContentResolver�е����ݣ���������֤�汾�ŵ�����
                     result = mContentResolver.update(ContentUris.withAppendedId(
                             Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
                             " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
@@ -173,16 +234,21 @@ public class SqlData {
                                     String.valueOf(noteId), String.valueOf(version)
                             });
                 }
+                // ������½��Ϊ0
                 if (result == 0) {
+                    // ��ӡ������־
                     Log.w(TAG, "there is no update. maybe user updates note when syncing");
                 }
             }
         }
 
+    // ���mDiffDataValues
         mDiffDataValues.clear();
+    // ��mIsCreate����Ϊfalse
         mIsCreate = false;
     }
 
+// ��ȡmDataId��ֵ
     public long getId() {
         return mDataId;
     }
diff --git a/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/SqlNote.java b/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/SqlNote.java
index 79a4095..c3fae0c 100644
--- a/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/SqlNote.java
+++ b/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/SqlNote.java
@@ -39,10 +39,13 @@ import java.util.ArrayList;
 
 
 public class SqlNote {
+    // ����һ�����������ڱ�ʶ��ļ�����
     private static final String TAG = SqlNote.class.getSimpleName();
 
+    // ����һ�����������ڱ�ʶ��Ч��ID
     private static final int INVALID_ID = -99999;
 
+    // ����һ�����������ڴ洢NoteColumns�е���������
     public static final String[] PROJECTION_NOTE = new String[] {
             NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
             NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
@@ -52,175 +55,241 @@ public class SqlNote {
             NoteColumns.VERSION
     };
 
-    public static final int ID_COLUMN = 0;
+    public static final int ID_COLUMN = 0; // ID��
 
-    public static final int ALERTED_DATE_COLUMN = 1;
+    public static final int ALERTED_DATE_COLUMN = 1; // ����������
 
-    public static final int BG_COLOR_ID_COLUMN = 2;
+    public static final int BG_COLOR_ID_COLUMN = 2; // ������ɫID��
 
-    public static final int CREATED_DATE_COLUMN = 3;
+    public static final int CREATED_DATE_COLUMN = 3; // ����������
 
-    public static final int HAS_ATTACHMENT_COLUMN = 4;
+    public static final int HAS_ATTACHMENT_COLUMN = 4; // �Ƿ��и�����
 
-    public static final int MODIFIED_DATE_COLUMN = 5;
+    public static final int MODIFIED_DATE_COLUMN = 5; // �޸�������
 
-    public static final int NOTES_COUNT_COLUMN = 6;
+    public static final int NOTES_COUNT_COLUMN = 6; // �ʼ�������
 
-    public static final int PARENT_ID_COLUMN = 7;
+    public static final int PARENT_ID_COLUMN = 7; // ��ID��
 
-    public static final int SNIPPET_COLUMN = 8;
+    public static final int SNIPPET_COLUMN = 8; // ժҪ��
 
-    public static final int TYPE_COLUMN = 9;
+    public static final int TYPE_COLUMN = 9; // ������
 
-    public static final int WIDGET_ID_COLUMN = 10;
+    public static final int WIDGET_ID_COLUMN = 10; // ����ID��
 
-    public static final int WIDGET_TYPE_COLUMN = 11;
+    public static final int WIDGET_TYPE_COLUMN = 11; // ����������
 
-    public static final int SYNC_ID_COLUMN = 12;
+    public static final int SYNC_ID_COLUMN = 12; // ͬ��ID��
 
-    public static final int LOCAL_MODIFIED_COLUMN = 13;
+    public static final int LOCAL_MODIFIED_COLUMN = 13; // �����޸���
 
-    public static final int ORIGIN_PARENT_ID_COLUMN = 14;
+    public static final int ORIGIN_PARENT_ID_COLUMN = 14; // ԭʼ��ID��
 
-    public static final int GTASK_ID_COLUMN = 15;
+    public static final int GTASK_ID_COLUMN = 15; // Google����ID��
 
-    public static final int VERSION_COLUMN = 16;
+    public static final int VERSION_COLUMN = 16; // �汾��
 
-    private Context mContext;
+    private Context mContext; // ������
 
-    private ContentResolver mContentResolver;
+    private ContentResolver mContentResolver; // ���ݽ�����
 
-    private boolean mIsCreate;
+    private boolean mIsCreate; // �Ƿ񴴽�
 
-    private long mId;
+    private long mId; // ID
 
-    private long mAlertDate;
+    private long mAlertDate; // ��������
 
-    private int mBgColorId;
+    private int mBgColorId; // ������ɫID
 
-    private long mCreatedDate;
+    private long mCreatedDate; // ��������
 
-    private int mHasAttachment;
+    private int mHasAttachment; // �Ƿ��и���
 
-    private long mModifiedDate;
+    private long mModifiedDate; // �޸�����
 
-    private long mParentId;
+    private long mParentId; // ��ID
 
-    private String mSnippet;
+    private String mSnippet; // ժҪ
 
-    private int mType;
+    private int mType; // ����
 
-    private int mWidgetId;
+    private int mWidgetId; // ����ID
 
-    private int mWidgetType;
+    private int mWidgetType; // ��������
 
-    private long mOriginParent;
+    private long mOriginParent; // ԭʼ��ID
 
-    private long mVersion;
+    private long mVersion; // �汾
 
-    private ContentValues mDiffNoteValues;
+    private ContentValues mDiffNoteValues; // ��ͬ�ʼ�ֵ
 
-    private ArrayList<SqlData> mDataList;
+    private ArrayList<SqlData> mDataList; // �����б�
 
+// ���캯�������ڳ�ʼ��SqlNote����
     public SqlNote(Context context) {
+ // ��ʼ��������
         mContext = context;
+ // ��ʼ�����ݽ�����
         mContentResolver = context.getContentResolver();
+ // ����Ϊ����״̬
         mIsCreate = true;
+ // ������ЧID
         mId = INVALID_ID;
+ // ������������Ϊ0
         mAlertDate = 0;
+ // ���ñ�����ɫIDΪĬ��ֵ
         mBgColorId = ResourceParser.getDefaultBgId(context);
+ // ���ô�������Ϊ��ǰʱ��
         mCreatedDate = System.currentTimeMillis();
+ // �����Ƿ��и���Ϊ0
         mHasAttachment = 0;
+ // �����޸�����Ϊ��ǰʱ��
         mModifiedDate = System.currentTimeMillis();
+ // ���ø�IDΪ0
         mParentId = 0;
+ // ����Ƭ��Ϊ���ַ���
         mSnippet = "";
+ // ��������Ϊ�ʼ�
         mType = Notes.TYPE_NOTE;
+ // ����С����IDΪ��Чֵ
         mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
+ // ����С��������Ϊ��Чֵ
         mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
+ // ����ԭʼ��IDΪ0
         mOriginParent = 0;
+ // ���ð汾Ϊ0
         mVersion = 0;
+ // ��ʼ������ֵ
         mDiffNoteValues = new ContentValues();
+ // ��ʼ�������б�
         mDataList = new ArrayList<SqlData>();
     }
 
+// ���캯�������ڴ�Cursor�м���SqlNote����
     public SqlNote(Context context, Cursor c) {
+        // ���������Ķ���
         mContext = context;
+        // ��ȡContentResolver����
         mContentResolver = context.getContentResolver();
+        // ���Ϊδ����
         mIsCreate = false;
+        // ��Cursor���SqlNote����
         loadFromCursor(c);
+        // ��ʼ�������б�
         mDataList = new ArrayList<SqlData>();
+        // �������ΪNotes.TYPE_NOTE�����������
         if (mType == Notes.TYPE_NOTE)
             loadDataContent();
+        // ��ʼ��ContentValues����
         mDiffNoteValues = new ContentValues();
     }
 
+ // ���캯�������������ĺ�id
     public SqlNote(Context context, long id) {
+        // ����������
         mContext = context;
+        // ��ȡ���ݽ�����
         mContentResolver = context.getContentResolver();
+        // ���Ϊδ����
         mIsCreate = false;
+        // ���α��м���
         loadFromCursor(id);
+        // ��ʼ�������б�
         mDataList = new ArrayList<SqlData>();
+        // �������Ϊ�ʼǣ����������
         if (mType == Notes.TYPE_NOTE)
             loadDataContent();
+        // ��ʼ������ֵ
         mDiffNoteValues = new ContentValues();
 
     }
 
     private void loadFromCursor(long id) {
+        // �����ݿ��в�ѯָ��id�ıʼ�
         Cursor c = null;
         try {
             c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
                     new String[] {
                         String.valueOf(id)
                     }, null);
+            // �����ѯ�����Ϊ��
             if (c != null) {
+                // ���α��ƶ�����һ����¼
                 c.moveToNext();
+                // ���α��м�������
                 loadFromCursor(c);
             } else {
+                // �����ѯ���Ϊ�գ������������־
                 Log.w(TAG, "loadFromCursor: cursor = null");
             }
         } finally {
+            // �ر��α�
             if (c != null)
                 c.close();
         }
     }
 
+ // ���α��м�������
     private void loadFromCursor(Cursor c) {
+ // ��ȡID
         mId = c.getLong(ID_COLUMN);
+ // ��ȡ��������
         mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
+ // ��ȡ������ɫID
         mBgColorId = c.getInt(BG_COLOR_ID_COLUMN);
+ // ��ȡ��������
         mCreatedDate = c.getLong(CREATED_DATE_COLUMN);
+ // ��ȡ�Ƿ��и���
         mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN);
+ // ��ȡ�޸�����
         mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN);
+ // ��ȡ��ID
         mParentId = c.getLong(PARENT_ID_COLUMN);
+ // ��ȡƬ��
         mSnippet = c.getString(SNIPPET_COLUMN);
+ // ��ȡ����
         mType = c.getInt(TYPE_COLUMN);
+ // ��ȡС����ID
         mWidgetId = c.getInt(WIDGET_ID_COLUMN);
+ // ��ȡС��������
         mWidgetType = c.getInt(WIDGET_TYPE_COLUMN);
+ // ��ȡ�汾
         mVersion = c.getLong(VERSION_COLUMN);
     }
 
     private void loadDataContent() {
+        // ����һ���α����
         Cursor c = null;
+        // ��������б�
         mDataList.clear();
         try {
+            // ��ѯ���ݿ⣬��ȡָ��id������
             c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
                     "(note_id=?)", new String[] {
                         String.valueOf(mId)
                     }, null);
+            // ����α겻Ϊ��
             if (c != null) {
+                // ����α���û������
                 if (c.getCount() == 0) {
+                    // ��ӡ������־
                     Log.w(TAG, "it seems that the note has not data");
+                    // ����
                     return;
                 }
+                // �����α�
                 while (c.moveToNext()) {
+                    // ����һ��SqlData���󣬲����α��е����ݸ�ֵ���ö���
                     SqlData data = new SqlData(mContext, c);
+                    // ���ö������ӵ������б���
                     mDataList.add(data);
                 }
             } else {
+                // ��ӡ������־
                 Log.w(TAG, "loadDataContent: cursor = null");
             }
         } finally {
+            // �ر��α�
             if (c != null)
                 c.close();
         }
@@ -228,114 +297,164 @@ public class SqlNote {
 
     public boolean setContent(JSONObject js) {
         try {
+            // ��ȡnote����
             JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            // ���note��������ϵͳ�ļ��У���������
             if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
+                // ���note��������ϵͳ�ļ��У������������Ϣ
                 Log.w(TAG, "cannot set system folder");
             } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
-                // for folder we can only update the snnipet and type
+                
+                // ���note���������ļ���
+                // ��ȡnote��ժҪ
                 String snippet = note.has(NoteColumns.SNIPPET) ? note
                         .getString(NoteColumns.SNIPPET) : "";
+                // ����Ǵ���note����ժҪ��mSnippet����ȣ���ժҪ����mDiffNoteValues��
                 if (mIsCreate || !mSnippet.equals(snippet)) {
                     mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
                 }
+                // ��ժҪ��ֵ��mSnippet
                 mSnippet = snippet;
 
+                // ��ȡnote������
                 int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
                         : Notes.TYPE_NOTE;
+                // ����Ǵ���note����note�����ͺ�mType��ͬ����type����mDiffNoteValues��
                 if (mIsCreate || mType != type) {
                     mDiffNoteValues.put(NoteColumns.TYPE, type);
                 }
+                // ����mType
                 mType = type;
             } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
+                // ��ȡnote������
                 JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+                // ��ȡnote��id
                 long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
+                // ����Ǵ���note����note��id��mId��ͬ����id����mDiffNoteValues��
                 if (mIsCreate || mId != id) {
                     mDiffNoteValues.put(NoteColumns.ID, id);
                 }
+                // ����mId
                 mId = id;
 
+// ��ȡ��������
                 long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note
                         .getLong(NoteColumns.ALERTED_DATE) : 0;
+// ������½��ʼǻ������������б仯�����������ڷ������ֵ��
                 if (mIsCreate || mAlertDate != alertDate) {
                     mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);
                 }
+// ������������
                 mAlertDate = alertDate;
 
+// ��ȡ������ɫID
                 int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note
                         .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
+// ������½��ʼǻ��߱�����ɫID�б仯���򽫱�����ɫID�������ֵ��
                 if (mIsCreate || mBgColorId != bgColorId) {
                     mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);
                 }
+// ���±�����ɫID
                 mBgColorId = bgColorId;
 
+// ��ȡ��������
                 long createDate = note.has(NoteColumns.CREATED_DATE) ? note
                         .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
+// ������½��ʼǻ��ߴ��������б仯���򽫴������ڷ������ֵ��
                 if (mIsCreate || mCreatedDate != createDate) {
                     mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
                 }
+// ���´�������
                 mCreatedDate = createDate;
 
+// ��ȡ�Ƿ��и���
                 int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note
                         .getInt(NoteColumns.HAS_ATTACHMENT) : 0;
+// ������½��ʼǻ����Ƿ��и����б仯�����Ƿ��и����������ֵ��
                 if (mIsCreate || mHasAttachment != hasAttachment) {
                     mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);
                 }
+// �����Ƿ��и���
                 mHasAttachment = hasAttachment;
 
+// ��ȡnote���޸����ڣ����û�����ȡ��ǰʱ��
                 long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note
                         .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();
+// ����Ǵ���note�����޸����ڲ�ͬ�����޸����ڷ���mDiffNoteValues��
                 if (mIsCreate || mModifiedDate != modifiedDate) {
                     mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
                 }
+// ����mModifiedDate
                 mModifiedDate = modifiedDate;
 
+// ��ȡnote�ĸ�id�����û��������Ϊ0
                 long parentId = note.has(NoteColumns.PARENT_ID) ? note
                         .getLong(NoteColumns.PARENT_ID) : 0;
+// ����Ǵ���note���߸�id��ͬ���򽫸�id����mDiffNoteValues��
                 if (mIsCreate || mParentId != parentId) {
                     mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
                 }
+// ����mParentId
                 mParentId = parentId;
 
+// ��ȡnote��ժҪ�����û��������Ϊ���ַ���
                 String snippet = note.has(NoteColumns.SNIPPET) ? note
                         .getString(NoteColumns.SNIPPET) : "";
+// ����Ǵ���note����ժҪ��ͬ����ժҪ����mDiffNoteValues��
                 if (mIsCreate || !mSnippet.equals(snippet)) {
                     mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
                 }
+// ����mSnippet
                 mSnippet = snippet;
 
+                // ��ȡnote�е�typeֵ�����û����ʹ��Notes.TYPE_NOTE
                 int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
                         : Notes.TYPE_NOTE;
+                // ����Ǵ���note����typeֵ��mType��ͬ����typeֵ����mDiffNoteValues��
                 if (mIsCreate || mType != type) {
                     mDiffNoteValues.put(NoteColumns.TYPE, type);
                 }
+                // ����mTypeֵ
                 mType = type;
 
+                // ��ȡnote�е�widgetIdֵ�����û����ʹ��AppWidgetManager.INVALID_APPWIDGET_ID
                 int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)
                         : AppWidgetManager.INVALID_APPWIDGET_ID;
+                // ����Ǵ���note����widgetIdֵ��mWidgetId��ͬ����widgetIdֵ����mDiffNoteValues��
                 if (mIsCreate || mWidgetId != widgetId) {
                     mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
                 }
+                // ����mWidgetIdֵ
                 mWidgetId = widgetId;
 
+                // ��ȡnote�е�widgetTypeֵ�����û����ʹ��Notes.TYPE_WIDGET_INVALIDE
                 int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
                         .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
+                // ����Ǵ���note����widgetTypeֵ��mWidgetType��ͬ����widgetTypeֵ����mDiffNoteValues��
                 if (mIsCreate || mWidgetType != widgetType) {
                     mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
                 }
+                // ����mWidgetTypeֵ
                 mWidgetType = widgetType;
 
+// ��ȡnote��ORIGIN_PARENT_ID�����û����ֵΪ0
                 long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
                         .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
+// ����Ǵ���note����mOriginParent��originParent����ȣ���originParent����mDiffNoteValues��
                 if (mIsCreate || mOriginParent != originParent) {
                     mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
                 }
+// ����mOriginParent��ֵ
                 mOriginParent = originParent;
 
+// ����dataArray�е�ÿһ��JSONObject
                 for (int i = 0; i < dataArray.length(); i++) {
                     JSONObject data = dataArray.getJSONObject(i);
                     SqlData sqlData = null;
+    // ���data����ID�����ȡID��ֵ
                     if (data.has(DataColumns.ID)) {
                         long dataId = data.getLong(DataColumns.ID);
+        // ����mDataList���ҵ���dataId��ȵ�SqlData
                         for (SqlData temp : mDataList) {
                             if (dataId == temp.getId()) {
                                 sqlData = temp;
@@ -343,64 +462,94 @@ public class SqlNote {
                         }
                     }
 
+                    // ���sqlDataΪ�գ��򴴽�һ���µ�SqlData���󣬲��������ӵ�mDataList��
                     if (sqlData == null) {
                         sqlData = new SqlData(mContext);
                         mDataList.add(sqlData);
                     }
 
+                    // ����sqlData������Ϊdata
                     sqlData.setContent(data);
                 }
             }
         } catch (JSONException e) {
+            // ����JSON�쳣
             Log.e(TAG, e.toString());
+            // ��ӡ�쳣��Ϣ
             e.printStackTrace();
+            // ����false
             return false;
         }
+        // ����true
         return true;
     }
 
     public JSONObject getContent() {
+        // ��ȡ����
         try {
             JSONObject js = new JSONObject();
 
+            // ���mIsCreateΪtrue����ʾ��û�������ݿ��д���
             if (mIsCreate) {
                 Log.e(TAG, "it seems that we haven't created this in database yet");
                 return null;
             }
 
+// ����һ��SONObject��������Ϊnote
             JSONObject note = new JSONObject();
+// ���mType����Notes.TYPE_NOTE
             if (mType == Notes.TYPE_NOTE) {
+                // ��mId����note��
                 note.put(NoteColumns.ID, mId);
+                // ��mAlertDate����note��
                 note.put(NoteColumns.ALERTED_DATE, mAlertDate);
+                // ��mBgColorId����note��
                 note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
+                // ��mCreatedDate����note��
                 note.put(NoteColumns.CREATED_DATE, mCreatedDate);
+                // ��mHasAttachment����note��
                 note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment);
+                // ��mModifiedDate����note��
                 note.put(NoteColumns.MODIFIED_DATE, mModifiedDate);
+                // ��mParentId����note��
                 note.put(NoteColumns.PARENT_ID, mParentId);
+                // ��mSnippet����note��
                 note.put(NoteColumns.SNIPPET, mSnippet);
+                // ��mType����note��
                 note.put(NoteColumns.TYPE, mType);
+                // ��mWidgetId����note��
                 note.put(NoteColumns.WIDGET_ID, mWidgetId);
+                // ��mWidgetType����note��
                 note.put(NoteColumns.WIDGET_TYPE, mWidgetType);
+                // ��mOriginParent����note��
                 note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
+                // ��note����js��
                 js.put(GTaskStringUtils.META_HEAD_NOTE, note);
 
+  // ����һ��JSONArray����
                 JSONArray dataArray = new JSONArray();
+  // ����mDataList�е�ÿһ��SqlData����
                 for (SqlData sqlData : mDataList) {
+      // ��ȡSqlData�����е�content���ԣ���JSONObject����
                     JSONObject data = sqlData.getContent();
+      // ���JSONObject����Ϊ�գ��������ӵ�dataArray��
                     if (data != null) {
                         dataArray.put(data);
                     }
                 }
                 js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
             } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
+                // ���mType���ļ��л�ϵͳ���ͣ���mId��mType��mSnippet����note��
                 note.put(NoteColumns.ID, mId);
                 note.put(NoteColumns.TYPE, mType);
                 note.put(NoteColumns.SNIPPET, mSnippet);
+                // ��note����js��
                 js.put(GTaskStringUtils.META_HEAD_NOTE, note);
             }
 
             return js;
         } catch (JSONException e) {
+            // �������JSONException�����ӡ������־
             Log.e(TAG, e.toString());
             e.printStackTrace();
         }
@@ -408,73 +557,97 @@ public class SqlNote {
     }
 
     public void setParentId(long id) {
+        // ���ø�ID
         mParentId = id;
+        // ����ID���ӵ�����ֵ��
         mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
     }
 
     public void setGtaskId(String gid) {
+        // ����GtaskId
         mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
     }
 
     public void setSyncId(long syncId) {
+        // ����ͬ��ID
         mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
     }
 
     public void resetLocalModified() {
+        // ���ñ����޸�
         mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
     }
 
     public long getId() {
+        // ��ȡID
         return mId;
     }
 
     public long getParentId() {
+        // ��ȡ��ID
+     // ���ظ�ID
         return mParentId;
     }
 
+    // ����Ƭ��
     public String getSnippet() {
         return mSnippet;
     }
 
+    // �ж��Ƿ�Ϊ�ʼ�����
     public boolean isNoteType() {
         return mType == Notes.TYPE_NOTE;
     }
 
     public void commit(boolean validateVersion) {
+        // ����Ǵ�������
         if (mIsCreate) {
+            // ���ID����mDiffNoteValues���ID��
             if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
+                // ��mDiffNoteValues���Ƴ�ID��
                 mDiffNoteValues.remove(NoteColumns.ID);
             }
 
+            // �������ݵ�Notes.CONTENT_NOTE_URI
             Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
             try {
+                // ��ȡ�������ݵ�ID
                 mId = Long.valueOf(uri.getPathSegments().get(1));
             } catch (NumberFormatException e) {
+                // �����ȡIDʧ�ܣ���ӡ������־���׳�ActionFailureException�쳣
                 Log.e(TAG, "Get note id error :" + e.toString());
                 throw new ActionFailureException("create note failed");
             }
+            // ���IDΪ0���׳�IllegalStateException�쳣
             if (mId == 0) {
                 throw new IllegalStateException("Create thread id failed");
             }
 
+            // �������ΪNotes.TYPE_NOTE
             if (mType == Notes.TYPE_NOTE) {
+                // ����mDataList
                 for (SqlData sqlData : mDataList) {
+                    // �ύ����
                     sqlData.commit(mId, false, -1);
                 }
             }
         } else {
+            // ���mIdС�ڵ���0������mId������Notes.ID_ROOT_FOLDER��Notes.ID_CALL_RECORD_FOLDER�����׳��쳣
             if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
                 Log.e(TAG, "No such note");
                 throw new IllegalStateException("Try to update note with invalid id");
             }
+            // ���mDiffNoteValues�Ĵ�С����0������°汾��
             if (mDiffNoteValues.size() > 0) {
                 mVersion ++;
                 int result = 0;
+                // ���validateVersionΪfalse����ֱ�Ӹ���
                 if (!validateVersion) {
                     result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
                             + NoteColumns.ID + "=?)", new String[] {
                         String.valueOf(mId)
                     });
+                // ���validateVersionΪtrue������°汾��С�ڵ���mVersion�ļ�¼
                 } else {
                     result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
                             + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
@@ -482,11 +655,13 @@ public class SqlNote {
                                     String.valueOf(mId), String.valueOf(mVersion)
                             });
                 }
+                // ������½��Ϊ0�������������־
                 if (result == 0) {
                     Log.w(TAG, "there is no update. maybe user updates note when syncing");
                 }
             }
 
+ // ���mType����Notes.TYPE_NOTE�������mDataList�е�ÿ��SqlData���󣬲�������commit����������mId��validateVersion��mVersion����
             if (mType == Notes.TYPE_NOTE) {
                 for (SqlData sqlData : mDataList) {
                     sqlData.commit(mId, validateVersion, mVersion);
@@ -494,12 +669,15 @@ public class SqlNote {
             }
         }
 
-        // refresh local info
+        
         loadFromCursor(mId);
+        // ���mType����Notes.TYPE_NOTE�������loadDataContent()����
         if (mType == Notes.TYPE_NOTE)
             loadDataContent();
 
+        // ���mDiffNoteValues
         mDiffNoteValues.clear();
+        // ��mIsCreate����Ϊfalse
         mIsCreate = false;
     }
 }
diff --git a/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/Task.java b/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/Task.java
index 6a19454..b83a533 100644
--- a/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/Task.java
+++ b/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/Task.java
@@ -31,72 +31,105 @@ import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-
 public class Task extends Node {
+
+    // ����һ�����������ڱ�ʶTask��ļ�����
     private static final String TAG = Task.class.getSimpleName();
 
+    // ����һ���������͵ı��������ڱ�ʶ�����Ƿ����
     private boolean mCompleted;
 
+    // ����һ���ַ������͵ı��������ڴ洢����ı�ע��Ϣ
     private String mNotes;
 
+    // ����һ��JSONObject���͵ı��������ڴ洢�����Ԫ��Ϣ
     private JSONObject mMetaInfo;
 
+    // ����һ��Task���͵ı��������ڴ洢�����ǰһ���ֵ�����
     private Task mPriorSibling;
 
+    // ����һ��TaskList���͵ı��������ڴ洢����ĸ������б�
     private TaskList mParent;
 
+// ���캯������ʼ��Task����
     public Task() {
+        // ���ø���Ĺ��캯��
         super();
+        // ��ʼ��mCompletedΪfalse
         mCompleted = false;
+        // ��ʼ��mNotesΪnull
         mNotes = null;
+        // ��ʼ��mPriorSiblingΪnull
         mPriorSibling = null;
+        // ��ʼ��mParentΪnull
         mParent = null;
+        // ��ʼ��mMetaInfoΪnull
         mMetaInfo = null;
     }
 
+// ����actionId��ȡ��������
     public JSONObject getCreateAction(int actionId) {
+        // ����һ��JSONObject����
         JSONObject js = new JSONObject();
 
         try {
-            // action_type
+           
+            // ��actionType��������
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
 
-            // action_id
+           
+            // ��actionId���������actionId
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
 
-            // index
+            
+            // ��index���������������������
             js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
 
-            // entity_delta
+            
+            // ����һ��JSONObject����
             JSONObject entity = new JSONObject();
+            // ��name����Ϊ��ǰ���������
             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            // ��creatorId����Ϊnull
             entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
+            // ��entityType��������
             entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
                     GTaskStringUtils.GTASK_JSON_TYPE_TASK);
+ // ���getNotes()��Ϊ�գ���getNotes()��ֵ����entity��
             if (getNotes() != null) {
                 entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
             }
+ // ��entity����js��
             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
 
-            // parent_id
+            
+ // ��mParent��Gid����js��
             js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
 
-            // dest_parent_type
+           
+ // ��GTaskStringUtils.GTASK_JSON_TYPE_GROUP����js��
             js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
                     GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
 
-            // list_id
+            
+ // ��mParent��Gid����js��
             js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
 
-            // prior_sibling_id
+            
+ // ���mPriorSibling��Ϊ�գ���mPriorSibling��Gid����js��
+ // ���mPriorSibling��Ϊ�գ���mPriorSibling��Gid����js��
             if (mPriorSibling != null) {
                 js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
             }
 
+        // ����JSONException�쳣
         } catch (JSONException e) {
+            // ��ӡ�쳣��Ϣ
             Log.e(TAG, e.toString());
+            // ��ӡ�쳣��ջ��Ϣ
             e.printStackTrace();
+            // �׳�ActionFailureException�쳣
             throw new ActionFailureException("fail to generate task-create jsonobject");
         }
 
@@ -104,207 +137,280 @@ public class Task extends Node {
     }
 
     public JSONObject getUpdateAction(int actionId) {
+        // ����һ��JSONObject����
         JSONObject js = new JSONObject();
 
         try {
-            // action_type
+           
+            // ��action������������
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
 
-            // action_id
+            
+            // ��actionId����js��
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
 
-            // id
+           
+            // ��getGid()�ķ���ֵ����js��
             js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
 
-            // entity_delta
+            
+ // ����һ��JSONObject����
             JSONObject entity = new JSONObject();
+ // ��getName()�����ķ���ֵ����JSONObject�����У���ΪGTASK_JSON_NAME
             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+ // ���getNotes()��������ֵ��Ϊnull����getNotes()�����ķ���ֵ����JSONObject�����У���ΪGTASK_JSON_NOTES
             if (getNotes() != null) {
                 entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
             }
+ // ��getDeleted()�����ķ���ֵ����JSONObject�����У���ΪGTASK_JSON_DELETED
             entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
+ // ��JSONObject�������js�����У���ΪGTASK_JSON_ENTITY_DELTA
             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
 
         } catch (JSONException e) {
+            // ����JSON�쳣
             Log.e(TAG, e.toString());
+            // ��ӡ�쳣��Ϣ
             e.printStackTrace();
+            // �׳��Զ����쳣
             throw new ActionFailureException("fail to generate task-update jsonobject");
         }
 
         return js;
     }
 
+    // ����Զ��JSON��������
     public void setContentByRemoteJSON(JSONObject js) {
         if (js != null) {
             try {
-                // id
+               
                 if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
+                    // ���json��������GTaskStringUtils.GTASK_JSON_ID�ֶΣ�������Gid
                     setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
                 }
 
-                // last_modified
+                
                 if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
+                    // ���json��������GTaskStringUtils.GTASK_JSON_LAST_MODIFIED�ֶΣ�������LastModified
                     setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
                 }
 
-                // name
+              
                 if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
+                    // ���json��������GTaskStringUtils.GTASK_JSON_NAME�ֶΣ�������Name
                     setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
                 }
 
-                // notes
+               
                 if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
+                    // ���json��������GTaskStringUtils.GTASK_JSON_NOTES�ֶΣ�������Notes
                     setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
                 }
 
-                // deleted
+                
                 if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
+                    // ���json��������GTaskStringUtils.GTASK_JSON_DELETED�ֶΣ�������Deleted
                     setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
                 }
 
-                // completed
+               
                 if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
+                    // ���json��������GTaskStringUtils.GTASK_JSON_COMPLETED�ֶΣ�������Completed
                     setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
                 }
             } catch (JSONException e) {
+                // ����JSONException�쳣
                 Log.e(TAG, e.toString());
+                // ��ӡ�쳣��Ϣ
                 e.printStackTrace();
+                // �׳��Զ����쳣ActionFailureException
                 throw new ActionFailureException("fail to get task content from jsonobject");
             }
         }
     }
 
     public void setContentByLocalJSON(JSONObject js) {
+        // �жϴ����JSONObject�Ƿ�Ϊ�գ������Ƿ����META_HEAD_NOTE��META_HEAD_DATA�ֶ�
         if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
                 || !js.has(GTaskStringUtils.META_HEAD_DATA)) {
+            // ����������������������־
             Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
         }
 
         try {
+            // ��ȡJSON�����е�note
             JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            // ��ȡJSON�����е�dataArray
             JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
 
+            // ���note�����Ͳ���Notes.TYPE_NOTE�������������Ϣ������
             if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
                 Log.e(TAG, "invalid type");
                 return;
             }
 
+// ����dataArray����
             for (int i = 0; i < dataArray.length(); i++) {
+    // ��ȡ�����е�JSONObject����
                 JSONObject data = dataArray.getJSONObject(i);
+    // �ж�MIME_TYPE�Ƿ�ΪNOTE
                 if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
+        // ��������
                     setName(data.getString(DataColumns.CONTENT));
+        // ����ѭ��
                     break;
                 }
             }
 
+// ����JSONException�쳣
         } catch (JSONException e) {
+    // ��ӡ�쳣��Ϣ
             Log.e(TAG, e.toString());
+    // ��ӡ�쳣��ջ��Ϣ
             e.printStackTrace();
         }
     }
 
     public JSONObject getLocalJSONFromContent() {
+        // ��ȡ�ʼ�����
         String name = getName();
         try {
+            // ���mMetaInfoΪ�գ�˵�����½��ıʼ�
             if (mMetaInfo == null) {
-                // new task created from web
+               
+                // ���nameΪ�գ�˵���ʼ�Ϊ��
                 if (name == null) {
                     Log.w(TAG, "the note seems to be an empty one");
                     return null;
                 }
 
                 JSONObject js = new JSONObject();
+                // ����һ��JSONObject����
                 JSONObject note = new JSONObject();
+                // ����һ��JSONObject����
                 JSONArray dataArray = new JSONArray();
+                // ����һ��JSONArray����
                 JSONObject data = new JSONObject();
+                // ����һ��JSONObject����
                 data.put(DataColumns.CONTENT, name);
+                // ��name����data������
                 dataArray.put(data);
+                // ��data�������dataArray��
                 js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
+                // ��dataArray�������js������
                 note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+                // ��Notes.TYPE_NOTE����note������
                 js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+                // ��note�������js������
                 return js;
             } else {
-                // 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);
+                    // ������ݶ����MIME����Ϊ�ʼ�
                     if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
+                        // �����ݶ����content�ֶ�����ΪgetName()�����ķ���ֵ
                         data.put(DataColumns.CONTENT, getName());
+                        // ����ѭ��
                         break;
                     }
                 }
 
+                // ��note��type����ΪNotes.TYPE_NOTE
                 note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+                // ����mMetaInfo
                 return mMetaInfo;
             }
         } catch (JSONException e) {
+            // ��ӡ������־
             Log.e(TAG, e.toString());
+            // ��ӡ�����ջ
             e.printStackTrace();
+            // ����null
             return null;
         }
     }
 
     public void setMetaInfo(MetaData metaData) {
+        // �жϴ����metaData�Ƿ�Ϊ�գ�����metaData�е�notes�Ƿ�Ϊ��
         if (metaData != null && metaData.getNotes() != null) {
             try {
+                // ��metaData�е�notesת��ΪJSONObject
                 mMetaInfo = new JSONObject(metaData.getNotes());
             } catch (JSONException e) {
+                // ���ת��ʧ�ܣ���ӡ������־������mMetaInfo��Ϊnull
                 Log.w(TAG, e.toString());
                 mMetaInfo = null;
             }
         }
     }
 
+ // �����α�c��ȡͬ������
     public int getSyncAction(Cursor c) {
         try {
+            // ��ȡnoteInfo����
             JSONObject noteInfo = null;
             if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
                 noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
             }
 
+            // ���noteInfoΪ�գ���˵��note meta�Ѿ���ɾ��
             if (noteInfo == null) {
                 Log.w(TAG, "it seems that note meta has been deleted");
                 return SYNC_ACTION_UPDATE_REMOTE;
             }
 
+            // ���noteInfo��û��ID����˵��remote note id�Ѿ���ɾ��
             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
+            
+            // ���note id�Ƿ�ƥ��
             if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
                 Log.w(TAG, "note id doesn't match");
                 return SYNC_ACTION_UPDATE_LOCAL;
             }
 
+            // ��鱾���Ƿ��޸�
             if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
-                // there is no local update
+                
+                // ���ͬ��id�Ƿ�ƥ��
                 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
+                
+                // ���gtask id�Ƿ�ƥ��
                 if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
                     Log.e(TAG, "gtask id doesn't match");
                     return SYNC_ACTION_ERROR;
                 }
+                // ���ͬ��id�Ƿ�ƥ��
                 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();
         }
 
@@ -312,39 +418,48 @@ public class Task extends Node {
     }
 
     public boolean isWorthSaving() {
+        // �ж��Ƿ���Ҫ���棬���mMetaInfo��Ϊ�գ�����getName()��Ϊ���ҳ��ȴ���0������getNotes()��Ϊ���ҳ��ȴ���0���򷵻�true
         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;
     }
 
diff --git a/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/TaskList.java b/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/TaskList.java
index 4ea21c5..e5db5ac 100644
--- a/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/TaskList.java
+++ b/src/Notesmaster/app/src/main/java/net/micode/notes/gtask/data/TaskList.java
@@ -31,127 +31,182 @@ import java.util.ArrayList;
 
 
 public class TaskList extends Node {
+    // ����һ�����������ڱ�ʶTaskList��ļ�����
     private static final String TAG = TaskList.class.getSimpleName();
 
+    // ����һ�����ͱ��������ڴ洢TaskList������
     private int mIndex;
 
+    // ����һ��ArrayList�����ڴ洢TaskList���ӽڵ�
     private ArrayList<Task> mChildren;
 
+    // ���캯������ʼ��mChildren��mIndex
     public TaskList() {
         super();
         mChildren = new ArrayList<Task>();
         mIndex = 1;
     }
 
+ // ����actionId��ȡ��������
     public JSONObject getCreateAction(int actionId) {
+        // ����һ��JSONObject����
         JSONObject js = new JSONObject();
 
         try {
-            // action_type
+           
+            // ��GTASK_JSON_ACTION_TYPE��ֵ����ΪGTASK_JSON_ACTION_TYPE_CREATE
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
 
-            // action_id
+          
+            // ��GTASK_JSON_ACTION_ID��ֵ����ΪactionId
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
 
-            // index
+           
+            // ��GTASK_JSON_INDEX��ֵ����ΪmIndex
             js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
 
-            // entity_delta
+          
+            // ����һ��JSONObject����entity
             JSONObject entity = new JSONObject();
+            // ��GTASK_JSON_NAME��ֵ����ΪgetName()�ķ���ֵ
             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            // ��GTASK_JSON_CREATOR_ID��ֵ����Ϊ"null"
             entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
+            // ��GTASK_JSON_ENTITY_TYPE��ֵ����ΪGTASK_JSON_TYPE_GROUP
             entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
                     GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
+            // ��GTASK_JSON_ENTITY_DELTA��ֵ����Ϊentity
             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
 
         } catch (JSONException e) {
+            // ����JSONException�쳣
             Log.e(TAG, e.toString());
+            // ��ӡ�쳣��Ϣ
             e.printStackTrace();
+            // �׳�ActionFailureException�쳣����ʾ����tasklist-create jsonobjectʧ��
             throw new ActionFailureException("fail to generate tasklist-create jsonobject");
         }
 
+        // ����js����
         return js;
     }
 
+ // ����actionId��ȡ���²���
     public JSONObject getUpdateAction(int actionId) {
+        // ����һ��JSONObject����
         JSONObject js = new JSONObject();
 
         try {
-            // action_type
+           
+            // ����action��������
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
 
-            // action_id
+           
+            // ����actionId
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
 
-            // id
+            
+            // ����gid
             js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
 
-            // entity_delta
+           
+            // ����entity����
             JSONObject entity = new JSONObject();
+            // ����entity��name����
             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            // ����entity��deleted����
             entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
+            // ��entity�������js��
             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
 
         } catch (JSONException e) {
+            // ����JSONException�쳣
             Log.e(TAG, e.toString());
+            // ��ӡ�쳣��Ϣ
             e.printStackTrace();
+            // �׳�ActionFailureException�쳣
             throw new ActionFailureException("fail to generate tasklist-update jsonobject");
         }
 
+        // ����js����
         return js;
     }
 
+ // ����Զ��JSON��������
     public void setContentByRemoteJSON(JSONObject js) {
         if (js != null) {
             try {
-                // id
+               
+                // �ж�json�������Ƿ����GTASK_JSON_ID�ֶ�
                 if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
+                    // �����������GTASK_JSON_ID�ֶε�ֵ����gid
                     setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
                 }
 
-                // last_modified
+               
+                // �ж�json�������Ƿ����GTASK_JSON_LAST_MODIFIED�ֶ�
                 if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
+                    // �����������GTASK_JSON_LAST_MODIFIED�ֶε�ֵ����lastModified
                     setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
                 }
 
-                // name
+                
+                // �ж�json�������Ƿ����GTASK_JSON_NAME�ֶ�
                 if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
+                    // �����������GTASK_JSON_NAME�ֶε�ֵ����name
                     setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
                 }
 
             } catch (JSONException e) {
+                // �������JSONException�쳣�����ӡ�쳣��Ϣ�����׳�ActionFailureException�쳣
+ // ��ӡ������־
                 Log.e(TAG, e.toString());
+ // ��ӡ��ջ��Ϣ
                 e.printStackTrace();
+ // �׳��쳣����ʾ��ȡ�����б�����ʧ��
                 throw new ActionFailureException("fail to get tasklist content from jsonobject");
             }
         }
     }
 
     public void setContentByLocalJSON(JSONObject js) {
+        // �жϴ����JSONObject�Ƿ�Ϊ�ջ����Ƿ����META_HEAD_NOTE�ֶ�
         if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
+            // ���Ϊ�ջ��߲�����META_HEAD_NOTE�ֶΣ������������־
             Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
         }
 
         try {
+            // ��ȡJSONObject����
             JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
 
+            // �ж������Ƿ�Ϊ�ļ���
             if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
+                // ��ȡ�ļ�������
                 String name = folder.getString(NoteColumns.SNIPPET);
+                // ��������
                 setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name);
             } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
+                // �ж��Ƿ�Ϊ���ļ���
                 if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
+                    // ���ø��ļ�������
                     setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
+                // �ж��Ƿ�Ϊͨ����¼�ļ���
                 else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
+                    // ����ͨ����¼�ļ�������
                     setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
                             + GTaskStringUtils.FOLDER_CALL_NOTE);
                 else
+                    // �Ƿ�ϵͳ�ļ���
                     Log.e(TAG, "invalid system folder");
             } else {
+                // ��������
                 Log.e(TAG, "error type");
             }
         } catch (JSONException e) {
+            // �쳣����
             Log.e(TAG, e.toString());
             e.printStackTrace();
         }
@@ -159,61 +214,86 @@ public class TaskList extends Node {
 
     public JSONObject getLocalJSONFromContent() {
         try {
+            // ����һ��JSONObject����
             JSONObject js = new JSONObject();
+            // ����һ��JSONObject����
             JSONObject folder = new JSONObject();
 
+            // ��ȡ�ļ�������
             String folderName = getName();
+            // ����ļ���������MIUI_FOLDER_PREFFIX��ͷ����ȥ����ǰ׺
             if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
                 folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
                         folderName.length());
+            // ���ļ������Ʒ���folder������
             folder.put(NoteColumns.SNIPPET, folderName);
+            // ����ļ���������Ĭ���ļ��л���ͨ����¼�ļ��У�����������Ϊϵͳ����
             if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
                     || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
                 folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+            // ������������Ϊ�ļ�������
             else
                 folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
 
+            // ��folder�������js������
             js.put(GTaskStringUtils.META_HEAD_NOTE, folder);
 
             return js;
         } catch (JSONException e) {
+            // ����JSON�쳣
             Log.e(TAG, e.toString());
+            // ��ӡ�쳣��Ϣ
             e.printStackTrace();
+            // ����null
             return null;
         }
     }
 
     public int getSyncAction(Cursor c) {
         try {
+            // ��������޸���Ϊ0
             if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
-                // there is no local update
+                
+                // ���ͬ��ID�е�������޸�ʱ��
                 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
+                
+                // ���gtask ID�в�����getGid()���ش���
                 if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
                     Log.e(TAG, "gtask id doesn't match");
                     return SYNC_ACTION_ERROR;
                 }
+                // ���ͬ��ID�е�������޸�ʱ��
                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                    // local modification only
+                    
+                    // ���ظ���Զ��
                     return SYNC_ACTION_UPDATE_REMOTE;
                 } else {
-                    // for folder conflicts, just apply local modification
+                    
+                    // ���ظ���Զ��
                     return SYNC_ACTION_UPDATE_REMOTE;
                 }
             }
         } catch (Exception e) {
+            // ��ӡ������־
             Log.e(TAG, e.toString());
+            // ��ӡ��ջ��Ϣ
             e.printStackTrace();
         }
 
+// ����ͬ����������
         return SYNC_ACTION_ERROR;
+// ��������������
+public int getChildTaskCount() {
+    return mChildren.size();
     }
 
     public int getChildTaskCount() {
@@ -221,38 +301,54 @@ public class TaskList extends Node {
     }
 
     public boolean addChildTask(Task task) {
+        // ���巵��ֵ
         boolean ret = false;
+        // �жϴ������������Ƿ�Ϊ�գ�����mChildren�����в��������������
         if (task != null && !mChildren.contains(task)) {
+            // ������������ӵ�mChildren������
             ret = mChildren.add(task);
+            // ������ӳɹ�
             if (ret) {
-                // need to set prior sibling and parent
+                
+                // ���mChildren����Ϊ�գ�����������ǰһ���ֵܽڵ�����Ϊnull
                 task.setPriorSibling(mChildren.isEmpty() ? null : mChildren
                         .get(mChildren.size() - 1));
+                // ���������ĸ��ڵ�����Ϊ��ǰ����
                 task.setParent(this);
             }
         }
+        // �������ӽ��
         return ret;
     }
 
     public boolean addChildTask(Task task, int index) {
+        // ���index�Ƿ�Ϸ�
         if (index < 0 || index > mChildren.size()) {
             Log.e(TAG, "add child task: invalid index");
             return false;
         }
 
+        // ���task�Ƿ�Ϊ�գ�����task�Ƿ��Ѿ�������mChildren��
         int pos = mChildren.indexOf(task);
         if (task != null && pos == -1) {
+            // ��task���ӵ�mChildren��ָ��λ��
             mChildren.add(index, task);
 
-            // update the task list
+            
+            // ��ȡ��ǰ�����ǰһ������ͺ�һ������
             Task preTask = null;
+// ��ȡ��ǰ�����ǰһ������
             Task afterTask = null;
+// �����ǰ�����ǵ�һ���������ȡǰһ������
             if (index != 0)
                 preTask = mChildren.get(index - 1);
+// �����ǰ���������һ���������ȡ��һ������
             if (index != mChildren.size() - 1)
-                afterTask = mChildren.get(index + 1);
+                afterTask = mChildren.get(index + 1);x + 1);
 
+            // ���õ�ǰ�����ǰһ������
             task.setPriorSibling(preTask);
+            // �����һ������Ϊ�գ����ú�һ�������ǰһ������Ϊ��ǰ����
             if (afterTask != null)
                 afterTask.setPriorSibling(task);
         }
@@ -261,21 +357,32 @@ public class TaskList extends Node {
     }
 
     public boolean removeChildTask(Task task) {
+        // ���巵��ֵ
         boolean ret = false;
+        // ��ȡҪɾ�����������������б��е�����
         int index = mChildren.indexOf(task);
+        // ���������Ϊ-1��˵���������
         if (index != -1) {
+            // ���������б���ɾ������
             ret = mChildren.remove(task);
 
+            // ���ɾ���ɹ�
             if (ret) {
-                // reset prior sibling and parent
+                
+                // ��������������ֵ�����Ϊnull
                 task.setPriorSibling(null);
+                // ��������ĸ�������Ϊnull
                 task.setParent(null);
 
-                // update the task list
+                
+// ���index������mChildren�Ĵ�С
                 if (index != mChildren.size()) {
+    // ��ȡmChildren��indexλ�õ�Ԫ�أ�������ǰһ���ֵܽڵ�����ΪmChildren��index-1λ�õ�Ԫ��
                     mChildren.get(index).setPriorSibling(
                             index == 0 ? null : mChildren.get(index - 1));
                 }
+// ����ret
+return ret;
             }
         }
         return ret;
@@ -283,25 +390,31 @@ public class TaskList extends Node {
 
     public boolean moveChildTask(Task task, int index) {
 
+        // ���index�Ƿ�Ϸ�
         if (index < 0 || index >= mChildren.size()) {
             Log.e(TAG, "move child task: invalid index");
             return false;
         }
 
+        // ���task�Ƿ���mChildren��
         int pos = mChildren.indexOf(task);
         if (pos == -1) {
             Log.e(TAG, "move child task: the task should in the list");
             return false;
         }
 
+        // ���pos��index��ȣ�����Ҫ�ƶ�
         if (pos == index)
             return true;
+        // �Ƴ�task�������ӵ�ָ��λ��
         return (removeChildTask(task) && addChildTask(task, index));
     }
 
+    // ����gid����������
     public Task findChildTaskByGid(String gid) {
         for (int i = 0; i < mChildren.size(); i++) {
             Task t = mChildren.get(i);
+            // ���gid��ȣ��򷵻ظ�����
             if (t.getGid().equals(gid)) {
                 return t;
             }
@@ -310,34 +423,43 @@ public class TaskList extends Node {
     }
 
     public int getChildTaskIndex(Task task) {
+        // ������������mChildren�����
         return mChildren.indexOf(task);
     }
 
     public Task getChildTaskByIndex(int index) {
+        // ����������ȡ������
         if (index < 0 || index >= mChildren.size()) {
+            // ���������Ч�����ӡ������־
             Log.e(TAG, "getTaskByIndex: invalid index");
             return null;
         }
+        // ����������Ӧ��������
         return mChildren.get(index);
     }
 
     public Task getChilTaskByGid(String gid) {
+        // ����mChildren�б�������gid��ȵ�Task
         for (Task task : mChildren) {
             if (task.getGid().equals(gid))
                 return task;
         }
+        // ���û���ҵ�������null
         return null;
     }
 
     public ArrayList<Task> getChildTaskList() {
+        // ����mChildren�б�
         return this.mChildren;
     }
 
     public void setIndex(int index) {
+        // ����mIndex��ֵ
         this.mIndex = index;
     }
 
     public int getIndex() {
+        // ���ص�ǰ���������
         return this.mIndex;
     }
 }