2Q1/WorkingNote.java

/*
 * 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;


public class WorkingNote {
    // Note for the working note
    private Note mNote;
    // Note Id
    private long mNoteId;
    // Note content
    private String mContent;
    // Note mode
    private int mMode;

    private long mAlertDate;

    private long mModifiedDate;

    private int mBgColorId;

    private int mWidgetId;

    private int mWidgetType;

    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
    };

    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;

    // New note construct
    private WorkingNote(Context context, long folderId) {
        mContext = context;
        mAlertDate = 0;
        mModifiedDate = System.currentTimeMillis();
        mFolderId = folderId;
        mNote = new Note();
        mNoteId = 0;
        mIsDeleted = false;
        mMode = 0;
        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
    }

    // Existing note construct
    private WorkingNote(Context context, long noteId, long folderId) {
        mContext = context;
        mNoteId = noteId;
        mFolderId = folderId;
        mIsDeleted = false;
        mNote = new Note();
        loadNote();
    }

    private void loadNote() {
        Cursor cursor = mContext.getContentResolver().query(
                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
                null, null);

        if (cursor != null) {
            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);
        }
    }

    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;
    }

    public static WorkingNote load(Context context, long id) {
        return new WorkingNote(context, id, 0);
    }

    public synchronized boolean saveNote() {
        if (isWorthSaving()) {
            if (!existInDatabase()) {
                if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
                    Log.e(TAG, "Create new note fail with id:" + mNoteId);
                    return false;
                }
            }

            mNote.syncNote(mContext, mNoteId);

            /**
             * Update widget content if there exist any widget of this note
             */
            if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
                    && mWidgetType != Notes.TYPE_WIDGET_INVALIDE
                    && mNoteSettingStatusListener != null) {
                mNoteSettingStatusListener.onWidgetChanged();
            }
            return true;
        } else {
            return false;
        }
    }

    public boolean existInDatabase() {
        return mNoteId > 0;
    }

    private boolean isWorthSaving() {
        if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
                || (existInDatabase() && !mNote.isLocalModified())) {
            return false;
        } else {
            return true;
        }
    }

    public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
        mNoteSettingStatusListener = l;
    }

   // 该方法用于设置提醒日期相关操作，根据传入的日期参数与当前保存的日期对比情况，更新日期值并通知相关监听器（如果存在）
public void setAlertDate(long date, boolean set) {
    // 比较传入的日期（date）和当前类中保存的提醒日期（mAlertDate）是否不相等，如果不相等，说明提醒日期有变化，需要进行相应更新操作
    if (date!= mAlertDate) {
        // 将当前类中保存的提醒日期更新为传入的新日期
        mAlertDate = date;
        // 通过mNote对象（应该是与笔记相关的某个实例，可能用于操作笔记数据）调用setNoteValue方法，
        // 将NoteColumns.ALERTED_DATE字段（可能是表示提醒日期的字段常量）的值设置为更新后的提醒日期的字符串表示形式
        mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));
    }
    // 判断mNoteSettingStatusListener（应该是实现了NoteSettingChangedListener接口的监听器对象，用于监听笔记相关设置状态变化）是否不为null，
    // 如果不为null，说明有对应的监听器，调用其onClockAlertChanged方法，通知监听器提醒日期发生了变化，传入更新后的日期和设置状态（set参数，具体含义取决于业务逻辑）
    if (mNoteSettingStatusListener!= null) {
        mNoteSettingStatusListener.onClockAlertChanged(date, set);
    }
}

