README.md

@@ -0,0 +1,2 @@
+# likehaobo
+

src/Note.java

@@ -1,336 +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;
-
-// 导入所需的Android和Java库
-import android.content.ContentProviderOperation;
-import android.content.ContentProviderResult;
-import android.content.ContentUris;
-import android.content.ContentValues;
-import android.content.Context;
-import android.content.OperationApplicationException;
-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;
-import net.micode.notes.data.Notes.NoteColumns;
-import net.micode.notes.data.Notes.TextNote;
-
-import java.util.ArrayList;
-
-/**
- * Note类用于表示和管理便签的基本信息和数据操作
- */
-public class Note {
-    private ContentValues mNoteDiffValues; // 存储便签的差异值（需要更新的字段）
-    private NoteData mNoteData;            // 内部类，用于管理便签的具体数据（如文本、通话记录）
-    private static final String TAG = "Note"; // 日志标签
-
-    /**
-     * 创建一个新的便签ID，用于向数据库中添加新便签
-     * @param context 上下文对象
-     * @param folderId 文件夹ID
-     * @return 新创建的便签ID
-     */
-    public static synchronized long getNewNoteId(Context context, long folderId) {
-        // 创建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.LOCAL_MODIFIED, 1);         // 标记为本地已修改
-        values.put(NoteColumns.PARENT_ID, folderId);        // 设置父文件夹ID
-
-        // 向数据库插入新便签，并获取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()); // 记录解析错误
-            noteId = 0;
-        }
-        if (noteId == -1) {
-            throw new IllegalStateException("Wrong note id:" + noteId); // 检查ID是否合法
-        }
-        return noteId;
-    }
-
-    /**
-     * 构造函数，初始化差异值和便签数据
-     */
-    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(NoteColumns.LOCAL_MODIFIED, 1); // 标记为本地已修改
-        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); // 更新修改时间
-    }
-
-    /**
-     * 设置文本数据
-     * @param key 数据键
-     * @param value 数据值
-     */
-    public void setTextData(String key, String value) {
-        mNoteData.setTextData(key, value);
-    }
-
-    /**
-     * 设置文本数据ID
-     * @param id 文本数据ID
-     */
-    public void setTextDataId(long id) {
-        mNoteData.setTextDataId(id);
-    }
-
-    /**
-     * 获取文本数据ID
-     * @return 文本数据ID
-     */
-    public long getTextDataId() {
-        return mNoteData.mTextDataId;
-    }
-
-    /**
-     * 设置通话数据ID
-     * @param id 通话数据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();
-    }
-
-    /**
-     * 同步便签数据到数据库
-     * @param context 上下文对象
-     * @param noteId 便签ID
-     * @return 同步成功返回true，否则返回false
-     */
-    public boolean syncNote(Context context, long noteId) {
-        if (noteId <= 0) {
-            throw new IllegalArgumentException("Wrong note id:" + noteId); // 检查便签ID是否合法
-        }
-
-        if (!isLocalModified()) {
-            return true; // 如果未修改，直接返回成功
-        }
-
-        // 更新便签的基本信息
-        if (context.getContentResolver().update(
-                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
-                null) == 0) {
-            Log.e(TAG, "Update note error, should not happen"); // 记录更新错误
-            // 继续执行，不返回
-        }
-        mNoteDiffValues.clear(); // 清空差异值
-
-        // 更新便签的具体数据
-        if (mNoteData.isLocalModified()
-                && (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
-            return false; // 如果数据更新失败，返回false
-        }
-
-        return true; // 同步成功
-    }
-
-    /**
-     * 内部类，用于管理便签的具体数据（文本和通话记录）
-     */
-    private class NoteData {
-        private long mTextDataId;              // 文本数据ID
-        private ContentValues mTextDataValues; // 存储文本数据的差异值
-        private long mCallDataId;              // 通话数据ID
-        private ContentValues mCallDataValues; // 存储通话数据的差异值
-        private static final String TAG = "NoteData"; // 日志标签
-
-        /**
-         * 构造函数，初始化数据
-         */
-        public NoteData() {
-            mTextDataValues = new ContentValues();
-            mCallDataValues = new ContentValues();
-            mTextDataId = 0;
-            mCallDataId = 0;
-        }
-
-        /**
-         * 检查数据是否被本地修改
-         * @return 如果文本或通话数据被修改，返回true；否则返回false
-         */
-        boolean isLocalModified() {
-            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"); // 检查ID是否合法
-            }
-            mTextDataId = id;
-        }
-
-        /**
-         * 设置通话数据ID
-         * @param id 通话数据ID
-         */
-        void setCallDataId(long id) {
-            if (id <= 0) {
-                throw new IllegalArgumentException("Call data id should larger than 0"); // 检查ID是否合法
-            }
-            mCallDataId = id;
-        }
-
-        /**
-         * 设置通话数据
-         * @param key 数据键
-         * @param value 数据值
-         */
-        void setCallData(String key, String value) {
-            mCallDataValues.put(key, value);
-            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); // 标记为本地已修改
-            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); // 更新修改时间
-        }
-
-        /**
-         * 设置文本数据
-         * @param key 数据键
-         * @param value 数据值
-         */
-        void setTextData(String key, String value) {
-            mTextDataValues.put(key, value);
-            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); // 标记为本地已修改
-            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); // 更新修改时间
-        }
-
-        /**
-         * 将数据推送到ContentResolver（数据库）
-         * @param context 上下文对象
-         * @param noteId 便签ID
-         * @return 操作成功返回URI，否则返回null
-         */
-        Uri pushIntoContentResolver(Context context, long noteId) {
-            if (noteId <= 0) {
-                throw new IllegalArgumentException("Wrong note id:" + noteId); // 检查便签ID是否合法
-            }
-
-            ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
-            ContentProviderOperation.Builder builder = null;
-
-            // 处理文本数据
-            if(mTextDataValues.size() > 0) {
-                mTextDataValues.put(DataColumns.NOTE_ID, noteId); // 设置便签ID
-                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))); // 设置文本数据ID
-                    } 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); // 设置便签ID
-                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))); // 设置通话数据ID
-                    } 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 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;
-        }
-    }
-}

