dingshuoran
dingshuoran 9 months ago
parent 73cdca93ee
commit c7e628c611

@ -35,76 +35,135 @@ import java.util.ArrayList;
public class Note {
// 存储笔记的差异值,使用 ContentValues 类型,可能用于存储一些更新信息
private ContentValues mNoteDiffValues;
// 存储笔记的数据,使用 NoteData 类型
private NoteData mNoteData;
// 日志标签,用于日志输出
private static final String TAG = "Note";
/**
* Create a new note id for adding a new note to databases
* ID 线
*/
public static synchronized long getNewNoteId(Context context, long folderId) {
// Create a new note in the database
// 创建一个新的 ContentValues 对象,用于存储即将插入数据库的数据
ContentValues values = new ContentValues();
// 获取当前系统时间作为创建时间和修改时间
long createdTime = System.currentTimeMillis();
// 将创建时间添加到 ContentValues 中
values.put(NoteColumns.CREATED_DATE, createdTime);
// 将修改时间添加到 ContentValues 中
values.put(NoteColumns.MODIFIED_DATE, createdTime);
// 笔记的类型,这里可能是预定义的 TYPE_NOTE
values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
// 标记为本地已修改
values.put(NoteColumns.LOCAL_MODIFIED, 1);
// 父文件夹的 ID
values.put(NoteColumns.PARENT_ID, folderId);
// 通过 ContentResolver 插入数据,并获取插入后的 Uri
Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
long noteId = 0;
try {
// 从 Uri 的路径段中获取笔记的 ID这里假定 Uri 的路径段的第二个元素是笔记 ID
noteId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
// 若获取 ID 时出现异常,输出错误日志,并将 noteId 设为 0
Log.e(TAG, "Get note id error :" + e.toString());
noteId = 0;
}
// 如果笔记 ID 为 -1抛出异常
if (noteId == -1) {
throw new IllegalStateException("Wrong note id:" + noteId);
}
// 返回创建的笔记 ID
return noteId;
}
// 构造函数,初始化 Note 对象
public Note() {
mNoteDiffValues = new ContentValues();
mNoteData = new NoteData();
}
/**
*
* @param key
* @param value
*/
public void setNoteValue(String key, String value) {
// 将键值对添加到 mNoteDiffValues 中
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 mNoteDiffValues mNoteData 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) {
// 如果笔记 ID 不合法,抛出异常
if (noteId <= 0) {
throw new IllegalArgumentException("Wrong note id:" + noteId);
}
// 如果笔记未在本地修改,认为同步成功
if (!isLocalModified()) {
return true;
}
@ -113,141 +172,195 @@ public class Note {
* In theory, once data changed, the note should be updated on {@link NoteColumns#LOCAL_MODIFIED} and
* {@link NoteColumns#MODIFIED_DATE}. For data safety, though update note fails, we also update the
* note data info
* NoteColumns#LOCAL_MODIFIED NoteColumns#MODIFIED_DATE 使
*/
if (context.getContentResolver().update(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
null) == 0) {
// 如果更新笔记失败,输出错误日志
Log.e(TAG, "Update note error, should not happen");
// Do not return, fall through
// 不返回,继续执行下面的操作
}
// 清空 mNoteDiffValues可能表示此次修改已同步
mNoteDiffValues.clear();
// 如果 mNoteData 本地修改且将数据推送到 ContentResolver 失败,同步失败
if (mNoteData.isLocalModified()
&& (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
return false;
}
// 同步成功
return true;
}
}
// 定义一个名为 Note 的公共类
public class Note {
// 存储笔记差异值的私有变量,使用 ContentValues 类型,可存储键值对数据
private ContentValues mNoteDiffValues;
// 存储笔记数据的私有变量,使用 NoteData 类型
private NoteData mNoteData;
// 用于日志输出的静态常量标签,方便在日志中识别该类的相关信息
private static final String TAG = "Note";
/**
* ID
* 线线
* @param context ContentResolver
* @param folderId ID
* @return ID
*/
public static synchronized long getNewNoteId(Context context, long folderId) {
// 创建一个新的 ContentValues 对象,用于存储插入数据库的数据
ContentValues values = new ContentValues();
// 获取当前系统时间的毫秒数作为笔记的创建时间
long createdTime = System.currentTimeMillis();
// 将创建时间存储在 CREATED_DATE 列中
values.put(NoteColumns.CREATED_DATE, createdTime);
// 将创建时间存储在 MODIFIED_DATE 列中,新笔记的创建时间也是其初始修改时间
values.put(NoteColumns.MODIFIED_DATE, createdTime);
// 存储笔记的类型Notes.TYPE_NOTE 应该是预定义的笔记类型常量
values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
// 标记该笔记在本地已修改,可能用于后续的同步或更新操作
values.put(NoteColumns.LOCAL_MODIFIED, 1);
// 存储笔记所属的父文件夹的 ID
values.put(NoteColumns.PARENT_ID, folderId);
// 通过 ContentResolver 插入新的笔记数据到指定的 URI并返回插入后的 URI
Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
long noteId = 0;
try {
// 从返回的 URI 中获取笔记的 ID这里假设 URI 的路径部分包含笔记的 ID通常是 URI 的第二个部分
noteId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
// 捕获数字格式异常,打印错误日志,并将 noteId 设置为 0
Log.e(TAG, "Get note id error :" + e.toString());
noteId = 0;
}
// 如果笔记 ID 为 -1则抛出异常因为这是一个错误的笔记 ID
if (noteId == -1) {
throw new IllegalStateException("Wrong note id:" + noteId);
}
// 返回新创建的笔记的 ID
return noteId;
}
// Note 类的构造函数,用于初始化 Note 对象
public Note() {
// 初始化存储笔记差异值的 ContentValues 对象
mNoteDiffValues = new ContentValues();
// 初始化存储笔记数据的 NoteData 对象
mNoteData = new NoteData();
}
private class NoteData {
private long mTextDataId;
/**
*
*
* @param key
* @param value
*/
public void setNoteValue(String key, String value) {
// 将键值对存储到 mNoteDiffValues 中
mNoteDiffValues.put(key, value);
// 标记该笔记在本地已修改
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
// 更新笔记的修改时间为当前系统时间
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
private ContentValues mTextDataValues;
/**
*
* NoteData
* @param key
* @param value
*/
public void setTextData(String key, String value) {
mNoteData.setTextData(key, value);
}
private long mCallDataId;
/**
* ID
* @param id ID
*/
public void setTextDataId(long id) {
mNoteData.setTextDataId(id);
}
private ContentValues mCallDataValues;
/**
* ID
* @return ID
*/
public long getTextDataId() {
return mNoteData.mTextDataId;
}
private static final String TAG = "NoteData";
/**
* ID
* NoteData ID
* @param id ID
*/
public void setCallDataId(long id) {
mNoteData.setCallDataId(id);
}
public NoteData() {
mTextDataValues = new ContentValues();
mCallDataValues = new ContentValues();
mTextDataId = 0;
mCallDataId = 0;
}
/**
*
* NoteData
* @param key
* @param value
*/
public void setCallData(String key, String value) {
mNoteData.setCallData(key, value);
}
boolean isLocalModified() {
return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
}
/**
*
* mNoteDiffValues NoteData
* @return true false
*/
public boolean isLocalModified() {
return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
}
void setTextDataId(long id) {
if(id <= 0) {
throw new IllegalArgumentException("Text data id should larger than 0");
}
mTextDataId = id;
/**
*
* @param context ContentResolver
* @param noteId ID
* @return true false
*/
public boolean syncNote(Context context, long noteId) {
// 检查笔记 ID 是否合法,如果不合法则抛出异常
if (noteId <= 0) {
throw new IllegalArgumentException("Wrong note id:" + noteId);
}
void setCallDataId(long id) {
if (id <= 0) {
throw new IllegalArgumentException("Call data id should larger than 0");
}
mCallDataId = id;
// 如果笔记未在本地修改,认为同步成功
if (!isLocalModified()) {
return true;
}
void setCallData(String key, String value) {
mCallDataValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
/**
* LOCAL_MODIFIED MODIFIED_DATE
* 使
*/
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可能表示当前的修改已同步到数据库
mNoteDiffValues.clear();
void setTextData(String key, String value) {
mTextDataValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
// 如果 NoteData 已在本地修改,并且将其数据推送到 ContentResolver 失败,则同步失败
if (mNoteData.isLocalModified()
&& (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
return false;
}
Uri pushIntoContentResolver(Context context, long noteId) {
/**
* Check for safety
*/
if (noteId <= 0) {
throw new IllegalArgumentException("Wrong note id:" + noteId);
}
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
ContentProviderOperation.Builder builder = null;
if(mTextDataValues.size() > 0) {
mTextDataValues.put(DataColumns.NOTE_ID, noteId);
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)));
} 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);
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)));
} 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;
}
// 表示笔记数据已成功同步
return true;
}
}
}

@ -33,35 +33,36 @@ import net.micode.notes.tool.ResourceParser.NoteBgResources;
public class WorkingNote {
// Note for the working note
// 存储工作笔记的信息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,
@ -72,6 +73,7 @@ public class WorkingNote {
DataColumns.DATA4,
};
// 用于查询笔记信息的投影,指定了需要从数据库中查询的列
public static final String[] NOTE_PROJECTION = new String[] {
NoteColumns.PARENT_ID,
NoteColumns.ALERTED_DATE,
@ -81,27 +83,21 @@ public class WorkingNote {
NoteColumns.MODIFIED_DATE
};
// 数据投影中各列的索引,方便从 Cursor 中获取数据
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;
// 笔记投影中各列的索引,方便从 Cursor 中获取数据
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
// 私有构造函数,用于创建新的笔记
// 初始化笔记的一些基本信息,如修改日期、文件夹 ID、创建 Note 对象、标记为未删除等
private WorkingNote(Context context, long folderId) {
mContext = context;
mAlertDate = 0;
@ -114,7 +110,8 @@ public class WorkingNote {
mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
}
// Existing note construct
// 私有构造函数,用于加载已存在的笔记
// 根据笔记 ID 和文件夹 ID 加载笔记信息
private WorkingNote(Context context, long noteId, long folderId) {
mContext = context;
mNoteId = noteId;
@ -124,13 +121,16 @@ public class WorkingNote {
loadNote();
}
// 从数据库中加载笔记信息
private void loadNote() {
// 使用 ContentResolver 查询笔记信息
Cursor cursor = mContext.getContentResolver().query(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
null, null);
if (cursor != null) {
if (cursor!= null) {
if (cursor.moveToFirst()) {
// 从 Cursor 中获取笔记的各项信息
mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN);
@ -140,22 +140,26 @@ public class WorkingNote {
}
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() {
// 使用 ContentResolver 查询笔记的数据信息
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!= 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);
@ -169,11 +173,13 @@ public class WorkingNote {
}
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);
@ -183,27 +189,27 @@ public class WorkingNote {
return note;
}
// 加载已存在的笔记
public static WorkingNote load(Context context, long id) {
return new WorkingNote(context, id, 0);
}
// 保存笔记到数据库
public synchronized boolean saveNote() {
if (isWorthSaving()) {
if (!existInDatabase()) {
// 获取新的笔记 ID如果获取失败记录错误日志
if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
Log.e(TAG, "Create new note fail with id:" + mNoteId);
return false;
}
}
// 同步笔记信息到数据库
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) {
// 如果笔记关联了小部件且设置监听器存在,通知小部件更新
if (mWidgetId!= AppWidgetManager.INVALID_APPWIDGET_ID
&& mWidgetType!= Notes.TYPE_WIDGET_INVALIDE
&& mNoteSettingStatusListener!= null) {
mNoteSettingStatusListener.onWidgetChanged();
}
return true;
@ -212,54 +218,62 @@ public class WorkingNote {
}
}
// 检查笔记是否已存在于数据库中
public boolean existInDatabase() {
return mNoteId > 0;
}
// 判断笔记是否值得保存
private boolean isWorthSaving() {
// 如果笔记已删除、不存在且内容为空或者已存在但未被本地修改,则不值得保存
if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
|| (existInDatabase() && !mNote.isLocalModified())) {
|| (existInDatabase() &&!mNote.isLocalModified())) {
return false;
} else {
return true;
}
}
// 设置笔记设置更改的监听器
public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
mNoteSettingStatusListener = l;
}
// 设置提醒日期,并通知监听器
public void setAlertDate(long date, boolean set) {
if (date != mAlertDate) {
if (date!= mAlertDate) {
mAlertDate = date;
mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));
}
if (mNoteSettingStatusListener != null) {
if (mNoteSettingStatusListener!= null) {
mNoteSettingStatusListener.onClockAlertChanged(date, set);
}
}
// 标记笔记是否已删除,并通知监听器
public void markDeleted(boolean mark) {
mIsDeleted = mark;
if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
&& mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) {
if (mWidgetId!= AppWidgetManager.INVALID_APPWIDGET_ID
&& mWidgetType!= Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener!= null) {
mNoteSettingStatusListener.onWidgetChanged();
}
}
// 设置背景颜色标识符,并通知监听器
public void setBgColorId(int id) {
if (id != mBgColorId) {
if (id!= mBgColorId) {
mBgColorId = id;
if (mNoteSettingStatusListener != null) {
if (mNoteSettingStatusListener!= null) {
mNoteSettingStatusListener.onBackgroundColorChanged();
}
mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id));
}
}
// 设置清单模式,并通知监听器
public void setCheckListMode(int mode) {
if (mMode != mode) {
if (mNoteSettingStatusListener != null) {
if (mMode!= mode) {
if (mNoteSettingStatusListener!= null) {
mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode);
}
mMode = mode;
@ -267,20 +281,23 @@ public class WorkingNote {
}
}
// 设置小部件类型
public void setWidgetType(int type) {
if (type != mWidgetType) {
if (type!= mWidgetType) {
mWidgetType = type;
mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
}
}
// 设置小部件标识符
public void setWidgetId(int id) {
if (id != mWidgetId) {
if (id!= mWidgetId) {
mWidgetId = id;
mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
}
}
// 设置笔记的工作文本
public void setWorkingText(String text) {
if (!TextUtils.equals(mContent, text)) {
mContent = text;
@ -288,81 +305,82 @@ public class WorkingNote {
}
}
// 将笔记转换为通话笔记
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));
}
// 判断是否设置了时钟提醒
public boolean hasClockAlert() {
return (mAlertDate > 0 ? true : false);
return (mAlertDate > 0? true : false);
}
// 获取笔记的内容
public String getContent() {
return mContent;
}
// 获取提醒日期
public long getAlertDate() {
return mAlertDate;
}
// 获取修改日期
public long getModifiedDate() {
return mModifiedDate;
}
// 获取背景颜色资源标识符
public int getBgColorResId() {
return NoteBgResources.getNoteBgResource(mBgColorId);
}
// 获取背景颜色标识符
public int getBgColorId() {
return mBgColorId;
}
// 获取标题背景资源标识符
public int getTitleBgResId() {
return NoteBgResources.getNoteTitleBgResource(mBgColorId);
}
// 获取清单模式
public int getCheckListMode() {
return mMode;
}
// 获取笔记的 ID
public long getNoteId() {
return mNoteId;
}
// 获取文件夹的 ID
public long getFolderId() {
return mFolderId;
}
// 获取小部件的 ID
public int getWidgetId() {
return mWidgetId;
}
// 获取小部件的类型
public int getWidgetType() {
return mWidgetType;
}
// 定义一个接口,用于监听笔记设置的更改
public interface NoteSettingChangedListener {
/**
* Called when the background color of current note has just changed
*/
// 当背景颜色改变时调用
void onBackgroundColorChanged();
/**
* Called when user set clock
*/
// 当设置时钟提醒时调用
void onClockAlertChanged(long date, boolean set);
/**
* Call when user create note from widget
*/
// 当小部件改变时调用
void onWidgetChanged();
/**
* Call when switch between check list mode and normal mode
* @param oldMode is previous mode before change
* @param newMode is new mode
*/
// 当切换清单模式时调用
void onCheckListModeChanged(int oldMode, int newMode);
}
}
}
Loading…
Cancel
Save