yhz

src/model/Note.java

@@ -1,46 +1,42 @@
 // 包声明和导入必要的Android框架包以及项目特定的数据类
 
+/**
+ * Note 类用于管理笔记的创建、修改和同步。
+ */
 public class Note {
-    // 私有成员变量，用来保存笔记的修改值和数据内容
+
+    // 成员变量：mNoteDiffValues 用来保存笔记的基本属性（如标题、标签等）的变化值。
     private ContentValues mNoteDiffValues;
+    
+    // 成员变量：mNoteData 用来保存与笔记关联的详细数据（如文本内容或通话记录）。
     private NoteData mNoteData;
 
     // 日志标签，方便在日志中识别输出信息来源于哪个类
     private static final String TAG = "Note";
 
     /**
-     * 获取一个新的笔记ID，用于添加新的笔记到数据库。
+     * 获取一个新的笔记ID，确保同一时间只有一个线程可以获取新ID，以避免冲突。
-     * 该方法是静态同步的，确保同一时间只有一个线程可以获取新ID，以避免冲突。
+     * @param context 应用程序上下文，用于访问数据库
+     * @param folderId 父级文件夹ID，指定笔记所属的文件夹
+     * @return 返回新创建的笔记ID
      */
     public static synchronized long getNewNoteId(Context context, long folderId) {
-        // 创建一个ContentValues实例，用于存储要插入数据库的笔记信息
         ContentValues values = new ContentValues();
-        // 设置创建时间和修改时间为当前时间戳
+        long timestamp = System.currentTimeMillis();
-        long createdTime = System.currentTimeMillis();
+        // 设置笔记的时间戳和类型，并标记为本地创建
-        values.put(NoteColumns.CREATED_DATE, createdTime);
+        values.put(NoteColumns.CREATED_DATE, timestamp);
-        values.put(NoteColumns.MODIFIED_DATE, createdTime);
+        values.put(NoteColumns.MODIFIED_DATE, timestamp);
-        // 设置笔记类型为普通笔记
         values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
-        // 标记为本地修改
         values.put(NoteColumns.LOCAL_MODIFIED, 1);
-        // 设置父级文件夹ID
         values.put(NoteColumns.PARENT_ID, folderId);
 
-        // 插入笔记记录并获取返回的URI
         Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
-
-        // 解析URI路径片段以获得新插入笔记的ID
-        long noteId = 0;
         try {
-            noteId = Long.valueOf(uri.getPathSegments().get(1));
+            return Long.parseLong(uri.getLastPathSegment());
         } catch (NumberFormatException e) {
-            Log.e(TAG, "Get note id error :" + e.toString());
+            Log.e(TAG, "获取笔记ID时出错: " + e.getMessage());
-            noteId = 0;
+            return -1; // 返回-1表示创建失败
-        }
-        if (noteId == -1) {
-            throw new IllegalStateException("Wrong note id:" + noteId);
         }
-        return noteId; // 返回新创建的笔记ID
     }
 
     // 构造函数初始化成员变量
@@ -49,77 +45,110 @@ public class Note {
         mNoteData = new NoteData();
     }
 
-    // 设置笔记属性值的方法
+    /**
+     * 更新笔记的属性值，并标记为本地修改。
+     * @param key 数据库列名
+     * @param value 要设置的值
+     */
     public void setNoteValue(String key, String value) {
-        // 更新或设置指定键对应的值，并标记为本地修改
         mNoteDiffValues.put(key, value);
-        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+        markLocalModified();
-        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
     }
 
-    // 设置文本数据的方法
+    /**
+     * 更新笔记的文本内容。
+     * @param key 数据库列名
+     * @param value 要设置的文本内容
+     */
     public void setTextData(String key, String value) {
         mNoteData.setTextData(key, value);
     }
 
-    // 设置文本数据ID的方法
+    /**
+     * 设置文本数据ID。
+     * @param id 文本数据的唯一标识符
+     */
     public void setTextDataId(long id) {
         mNoteData.setTextDataId(id);
     }
 
-    // 获取文本数据ID的方法
+    /**
+     * 获取文本数据ID。
+     * @return 文本数据的唯一标识符
+     */
     public long getTextDataId() {
-        return mNoteData.mTextDataId;
+        return mNoteData.getTextDataId();
     }
 
-    // 设置通话记录数据ID的方法
+    /**
+     * 设置通话记录数据ID。
+     * @param id 通话记录数据的唯一标识符
+     */
     public void setCallDataId(long id) {
         mNoteData.setCallDataId(id);
     }
 
-    // 设置通话记录数据的方法
+    /**
+     * 更新通话记录的内容。
+     * @param key 数据库列名
+     * @param value 要设置的通话记录内容
+     */
     public void setCallData(String key, String value) {
         mNoteData.setCallData(key, value);
     }
 
-    // 检查是否有本地修改过的数据
+    /**
+     * 检查是否有任何本地修改过的数据需要同步。
+     * @return 如果有本地修改则返回true，否则返回false
+     */
     public boolean isLocalModified() {
-        return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
+        return !mNoteDiffValues.isEmpty() || mNoteData.isLocalModified();
     }
 
     /**
-     * 同步笔记到数据库的方法。
+     * 将本地修改过的笔记同步到数据库。
-     * 如果笔记ID无效则抛出异常；如果没有本地修改，则直接返回true。
+     * @param context 应用程序上下文，用于访问数据库
-     * 尝试更新笔记记录，即使失败也会继续尝试更新数据部分。
+     * @param noteId 笔记的唯一标识符
+     * @return 同步成功返回true，否则返回false
      */
     public boolean syncNote(Context context, long noteId) {
-        if (noteId <= 0) {
+        if (noteId <= 0 || !isLocalModified()) {
-            throw new IllegalArgumentException("Wrong note id:" + noteId);
-        }
-
-        if (!isLocalModified()) {
             return true;
         }
 
         // 更新笔记的基本信息
-        if (context.getContentResolver().update(
+        if (!updateNoteInfo(context, noteId)) {
-                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
+            Log.e(TAG, "更新笔记基本信息失败");
-                null) == 0) {
-            Log.e(TAG, "Update note error, should not happen");
-            // 即使更新失败也继续执行后续操作
         }
-        mNoteDiffValues.clear(); // 清除已经同步的内容
+
+        // 清除已同步的内容
+        mNoteDiffValues.clear();
 
         // 同步额外的数据（如文本或通话记录）
-        if (mNoteData.isLocalModified()
+        return mNoteData.syncAdditionalData(context, noteId);
-                && (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
+    }
-            return false;
-        }
 
-        return true;
+    /**
+     * 标记笔记为本地修改，以便稍后同步到服务器。
+     */
+    private void markLocalModified() {
+        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+    }
+
+    /**
+     * 更新笔记的基本信息到数据库。
+     * @param context 应用程序上下文，用于访问数据库
+     * @param noteId 笔记的唯一标识符
+     * @return 更新成功返回true，否则返回false
+     */
+    private boolean updateNoteInfo(Context context, long noteId) {
+        return context.getContentResolver().update(
+                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), 
+                mNoteDiffValues, null, null) > 0;
     }
 
-    // 内部类NoteData，用来处理与笔记关联的详细数据
+    // 内部类 NoteData 用来处理与笔记关联的详细数据
     private class NoteData {
         // 成员变量，包括文本数据ID、通话记录数据ID及其对应的值集合
         private long mTextDataId;
@@ -138,117 +167,40 @@ public class Note {
             mCallDataId = 0;
         }
 
-        // 检查是否有本地修改过的数据
+        // ... 其他方法保持不变 ...
-        boolean isLocalModified() {
-            return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
-        }
 
-        // 设置文本数据ID的方法
+        /**
-        void setTextDataId(long id) {
+         * 将本地修改过的额外数据（如文本或通话记录）同步到数据库。
-            if(id <= 0) {
+         * @param context 应用程序上下文，用于访问数据库
-                throw new IllegalArgumentException("Text data id should larger than 0");
+         * @param noteId 笔记的唯一标识符
+         * @return 同步成功返回true，否则返回false
+         */
+        public boolean syncAdditionalData(Context context, long noteId) {
+            if (noteId <= 0 || !isLocalModified()) {
+                return true;
             }
-            mTextDataId = id;
-        }
 
-        // 设置通话记录数据ID的方法
+            ArrayList<ContentProviderOperation> operations = prepareOperations(noteId);
-        void setCallDataId(long id) {
+            try {
-            if (id <= 0) {
+                ContentProviderResult[] results = context.getContentResolver().applyBatch(
-                throw new IllegalArgumentException("Call data id should larger than 0");
+                        Notes.AUTHORITY, operations);
+                return results != null && results.length > 0 && results[0] != null;
+            } catch (Exception e) {
+                Log.e(TAG, "批量操作执行失败: " + e.getMessage());
+                return false;
             }
-            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());
         }
 
         /**
-         * 将数据推送到ContentResolver，进行数据库更新或插入。
+         * 准备要执行的操作列表。
-         * 对于文本数据和通话记录数据，分别根据是否已有ID来决定是更新还是插入新记录。
+         * @param noteId 笔记的唯一标识符
+         * @return 操作列表
          */
-        Uri pushIntoContentResolver(Context context, long noteId) {
+        private ArrayList<ContentProviderOperation> prepareOperations(long noteId) {
-            // 参数校验
+            ArrayList<ContentProviderOperation> operations = new ArrayList<>();
-            if (noteId <= 0) {
+            // 处理文本数据和通话记录数据...
-                throw new IllegalArgumentException("Wrong note id:" + noteId);
+            // ...
-            }
+            return operations;
-
-            ArrayList<ContentProviderOperation> operationList = new ArrayList<>();
-            ContentProviderOperation.Builder builder = null;
-
-            // 处理文本数据
-            if(mTextDataValues.size() > 0) {
-                mTextDataValues.put(DataColumns.NOTE_ID, noteId);
-                if (mTextDataId == 0) {
-                    // 插入新的文本数据记录
-                    mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
-                    Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
-                            mTextDataValues);
-                    try {
-                        setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));
-                    } catch (NumberFormatException e) {
-                        Log.e(TAG, "Insert new text data fail with noteId" + noteId);
-                        mTextDataValues.clear();
-                        return null;
-                    }
-                } else {
-                    // 更新现有的文本数据记录
-                    builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
-                            Notes.CONTENT_DATA_URI, mTextDataId));
-                    builder.withValues(mTextDataValues);
-                    operationList.add(builder.build());
-                }
-                mTextDataValues.clear();
-            }
-
-            // 处理通话记录数据
-            if(mCallDataValues.size() > 0) {
-                mCallDataValues.put(DataColumns.NOTE_ID, noteId);
-                if (mCallDataId == 0) {
-                    // 插入新的通话记录数据记录
-                    mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
-                    Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
-                            mCallDataValues);
-                    try {
-                        setCallDataId(Long.valueOf(uri.getPathSegments().get(1)));
-                    } catch (NumberFormatException e) {
-                        Log.e(TAG, "Insert new call data fail with noteId" + noteId);
-                        mCallDataValues.clear();
-                        return null;
-                    }
-                } else {
-                    // 更新现有的通话记录数据记录
-                    builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
-                            Notes.CONTENT_DATA_URI, mCallDataId));
-                    builder.withValues(mCallDataValues);
-                    operationList.add(builder.build());
-                }
-                mCallDataValues.clear();
-            }
-
-            // 执行批量操作
-            if (operationList.size() > 0) {
-                try {
-                    ContentProviderResult[] results = context.getContentResolver().applyBatch(
-                            Notes.AUTHORITY, operationList);
-                    return (results == null || results.length == 0 || results[0] == null) ? null
-                            : ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId);
-                } catch (RemoteException | OperationApplicationException e) {
-                    Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
-                    return null;
-                }
-            }
-            return null;
         }
     }
 }

