ADD file via upload

NotesDatabaseHelper.java

@@ -105,7 +105,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
         "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
         "  AND " + NoteColumns.NOTES_COUNT + ">0" + ";" +
-        " END";
+        " END";//在文件夹中移出一个Note之后需要更改的数据的表格。
 
     /**
      * Increase folder's note count when insert new note to the folder

NotesProvider.java

@@ -259,7 +259,6 @@ public class NotesProvider extends ContentProvider {
     @Override
     // 更新一个uri
     public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
-        //这是 ContentProvider 的标准 update 方法签名，用于更新数据库中的记录。
         int count = 0;
         String id = null;
         SQLiteDatabase db = mHelper.getWritableDatabase();
@@ -289,14 +288,13 @@ public class NotesProvider extends ContentProvider {
                 throw new IllegalArgumentException("Unknown URI " + uri);
         }
 
-        if (count > 0) {//: 如果更新操作成功（即有记录被更新），则执行以下操作：
-           // if (updateData): 如果更新了数据字段，则通知内容解析器 Notes.CONTENT_NOTE_URI 发生了变化。
+        if (count > 0) {
             if (updateData) {
-                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);// 通知内容解析器指定的 URI 发生了变化
+                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
             }
             getContext().getContentResolver().notifyChange(uri, null);
         }
-        return count;//: 返回更新的记录数量。
+        return count;
     }
     // 将字符串解析成规定格式
     private String parseSelection(String selection) {

src/Contact.java

@@ -1,76 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.data;
-
-import android.content.Context;
-import android.database.Cursor;
-import android.provider.ContactsContract.CommonDataKinds.Phone;
-import android.provider.ContactsContract.Data;
-import android.telephony.PhoneNumberUtils;
-import android.util.Log;
-
-import java.util.HashMap;
-//change
-public class Contact {//定义了一个公共类 Contact
-    private static HashMap<String, String> sContactCache;//这是一个私有的静态 HashMap，用于缓存联系人信息。键和值的类型都是 String。
-    private static final String TAG = "Contact";
-    private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER//这是一个私有的静态最终字符串常量 TAG，通常用于日志记录，以便在日志输出中标识这个类的来源。
-    + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'"
-    + " AND " + Data.RAW_CONTACT_ID + " IN "
-            + "(SELECT raw_contact_id "
-            + " FROM phone_lookup"
-            + " WHERE min_match = '+')";
-    //获取联系人
-    public static String getContact(Context context, String phoneNumber) { //方法可以被任何对象调用 方法属于类本身，而不是类的实例
-        if(sContactCache == null) {
-            sContactCache = new HashMap<String, String>();
-        }
-        if(sContactCache.containsKey(phoneNumber)) {
-            return sContactCache.get(phoneNumber);
-        }//展示如何处理查询结果
-
-        String selection = CALLER_ID_SELECTION.replace("+",
-                PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));//使用 CALLER_ID_SELECTION 常量作为基础查询，并将其中的 + 替换为电话号码的最小匹配格式，这是通过 PhoneNumberUtils.toCallerIDMinMatch(phoneNumber) 实现的
-        Cursor cursor = context.getContentResolver().query(
-                Data.CONTENT_URI,
-                new String [] { Phone.DISPLAY_NAME },
-                selection,
-                new String[] { phoneNumber },
-                null);
-
-        // 判定查询结果
-        // moveToFirst()返回第一条
-        if (cursor != null && cursor.moveToFirst()) {
-            try {
-                // 找到相关信息
-                String name = cursor.getString(0);
-                sContactCache.put(phoneNumber, name);
-                return name;
-                // 异常
-            } catch (IndexOutOfBoundsException e) {
-                Log.e(TAG, " Cursor get string error " + e.toString());
-                return null;
-            } finally {
-                cursor.close();
-            }
-            // 未找到相关信息
-        } else {
-            Log.d(TAG, "No contact matched with number:" + phoneNumber);
-            return null;
-        }
-    }
-}

src/Notes.java

@@ -1,280 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.data;
-
-import android.net.Uri;
-
-public class Notes {
-    public static final String AUTHORITY = "micode_notes";//ContentProvider 的授权字符串，用于唯一标识 ContentProvider
-    public static final String TAG = "Notes";
-//TAG: 用于日志记录的标签。
-    public static final int TYPE_NOTE     = 0;
-    public static final int TYPE_FOLDER   = 1;
-    public static final int TYPE_SYSTEM   = 2;
-    //TYPE_NOTE, TYPE_FOLDER, TYPE_SYSTEM: 定义了笔记、文件夹和系统项的类型常量。
-    /**
-     * Following IDs are system folders' identifiers
-     * {@link Notes#ID_ROOT_FOLDER } is default folder
-     * {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
-     * {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
-     */
-    public static final int ID_ROOT_FOLDER = 0;
-    public static final int ID_TEMPARAY_FOLDER = -1;
-    public static final int ID_CALL_RECORD_FOLDER = -2;
-    public static final int ID_TRASH_FOLER = -3;
-//ID_ROOT_FOLDER, ID_TEMPARAY_FOLDER, ID_CALL_RECORD_FOLDER, ID_TRASH_FOLER: 定义了系统文件夹的 ID 常量。
-    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";
-//INTENT_EXTRA_*: 定义了一系列用于 Intent 的额外数据键。
-    public static final int TYPE_WIDGET_INVALIDE      = -1;
-    public static final int TYPE_WIDGET_2X            = 0;
-    public static final int TYPE_WIDGET_4X            = 1;
-//TYPE_WIDGET_INVALIDE, TYPE_WIDGET_2X, TYPE_WIDGET_4X: 定义了小部件类型的常量。
-    public static class DataConstants {
-        //DataConstants: 内部静态类，定义了笔记和通话记录的 MIME 类型。
-        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
-        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
-    }
-
-    /**
-     * Uri to query all notes and folders
-     */
-    public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
-    // CONTENT_NOTE_URI, CONTENT_DATA_URI: 定义了用于查询笔记和数据的 Content URI。
-    /**
-     * Uri to query data
-     */
-    public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
-
-    public interface NoteColumns {
-        /**
-         * The unique ID for a row
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String ID = "_id";
-
-        /**
-         * The parent's id for note or folder
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String PARENT_ID = "parent_id";//为什么会有prant_id
-
-        /**
-         * Created data for note or folder
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String CREATED_DATE = "created_date";
-
-        /**
-         * Latest modified date
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String MODIFIED_DATE = "modified_date";
-
-
-        /**
-         * Alert date
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String ALERTED_DATE = "alert_date";
-
-        /**
-         * Folder's name or text content of note
-         * <P> Type: TEXT </P>
-         */
-        public static final String SNIPPET = "snippet";
-
-        /**
-         * Note's widget id
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String WIDGET_ID = "widget_id";
-
-        /**
-         * Note's widget type
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String WIDGET_TYPE = "widget_type";
-
-        /**
-         * Note's background color's id
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String BG_COLOR_ID = "bg_color_id";
-
-        /**
-         * For text note, it doesn't has attachment, for multi-media
-         * note, it has at least one attachment
-         * <P> Type: INTEGER </P>
-         */
-        public static final String HAS_ATTACHMENT = "has_attachment";
-
-        /**
-         * Folder's count of notes
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String NOTES_COUNT = "notes_count";
-
-        /**
-         * The file type: folder or note
-         * <P> Type: INTEGER </P>
-         */
-        public static final String TYPE = "type";
-
-        /**
-         * The last sync id
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String SYNC_ID = "sync_id";
-
-        /**
-         * Sign to indicate local modified or not
-         * <P> Type: INTEGER </P>
-         */
-        public static final String LOCAL_MODIFIED = "local_modified";
-
-        /**
-         * Original parent id before moving into temporary folder
-         * <P> Type : INTEGER </P>
-         */
-        public static final String ORIGIN_PARENT_ID = "origin_parent_id";
-
-        /**
-         * The gtask id
-         * <P> Type : TEXT </P>
-         */
-        public static final String GTASK_ID = "gtask_id";
-
-        /**
-         * The version code
-         * <P> Type : INTEGER (long) </P>
-         */
-        public static final String VERSION = "version";
-    }
-    public interface DataColumns {
-        /**
-         * The unique ID for a row
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String ID = "_id";
-
-        /**
-         * The MIME type of the item represented by this row.
-         * <P> Type: Text </P>
-         */
-        public static final String MIME_TYPE = "mime_type";
-
-        /**
-         * The reference id to note that this data belongs to
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String NOTE_ID = "note_id";
-
-        /**
-         * Created data for note or folder
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String CREATED_DATE = "created_date";
-
-        /**
-         * Latest modified date
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String MODIFIED_DATE = "modified_date";
-
-        /**
-         * Data's content
-         * <P> Type: TEXT </P>
-         */
-        public static final String CONTENT = "content";
-
-
-        /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * integer data type
-         * <P> Type: INTEGER </P>
-         */
-        public static final String DATA1 = "data1";
-
-        /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * integer data type
-         * <P> Type: INTEGER </P>
-         */
-        public static final String DATA2 = "data2";
-
-        /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * TEXT data type
-         * <P> Type: TEXT </P>
-         */
-        public static final String DATA3 = "data3";
-
-        /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * TEXT data type
-         * <P> Type: TEXT </P>
-         */
-        public static final String DATA4 = "data4";
-
-        /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * TEXT data type
-         * <P> Type: TEXT </P>
-         */
-        public static final String DATA5 = "data5";
-    }
-    public static final class TextNote implements DataColumns {
-        /**
-         * Mode to indicate the text in check list mode or not
-         * <P> Type: Integer 1:check list mode 0: normal mode </P>
-         */
-        public static final String MODE = DATA1;
-
-        public static final int MODE_CHECK_LIST = 1;
-
-        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
-
-        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
-
-        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
-    }//文本内容的数据结构
-
-    public static final class CallNote implements DataColumns {
-        /**
-         * Call date for this record
-         * <P> Type: INTEGER (long) </P>
-         */
-        public static final String CALL_DATE = DATA1;
-
-        /**
-         * Phone number for this record
-         * <P> Type: TEXT </P>
-         */
-        public static final String PHONE_NUMBER = DATA3;
-
-        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
-
-        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
-
-        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
-    }
-}