// 该方法用于标记笔记是否被删除的状态，根据传入的标记值更新内部状态，并在满足一定条件下通知相关监听器（如果存在）
public void markDeleted(boolean mark) {
    // 将当前类中保存的表示笔记是否被删除的状态变量（mIsDeleted）更新为传入的标记值（mark），以此改变笔记的删除状态
    mIsDeleted = mark;
    // 判断以下多个条件是否同时满足：
    // 1. mWidgetId不等于AppWidgetManager.INVALID_APPWIDGET_ID，表示当前的小部件ID是有效的（不是无效的默认值）
    // 2. mWidgetType不等于Notes.TYPE_WIDGET_INVALIDE，表示小部件类型是有效的（不是无效的类型值）
    // 3. mNoteSettingStatusListener不为null，即存在对应的监听器
    // 如果这些条件都满足，说明符合通知监听器的情况，调用监听器的onWidgetChanged方法，通知监听器笔记的相关状态（可能与小部件相关，取决于业务逻辑）发生了变化
    if (mWidgetId!= AppWidgetManager.INVALID_APPWIDGET_ID
            && mWidgetType!= Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener!= null) {
        mNoteSettingStatusListener.onWidgetChanged();
    }
}

// 该方法用于设置笔记的背景颜色ID，根据传入的ID与当前保存的ID对比情况，更新ID值并通知相关监听器（如果存在），同时更新笔记对应的数据字段
public void setBgColorId(int id) {
    // 比较传入的背景颜色ID（id）和当前类中保存的背景颜色ID（mBgColorId）是否不相等，如果不相等，说明背景颜色ID有变化，需要进行相应更新操作
    if (id!= mBgColorId) {
        // 将当前类中保存的背景颜色ID更新为传入的新ID
        mBgColorId = id;
        // 判断mNoteSettingStatusListener（应该是实现了NoteSettingChangedListener接口的监听器对象，用于监听笔记相关设置状态变化）是否不为null，
        // 如果不为null，说明有对应的监听器，调用其onBackgroundColorChanged方法，通知监听器笔记的背景颜色ID发生了变化
        if (mNoteSettingStatusListener!= null) {
            mNoteSettingStatusListener.onBackgroundColorChanged();
        }
        // 通过mNote对象（应该是与笔记相关的某个实例，可能用于操作笔记数据）调用setNoteValue方法，
        // 将NoteColumns.BG_COLOR_ID字段（可能是表示背景颜色ID的字段常量）的值设置为更新后的背景颜色ID的字符串表示形式，以此在笔记数据中记录新的背景颜色ID
        mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id));
    }
}

// 该方法用于设置笔记的复选框列表模式，根据传入的模式与当前保存的模式对比情况，更新模式值并通知相关监听器（如果存在），同时更新笔记对应的数据字段
public void setCheckListMode(int mode) {
    // 比较传入的复选框列表模式（mode）和当前类中保存的模式（mMode）是否不相等，如果不相等，说明模式有变化，需要进行相应更新操作
    if (mMode!= mode) {
        // 判断mNoteSettingStatusListener（应该是实现了NoteSettingChangedListener接口的监听器对象，用于监听笔记相关设置状态变化）是否不为null，
        // 如果不为null，说明有对应的监听器，调用其onCheckListModeChanged方法，通知监听器笔记的复选框列表模式发生了变化，传入旧模式（mMode）和新模式（mode），方便监听器根据变化情况做相应处理
        if (mNoteSettingStatusListener!= null) {
            mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode);
        }
        // 将当前类中保存的复选框列表模式更新为传入的新模式
        mMode = mode;
        // 通过mNote对象（应该是与笔记相关的某个实例，可能用于操作笔记数据）调用setTextData方法，
        // 将TextNote.MODE字段（可能是表示复选框列表模式的字段常量）的值设置为更新后的模式的字符串表示形式，以此在笔记数据中记录新的模式
        mNote.setTextData(TextNote.MODE, String.valueOf(mMode));
    }
}

