Update Note.java

xiaomi/src/model/Note.java

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
+// 定义包名，表示该类属于 net.micode.notes.model 包
 package net.micode.notes.model;
+
+// 导入 Android 系统提供的相关类
 import android.content.ContentProviderOperation;
 import android.content.ContentProviderResult;
 import android.content.ContentUris;
@@ -25,33 +28,45 @@ import android.net.Uri;
 import android.os.RemoteException;
 import android.util.Log;
 
+// 导入自定义的 Notes 数据模型类
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.CallNote;
 import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.Notes.TextNote;
 
+// 导入 Java 的 ArrayList 类，用于批量操作
 import java.util.ArrayList;
 
-
+// 定义一个名为 Note 的类，用于表示一个笔记对象
 public class Note {
+    // 用于存储笔记的修改值
     private ContentValues mNoteDiffValues;
+    // 用于存储笔记的详细数据（如文本数据、通话数据等）
     private NoteData mNoteData;
+    // 定义日志标签，用于打印日志信息
     private static final String TAG = "Note";
+
     /**
-     * Create a new note id for adding a new note to databases
+     * 静态方法：创建一个新的笔记 ID，用于在数据库中添加新笔记
+     * @param context 应用程序上下文
+     * @param folderId 父文件夹的 ID
+     * @return 新创建的笔记 ID
      */
     public static synchronized long getNewNoteId(Context context, long folderId) {
-        // Create a new note in the database
+        // 创建一个 ContentValues 对象，用于存储笔记的初始值
         ContentValues values = new ContentValues();
+        // 获取当前时间戳，作为笔记的创建时间和修改时间
         long createdTime = System.currentTimeMillis();
         values.put(NoteColumns.CREATED_DATE, createdTime);
         values.put(NoteColumns.MODIFIED_DATE, createdTime);
-        values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+        values.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 设置笔记类型为普通笔记
-        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+        values.put(NoteColumns.LOCAL_MODIFIED, 1); // 标记为本地已修改
-        values.put(NoteColumns.PARENT_ID, folderId);
+        values.put(NoteColumns.PARENT_ID, folderId); // 设置父文件夹 ID
+        // 向数据库插入新笔记，并获取返回的 Uri
         Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
 
+        // 从 Uri 中解析新笔记的 ID
         long noteId = 0;
         try {
             noteId = Long.valueOf(uri.getPathSegments().get(1));
@@ -59,88 +74,129 @@ public class Note {
             Log.e(TAG, "Get note id error :" + e.toString());
             noteId = 0;
         }
+        // 如果笔记 ID 为 -1，抛出异常
         if (noteId == -1) {
             throw new IllegalStateException("Wrong note id:" + noteId);
         }
         return noteId;
     }
 
+    // 构造方法，初始化 Note 对象
     public Note() {
         mNoteDiffValues = new ContentValues();
         mNoteData = new NoteData();
     }
 
+    /**
+     * 设置笔记的某个字段值
+     * @param key 字段名称
+     * @param value 字段值
+     */
     public void setNoteValue(String key, String value) {
-        mNoteDiffValues.put(key, value);
+        mNoteDiffValues.put(key, value); // 将字段值存储到 mNoteDiffValues 中
-        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); // 标记为本地已修改
-        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); // 更新修改时间
     }
 
+    /**
+     * 设置笔记的文本数据
+     * @param key 字段名称
+     * @param value 字段值
+     */
     public void setTextData(String key, String value) {
-        mNoteData.setTextData(key, value);
+        mNoteData.setTextData(key, value); // 调用 NoteData 的 setTextData 方法
     }
 
+    /**
+     * 设置笔记的文本数据 ID
+     * @param id 文本数据的 ID
+     */
     public void setTextDataId(long id) {
-        mNoteData.setTextDataId(id);
+        mNoteData.setTextDataId(id); // 调用 NoteData 的 setTextDataId 方法
     }
 
