JJJ/src/net/micode/notes/model/WorkingNote.java

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;

/**
 * 表示一个正在编辑或显示的笔记，负责管理笔记的加载、保存和数据同步
 */
public class WorkingNote {
    // 核心Note对象，用于实际数据操作
    private Note mNote;
    // 当前笔记的数据库ID（0表示新笔记）
    private long mNoteId;
    // 笔记的文本内容
    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,       // 父文件夹ID
            NoteColumns.ALERTED_DATE,     // 提醒时间
            NoteColumns.BG_COLOR_ID,     // 背景色ID
            NoteColumns.WIDGET_ID,        // 小部件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;  // 默认无提醒
        mModifiedDate = System.currentTimeMillis();
        mFolderId = folderId;
        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;
        mFolderId = folderId;
        mIsDeleted = false;
        mNote = new Note();
        loadNote(); // 从数据库加载数据
    }

    /**
     * 从数据库加载笔记元数据
     * @throws IllegalArgumentException 如果找不到对应笔记时抛出
     */
    private void loadNote() {
        // 构建笔记URI并查询
        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, "找不到ID为 " + mNoteId + " 的笔记");
            throw new IllegalArgumentException("找不到笔记: " + 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, "未知笔记类型: " + type);
                    }
                } while (cursor.moveToNext());
            }
            cursor.close();
        } else {
            Log.e(TAG, "找不到ID为 " + mNoteId + " 的笔记数据");
            throw new IllegalArgumentException("找不到笔记数据: " + mNoteId);
        }
    }

    /**
     * 创建新的空笔记
     * @param context 上下文
     * @param folderId 文件夹ID
     * @param widgetId 关联小部件ID
     * @param widgetType 小部件类型
     * @param defaultBgColorId 默认背景色
     * @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);
        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()) { // 新笔记需要生成ID
                if ((mNoteId =