zhou

Note.java

@@ -0,0 +1,416 @@
+/*
+ * 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.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);
+        // 设置笔记所属文件夹的ID
+        values.put(NoteColumns.PARENT_ID, folderId);
+        // 插入新笔记到数据库，并获取返回的URI
+        Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
+
+        long noteId = 0;
+        try {
+            // 从URI中提取笔记的ID
+            noteId = Long.valueOf(uri.getPathSegments().get(1));
+        } catch (NumberFormatException e) {
+            // 记录获取笔记ID时的错误信息
+            Log.e(TAG, "Get note id error :" + e.toString());
+            noteId = 0;
+        }
+        if (noteId == -1) {
+            // 如果笔记ID为-1，抛出异常表示笔记ID错误
+            throw new IllegalStateException("Wrong note id:" + noteId);
+        }
+        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) {
+        // 调用NoteData对象的方法设置文本数据值
+        mNoteData.setTextData(key, value);
+    }
+
+    /**
+     * 设置笔记的文本数据ID。
+     *
+     * @param id 文本数据的ID
+     */
+    public void setTextDataId(long id) {
+        // 调用NoteData对象的方法设置文本数据ID
+        mNoteData.setTextDataId(id);
+    }
+
+    /**
+     * 获取笔记的文本数据ID。
+     *
+     * @return 文本数据的ID
+     */
+    public long getTextDataId() {
+        return mNoteData.mTextDataId;
+    }
+
+    /**
+     * 设置笔记的通话数据ID。
+     *
+     * @param id 通话数据的ID
+     */
+    public void setCallDataId(long id) {
+        // 调用NoteData对象的方法设置通话数据ID
+        mNoteData.setCallDataId(id);
+    }
+
+    /**
+     * 设置笔记的通话数据值。
+     *
+     * @param key 要设置的键
+     * @param value 要设置的值
+     */
+    public void setCallData(String key, String value) {
+        // 调用NoteData对象的方法设置通话数据值
+        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) {
+            // 如果笔记ID小于等于0，抛出异常表示笔记ID错误
+            throw new IllegalArgumentException("Wrong note id:" + noteId);
+        }
+
+        if (!isLocalModified()) {
+            // 如果笔记没有本地修改，直接返回true
+            return true;
+        }
+
+        /**
+         * 理论上，一旦数据发生变化，笔记的LOCAL_MODIFIED和MODIFIED_DATE应该更新。
+         * 为了数据安全，即使更新笔记失败，我们也会更新笔记数据信息。
+         */
+        if (context.getContentResolver().update(
+                // 构建要更新的笔记的URI
+                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)) {
+            // 如果笔记数据有本地修改，并且将笔记数据推送到内容解析器失败，返回false
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * 内部类，用于管理笔记的文本数据和通话数据。
+     */
+    private class NoteData {
+        // 文本数据的ID
+        private long mTextDataId;
+        // 用于存储文本数据的键值对
+        private ContentValues mTextDataValues;
+        // 通话数据的ID
+        private long mCallDataId;
+        // 用于存储通话数据的键值对
+        private ContentValues mCallDataValues;
+        // 日志标签，用于在日志中标识该类的相关信息
+        private static final String TAG = "NoteData";
+
+        /**
+         * 构造函数，初始化文本数据和通话数据的ContentValues对象，以及ID为0。
+         */
+        public NoteData() {
+            mTextDataValues = new ContentValues();
+            mCallDataValues = new ContentValues();
+            mTextDataId = 0;
+            mCallDataId = 0;
+        }
+
+        /**
+         * 判断笔记数据是否有本地修改。
+         *
+         * @return 如果有本地修改返回true，否则返回false
+         */
+        boolean isLocalModified() {
+            // 检查文本数据或通话数据的ContentValues对象是否有数据
+            return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
+        }
+
+        /**
+         * 设置文本数据的ID。
+         *
+         * @param id 文本数据的ID
+         */
+        void setTextDataId(long id) {
+            if(id <= 0) {
+                // 如果文本数据ID小于等于0，抛出异常表示ID错误
+                throw new IllegalArgumentException("Text data id should larger than 0");
+            }
+            mTextDataId = id;
+        }
+
+        /**
+         * 设置通话数据的ID。
+         *
+         * @param id 通话数据的ID
+         */
+        void setCallDataId(long id) {
+            if (id <= 0) {
+                // 如果通话数据ID小于等于0，抛出异常表示ID错误
+                throw new IllegalArgumentException("Call data id should larger than 0");
+            }
+            mCallDataId = id;
+        }
+
+        /**
+         * 设置通话数据的键值对。
+         *
+         * @param key 要设置的键
+         * @param value 要设置的值
+         */
+        void setCallData(String key, String value) {
+            // 将键值对添加到通话数据的ContentValues对象中
+            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) {
+            // 将键值对添加到文本数据的ContentValues对象中
+            mTextDataValues.put(key, value);
+            // 标记笔记为本地修改过
+            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+            // 更新笔记的修改时间为当前时间
+            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+        }
+
+        /**
+         * 将笔记数据推送到内容解析器中。
+         *
+         * @param context 应用程序上下文
+         * @param noteId 笔记的ID
+         * @return 如果推送成功返回笔记的URI，否则返回null
+         */
+        Uri pushIntoContentResolver(Context context, long noteId) {
+            /**
+             * 安全检查，确保笔记ID大于0。
+             */
+            if (noteId <= 0) {
+                // 如果笔记ID小于等于0，抛出异常表示笔记ID错误
+                throw new IllegalArgumentException("Wrong note id:" + noteId);
+            }
+
+            // 创建一个ArrayList，用于存储要执行的内容提供者操作
+            ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+            // 内容提供者操作的构建器
+            ContentProviderOperation.Builder builder = null;
+
+            if(mTextDataValues.size() > 0) {
+                // 设置文本数据所属的笔记ID
+                mTextDataValues.put(DataColumns.NOTE_ID, noteId);
+                if (mTextDataId == 0) {
+                    // 如果文本数据ID为0，说明是新的文本数据
+                    // 设置文本数据的MIME类型
+                    mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
+                    // 插入新的文本数据到数据库，并获取返回的URI
+                    Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
+                            mTextDataValues);
+                    try {
+                        // 从URI中提取文本数据的ID，并设置到mTextDataId中
+                        setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));
+                    } catch (NumberFormatException e) {
+                        // 记录插入新文本数据失败的错误信息
+                        Log.e(TAG, "Insert new text data fail with noteId" + noteId);
+                        // 清空文本数据的ContentValues对象
+                        mTextDataValues.clear();
+                        return null;
+                    }
+                } else {
+                    // 如果文本数据ID不为0，说明是更新已有的文本数据
+                    // 创建一个更新操作的构建器
+                    builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mTextDataId));
+                    // 设置要更新的值
+                    builder.withValues(mTextDataValues);
+                    // 将更新操作添加到操作列表中
+                    operationList.add(builder.build());
+                }
+                // 清空文本数据的ContentValues对象
+                mTextDataValues.clear();
+            }
+
+            if(mCallDataValues.size() > 0) {
+                // 设置通话数据所属的笔记ID
+                mCallDataValues.put(DataColumns.NOTE_ID, noteId);
+                if (mCallDataId == 0) {
+                    // 如果通话数据ID为0，说明是新的通话数据
+                    // 设置通话数据的MIME类型
+                    mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
+                    // 插入新的通话数据到数据库，并获取返回的URI
+                    Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
+                            mCallDataValues);
+                    try {
+                        // 从URI中提取通话数据的ID，并设置到mCallDataId中
+                        setCallDataId(Long.valueOf(uri.getPathSegments().get(1)));
+                    } catch (NumberFormatException e) {
+                        // 记录插入新通话数据失败的错误信息
+                        Log.e(TAG, "Insert new call data fail with noteId" + noteId);
+                        // 清空通话数据的ContentValues对象
+                        mCallDataValues.clear();
+                        return null;
+                    }
+                } else {
+                    // 如果通话数据ID不为0，说明是更新已有的通话数据
+                    // 创建一个更新操作的构建器
+                    builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mCallDataId));
+                    // 设置要更新的值
+                    builder.withValues(mCallDataValues);
+                    // 将更新操作添加到操作列表中
+                    operationList.add(builder.build());
+                }
+                // 清空通话数据的ContentValues对象
+                mCallDataValues.clear();
+            }
+
+            if (operationList.size() > 0) {
+                try {
+                    // 批量执行操作列表中的内容提供者操作
+                    ContentProviderResult[] results = context.getContentResolver().applyBatch(
+                            Notes.AUTHORITY, operationList);
+                    // 如果操作结果为空或长度为0或第一个结果为空，返回null，否则返回笔记的URI
+                    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;
+        }
+    }
+}

