Update Note.java

Note.java

@@ -15,6 +15,7 @@
  */
 
 package net.micode.notes.model;
+// 导入必要的Android类库
 import android.content.ContentProviderOperation;
 import android.content.ContentProviderResult;
 import android.content.ContentUris;
@@ -25,6 +26,7 @@ import android.net.Uri;
 import android.os.RemoteException;
 import android.util.Log;
 
+// 导入项目中定义的数据访问类库
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.CallNote;
 import net.micode.notes.data.Notes.DataColumns;
@@ -33,16 +35,20 @@ import net.micode.notes.data.Notes.TextNote;
 
 import java.util.ArrayList;
 
-
+// 定义Note类，用于处理笔记数据的创建、更新和同步
 public class Note {
+    // 用于存储笔记数据变化的ContentValues对象
     private ContentValues mNoteDiffValues;
+    // 内部类NoteData的实例，用于存储笔记的文本和呼叫数据
     private NoteData mNoteData;
+    // 用于日志记录的标签
     private static final String TAG = "Note";
+
     /**
-     * Create a new note id for adding a new note to databases
+     * 创建一个新的笔记ID，用于将新笔记添加到数据库
      */
     public static synchronized long getNewNoteId(Context context, long folderId) {
-        // Create a new note in the database
+        // 创建一个新的笔记条目在数据库中
         ContentValues values = new ContentValues();
         long createdTime = System.currentTimeMillis();
         values.put(NoteColumns.CREATED_DATE, createdTime);
@@ -50,10 +56,12 @@ public class Note {
         values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
         values.put(NoteColumns.LOCAL_MODIFIED, 1);
         values.put(NoteColumns.PARENT_ID, folderId);
+        // 将新笔记插入数据库，并获取返回的URI
         Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
 
         long noteId = 0;
         try {
+            // 从URI中解析出新创建的笔记ID
             noteId = Long.valueOf(uri.getPathSegments().get(1));
         } catch (NumberFormatException e) {
             Log.e(TAG, "Get note id error :" + e.toString());
@@ -65,41 +73,50 @@ public class Note {
         return noteId;
     }
 
+    // Note类的构造函数
     public Note() {
         mNoteDiffValues = new ContentValues();
         mNoteData = new NoteData();
     }
 
+    // 设置笔记的值
     public void setNoteValue(String key, String value) {
         mNoteDiffValues.put(key, value);
         mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
         mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
     }
 
+    // 设置笔记的文本数据
     public void setTextData(String key, String value) {
         mNoteData.setTextData(key, value);
     }
 
+    // 设置笔记的文本数据ID
     public void setTextDataId(long id) {
         mNoteData.setTextDataId(id);
     }
 
+    // 获取笔记的文本数据ID
     public long getTextDataId() {
         return mNoteData.mTextDataId;
     }
 
+    // 设置笔记的呼叫数据ID
     public void setCallDataId(long id) {
         mNoteData.setCallDataId(id);
     }
 
+    // 设置笔记的呼叫数据
     public void setCallData(String key, String value) {
         mNoteData.setCallData(key, value);
     }
 
+    // 检查笔记是否在本地被修改过
     public boolean isLocalModified() {
         return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
     }
 
+    // 同步笔记到数据库
     public boolean syncNote(Context context, long noteId) {
         if (noteId <= 0) {
             throw new IllegalArgumentException("Wrong note id:" + noteId);
@@ -110,15 +127,14 @@ public class Note {
         }
 
         /**
-         * In theory, once data changed, the note should be updated on {@link NoteColumns#LOCAL_MODIFIED} and
-         * {@link NoteColumns#MODIFIED_DATE}. For data safety, though update note fails, we also update the
-         * note data info
+         * 理论上，一旦数据发生变化，就应该更新笔记的LOCAL_MODIFIED和MODIFIED_DATE字段。
+         * 为了数据安全，即使更新失败，也应该更新笔记数据信息。
          */
         if (context.getContentResolver().update(
                 ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
                 null) == 0) {
             Log.e(TAG, "Update note error, should not happen");
-            // Do not return, fall through
+            // 即使更新失败，也不返回，继续执行
         }
         mNoteDiffValues.clear();
 
@@ -130,15 +146,12 @@ public class Note {
         return true;
     }
 
+    // 内部类NoteData，用于存储笔记的文本和呼叫数据
     private class NoteData {
         private long mTextDataId;
-
         private ContentValues mTextDataValues;
-
         private long mCallDataId;
-
         private ContentValues mCallDataValues;
-
         private static final String TAG = "NoteData";
 
         public NoteData() {
@@ -148,10 +161,12 @@ public class Note {
             mCallDataId = 0;
         }
 
+        // 检查笔记数据是否在本地被修改过
         boolean isLocalModified() {
             return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
         }
 
+        // 设置笔记的文本数据ID
         void setTextDataId(long id) {
             if(id <= 0) {
                 throw new IllegalArgumentException("Text data id should larger than 0");
@@ -159,6 +174,7 @@ public class Note {
             mTextDataId = id;
         }
 
+        // 设置笔记的呼叫数据ID
         void setCallDataId(long id) {
             if (id <= 0) {
                 throw new IllegalArgumentException("Call data id should larger than 0");
@@ -166,21 +182,24 @@ public class Note {
             mCallDataId = id;
         }
 
+        // 设置笔记的呼叫数据
         void setCallData(String key, String value) {
             mCallDataValues.put(key, value);
             mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
             mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
         }
 
+        // 设置笔记的文本数据
         void setTextData(String key, String value) {
             mTextDataValues.put(key, value);
             mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
             mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
         }
 
+        // 将笔记数据推送到内容解析器
         Uri pushIntoContentResolver(Context context, long noteId) {
             /**
-             * Check for safety
+             * 检查参数安全
              */
             if (noteId <= 0) {
                 throw new IllegalArgumentException("Wrong note id:" + noteId);