// 该方法用于设置笔记关联的小部件类型，根据传入的类型与当前保存的类型对比情况，更新类型值并更新笔记对应的数据字段
public void setWidgetType(int type) {
    // 比较传入的小部件类型（type）和当前类中保存的小部件类型（mWidgetType）是否不相等，如果不相等，说明小部件类型有变化，需要进行相应更新操作
    if (type!= mWidgetType) {
        // 将当前类中保存的小部件类型更新为传入的新类型
        mWidgetType = type;
        // 通过mNote对象（应该是与笔记相关的某个实例，可能用于操作笔记数据）调用setNoteValue方法，
        // 将NoteColumns.WIDGET_TYPE字段（可能是表示小部件类型的字段常量）的值设置为更新后的小部件类型的字符串表示形式，以此在笔记数据中记录新的小部件类型
        mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
    }
}

// 该方法用于设置笔记关联的小部件ID，根据传入的ID与当前保存的ID对比情况，更新ID值并更新笔记对应的数据字段
public void setWidgetId(int id) {
    // 比较传入的小部件ID（id）和当前类中保存的小部件ID（mWidgetId）是否不相等，如果不相等，说明小部件ID有变化，需要进行相应更新操作
    if (id!= mWidgetId) {
        // 将当前类中保存的小部件ID更新为传入的新ID
        mWidgetId = id;
        // 通过mNote对象（应该是与笔记相关的某个实例，可能用于操作笔记数据）调用setNoteValue方法，
        // 将NoteColumns.WIDGET_ID字段（可能是表示小部件ID的字段常量）的值设置为更新后的小部件ID的字符串表示形式，以此在笔记数据中记录新的小部件ID
        mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
    }
}

// 该方法用于设置笔记的工作文本内容（可能是笔记正文等相关文本），根据传入的文本与当前保存的文本对比情况，更新文本内容并更新笔记对应的数据字段
public void setWorkingText(String text) {
    // 使用TextUtils.equals方法（可能是用于比较字符串是否相等的工具方法）比较传入的文本（text）和当前类中保存的文本内容（mContent）是否不相等，
    // 如果不相等，说明文本内容有变化，需要进行相应更新操作
    if (!TextUtils.equals(mContent, text)) {
        // 将当前类中保存的文本内容更新为传入的新文本
        mContent = text;
        // 通过mNote对象（应该是与笔记相关的某个实例，可能用于操作笔记数据）调用setTextData方法，
        // 将DataColumns.CONTENT字段（可能是表示笔记文本内容的字段常量）的值设置为更新后的文本内容（mContent），以此在笔记数据中记录新的文本内容
        mNote.setTextData(DataColumns.CONTENT, mContent);
    }
}

// 该方法用于将笔记转换为通话笔记类型，设置通话笔记相关的数据字段，比如通话日期、电话号码以及所属文件夹ID（可能是将普通笔记转换为通话记录相关的笔记）
public void convertToCallNote(String phoneNumber, long callDate) {
    // 通过mNote对象（应该是与笔记相关的某个实例，可能用于操作笔记数据）调用setCallData方法，
    // 将CallNote.CALL_DATE字段（可能是表示通话日期的字段常量）的值设置为通话日期的字符串表示形式，以此在笔记数据中记录通话日期信息
    mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
    // 通过mNote对象（应该是与笔记相关的某个实例，可能用于操作笔记数据）调用setCallData方法，
    // 将CallNote.PHONE_NUMBER字段（可能是表示电话号码的字段常量）的值设置为传入的电话号码（phoneNumber），以此在笔记数据中记录电话号码信息
    mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
    // 通过mNote对象（应该是与笔记相关的某个实例，可能用于操作笔记数据）调用setNoteValue方法，
    // 将NoteColumns.PARENT_ID字段（可能是表示笔记所属文件夹ID的字段常量）的值设置为Notes.ID_CALL_RECORD_FOLDER（可能是代表通话记录文件夹的常量ID）的字符串表示形式，
    // 以此将笔记的所属文件夹设置为通话记录文件夹，完成将笔记转换为通话笔记并关联到对应文件夹的操作
    mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
}