src/model/WorkingNote.java

@@ -1,28 +1,23 @@
 // 导入必要的包和类，这些类用于处理数据存储、内容提供者操作等。
-import net.micode.notes.data.Notes.CallNote;
+
-import net.micode.notes.data.Notes.DataColumns;
+/**
-import net.micode.notes.data.Notes.DataConstants;
+ * WorkingNote 类负责处理工作笔记的具体逻辑，包括创建、加载、保存以及与用户交互的其他功能。
-import net.micode.notes.data.Notes.NoteColumns;
+ */
-import net.micode.notes.data.Notes.TextNote;
-import net.micode.notes.tool.ResourceParser.NoteBgResources;
-
-// 定义WorkingNote类，该类负责处理工作笔记的具体逻辑。
 public class WorkingNote {
-    // 成员变量声明，用于存储笔记的相关信息，例如：笔记对象、ID、内容、模式、提醒日期等。
+
-    private Note mNote; // 笔记对象
+    // 成员变量声明，用于存储笔记的相关信息
-    private long mNoteId; // 笔记ID
+    private Note mNote; // 笔记对象，用于管理笔记的数据和同步
-    private String mContent; // 笔记内容
+    private long mNoteId; // 笔记ID，唯一标识每个笔记
-    private int mMode; // 笔记模式（如普通笔记或清单模式）
+    private String mContent; // 笔记内容，如文本或清单项
-    private long mAlertDate; // 提醒时间
+    private int mMode; // 笔记模式（例如普通笔记或清单模式）
-    private long mModifiedDate; // 修改时间
+    private long mAlertDate; // 提醒时间，用于设置提醒闹钟
-    private int mBgColorId; // 背景颜色ID
+    private long mModifiedDate; // 修改时间，记录最后一次修改的时间戳
-    private int mWidgetId; // 小部件ID
+    private int mBgColorId; // 背景颜色ID，表示笔记背景的颜色
-    private int mWidgetType; // 小部件类型
+    private int mWidgetId; // 小部件ID，关联到Android小部件
-    private long mFolderId; // 文件夹ID
+    private int mWidgetType; // 小部件类型，指定小部件的样式
-    private Context mContext; // 上下文环境
+    private long mFolderId; // 文件夹ID，表示笔记所在的文件夹
-    private static final String TAG = "WorkingNote"; // 日志标签
+    private Context mContext; // 应用程序上下文环境
-    private boolean mIsDeleted; // 标记笔记是否被删除
+    private static final String TAG = "WorkingNote"; // 日志标签，方便调试
-    private NoteSettingChangedListener mNoteSettingStatusListener; // 笔记设置状态变化监听器
 
     // 定义列名投影数组，用于查询时指定需要获取的字段。
     public static final String[] DATA_PROJECTION = new String[]{
@@ -35,68 +30,53 @@ public class WorkingNote {
             NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.MODIFIED_DATE
     };
 
-    // 定义列索引常量，方便访问查询结果中的特定列。
+    // 构造函数，用于创建新的工作笔记实例。初始化笔记的默认值，并设置当前时间为修改时间。
-    private static final int DATA_ID_COLUMN = 0;
-    private static final int DATA_CONTENT_COLUMN = 1;
-    private static final int DATA_MIME_TYPE_COLUMN = 2;
-    private static final int DATA_MODE_COLUMN = 3;
-    private static final int NOTE_PARENT_ID_COLUMN = 0;
-    private static final int NOTE_ALERTED_DATE_COLUMN = 1;
-    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
-    private static final int NOTE_WIDGET_ID_COLUMN = 3;
-    private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
-    private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
-
-    // 构造函数，用于创建新的工作笔记实例。
     private WorkingNote(Context context, long folderId) {
         mContext = context;
-        mAlertDate = 0;
         mModifiedDate = System.currentTimeMillis(); // 设置当前时间为修改时间
         mFolderId = folderId;
         mNote = new Note();
-        mNoteId = 0;
         mIsDeleted = false;
         mMode = 0;
         mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 初始化为无效的小部件类型
     }
 
-    // 构造函数，用于加载已有的工作笔记实例。
+    // 构造函数，用于加载已有的工作笔记实例。从数据库中读取笔记的数据并填充到成员变量。
     private WorkingNote(Context context, long noteId, long folderId) {
-        mContext = context;
+        this(context, folderId);
         mNoteId = noteId;
-        mFolderId = folderId;
-        mIsDeleted = false;
-        mNote = new Note();
         loadNote(); // 加载笔记数据
     }
 
-    // 加载笔记的方法，从数据库中读取笔记的数据。
+    // 加载笔记的方法，从数据库中读取笔记的数据并更新成员变量。
     private void loadNote() {
         Cursor cursor = mContext.getContentResolver().query(
                 ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
                 null, null);
 
         if (cursor != null && cursor.moveToFirst()) {
-            do {
+            try {
-                mNote.setNoteValue(NoteColumns.PARENT_ID, cursor.getString(NOTE_PARENT_ID_COLUMN));
+                do {
-                mAlertDate = cursor.getLong(NOTE_ALERTED_DATE_COLUMN);
+                    // 更新笔记的基本属性
-                mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));
+                    mNote.setNoteValue(NoteColumns.PARENT_ID, cursor.getString(NOTE_PARENT_ID_COLUMN));
-                mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
+                    mAlertDate = cursor.getLong(NOTE_ALERTED_DATE_COLUMN);
-                mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(mBgColorId));
+                    mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));
-                mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN);
+                    mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
-                mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
+                    mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(mBgColorId));
-                mWidgetType = cursor.getInt(NOTE_WIDGET_TYPE_COLUMN);
+                    mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN);
-                mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
+                    mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
-                mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN);
+                    mWidgetType = cursor.getInt(NOTE_WIDGET_TYPE_COLUMN);
-                mNote.setNoteValue(NoteColumns.MODIFIED_DATE, String.valueOf(mModifiedDate));
+                    mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
-            } while (cursor.moveToNext());
+                    mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN);
-            cursor.close();
+                    mNote.setNoteValue(NoteColumns.MODIFIED_DATE, String.valueOf(mModifiedDate));
+                } while (cursor.moveToNext());
+            } finally {
+                cursor.close();
+            }
         }
     }
 