+    /**
+     * 获取笔记的文本数据 ID
+     * @return 文本数据的 ID
+     */
     public long getTextDataId() {
-        return mNoteData.mTextDataId;
+        return mNoteData.mTextDataId; // 返回 NoteData 中的文本数据 ID
     }
 
+    /**
+     * 设置笔记的通话数据 ID
+     * @param id 通话数据的 ID
+     */
     public void setCallDataId(long id) {
-        mNoteData.setCallDataId(id);
+        mNoteData.setCallDataId(id); // 调用 NoteData 的 setCallDataId 方法
     }
 
+    /**
+     * 设置笔记的通话数据
+     * @param key 字段名称
+     * @param value 字段值
+     */
     public void setCallData(String key, String value) {
-        mNoteData.setCallData(key, value);
+        mNoteData.setCallData(key, value); // 调用 NoteData 的 setCallData 方法
     }
 
+    /**
+     * 检查笔记是否本地已修改
+     * @return 如果笔记有本地修改，则返回 true
+     */
     public boolean isLocalModified() {
-        return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
+        return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified(); // 检查 mNoteDiffValues 或 NoteData 是否有修改
     }
 
+    /**
+     * 同步笔记到数据库
+     * @param context 应用程序上下文
+     * @param noteId 笔记的 ID
+     * @return 如果同步成功，则返回 true
+     */
     public boolean syncNote(Context context, long noteId) {
+        // 检查笔记 ID 是否有效
         if (noteId <= 0) {
             throw new IllegalArgumentException("Wrong note id:" + noteId);
         }
 
+        // 如果笔记没有本地修改，则直接返回 true
         if (!isLocalModified()) {
             return true;
         }
 
-        /**
+        // 更新笔记的基本信息
-         * 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
-         */
         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();
+        mNoteDiffValues.clear(); // 清空 mNoteDiffValues
 
+        // 更新笔记的详细数据
         if (mNoteData.isLocalModified()
                 && (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
-            return false;
+            return false; // 如果笔记数据更新失败，则返回 false
         }
 
-        return true;
+        return true; // 同步成功
     }
 
+    // 定义一个内部类 NoteData，用于存储笔记的详细数据
     private class NoteData {
+        // 文本数据的 ID
         private long mTextDataId;
-
+        // 存储文本数据的 ContentValues 对象
         private ContentValues mTextDataValues;
-
+        // 通话数据的 ID
         private long mCallDataId;
-
+        // 存储通话数据的 ContentValues 对象
         private ContentValues mCallDataValues;
-
+        // 定义日志标签
         private static final String TAG = "NoteData";
 
+        // 构造方法，初始化 NoteData 对象
         public NoteData() {
             mTextDataValues = new ContentValues();
             mCallDataValues = new ContentValues();
@@ -148,106 +204,177 @@ public class Note {
             mCallDataId = 0;
         }
 
+        /**
+         * 检查笔记数据是否本地已修改
+         * @return 如果笔记数据有本地修改，则返回 true
+         */
         boolean isLocalModified() {
-            return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
+            return mTextDataValues.size() > 0 || mCallDataValues.size() > 0; // 检查文本数据或通话数据是否有修改
         }
 
+        /**
+         * 设置文本数据的 ID
+         * @param id 文本数据的 ID
+         */
         void setTextDataId(long id) {
             if(id <= 0) {
                 throw new IllegalArgumentException("Text data id should larger than 0");
             }
-            mTextDataId = id;
+            mTextDataId = id; // 设置文本数据的 ID
         }
 
+        /**
+         * 设置通话数据的 ID
+         * @param id 通话数据的 ID
+         */
         void setCallDataId(long id) {
             if (id <= 0) {
                 throw new IllegalArgumentException("Call data id should larger than 0");
             }
-            mCallDataId = id;
+            mCallDataId = id; // 设置通话数据的 ID
         }
 
+        /**
+         * 设置通话数据
+         * @param key 字段名称
+         * @param value 字段值
+         */
         void setCallData(String key, String value) {
-            mCallDataValues.put(key, value);
+            mCallDataValues.put(key, value); // 将通话数据存储到 mCallDataValues 中
-            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); // 标记为本地已修改
-            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); // 更新修改时间
         }
 
-        void setTextData(String key, String value) {
+        /**
-            mTextDataValues.put(key, value);
+         * 设置文本数据
-            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+         * @param key 字段名称
-            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+         * @param value 字段值
-        }
+         */
+        // 定义一个内部类 NoteData，用于存储笔记的详细数据
+private class NoteData {
+    // 文本数据的 ID
+    private long mTextDataId;
+    // 存储文本数据的 ContentValues 对象
+    private ContentValues mTextDataValues;
+    // 通话数据的 ID
+    private long mCallDataId;
+    // 存储通话数据的 ContentValues 对象
+    private ContentValues mCallDataValues;
+    // 定义日志标签
+    private static final String TAG = "NoteData";
+
+    // 构造方法，初始化 NoteData 对象
+    public NoteData() {
+        mTextDataValues = new ContentValues();
+        mCallDataValues = new ContentValues();
+        mTextDataId = 0;
+        mCallDataId = 0;
+    }
 
-        Uri pushIntoContentResolver(Context context, long noteId) {
+    /**
-            /**
+     * 设置文本数据
-             * Check for safety
+     * @param key 字段名称
-             */
+     * @param value 字段值
-            if (noteId <= 0) {
+     */
-                throw new IllegalArgumentException("Wrong note id:" + noteId);
+    void setTextData(String key, String value) {
-            }
+        mTextDataValues.put(key, value); // 将文本数据存储到 mTextDataValues 中
+        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); // 标记笔记为本地已修改
+        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); // 更新笔记的修改时间
+    }
 
-            ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+    /**
-            ContentProviderOperation.Builder builder = null;
+     * 设置通话数据
-
+     * @param key 字段名称
-            if(mTextDataValues.size() > 0) {
+     * @param value 字段值
-                mTextDataValues.put(DataColumns.NOTE_ID, noteId);
+     */
-                if (mTextDataId == 0) {
+    void setCallData(String key, String value) {
-                    mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
+        mCallDataValues.put(key, value); // 将通话数据存储到 mCallDataValues 中
-                    Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
+        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); // 标记笔记为本地已修改
-                            mTextDataValues);
+        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); // 更新笔记的修改时间
-                    try {
+    }
-                        setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));
+
-                    } catch (NumberFormatException e) {
+    /**
-                        Log.e(TAG, "Insert new text data fail with noteId" + noteId);
+     * 将笔记数据同步到 ContentResolver
-                        mTextDataValues.clear();
+     * @param context 应用程序上下文
-                        return null;
+     * @param noteId 笔记的 ID
-                    }
+     * @return 如果同步成功，返回笔记的 Uri；否则返回 null
-                } else {
+     */
-                    builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+    Uri pushIntoContentResolver(Context context, long noteId) {
-                            Notes.CONTENT_DATA_URI, mTextDataId));
+        /**
-                    builder.withValues(mTextDataValues);
+         * 检查安全性
-                    operationList.add(builder.build());
+         */
-                }
+        if (noteId <= 0) {
-                mTextDataValues.clear();
+            throw new IllegalArgumentException("Wrong note id:" + noteId); // 检查笔记 ID 是否有效
-            }
+        }
 