src/WorkingNote.java

@@ -1,490 +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;
-
-// 导入所需的Android和Java库
-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 {
-    private Note mNote;                // 便签对象，用于管理便签的基本数据
-    private long mNoteId;              // 便签ID
-    private String mContent;           // 便签内容
-    private int mMode;                 // 便签模式（如普通模式或清单模式）
-    private long mAlertDate;           // 提醒日期
-    private long mModifiedDate;        // 修改日期
-    private int mBgColorId;            // 背景颜色ID
-    private int mWidgetId;             // 关联的小部件ID
-    private int mWidgetType;           // 小部件类型
-    private long mFolderId;            // 所属文件夹ID
-    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
-    };
-
-    // 数据表列的索引常量
-    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;
-
-    /**
-     * 构造函数，用于创建新便签
-     * @param context 上下文对象
-     * @param folderId 文件夹ID
-     */
-    private WorkingNote(Context context, long folderId) {
-        mContext = context;
-        mAlertDate = 0; // 初始提醒日期为0（未设置）
-        mModifiedDate = System.currentTimeMillis(); // 设置修改日期为当前时间
-        mFolderId = folderId; // 设置文件夹ID
-        mNote = new Note(); // 初始化便签对象
-        mNoteId = 0; // 初始便签ID为0（未保存到数据库）
-        mIsDeleted = false; // 初始未删除
-        mMode = 0; // 初始模式为普通模式
-        mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 初始小部件类型为无效
-    }
-
-    /**
-     * 构造函数，用于加载已有便签
-     * @param context 上下文对象
-     * @param noteId 便签ID
-     * @param folderId 文件夹ID
-     */
-    private WorkingNote(Context context, long noteId, long folderId) {
-        mContext = context;
-        mNoteId = noteId; // 设置便签ID
-        mFolderId = folderId; // 设置文件夹ID
-        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) {
-            if (cursor.moveToFirst()) {
-                // 从游标中读取便签属性
-                mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
-                mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
-                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 {
-            Log.e(TAG, "No note with id:" + mNoteId); // 记录错误日志
-            throw new IllegalArgumentException("Unable to find note with id " + mNoteId); // 抛出异常
-        }
-        loadNoteData(); // 加载便签的具体数据
-    }
-
-    /**
-     * 加载便签的具体数据（如内容和模式）
-     */
-    private void loadNoteData() {
-        // 查询数据表
-        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 {
-                    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);
-                        mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN));
-                    } else if (DataConstants.CALL_NOTE.equals(type)) {
-                        // 加载通话记录数据
-                        mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN));
-                    } else {
-                        Log.d(TAG, "Wrong note type with type:" + type); // 记录错误日志
-                    }
-                } while (cursor.moveToNext());
-            }
-            cursor.close();
-        } else {
-            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 新创建的WorkingNote对象
-     */
-    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); // 设置小部件ID
-        note.setWidgetType(widgetType); // 设置小部件类型
-        return note;
-    }
-
-    /**
-     * 加载已有便签
-     * @param context 上下文对象
-     * @param id 便签ID
-     * @return 加载的WorkingNote对象
-     */
-    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()) { // 如果便签未保存到数据库
-                if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) { // 获取新便签ID
-                    Log.e(TAG, "Create new note fail with id:" + mNoteId); // 记录错误日志
-                    return false;
-                }
-            }
-
-            mNote.syncNote(mContext, mNoteId); // 同步便签数据到数据库
-
-            // 更新关联的小部件
-            if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
-                    && mWidgetType != Notes.TYPE_WIDGET_INVALIDE
-                    && mNoteSettingStatusListener != null) {
-                mNoteSettingStatusListener.onWidgetChanged();
-            }
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * 检查便签是否已存在于数据库中
-     * @return 存在返回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 监听器对象
-     */
-    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 是否删除
-     */
-    public void markDeleted(boolean mark) {
-        mIsDeleted = mark;
-        if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
-                && mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) {
-                mNoteSettingStatusListener.onWidgetChanged(); // 通知监听器
-        }
-    }
-
-    /**
-     * 设置背景颜色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); // 通知监听器
-            }
-            mMode = mode;
-            mNote.setTextData(TextNote.MODE, String.valueOf(mMode)); // 更新模式
-        }
-    }
-
-    /**
-     * 设置小部件类型
-     * @param type 小部件类型
-     */
-    public void setWidgetType(int type) {
-        if (type != mWidgetType) {
-            mWidgetType = type;
-            mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType)); // 更新小部件类型
-        }
-    }
-
-    /**
-     * 设置小部件ID
-     * @param id 小部件ID
-     */
-    public void setWidgetId(int id) {
-        if (id != mWidgetId) {
-            mWidgetId = id;
-            mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId)); // 更新小部件ID
-        }
-    }
-
-    /**
-     * 设置便签内容
-     * @param text 内容文本
-     */
-    public void setWorkingText(String 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)); // 设置父文件夹为通话记录文件夹
-    }
-
-    /**
-     * 检查是否设置了提醒
-     * @return 设置了提醒返回true，否则返回false
-     */
-    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
-     * @return 背景颜色资源ID
-     */
-    public int getBgColorResId() {
-        return NoteBgResources.getNoteBgResource(mBgColorId);
-    }
-
-    /**
-     * 获取背景颜色ID
-     * @return 背景颜色ID
-     */
-    public int getBgColorId() {
-        return mBgColorId;
-    }
-
-    /**
-     * 获取标题背景颜色资源ID
-     * @return 标题背景颜色资源ID
-     */
-    public int getTitleBgResId() {
-        return NoteBgResources.getNoteTitleBgResource(mBgColorId);
-    }
-
-    /**
-     * 获取清单模式
-     * @return 清单模式值
-     */
-    public int getCheckListMode() {
-        return mMode;
-    }
-
-    /**
-     * 获取便签ID
-     * @return 便签ID
-     */
-    public long getNoteId() {
-        return mNoteId;
-    }
-
-    /**
-     * 获取文件夹ID
-     * @return 文件夹ID
-     */
-    public long getFolderId() {
-        return mFolderId;
-    }
-
-    /**
-     * 获取小部件ID
-     * @return 小部件ID
-     */
-    public int getWidgetId() {
-        return mWidgetId;
-    }
-
-    /**
-     * 获取小部件类型
-     * @return 小部件类型
-     */
-    public int getWidgetType() {
-        return mWidgetType;
-    }
-
-    /**
-     * 便签设置变化监听器接口
-     */
-    public interface NoteSettingChangedListener {
-        /**
-         * 背景颜色变化时调用
-         */
-        void onBackgroundColorChanged();
-
-        /**
-         * 提醒日期变化时调用
-         * @param date 提醒日期
-         * @param set 是否设置提醒
-         */
-        void onClockAlertChanged(long date, boolean set);
-
-        /**
-         * 小部件变化时调用
-         */
-        void onWidgetChanged();
-
-        /**
-         * 清单模式变化时调用
-         * @param oldMode 旧模式
-         * @param newMode 新模式
-         */
-        void onCheckListModeChanged(int oldMode, int newMode);
-    }
-}