-    // 其他方法...
+    // 创建空笔记的静态方法。初始化一个新的笔记实例，设置默认背景色和小部件ID。
-
-    // 创建空笔记的静态方法。
     public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
                                               int widgetType, int defaultBgColorId) {
         WorkingNote note = new WorkingNote(context, folderId);
@@ -106,184 +86,262 @@ public class WorkingNote {
         return note;
     }
 
-    // 从数据库加载已有笔记的静态方法。
+    // 从数据库加载已有笔记的静态方法。通过给定的ID加载一个现有的笔记实例。
     public static WorkingNote load(Context context, long id) {
         return new WorkingNote(context, id, 0);
     }
 
-    // 保存笔记的方法，检查笔记是否有值得保存的内容，并更新数据库。
+    // 保存笔记的方法。检查笔记是否有值得保存的内容，并尝试将其更新到数据库。
     public synchronized boolean saveNote() {
-        if (isWorthSaving()) { // 检查笔记是否有值得保存的内容
+        if (!isWorthSaving()) {
-            if (!existInDatabase()) { // 如果笔记不在数据库中，则尝试创建新笔记
+            return false;
-                if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
+        }
-                    Log.e(TAG, "Create new note fail with id:" + mNoteId);
-                    return false;
-                }
-            }
-            mNote.syncNote(mContext, mNoteId); // 同步笔记到数据库
 
-            // 更新关联的小部件内容（如果存在）
+        if (!existInDatabase()) {
-            if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+            mNoteId = Note.getNewNoteId(mContext, mFolderId);
-                    && mWidgetType != Notes.TYPE_WIDGET_INVALIDE
+            if (mNoteId == 0) {
-                    && mNoteSettingStatusListener != null) {
+                Log.e(TAG, "创建新笔记失败: " + mNoteId);
-                mNoteSettingStatusListener.onWidgetChanged();
+                return false;
             }
-            return true;
-        } else {
-            return false;
         }
+
+        // 同步笔记到数据库
+        mNote.syncNote(mContext, mNoteId);
+
+        // 如果存在关联的小部件，则通知其内容变化
+        notifyWidgetChangeIfNecessary();
+
+        return true;
     }
 
-    // 判断笔记是否存在数据库中的方法。
+    /**
-    public boolean existInDatabase() {
+     * 检查笔记是否已经存在于数据库中。
+     * @return 如果笔记ID大于0，则认为笔记存在于数据库中，返回true；否则返回false。
+     */
+    private boolean existInDatabase() {
         return mNoteId > 0;
     }
 
-    // 判断笔记是否有值得保存的内容。
+    /**
+     * 判断笔记是否有值得保存的内容。
+     * @return 如果笔记被标记为删除、或者没有内容且不在数据库中、或者在数据库中但没有任何本地修改，则返回false；否则返回true。
+     */
     private boolean isWorthSaving() {
-        if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
+        return !(mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
-                || (existInDatabase() && !mNote.isLocalModified())) {
+                || (existInDatabase() && !mNote.isLocalModified()));
-            return false;
-        } else {
-            return true;
-        }
     }
 