-            if(mCallDataValues.size() > 0) {
+        // 创建一个操作列表，用于批量更新数据
-                mCallDataValues.put(DataColumns.NOTE_ID, noteId);
+        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
-                if (mCallDataId == 0) {
+        ContentProviderOperation.Builder builder = null; // 构造器，用于构建操作对象
-                    mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
+
-                    Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
+        // 处理文本数据
-                            mCallDataValues);
+        if(mTextDataValues.size() > 0) {
-                    try {
+            mTextDataValues.put(DataColumns.NOTE_ID, noteId); // 将笔记 ID 添加到文本数据中
-                        setCallDataId(Long.valueOf(uri.getPathSegments().get(1)));
+            if (mTextDataId == 0) {
-                    } catch (NumberFormatException e) {
+                // 如果文本数据 ID 为 0，表示需要插入新数据
-                        Log.e(TAG, "Insert new call data fail with noteId" + noteId);
+                mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE); // 设置 MIME 类型为文本笔记
-                        mCallDataValues.clear();
+                Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI, mTextDataValues); // 插入新数据
-                        return null;
+                try {
-                    }
+                    setTextDataId(Long.valueOf(uri.getPathSegments().get(1))); // 获取新插入数据的 ID
-                } else {
+                } catch (NumberFormatException e) {
-                    builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+                    Log.e(TAG, "Insert new text data fail with noteId" + noteId); // 如果获取 ID 失败，记录日志
-                            Notes.CONTENT_DATA_URI, mCallDataId));
+                    mTextDataValues.clear(); // 清空文本数据
-                    builder.withValues(mCallDataValues);
+                    return null; // 返回 null
-                    operationList.add(builder.build());
                 }