NoteEditText.java

@@ -0,0 +1,331 @@
+/*
+ * 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.ui;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.text.Layout;
+import android.text.Selection;
+import android.text.Spanned;
+import android.text.TextUtils;
+import android.text.style.URLSpan;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.KeyEvent;
+import android.view.MenuItem;
+import android.view.MenuItem.OnMenuItemClickListener;
+import android.view.MotionEvent;
+import android.widget.EditText;
+
+import net.micode.notes.R;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * NoteEditText 类继承自 EditText，用于处理笔记编辑文本框的特殊逻辑，
+ * 包括按键事件处理、文本变化监听、链接点击处理等。
+ */
+public class NoteEditText extends EditText {
+    // 日志标签，用于调试日志输出
+    private static final String TAG = "NoteEditText";
+    // 当前编辑文本框的索引，用于标识其在列表中的位置
+    private int mIndex;
+    // 删除操作前的光标起始位置
+    private int mSelectionStartBeforeDelete;
+
+    // 定义电话链接的协议前缀
+    private static final String SCHEME_TEL = "tel:" ;
+    // 定义 HTTP 链接的协议前缀
+    private static final String SCHEME_HTTP = "http:" ;
+    // 定义邮件链接的协议前缀
+    private static final String SCHEME_EMAIL = "mailto:" ;
+
+    // 存储协议前缀与对应的菜单项资源 ID 的映射
+    private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
+    static {
+        // 初始化电话链接对应的菜单项资源 ID
+        sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
+        // 初始化 HTTP 链接对应的菜单项资源 ID
+        sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);
+        // 初始化邮件链接对应的菜单项资源 ID
+        sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email);
+    }
+
+    /**
+     * OnTextViewChangeListener 接口，用于通知外部类文本框的变化事件，
+     * 包括删除、换行和文本内容变化。
+     */
+    public interface OnTextViewChangeListener {
+        /**
+         * 当按下删除键（{@link KeyEvent#KEYCODE_DEL}）且文本为空时，
+         * 通知外部类删除当前编辑文本框。
+         *
+         * @param index 当前编辑文本框的索引
+         * @param text 当前编辑文本框的文本内容
+         */
+        void onEditTextDelete(int index, String text);
+
+        /**
+         * 当按下回车键（{@link KeyEvent#KEYCODE_ENTER}）时，
+         * 通知外部类在当前编辑文本框之后添加一个新的编辑文本框。
+         *
+         * @param index 新编辑文本框的索引
+         * @param text 从当前光标位置到文本末尾的内容
+         */
+        void onEditTextEnter(int index, String text);
+
+        /**
+         * 当文本内容发生变化时，通知外部类隐藏或显示菜单项。
+         *
+         * @param index 当前编辑文本框的索引
+         * @param hasText 文本框是否有内容
+         */
+        void onTextChange(int index, boolean hasText);
+    }
+
+    // 文本变化监听器实例
+    private OnTextViewChangeListener mOnTextViewChangeListener;
+
+    /**
+     * 构造函数，使用默认的属性集初始化 NoteEditText。
+     *
+     * @param context 上下文对象
+     */
+    public NoteEditText(Context context) {
+        super(context, null);
+        // 初始化索引为 0
+        mIndex = 0;
+    }
+
+    /**
+     * 设置当前编辑文本框的索引。
+     *
+     * @param index 要设置的索引值
+     */
+    public void setIndex(int index) {
+        mIndex = index;
+    }
+
+    /**
+     * 设置文本变化监听器。
+     *
+     * @param listener 实现了 OnTextViewChangeListener 接口的监听器实例
+     */
+    public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
+        mOnTextViewChangeListener = listener;
+    }
+
+    /**
+     * 构造函数，使用指定的属性集初始化 NoteEditText。
+     *
+     * @param context 上下文对象
+     * @param attrs 属性集
+     */
+    public NoteEditText(Context context, AttributeSet attrs) {
+        super(context, attrs, android.R.attr.editTextStyle);
+    }
+
+    /**
+     * 构造函数，使用指定的属性集和默认样式初始化 NoteEditText。
+     *
+     * @param context 上下文对象
+     * @param attrs 属性集
+     * @param defStyle 默认样式
+     */
+    public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        // TODO Auto-generated constructor stub
+    }
+
+    /**
+     * 处理触摸事件，当用户按下屏幕时，根据触摸位置设置光标位置。
+     *
+     * @param event 触摸事件对象
+     * @return 是否消费该事件
+     */
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        switch (event.getAction()) {
+            case MotionEvent.ACTION_DOWN:
+                // 获取触摸点的 x 坐标
+                int x = (int) event.getX();
+                // 获取触摸点的 y 坐标
+                int y = (int) event.getY();
+                // 减去左边的总内边距
+                x -= getTotalPaddingLeft();
+                // 减去顶部的总内边距
+                y -= getTotalPaddingTop();
+                // 加上水平滚动偏移量
+                x += getScrollX();
+                // 加上垂直滚动偏移量
+                y += getScrollY();
+
+                // 获取文本布局对象
+                Layout layout = getLayout();
+                // 根据垂直位置获取所在的行
+                int line = layout.getLineForVertical(y);
+                // 根据行和水平位置获取文本中的偏移量
+                int off = layout.getOffsetForHorizontal(line, x);
+                // 设置光标位置
+                Selection.setSelection(getText(), off);
+                break;
+        }
+
+        return super.onTouchEvent(event);
+    }
+
+    /**
+     * 处理按键按下事件，记录删除操作前的光标起始位置。
+     *
+     * @param keyCode 按下的按键码
+     * @param event 按键事件对象
+     * @return 是否消费该事件
+     */
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        switch (keyCode) {
+            case KeyEvent.KEYCODE_ENTER:
+                if (mOnTextViewChangeListener != null) {
+                    // 如果有监听器，不处理回车键事件
+                    return false;
+                }
+                break;
+            case KeyEvent.KEYCODE_DEL:
+                // 记录删除操作前的光标起始位置
+                mSelectionStartBeforeDelete = getSelectionStart();
+                break;
+            default:
+                break;
+        }
+        return super.onKeyDown(keyCode, event);
+    }
+
+    /**
+     * 处理按键抬起事件，根据按键码调用相应的监听器方法。
+     *
+     * @param keyCode 按下的按键码
+     * @param event 按键事件对象
+     * @return 是否消费该事件
+     */
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        switch(keyCode) {
+            case KeyEvent.KEYCODE_DEL:
+                if (mOnTextViewChangeListener != null) {
+                    if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
+                        // 当光标在文本开头且不是第一个文本框时，调用删除监听器方法
+                        mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
+                        return true;
+                    }
+                } else {
+                    // 若监听器未设置，输出日志
+                    Log.d(TAG, "OnTextViewChangeListener was not seted");
+                }
+                break;
+            case KeyEvent.KEYCODE_ENTER:
+                if (mOnTextViewChangeListener != null) {
+                    // 获取当前光标起始位置
+                    int selectionStart = getSelectionStart();
+                    // 获取从光标位置到文本末尾的内容
+                    String text = getText().subSequence(selectionStart, length()).toString();
+                    // 设置文本为从开头到光标位置的内容
+                    setText(getText().subSequence(0, selectionStart));
+                    // 调用换行监听器方法
+                    mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
+                } else {
+                    // 若监听器未设置，输出日志
+                    Log.d(TAG, "OnTextViewChangeListener was not seted");
+                }
+                break;
+            default:
+                break;
+        }
+        return super.onKeyUp(keyCode, event);
+    }
+
+    /**
+     * 处理焦点变化事件，根据焦点状态和文本内容调用文本变化监听器方法。
+     *
+     * @param focused 是否获得焦点
+     * @param direction 焦点变化的方向
+     * @param previouslyFocusedRect 之前聚焦的矩形区域
+     */
+    @Override
+    protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
+        if (mOnTextViewChangeListener != null) {
+            if (!focused && TextUtils.isEmpty(getText())) {
+                // 失去焦点且文本为空时，调用文本变化监听器方法
+                mOnTextViewChangeListener.onTextChange(mIndex, false);
+            } else {
+                // 其他情况，调用文本变化监听器方法
+                mOnTextViewChangeListener.onTextChange(mIndex, true);
+            }
+        }
+        super.onFocusChanged(focused, direction, previouslyFocusedRect);
+    }
+
+    /**
+     * 创建上下文菜单，当选中的文本包含链接时，添加相应的菜单项。
+     *
+     * @param menu 上下文菜单对象
+     */
+    @Override
+    protected void onCreateContextMenu(ContextMenu menu) {
+        if (getText() instanceof Spanned) {
+            // 获取选中区域的起始位置
+            int selStart = getSelectionStart();
+            // 获取选中区域的结束位置
+            int selEnd = getSelectionEnd();
+
+            // 计算选中区域的最小位置
+            int min = Math.min(selStart, selEnd);
+            // 计算选中区域的最大位置
+            int max = Math.max(selStart, selEnd);
+
+            // 获取选中区域内的所有 URLSpan 对象
+            final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
+            if (urls.length == 1) {
+                int defaultResId = 0;
+                for(String schema: sSchemaActionResMap.keySet()) {
+                    if(urls[0].getURL().indexOf(schema) >= 0) {
+                        // 根据链接协议获取对应的菜单项资源 ID
+                        defaultResId = sSchemaActionResMap.get(schema);
+                        break;
+                    }
+                }
+
+                if (defaultResId == 0) {
+                    // 若未匹配到协议，使用默认的菜单项资源 ID
+                    defaultResId = R.string.note_link_other;
+                }
+
+                // 添加菜单项并设置点击监听器
+                menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
+                        new OnMenuItemClickListener() {
+                            public boolean onMenuItemClick(MenuItem item) {
+                                // 点击菜单项时，调用 URLSpan 的点击方法
+                                urls[0].onClick(NoteEditText.this);
+                                return true;
+                            }
+                        });
+            }
+        }
+        super.onCreateContextMenu(menu);
+    }
+}