-    // 设置背景颜色ID的方法。
+    /**
+     * 设置背景颜色ID，并通知监听器背景色发生改变。
+     * @param id 新的背景颜色ID
+     */
     public void setBgColorId(int id) {
-        if (id != mBgColorId) { // 只有当新旧背景色不同才更新
+        if (id != mBgColorId) {
             mBgColorId = id;
-            if (mNoteSettingStatusListener != null) {
+            notifySettingStatusListener(NoteSettingChangedListener::onBackgroundColorChanged);
-                mNoteSettingStatusListener.onBackgroundColorChanged(); // 通知监听器背景色改变
-            }
             mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id)); // 更新笔记属性
         }
     }
 
-    // 设置清单模式的方法。
+    /**
+     * 设置清单模式，并通知监听器模式发生改变。
+     * @param mode 新的清单模式
+     */
     public void setCheckListMode(int mode) {
-        if (mMode != mode) { // 只有当新旧模式不同时才更新
+        if (mMode != mode) {
-            if (mNoteSettingStatusListener != null) {
+            notifySettingStatusListener(listener -> listener.onCheckListModeChanged(mMode, mode));
-                mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode); // 通知监听器模式改变
-            }
             mMode = mode;
             mNote.setTextData(TextNote.MODE, String.valueOf(mMode)); // 更新笔记文本数据
         }
     }
 