// 该方法用于判断笔记是否设置了时钟提醒，根据保存的提醒日期（mAlertDate）的值来返回相应的布尔值结果
public boolean hasClockAlert() {
    // 使用三目运算符判断mAlertDate是否大于0，如果大于0，表示设置了提醒日期，返回true；否则返回false，以此表明笔记是否有设置时钟提醒
    return (mAlertDate > 0? true : false);
}

// 该方法用于获取笔记的文本内容（可能是笔记正文等相关文本），直接返回当前类中保存的文本内容（mContent）变量的值
public String getContent() {
    return mContent;
}

// 该方法用于获取笔记设置的提醒日期，直接返回当前类中保存的提醒日期（mAlertDate）变量的值
public long getAlertDate() {
    return mAlertDate;
}

// 该方法用于获取笔记的最后修改日期，直接返回当前类中保存的最后修改日期（mModifiedDate）变量的值
public long getModifiedDate() {
    return mModifiedDate;
}

// 该方法用于获取笔记背景颜色对应的资源ID，通过NoteBgResources类（可能是用于管理笔记背景资源相关的工具类）的getNoteBgResource静态方法，
// 传入当前类中保存的背景颜色ID（mBgColorId）来获取对应的背景颜色资源ID并返回
public int getBgColorResId() {
    return NoteBgResources.getNoteBgResource(mBgColorId);
}

// 该方法用于获取笔记的背景颜色ID，直接返回当前类中保存的背景颜色ID（mBgColorId）变量的值
public int getBgColorId() {
    return mBgColorId;
}

// 该方法用于获取笔记标题背景对应的资源ID，通过NoteBgResources类（可能是用于管理笔记背景资源相关的工具类）的getNoteTitleBgResource静态方法，
// 传入当前类中保存的背景颜色ID（mBgColorId）来获取对应的标题背景资源ID并返回
public int getTitleBgResId() {
    return NoteBgResources.getNoteTitleBgResource(mBgColorId);
}

// 该方法用于获取笔记的复选框列表模式，直接返回当前类中保存的复选框列表模式（mMode）变量的值
public int getCheckListMode() {
    return mMode;
}

// 该方法用于获取笔记的唯一标识ID，直接返回当前类中保存的笔记ID（mNoteId）变量的值
public long getNoteId() {
    return mNoteId;
}

// 该方法用于获取笔记所属文件夹的ID，直接返回当前类中保存的文件夹ID（mFolderId）变量的值
public long getFolderId() {
    return mFolderId;
}

// 该方法用于获取笔记关联的小部件ID，直接返回当前类中保存的小部件ID（mWidgetId）变量的值
public int getWidgetId() {
    return mWidgetId;
}

// 该方法用于获取笔记关联的小部件类型，直接返回当前类中保存的小部件类型（mWidgetType）变量的值
public int getWidgetType() {
    return mWidgetType;
}

// 定义一个内部接口NoteSettingChangedListener，用于定义当笔记相关设置发生变化时需要调用的回调方法，方便外部类实现该接口来监听并处理相应变化
public interface NoteSettingChangedListener {
    /**
     * 当笔记的背景颜色刚刚发生变化时调用的方法，具体实现由实现该接口的类来定义，用于处理背景颜色变化后的相关逻辑
     */
    void onBackgroundColorChanged();

    /**
     * 当用户设置时钟（可能是设置提醒时钟相关操作）时调用的方法，传入设置的日期和设置状态（具体含义由业务逻辑决定），
     * 具体实现由实现该接口的类来定义，用于处理时钟设置相关的逻辑
     */
    void onClockAlertChanged(long date, boolean set);

    /**
     * 当用户从小部件创建笔记时调用的方法，具体实现由实现该接口的类来定义，用于处理从小部件创建笔记相关的逻辑
     */
    void onWidgetChanged();

    /**
     * 当在复选框列表模式和普通模式之间切换时调用的方法，传入旧模式（切换前的模式）和新模式（切换后的模式），
     * 具体实现由实现该接口的类来定义，用于处理模式切换相关的逻辑
     */
    void onCheckListModeChanged(int oldMode, int newMode);
}