SqlData.java

@@ -0,0 +1,283 @@
+/*
+ * 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.gtask.data;
+
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+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.NotesDatabaseHelper.TABLE;
+import net.micode.notes.gtask.exception.ActionFailureException;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * SqlData 类用于处理与数据库中笔记数据相关的操作，
+ * 包括数据的创建、加载、更新以及提交到数据库等操作。
+ */
+public class SqlData {
+    // 日志标签，用于标识该类的日志信息
+    private static final String TAG = SqlData.class.getSimpleName();
+    // 无效的 ID 值，用于初始化或标识无效的 ID
+    private static final int INVALID_ID = -99999;
+
+    // 查询数据时使用的投影，指定要查询的列
+    public static final String[] PROJECTION_DATA = new String[] {
+            DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
+            DataColumns.DATA3
+    };
+
+    // 数据 ID 列在投影数组中的索引
+    public static final int DATA_ID_COLUMN = 0;
+    // 数据 MIME 类型列在投影数组中的索引
+    public static final int DATA_MIME_TYPE_COLUMN = 1;
+    // 数据内容列在投影数组中的索引
+    public static final int DATA_CONTENT_COLUMN = 2;
+    // 数据内容的 DATA1 列在投影数组中的索引
+    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
+    // 数据内容的 DATA3 列在投影数组中的索引
+    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
+
+    // 内容解析器，用于与内容提供者进行交互
+    private ContentResolver mContentResolver;
+    // 标记数据是否为新创建的
+    private boolean mIsCreate;
+    // 数据的 ID
+    private long mDataId;
+    // 数据的 MIME 类型
+    private String mDataMimeType;
+    // 数据的内容
+    private String mDataContent;
+    // 数据内容的 DATA1 字段
+    private long mDataContentData1;
+    // 数据内容的 DATA3 字段
+    private String mDataContentData3;
+    // 存储数据差异的 ContentValues 对象，用于更新或插入数据
+    private ContentValues mDiffDataValues;
+
+    /**
+     * 构造函数，用于创建一个新的 SqlData 对象。
+     *
+     * @param context 应用程序的上下文
+     */
+    public SqlData(Context context) {
+        // 获取内容解析器
+        mContentResolver = context.getContentResolver();
+        // 标记为新创建的数据
+        mIsCreate = true;
+        // 初始化数据 ID 为无效值
+        mDataId = INVALID_ID;
+        // 初始化数据 MIME 类型为默认值
+        mDataMimeType = DataConstants.NOTE;
+        // 初始化数据内容为空字符串
+        mDataContent = "";
+        // 初始化数据内容的 DATA1 字段为 0
+        mDataContentData1 = 0;
+        // 初始化数据内容的 DATA3 字段为空字符串
+        mDataContentData3 = "";
+        // 初始化差异数据的 ContentValues 对象
+        mDiffDataValues = new ContentValues();
+    }
+
+    /**
+     * 构造函数，用于从游标中加载数据创建 SqlData 对象。
+     *
+     * @param context 应用程序的上下文
+     * @param c       包含数据的游标
+     */
+    public SqlData(Context context, Cursor c) {
+        // 获取内容解析器
+        mContentResolver = context.getContentResolver();
+        // 标记为非新创建的数据
+        mIsCreate = false;
+        // 从游标中加载数据
+        loadFromCursor(c);
+        // 初始化差异数据的 ContentValues 对象
+        mDiffDataValues = new ContentValues();
+    }
+
+    /**
+     * 从游标中加载数据到当前对象。
+     *
+     * @param c 包含数据的游标
+     */
+    private void loadFromCursor(Cursor c) {
+        // 从游标中获取数据 ID
+        mDataId = c.getLong(DATA_ID_COLUMN);
+        // 从游标中获取数据 MIME 类型
+        mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
+        // 从游标中获取数据内容
+        mDataContent = c.getString(DATA_CONTENT_COLUMN);
+        // 从游标中获取数据内容的 DATA1 字段
+        mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
+        // 从游标中获取数据内容的 DATA3 字段
+        mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
+    }
+
+    /**
+     * 根据 JSON 对象设置数据内容，并记录差异。
+     *
+     * @param js 包含数据的 JSON 对象
+     * @throws JSONException 如果 JSON 解析出错
+     */
+    public void setContent(JSONObject js) throws JSONException {
+        // 从 JSON 对象中获取数据 ID，如果不存在则使用无效值
+        long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
+        // 如果是新创建的数据或者数据 ID 不同，则记录差异
+        if (mIsCreate || mDataId != dataId) {
+            mDiffDataValues.put(DataColumns.ID, dataId);
+        }
+        // 更新数据 ID
+        mDataId = dataId;
+
+        // 从 JSON 对象中获取数据 MIME 类型，如果不存在则使用默认值
+        String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
+                : DataConstants.NOTE;
+        // 如果是新创建的数据或者 MIME 类型不同，则记录差异
+        if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
+            mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
+        }
+        // 更新数据 MIME 类型
+        mDataMimeType = dataMimeType;
+
+        // 从 JSON 对象中获取数据内容，如果不存在则使用空字符串
+        String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
+        // 如果是新创建的数据或者数据内容不同，则记录差异
+        if (mIsCreate || !mDataContent.equals(dataContent)) {
+            mDiffDataValues.put(DataColumns.CONTENT, dataContent);
+        }
+        // 更新数据内容
+        mDataContent = dataContent;
+
+        // 从 JSON 对象中获取数据内容的 DATA1 字段，如果不存在则使用 0
+        long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
+        // 如果是新创建的数据或者 DATA1 字段不同，则记录差异
+        if (mIsCreate || mDataContentData1 != dataContentData1) {
+            mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
+        }
+        // 更新数据内容的 DATA1 字段
+        mDataContentData1 = dataContentData1;
+
+        // 从 JSON 对象中获取数据内容的 DATA3 字段，如果不存在则使用空字符串
+        String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
+        // 如果是新创建的数据或者 DATA3 字段不同，则记录差异
+        if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
+            mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
+        }
+        // 更新数据内容的 DATA3 字段
+        mDataContentData3 = dataContentData3;
+    }
+
+    /**
+     * 获取当前数据的 JSON 对象表示。
+     *
+     * @return 包含数据的 JSON 对象
+     * @throws JSONException 如果 JSON 构建出错
+     */
+    public JSONObject getContent() throws JSONException {
+        // 如果是新创建的数据且未提交到数据库，则记录错误日志并返回 null
+        if (mIsCreate) {
+            Log.e(TAG, "it seems that we haven't created this in database yet");
+            return null;
+        }
+        // 创建一个新的 JSON 对象
+        JSONObject js = new JSONObject();
+        // 将数据 ID 放入 JSON 对象
+        js.put(DataColumns.ID, mDataId);
+        // 将数据 MIME 类型放入 JSON 对象
+        js.put(DataColumns.MIME_TYPE, mDataMimeType);
+        // 将数据内容放入 JSON 对象
+        js.put(DataColumns.CONTENT, mDataContent);
+        // 将数据内容的 DATA1 字段放入 JSON 对象
+        js.put(DataColumns.DATA1, mDataContentData1);
+        // 将数据内容的 DATA3 字段放入 JSON 对象
+        js.put(DataColumns.DATA3, mDataContentData3);
+        return js;
+    }
+
+    /**
+     * 将数据提交到数据库，根据数据是否为新创建进行插入或更新操作。
+     *
+     * @param noteId          笔记的 ID
+     * @param validateVersion 是否验证版本
+     * @param version         版本号
+     */
+    public void commit(long noteId, boolean validateVersion, long version) {
+        if (mIsCreate) {
+            // 如果数据 ID 无效且差异数据中包含 ID 字段，则移除该字段
+            if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
+                mDiffDataValues.remove(DataColumns.ID);
+            }
+            // 将笔记 ID 放入差异数据中
+            mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
+            // 插入数据到数据库
+            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
+            try {
+                // 从插入结果的 URI 中获取数据 ID
+                mDataId = Long.valueOf(uri.getPathSegments().get(1));
+            } catch (NumberFormatException e) {
+                // 记录错误日志并抛出异常
+                Log.e(TAG, "Get note id error :" + e.toString());
+                throw new ActionFailureException("create note failed");
+            }
+        } else {
+            // 如果有差异数据需要更新
+            if (mDiffDataValues.size() > 0) {
+                int result = 0;
+                if (!validateVersion) {
+                    // 不验证版本时，直接更新数据
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
+                } else {
+                    // 验证版本时，根据版本号进行更新
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
+                            " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+                                    + " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
+                                    String.valueOf(noteId), String.valueOf(version)
+                            });
+                }
+                // 如果更新结果为 0，记录警告日志
+                if (result == 0) {
+                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
+                }
+            }
+        }
+        // 清空差异数据
+        mDiffDataValues.clear();
+        // 标记数据为非新创建
+        mIsCreate = false;
+    }
+
+    /**
+     * 获取数据的 ID。
+     *
+     * @return 数据的 ID
+     */
+    public long getId() {
+        return mDataId;
+    }
+}