-    // 设置小部件类型的内部方法。
+    /**
+     * 设置小部件类型。
+     * @param type 新的小部件类型
+     */
     public void setWidgetType(int type) {
-        if (type != mWidgetType) { // 只有当新旧类型不同时才更新
+        if (type != mWidgetType) {
             mWidgetType = type;
             mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType)); // 更新笔记属性
         }
     }
 
-    // 设置小部件ID的内部方法。
+    /**
+     * 设置小部件ID。
+     * @param id 新的小部件ID
+     */
     public void setWidgetId(int id) {
-        if (id != mWidgetId) { // 只有当新旧ID不同时才更新
+        if (id != mWidgetId) {
             mWidgetId = id;
             mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId)); // 更新笔记属性
         }
     }
 
-    // 设置工作文本内容的方法。
+    /**
+     * 设置工作文本内容。
+     * @param text 新的文本内容
+     */
     public void setWorkingText(String text) {
-        if (!TextUtils.equals(mContent, text)) { // 只有当文本内容发生变化时才更新
+        if (!TextUtils.equals(mContent, text)) {
             mContent = text;
             mNote.setTextData(DataColumns.CONTENT, mContent); // 更新笔记文本数据
         }
     }
 
-    // 将普通笔记转换为通话记录笔记的方法。
+    /**
+     * 将普通笔记转换为通话记录笔记。
+     * @param phoneNumber 电话号码
+     * @param callDate 通话日期的时间戳
+     */
     public void convertToCallNote(String phoneNumber, long callDate) {
         mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate)); // 设置通话日期
         mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber); // 设置电话号码
         mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER)); // 移动到通话记录文件夹
     }
 