-                mCallDataValues.clear();
+            } else {
+                // 如果文本数据 ID 不为 0，表示需要更新现有数据
+                builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+                        Notes.CONTENT_DATA_URI, mTextDataId)); // 构建更新操作
+                builder.withValues(mTextDataValues); // 设置更新的值
+                operationList.add(builder.build()); // 将操作添加到操作列表
             }
+            mTextDataValues.clear(); // 清空文本数据
+        }
 
-            if (operationList.size() > 0) {
+        // 处理通话数据
+        if(mCallDataValues.size() > 0) {
+            mCallDataValues.put(DataColumns.NOTE_ID, noteId); // 将笔记 ID 添加到通话数据中
+            if (mCallDataId == 0) {
+                // 如果通话数据 ID 为 0，表示需要插入新数据
+                mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE); // 设置 MIME 类型为通话笔记
+                Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI, mCallDataValues); // 插入新数据
                 try {
-                    ContentProviderResult[] results = context.getContentResolver().applyBatch(
+                    setCallDataId(Long.valueOf(uri.getPathSegments().get(1))); // 获取新插入数据的 ID
-                            Notes.AUTHORITY, operationList);
+                } catch (NumberFormatException e) {
-                    return (results == null || results.length == 0 || results[0] == null) ? null
+                    Log.e(TAG, "Insert new call data fail with noteId" + noteId); // 如果获取 ID 失败，记录日志
-                            : ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId);
+                    mCallDataValues.clear(); // 清空通话数据
-                } catch (RemoteException e) {
+                    return null; // 返回 null
-                    Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
-                    return null;
-                } catch (OperationApplicationException e) {
-                    Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
-                    return null;
                 }
+            } else {
+                // 如果通话数据 ID 不为 0，表示需要更新现有数据
+                builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+                        Notes.CONTENT_DATA_URI, mCallDataId)); // 构建更新操作
+                builder.withValues(mCallDataValues); // 设置更新的值
+                operationList.add(builder.build()); // 将操作添加到操作列表
+            }
+            mCallDataValues.clear(); // 清空通话数据
+        }
+
+        // 如果操作列表中有操作，执行批量更新
+        if (operationList.size() > 0) {
+            try {
+                ContentProviderResult[] results = context.getContentResolver().applyBatch(
+                        Notes.AUTHORITY, operationList); // 执行批量更新
+                // 如果更新成功，返回笔记的 Uri；否则返回 null
+                return (results == null || results.length == 0 || results[0] == null) ? null
+                        : ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId);
+            } catch (RemoteException e) {
+                Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage())); // 记录远程异常
+                return null;
+            } catch (OperationApplicationException e) {
+                Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage())); // 记录操作应用异常
+                return null;
             }
-            return null;
         }
+        return null; // 如果没有操作，返回 null
     }
 }