WorkingNote.java

@@ -0,0 +1,468 @@
+/*
+ * 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 {
+    // 笔记对象，用于存储笔记的相关数据
+    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;
+    // 笔记关联的小部件类型
+    private int mWidgetType;
+    // 笔记所属的文件夹ID
+    private long mFolderId;
+    // 上下文对象，用于访问系统资源和执行数据库操作
+    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列的索引
+    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列的索引
+    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;
+        mNote = new Note();
+        // 新笔记的ID初始为0
+        mNoteId = 0;
+        // 标记笔记未被删除
+        mIsDeleted = false;
+        // 初始模式为0
+        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;
+        mFolderId = folderId;
+        mIsDeleted = false;
+        mNote = new Note();
+        // 加载笔记的相关信息
+        loadNote();
+    }
+
+    /**
+     * 加载笔记的基本信息，如所属文件夹、背景颜色、小部件信息等。
+     */
+    private void loadNote() {
+        // 查询指定ID的笔记信息
+        Cursor cursor = mContext.getContentResolver().query(
+                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
+                null, null);
+
+        if (cursor != null) {
+            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 {
+            // 若未找到笔记，记录错误日志并抛出异常
+            Log.e(TAG, "No note with id:" + mNoteId);
+            throw new IllegalArgumentException("Unable to find note with id " + mNoteId);
+        }
+        // 加载笔记的数据内容
+        loadNoteData();
+    }
+
+    /**
+     * 加载笔记的数据内容，如文本内容、模式等。
+     */
+    private void loadNoteData() {
+        // 查询指定笔记ID的数据信息
+        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 {
+            // 若未找到笔记数据，记录错误日志并抛出异常
+            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);
+        // 设置笔记的背景颜色ID
+        note.setBgColorId(defaultBgColorId);
+        // 设置笔记关联的小部件ID
+        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) {
+                    // 若创建失败，记录错误日志并返回false
+                    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();
+            }
+            // 设置笔记的背景颜色ID值
+            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;
+            // 设置笔记的小部件ID值
+            mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
+        }
+    }
+
+    /**
+     * 设置笔记的文本内容。
+     *
+     * @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);
+        // 设置笔记的父ID为通话记录文件夹ID
+        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;
+    }
+
+    /**