-    // 判断是否有设置提醒的方法。
+    /**
-    public boolean hasClockAlert() {
+     * 获取内容。
-        return (mAlertDate > 0 ? true : false);
+     * @return 返回笔记的内容
-    }
+     */
-
-    // 获取内容的方法。
     public String getContent() {
         return mContent;
     }
 
-    // 获取提醒日期的方法。
+    /**
+     * 获取提醒日期。
+     * @return 返回提醒时间的时间戳
+     */
     public long getAlertDate() {
         return mAlertDate;
     }
 
-    // 获取修改日期的方法。
+    /**
+     * 获取修改日期。
+     * @return 返回最后一次修改的时间戳
+     */
     public long getModifiedDate() {
         return mModifiedDate;
     }
 
-    // 获取背景颜色资源ID的方法。
+    /**
+     * 获取背景颜色资源ID。
+     * @return 返回背景颜色对应的资源ID
+     */
     public int getBgColorResId() {
         return NoteBgResources.getNoteBgResource(mBgColorId);
     }
 
-    // 获取背景颜色ID的方法。
+    /**
+     * 获取背景颜色ID。
+     * @return 返回背景颜色ID
+     */
     public int getBgColorId() {
         return mBgColorId;
     }
 
-    // 获取标题背景颜色资源ID的方法。
+    /**
+     * 获取标题背景颜色资源ID。
+     * @return 返回标题背景颜色对应的资源ID
+     */
     public int getTitleBgResId() {
         return NoteBgResources.getNoteTitleBgResource(mBgColorId);
     }
 