src/WorkingNote.java

@@ -1,331 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.model;
-
-import android.appwidget.AppWidgetManager;
-import android.content.ContentUris;
-import android.content.Context;
-import android.database.Cursor;
-import android.text.TextUtils;
-import android.util.Log;
-
-import net.micode.notes.data.Notes;
-import net.micode.notes.data.Notes.CallNote;
-import net.micode.notes.data.Notes.DataColumns;
-import net.micode.notes.data.Notes.DataConstants;
-import net.micode.notes.data.Notes.NoteColumns;
-import net.micode.notes.data.Notes.TextNote;
-import net.micode.notes.tool.ResourceParser.NoteBgResources;
-
-// WorkingNote类，用于处理正在操作的笔记相关功能，例如加载、保存、修改笔记的各种属性等操作
-public class WorkingNote {
-    // 关联的Note对象，用于处理笔记更底层的数据操作（如保存、修改等），Note类可能包含更多具体的数据操作逻辑
-    private Note mNote;
-    // 笔记的ID，唯一标识该笔记
-    private long mNoteId;
-    // 笔记的内容，比如文本内容等
-    private String mContent;
-    // 笔记的模式，具体含义可能根据应用场景而定（例如不同的编辑模式等）
-    private int mMode;
-    // 提醒日期相关的时间戳，用于设置笔记的提醒时间
-    private long mAlertDate;
-    // 笔记最后修改日期的时间戳，用于记录笔记最后一次被修改的时间
-    private long mModifiedDate;
-    // 笔记背景颜色的ID，可能对应着某种颜色资源的标识
-    private int mBgColorId;
-    // 与该笔记关联的桌面小部件的ID，如果有的话
-    private int mWidgetId;
-    // 桌面小部件的类型，可能有不同的类型区分（具体由Notes类中定义）
-    private int mWidgetType;
-    // 笔记所属文件夹的ID，用于在文件夹结构中定位笔记
-    private long mFolderId;
-    // 上下文对象，用于获取如ContentResolver等系统资源进行数据库操作等
-    private Context mContext;
-    // 用于日志记录时标识当前类，方便调试定位问题
-    private static final String TAG = "WorkingNote";
-    // 标记笔记是否已被删除
-    private boolean mIsDeleted;
-    // 笔记设置变更监听器，用于监听笔记相关设置（如背景色、提醒等）发生变化的情况
-    private NoteSettingChangedListener mNoteSettingStatusListener;
-
-    // 用于查询笔记数据时的投影字段数组，指定要从数据库中获取的列，这里是与笔记数据相关的列
-    public static final String[] DATA_PROJECTION = new String[] {
-            DataColumns.ID,
-            DataColumns.CONTENT,
-            DataColumns.MIME_TYPE,
-            DataColumns.DATA1,
-            DataColumns.DATA2,
-            DataColumns.DATA3,
-            DataColumns.DATA4,
-    };
-
-    // 用于查询笔记基本信息时的投影字段数组，指定要从数据库中获取的列，这里是笔记基本属性相关的列
-    public static final String[] NOTE_PROJECTION = new String[] {
-            NoteColumns.PARENT_ID,
-            NoteColumns.ALERTED_DATE,
-            NoteColumns.BG_COLOR_ID,
-            NoteColumns.WIDGET_ID,
-            NoteColumns.WIDGET_TYPE,
-            NoteColumns.MODIFIED_DATE
-    };
-
-    // 对应DATA_PROJECTION数组中数据ID列的索引，方便从查询结果游标中获取对应列的数据
-    private static final int DATA_ID_COLUMN = 0;
-    // 对应DATA_PROJECTION数组中内容列的索引，用于获取笔记的内容数据
-    private static final int DATA_CONTENT_COLUMN = 1;
-    // 对应DATA_PROJECTION数组中MIME类型列的索引，用于判断数据的类型（如文本、通话等类型）
-    private static final int DATA_MIME_TYPE_COLUMN = 2;
-    // 对应DATA_PROJECTION数组中模式列的索引，可能用于获取笔记特定的模式相关数据
-    private static final int DATA_MODE_COLUMN = 3;
-    // 对应NOTE_PROJECTION数组中父文件夹ID列的索引，用于获取笔记所属文件夹的ID
-    private static final int NOTE_PARENT_ID_COLUMN = 0;
-    // 对应NOTE_PROJECTION数组中提醒日期列的索引，用于获取笔记的提醒日期
-    private static final int NOTE_ALERTED_DATE_COLUMN = 1;
-    // 对应NOTE_PROJECTION数组中背景颜色ID列的索引，用于获取笔记的背景颜色标识
-    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
-    // 对应NOTE_PROJECTION数组中小部件ID列的索引，用于获取关联的小部件ID
-    private static final int NOTE_WIDGET_ID_COLUMN = 3;
-    // 对应NOTE_PROJECTION数组中小部件类型列的索引，用于获取小部件的类型
-    private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
-    // 对应NOTE_PROJECTION数组中修改日期列的索引，用于获取笔记的最后修改日期
-    private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
-
-    // 创建一个新的空白笔记的构造函数（用于创建新笔记场景）
-    // @param context 上下文对象，用于后续的资源获取及数据库操作等
-    // @param folderId 新笔记所属的文件夹ID，确定笔记在文件夹结构中的位置
-    private WorkingNote(Context context, long folderId) {
-        mContext = context;
-        // 初始化提醒日期为0，表示未设置提醒时间
-        mAlertDate = 0;
-        // 设置修改日期为当前系统时间，即创建时的时间作为初始修改时间
-        mModifiedDate = System.currentTimeMillis();
-        mFolderId = folderId;
-        // 创建一个Note对象，用于处理笔记底层的数据操作
-        mNote = new Note();
-        // 新笔记初始ID设为0，待后续保存成功获取到实际ID
-        mNoteId = 0;
-        mIsDeleted = false;
-        mMode = 0;
-        // 初始小部件类型设为无效类型（可能在Notes类中有对应定义）
-        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
-    }
-
-    // 通过已有笔记ID加载笔记的构造函数（用于打开已存在笔记的场景）
-    // @param context 上下文对象，用于后续的资源获取及数据库操作等
-    // @param noteId 要加载的笔记的ID
-    // @param folderId 笔记所属的文件夹ID，确定笔记在文件夹结构中的位置（此处folderId参数可能在某些情况下有特殊用途，当前代码未完全体现）
-    private WorkingNote(Context context, long noteId, long folderId) {
-        mContext = context;
-        mNoteId = noteId;
-        mFolderId = folderId;
-        mIsDeleted = false;
-        mNote = new Note();
-        // 调用加载笔记方法，从数据库等数据源获取笔记详细信息
-        loadNote();
-    }
-
-    // 从数据库加载笔记的基本信息（如所属文件夹、背景色、小部件相关信息、提醒日期、修改日期等）
-    private void loadNote() {
-        // 通过ContentResolver查询指定笔记ID对应的笔记基本信息，使用NOTE_PROJECTION指定要获取的列
-        Cursor cursor = mContext.getContentResolver().query(
-                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
-                null, null);
-
-        if (cursor!= null) {
-            // 如果查询结果游标有数据，移动到第一条记录（通常只有一条对应这个笔记ID的记录）
-            if (cursor.moveToFirst()) {
-                // 从游标中获取笔记所属文件夹ID
-                mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
-                // 获取笔记的背景颜色ID
-                mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
-                // 获取关联的小部件ID
-                mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN);
-                // 获取小部件的类型
-                mWidgetType = cursor.getInt(NOTE_WIDGET_TYPE_COLUMN);
-                // 获取笔记的提醒日期
-                mAlertDate = cursor.getLong(NOTE_ALERTED_DATE_COLUMN);
-                // 获取笔记的最后修改日期
-                mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN);
-            }
-            // 关闭游标，释放资源
-            cursor.close();
-        } else {
-            // 如果查询结果为空，记录错误日志，并抛出异常表示找不到对应ID的笔记
-            Log.e(TAG, "No note with id:" + mNoteId);
-            throw new IllegalArgumentException("Unable to find note with id " + mNoteId);
-        }
-        // 加载笔记的数据内容（如文本内容等）
-        loadNoteData();
-    }
-
-    // 从数据库加载笔记的数据内容（根据数据类型分别处理文本、通话等不同类型的数据）
-    private void loadNoteData() {
-        // 通过ContentResolver查询指定笔记ID对应的笔记数据内容，使用DATA_PROJECTION指定要获取的列
-        Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
-                DataColumns.NOTE_ID + "=?", new String[] {
-                    String.valueOf(mNoteId)
-                }, null);
-
-        if (cursor!= null) {
-            // 如果查询结果游标有数据，移动到第一条记录
-            if (cursor.moveToFirst()) {
-                do {
-                    // 获取数据的MIME类型，用于判断数据是哪种类型（文本、通话等）
-                    String type = cursor.getString(DATA_MIME_TYPE_COLUMN);
-                    if (DataConstants.NOTE.equals(type)) {
-                        // 如果是普通笔记类型，获取笔记的内容文本
-                        mContent = cursor.getString(DATA_CONTENT_COLUMN);
-                        // 获取笔记的模式（可能对应某种编辑模式等）
-                        mMode = cursor.getInt(DATA_MODE_COLUMN);
-                        // 设置笔记的文本数据ID（可能用于关联文本数据记录等）
-                        mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN));
-                    } else if (DataConstants.CALL_NOTE.equals(type)) {
-                        // 如果是通话笔记类型，设置通话数据的ID（用于关联通话数据记录等）
-                        mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN));
-                    } else {
-                        // 如果是其他未知类型，记录调试日志
-                        Log.d(TAG, "Wrong note type with type:" + type);
-                    }
-                } while (cursor.moveToNext());
-            }
-            // 关闭游标，释放资源
-            cursor.close();
-        } else {
-            // 如果查询结果为空，记录错误日志，并抛出异常表示找不到对应ID笔记的数据
-            Log.e(TAG, "No data with id:" + mNoteId);
-            throw new IllegalArgumentException("Unable to find note's data with id " + mNoteId);
-        }
-    }
-
-    // 创建一个空的笔记对象（通常用于新建笔记的场景）
-    // @param context 上下文对象，用于后续的资源获取及操作
-    // @param folderId 新笔记所属的文件夹ID
-    // @param widgetId 关联的小部件ID，如果有的话（初始设置小部件相关信息）
-    // @param widgetType 小部件的类型，如果有的话（初始设置小部件相关信息）
-    // @param defaultBgColorId 默认的背景颜色ID，用于设置笔记的初始背景颜色
-    // @return 返回创建好的空笔记对象
-    public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
-            int widgetType, int defaultBgColorId) {
-        WorkingNote note = new WorkingNote(context, folderId);
-        note.setBgColorId(defaultBgColorId);
-        note.setWidgetId(widgetId);
-        note.setWidgetType(widgetType);
-        return note;
-    }
-
-    // 通过笔记ID加载已存在的笔记对象
-    // @param context 上下文对象，用于后续的资源获取及操作
-    // @param id 要加载的笔记的ID
-    // @return 返回加载好的笔记对象
-    public static WorkingNote load(Context context, long id) {
-        return new WorkingNote(context, id, 0);
-    }
-
-    // 同步保存笔记到数据库等存储（如果笔记有值得保存的修改内容）
-    // @return 如果保存成功返回true，否则返回false
-    public synchronized boolean saveNote() {
-        if (isWorthSaving()) {
-            if (!existInDatabase()) {
-                // 如果笔记不存在于数据库中，尝试创建新笔记并获取新笔记的ID
-                if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
-                    Log.e(TAG, "Create new note fail with id:" + mNoteId);
-                    return false;
-                }
-            }
-            // 调用Note对象的方法同步保存笔记数据到存储（可能是数据库等）
-            mNote.syncNote(mContext, mNoteId);
-
-            /**
-             * 如果存在与该笔记关联的小部件，并且小部件相关信息有效，同时设置了笔记设置变更监听器，
-             * 则触发小部件变更的监听器方法，用于更新小部件显示内容等操作。
-             */
-            if (mWidgetId!= AppWidgetManager.INVALID_APPWIDGET_ID
-                    && mWidgetType!= Notes.TYPE_WIDGET_INVALIDE
-                    && mNoteSettingStatusListener!= null) {
-                mNoteSettingStatusListener.onWidgetChanged();
-            }
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    // 判断笔记是否已存在于数据库中（通过笔记ID是否大于0来判断）
-    // @return 如果笔记ID大于0，表示存在于数据库中，返回true，否则返回false
-    public boolean existInDatabase() {
-        return mNoteId > 0;
-    }
-
-    // 判断笔记是否有值得保存的修改内容（比如是否被删除、新建笔记时内容是否为空、已存在笔记是否有本地修改等情况）
-    // @return 如果有值得保存的修改内容返回true，否则返回false
-    private boolean isWorthSaving() {
-        if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
-                || (existInDatabase() &&!mNote.isLocalModified())) {
-            return false;
-        } else {
-            return true;
-        }
-    }
-
-    // 设置笔记设置变更监听器，用于监听笔记相关设置变化情况
-    // @param l 实现了NoteSettingChangedListener接口的监听器对象
-    public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
-        mNoteSettingStatusListener = l;
-    }
-
-    // 设置笔记的提醒日期，并根据日期变化触发相应的监听器方法（如果设置了监听器）
-    // @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) {
-            mNoteSettingStatusListener.onClockAlertChanged(date, set);
-        }
-    }
-
-    // 标记笔记是否已删除，并根据删除状态和小部件相关情况触发小部件变更的监听器方法（如果设置了监听器）
-    // @param mark 布尔值，true表示标记为已删除，false表示未删除
-    public void markDeleted(boolean mark) {
-        mIsDeleted = mark;
-        if (mWidgetId!= AppWidgetManager.INVALID_APPWIDGET_ID
-                && mWidgetType!= Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener!= null) {
-                mNoteSettingStatusListener.onWidgetChanged();
-        }
-    }
-
-    // 设置笔记的背景颜色ID，并根据颜色ID变化触发相应的监听器方法（如果设置了监听器）
-    // @param id 要设置的背景颜色的ID
-    public void setBgColorId(int id) {
-        if (id!= mBgColorId) {
-            mBgColorId = id;
-            if (mNoteSettingStatusListener!= null) {
-                mNoteSettingStatusListener.onBackgroundColorChanged();
-            }
-            mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id));
-        }
-    }
-
-    // 设置笔记的检查列表模式（可能对应某种编辑模式），并根据模式变化触发相应的监听器方法（如果设置了监听器）
-    // @param mode 要设置的检查列表模式值
-    public void setCheckListMode(int mode) {
-        if (mMode!= mode) {
-            if (mNoteSettingStatusListener!= null) {
-                mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode);
-            }