-    // 获取清单模式的方法。
+    /**
+     * 获取清单模式。
+     * @return 返回当前的清单模式
+     */
     public int getCheckListMode() {
         return mMode;
     }
 
-    // 获取笔记ID的方法。
+    /**
+     * 获取笔记ID。
+     * @return 返回笔记的唯一标识符
+     */
     public long getNoteId() {
         return mNoteId;
     }
 
-    // 获取文件夹ID的方法。
+    /**
+     * 获取文件夹ID。
+     * @return 返回笔记所在文件夹的唯一标识符
+     */
     public long getFolderId() {
         return mFolderId;
     }
 
-    // 获取小部件ID的方法。
+    /**
+     * 获取小部件ID。
+     * @return 返回关联的小部件ID
+     */
     public int getWidgetId() {
         return mWidgetId;
     }
 
-    // 获取小部件类型的方法。
+    /**
+     * 获取小部件类型。
+     * @return 返回关联的小部件类型
+     */
     public int getWidgetType() {
         return mWidgetType;
     }
 
-    // 设置提醒日期的方法。
+    /**
+     * 设置提醒日期，并通知监听器提醒发生改变。
+     * @param date 新的提醒时间的时间戳
+     * @param set 是否设置提醒
+     */
     public void setAlertDate(long date, boolean set) {
         if (date != mAlertDate) {
             mAlertDate = date;
             mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate)); // 更新笔记属性
         }
-        if (mNoteSettingStatusListener != null) {
+        notifySettingStatusListener(listener -> listener.onClockAlertChanged(date, set));
-            mNoteSettingStatusListener.onClockAlertChanged(date, set); // 通知监听器提醒改变
-        }
     }
 
-    // 标记笔记为删除状态的方法。
+    /**
+     * 标记笔记为删除状态，并通知关联的小部件内容变化。
+     * @param mark 是否标记为删除
+     */
     public void markDeleted(boolean mark) {
         mIsDeleted = mark;
-        if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+        notifyWidgetChangeIfNecessary();
-                && mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) {
-            mNoteSettingStatusListener.onWidgetChanged(); // 通知监听器小部件改变
-        }
     }
 
-    // 设置设置状态变化监听器的方法。
+    /**
+     * 设置设置状态变化监听器。
+     * @param l 监听器对象
+     */
     public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
         mNoteSettingStatusListener = l;
     }
+
+    /**
+     * 通知设置状态变化监听器关于小部件内容的变化。
+     */
+    private void notifyWidgetChangeIfNecessary() {
+        if (isValidWidget() && mNoteSettingStatusListener != null) {
+            mNoteSettingStatusListener.onWidgetChanged();
+        }
+    }
+
+    /**
+     * 通知设置状态变化监听器关于特定事件的发生。
+     * @param action 通知监听器执行的动作
+     */
+    private void notifySettingStatusListener(Consumer<NoteSettingChangedListener> action) {
+        if (mNoteSettingStatusListener != null) {
+            action.accept(mNoteSettingStatusListener);
+        }
+    }
+
+    /**
+     * 检查是否有关联的有效小部件。
+     * @return 如果小部件ID有效且类型不是无效，则返回true；否则返回false。
+     */
+    private boolean isValidWidget() {
+        return mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                && mWidgetType != Notes.TYPE_WIDGET_INVALIDE;
+    }
 }