p2cafumxo
/
5._Open-source-software-reading-annotation
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

yhz

Browse Source
于昊正
yhz 7 months ago
parent 0988272265
commit e520938d17
6 changed files with 468 additions and 2211 deletions
Show Stats Download Patch File Download Diff File

255
src/ui/NoteItemData.java
Unescape View File

@ -13,107 +13,106 @@
* 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.database.Cursor;
import android.text.TextUtils;
import net.micode.notes.data.Contact;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.tool.DataUtils;
/**
* 代表一个笔记项的数据类，用于存储和管理笔记的各种信息。
* 此类封装了笔记的所有属性，并提供构造函数来填充这些属性，以及辅助方法来确定笔记在列表中的位置状态。
*/
public class NoteItemData {
// 定义查询时要投影的列
// 定义查询时要投影的列（即从数据库中读取哪些字段）
static final String[] PROJECTION = new String[]{
NoteColumns.ID,
NoteColumns.ALERTED_DATE,
NoteColumns.BG_COLOR_ID,
NoteColumns.CREATED_DATE,
NoteColumns.HAS_ATTACHMENT,
NoteColumns.MODIFIED_DATE,
NoteColumns.NOTES_COUNT,
NoteColumns.PARENT_ID,
NoteColumns.SNIPPET,
NoteColumns.TYPE,
NoteColumns.WIDGET_ID,
NoteColumns.WIDGET_TYPE,
NoteColumns.ID, // 笔记ID
NoteColumns.ALERTED_DATE, // 提醒日期
NoteColumns.BG_COLOR_ID, // 背景颜色ID
NoteColumns.CREATED_DATE, // 创建日期
NoteColumns.HAS_ATTACHMENT, // 是否有附件
NoteColumns.MODIFIED_DATE, // 修改日期
NoteColumns.NOTES_COUNT, // 子笔记数量（如果是文件夹类型）
NoteColumns.PARENT_ID, // 父级ID（用于组织结构）
NoteColumns.SNIPPET, // 笔记摘要或片段
NoteColumns.TYPE, // 笔记类型（例如普通笔记、通话记录等）
NoteColumns.WIDGET_ID, // 关联的小部件ID
NoteColumns.WIDGET_TYPE // 小部件类型
};
// 各列数据的索引
private static final int ID_COLUMN = 0;
private static final int ALERTED_DATE_COLUMN = 1;
private static final int BG_COLOR_ID_COLUMN = 2;
private static final int CREATED_DATE_COLUMN = 3;
private static final int HAS_ATTACHMENT_COLUMN = 4;
private static final int MODIFIED_DATE_COLUMN = 5;
private static final int NOTES_COUNT_COLUMN = 6;
private static final int PARENT_ID_COLUMN = 7;
private static final int SNIPPET_COLUMN = 8;
private static final int TYPE_COLUMN = 9;
private static final int WIDGET_ID_COLUMN = 10;
private static final int WIDGET_TYPE_COLUMN = 11;
// 笔记的各项数据
private long mId;
private long mAlertDate;
private int mBgColorId;
private long mCreatedDate;
private boolean mHasAttachment;
private long mModifiedDate;
private int mNotesCount;
private long mParentId;
private String mSnippet;
private int mType;
private int mWidgetId;
private int mWidgetType;
private String mName;
private String mPhoneNumber;
// 各列数据的索引常量，方便通过Cursor获取数据
private static final int ID_COLUMN = 0; // 笔记ID的索引
private static final int ALERTED_DATE_COLUMN = 1; // 提醒日期的索引
private static final int BG_COLOR_ID_COLUMN = 2; // 背景颜色ID的索引
private static final int CREATED_DATE_COLUMN = 3; // 创建日期的索引
private static final int HAS_ATTACHMENT_COLUMN = 4; // 是否有附件的索引
private static final int MODIFIED_DATE_COLUMN = 5; // 修改日期的索引
private static final int NOTES_COUNT_COLUMN = 6; // 子笔记数量的索引
private static final int PARENT_ID_COLUMN = 7; // 父级ID的索引
private static final int SNIPPET_COLUMN = 8; // 笔记摘要的索引
private static final int TYPE_COLUMN = 9; // 笔记类型的索引
private static final int WIDGET_ID_COLUMN = 10; // 小部件ID的索引
private static final int WIDGET_TYPE_COLUMN = 11; // 小部件类型的索引
// 笔记的各项数据成员变量
private long mId; // 笔记ID
private long mAlertDate; // 提醒日期
private int mBgColorId; // 背景颜色ID
private long mCreatedDate; // 创建日期
private boolean mHasAttachment; // 是否有附件
private long mModifiedDate; // 修改日期
private int mNotesCount; // 子笔记数量
private long mParentId; // 父级ID
private String mSnippet; // 笔记摘要
private int mType; // 笔记类型
private int mWidgetId; // 小部件ID
private int mWidgetType; // 小部件类型
private String mName; // 对于通话记录笔记，联系人名称
private String mPhoneNumber; // 对于通话记录笔记，电话号码
// 用于标识笔记在列表中的位置状态
private boolean mIsLastItem;
private boolean mIsFirstItem;
private boolean mIsOnlyOneItem;
private boolean mIsOneNoteFollowingFolder;
private boolean mIsMultiNotesFollowingFolder;
private boolean mIsLastItem; // 是否为列表最后一项
private boolean mIsFirstItem; // 是否为列表第一项
private boolean mIsOnlyOneItem; // 列表是否仅有一项
private boolean mIsOneNoteFollowingFolder; // 是否为紧跟在文件夹后的单个笔记
private boolean mIsMultiNotesFollowingFolder; // 是否为紧跟在文件夹后的多个笔记
/**
* 根据Cursor数据构造一个NoteItemData对象。
*
* @param context 上下文对象，用于访问应用全局功能。
* @param cursor 包含笔记数据的Cursor对象。
* 构造函数，根据给定的上下文和游标创建一个新的 NoteItemData 对象。
* @param context 应用程序上下文，用于访问全局资源和服务
* @param cursor 包含笔记数据的游标
*/
public NoteItemData(Context context, Cursor cursor) {
// 从Cursor中提取各项数据并赋值
// 使用游标中的数据初始化笔记对象的各个属性
mId = cursor.getLong(ID_COLUMN);
mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false;
mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0); // 是否存在附件
mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
mParentId = cursor.getLong(PARENT_ID_COLUMN);
mSnippet = cursor.getString(SNIPPET_COLUMN);
mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
NoteEditActivity.TAG_UNCHECKED, "");
// 清除HTML标签，如果有的话（如复选框标记）
mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "")
.replace(NoteEditActivity.TAG_UNCHECKED, "");
mType = cursor.getInt(TYPE_COLUMN);
mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
// 如果是通话记录笔记，尝试获取通话号码和联系人名称
mPhoneNumber = "";
// 如果是通话记录笔记，则尝试获取与之关联的电话号码和联系人名称
if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
if (!TextUtils.isEmpty(mPhoneNumber)) {
mName = Contact.getContact(context, mPhoneNumber);
if (mName == null) {
mName = mPhoneNumber;
mName = mPhoneNumber; // 如果没有找到联系人，则使用电话号码作为名称
}
}
}
@ -122,136 +121,30 @@ public class NoteItemData {
if (mName == null) {
mName = "";
}
checkPostion(cursor);
checkPostion(cursor); // 检查并设置笔记的位置状态
}
/**
* 根据当前Cursor位置，更新NoteItemData的状态信息（如是否为列表中的最后一个项目等）。
*
* @param cursor 包含笔记数据的Cursor对象。
* 根据当前游标的位置更新 NoteItemData 的位置状态信息。
* @param cursor 包含笔记数据的游标
*/
private void checkPostion(Cursor cursor) {
// 更新位置状态信息
mIsLastItem = cursor.isLast();
mIsFirstItem = cursor.isFirst();
mIsOnlyOneItem = (cursor.getCount() == 1);
mIsMultiNotesFollowingFolder = false;
mIsOneNoteFollowingFolder = false;
// 更新笔记的位置状态信息
mIsLastItem = cursor.isLast(); // 是否为最后一条记录
mIsFirstItem = cursor.isFirst(); // 是否为第一条记录
mIsOnlyOneItem = (cursor.getCount() == 1); // 是否只有这一条记录
// 检查当前笔记是否跟随文件夹，并更新相应状态
if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
int position = cursor.getPosition();
if (cursor.moveToPrevious()) {
if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
|| cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
if (cursor.getCount() > (position + 1)) {
mIsMultiNotesFollowingFolder = true;
cursor.moveToPrevious();
mIsOneNoteFollowingFolder = (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER);
mIsMultiNotesFollowingFolder = false; // 默认值
cursor.moveToPosition(position); // 移回原来的位置
} else {
mIsOneNoteFollowingFolder = true;
}
}
// 确保Cursor能够回到原来的位置
if (!cursor.moveToNext()) {
throw new IllegalStateException("cursor move to previous but can't move back");
}
}
}
}
// 以下为获取NoteItemData各项属性的方法
public boolean isOneFollowingFolder() {
return mIsOneNoteFollowingFolder;
}
public boolean isMultiFollowingFolder() {
return mIsMultiNotesFollowingFolder;
}
public boolean isLast() {
return mIsLastItem;
}
public String getCallName() {
return mName;
}
public boolean isFirst() {
return mIsFirstItem;
}
public boolean isSingle() {
return mIsOnlyOneItem;
}
public long getId() {
return mId;
}
public long getAlertDate() {
return mAlertDate;
}
public long getCreatedDate() {
return mCreatedDate;
}
public boolean hasAttachment() {
return mHasAttachment;
}
public long getModifiedDate() {
return mModifiedDate;
}
public int getBgColorId() {
return mBgColorId;
}
public long getParentId() {
return mParentId;
}
public int getNotesCount() {
return mNotesCount;
}
public long getFolderId() {
return mParentId;
}
public int getType() {
return mType;
}
public int getWidgetType() {
return mWidgetType;
}
public int getWidgetId() {
return mWidgetId;
}
public String getSnippet() {
return mSnippet;
}
public boolean hasAlert() {
return (mAlertDate > 0);
}
public boolean isCallRecord() {
return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
mIsOneNoteFollowingFolder = false;
mIsMultiNotesFollowingFolder = false;
}
/**
* 从Cursor中获取笔记的类型。
*
* @param cursor 包含笔记数据的Cursor对象。
* @return 笔记的类型。
*/
public static int getNoteType(Cursor cursor) {
return cursor.getInt(TYPE_COLUMN);
}
}

141
src/ui/NoteWidgetProvider.java
Unescape View File

@ -2,7 +2,6 @@
* 注意：此代码段的版权归 MiCode 开源社区所有（www.micode.net）
* 本代码遵循 Apache 2.0 许可证，您可以在 http://www.apache.org/licenses/LICENSE-2.0 查看许可证内容。
*/
package net.micode.notes.widget;
import android.app.PendingIntent;
@ -14,7 +13,6 @@ import android.content.Intent;
import android.database.Cursor;
import android.util.Log;
import android.widget.RemoteViews;
import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
@ -24,83 +22,89 @@ import net.micode.notes.ui.NotesListActivity;
/**
* 笔记小部件提供者抽象类，扩展自AppWidgetProvider，用于管理和更新笔记小部件的内容。
* 此类提供了小部件的基本功能，如查询、更新和删除小部件关联的数据，并为子类提供了必要的工具方法。
*/
public abstract class NoteWidgetProvider extends AppWidgetProvider {
// 查询笔记时用到的列名数组
// 定义查询数据库时需要的列名数组
public static final String[] PROJECTION = new String[]{
NoteColumns.ID,
NoteColumns.BG_COLOR_ID,
NoteColumns.SNIPPET
NoteColumns.ID, // 笔记ID
NoteColumns.BG_COLOR_ID, // 背景颜色ID
NoteColumns.SNIPPET // 笔记摘要或片段
};
// 列的索引常量
public static final int COLUMN_ID = 0;
public static final int COLUMN_BG_COLOR_ID = 1;
public static final int COLUMN_SNIPPET = 2;
// 定义对应于上述PROJECTION数组中各元素的索引常量
public static final int COLUMN_ID = 0; // 笔记ID的索引
public static final int COLUMN_BG_COLOR_ID = 1; // 背景颜色ID的索引
public static final int COLUMN_SNIPPET = 2; // 笔记摘要的索引
// 日志标签
// 定义日志标签，方便调试输出
private static final String TAG = "NoteWidgetProvider";
/**
* 当小部件被删除时调用，更新数据库中对应小部件的ID为无效ID。
* 当小部件被用户从主屏幕移除时调用，将数据库中与该小部件相关联的记录更新为无效状态。
*/
@Override
public void onDeleted(Context context, int[] appWidgetIds) {
ContentValues values = new ContentValues();
values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); // 设置为无效的小部件ID
for (int i = 0; i < appWidgetIds.length; i++) {
context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
values,
NoteColumns.WIDGET_ID + "=?",
new String[]{String.valueOf(appWidgetIds[i])});
context.getContentResolver().update(
Notes.CONTENT_NOTE_URI, // 更新的URI
values, // 新值
NoteColumns.WIDGET_ID + "=?", // WHERE子句
new String[]{String.valueOf(appWidgetIds[i])} // WHERE参数
);
}
}
/**
* 根据小部件ID查询对应的笔记信息。
* 根据给定的小部件ID查询对应的笔记信息。
*
* @param context 上下文
* @param context 上下文环境
* @param widgetId 小部件ID
* @return 返回查询到的Cursor对象，包含笔记的摘要、背景ID等信息。
* @return 返回包含笔记摘要、背景ID等信息的Cursor对象
*/
private Cursor getNoteWidgetInfo(Context context, int widgetId) {
return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
PROJECTION,
NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
new String[]{String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER)},
null);
return context.getContentResolver().query(
Notes.CONTENT_NOTE_URI, // 查询的URI
PROJECTION, // 查询的列
NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?", // 查询条件
new String[]{String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER)}, // 查询条件参数
null // 排序依据
);
}
/**
* 更新小部件显示内容的通用方法。
* 更新小部件显示内容的方法，可以根据是否隐私模式来调整显示内容。
*
* @param context 上下文
* @param appWidgetManager AppWidget管理器
* @param appWidgetIds 小部件ID数组
* @param context 应用上下文
* @param appWidgetManager AppWidget管理器实例
* @param appWidgetIds 需要更新的小部件ID数组
*/
protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
update(context, appWidgetManager, appWidgetIds, false);
}
/**
* 根据是否隐私模式更新小部件显示内容。
* 私有方法，根据是否隐私模式更新小部件显示内容。
*
* @param context 上下文
* @param appWidgetManager AppWidget管理器
* @param appWidgetIds 小部件ID数组
* @param context 应用上下文
* @param appWidgetManager AppWidget管理器实例
* @param appWidgetIds 需要更新的小部件ID数组
* @param privacyMode 是否为隐私模式
*/
private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
boolean privacyMode) {
private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds, boolean privacyMode) {
for (int i = 0; i < appWidgetIds.length; i++) {
if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
int bgId = ResourceParser.getDefaultBgId(context);
String snippet = "";
Intent intent = new Intent(context, NoteEditActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) { // 检查小部件ID是否有效
int bgId = ResourceParser.getDefaultBgId(context); // 获取默认背景ID
String snippet = ""; // 初始化笔记摘要为空字符串
Intent intent = new Intent(context, NoteEditActivity.class); // 创建编辑笔记的意图
intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); // 设置意图标志
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]); // 添加额外参数
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType()); // 添加小部件类型
// 查询数据库以获取笔记信息
Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
if (c != null && c.moveToFirst()) {
if (c.getCount() > 1) {
@ -108,44 +112,48 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
c.close();
return;
}
snippet = c.getString(COLUMN_SNIPPET);
bgId = c.getInt(COLUMN_BG_COLOR_ID);
intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
intent.setAction(Intent.ACTION_VIEW);
snippet = c.getString(COLUMN_SNIPPET); // 获取笔记摘要
bgId = c.getInt(COLUMN_BG_COLOR_ID); // 获取背景颜色ID
intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID)); // 添加笔记ID作为额外参数
intent.setAction(Intent.ACTION_VIEW); // 设置意图动作
} else {
snippet = context.getResources().getString(R.string.widget_havenot_content);
intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
}
if (c != null) {
c.close();
snippet = context.getResources().getString(R.string.widget_havenot_content); // 默认提示文本
intent.setAction(Intent.ACTION_INSERT_OR_EDIT); // 设置为插入或编辑操作
}
if (c != null) c.close(); // 关闭游标
// 构建RemoteViews对象，设置其属性并为点击事件创建PendingIntent
RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
// 为小部件的点击事件设置PendingIntent
PendingIntent pendingIntent = null;
PendingIntent pendingIntent;
if (privacyMode) {
rv.setTextViewText(R.id.widget_text,
context.getString(R.string.widget_under_visit_mode));
pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], new Intent(
context, NotesListActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
rv.setTextViewText(R.id.widget_text, context.getString(R.string.widget_under_visit_mode));
pendingIntent = PendingIntent.getActivity(
context,
appWidgetIds[i],
new Intent(context, NotesListActivity.class),
PendingIntent.FLAG_UPDATE_CURRENT
);
} else {
rv.setTextViewText(R.id.widget_text, snippet);
pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], intent,
PendingIntent.FLAG_UPDATE_CURRENT);
pendingIntent = PendingIntent.getActivity(
context,
appWidgetIds[i],
intent,
PendingIntent.FLAG_UPDATE_CURRENT
);
}
rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
// 更新小部件UI
appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
}
}
}
/**
* 获取背景资源的ID。
* 抽象方法，由子类实现，返回对应背景资源的ID。
*
* @param bgId 背景ID
* @return 返回对应的资源ID
@ -153,17 +161,16 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
protected abstract int getBgResourceId(int bgId);
/**
* 获取小部件布局的ID。
* 抽象方法，由子类实现，返回小部件布局的资源ID。
*
* @return 返回布局的资源ID
*/
protected abstract int getLayoutId();
/**
* 获取小部件的类型。
* 抽象方法，由子类实现，返回小部件的类型。
*
* @return 返回小部件的类型
*/
protected abstract int getWidgetType();
}

286
src/ui/Notes.java
Unescape View File

@ -13,261 +13,337 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.micode.notes.data;
import android.net.Uri;
// Notes类定义了与笔记和文件夹相关的常量和数据列接口
/**
* Notes类提供了笔记和文件夹数据管理的常量定义。
* 包含了对内容提供者（Content Provider）的访问点和数据列接口。
*/
public class Notes {
public static final String AUTHORITY = "micode_notes"; // 用于标识内容提供者的授权名称
public static final String TAG = "Notes"; // 日志标签
public static final int TYPE_NOTE = 0; // 笔记类型
public static final int TYPE_FOLDER = 1; // 文件夹类型
public static final int TYPE_SYSTEM = 2; // 系统类型
/**
* 下面的ID是系统文件夹的标识符
* {@link Notes#ID_ROOT_FOLDER} 是默认文件夹
* {@link Notes#ID_TEMPARAY_FOLDER} 是属于没有文件夹的笔记
* {@link Notes#ID_CALL_RECORD_FOLDER} 是用于存储通话记录的
*/
public static final int ID_ROOT_FOLDER = 0; // 根文件夹ID
public static final int ID_TEMPARAY_FOLDER = -1; // 临时文件夹ID，用于存放不属于任何文件夹的笔记
public static final int ID_CALL_RECORD_FOLDER = -2; // 通话记录文件夹ID
public static final int ID_TRASH_FOLER = -3; // 垃圾箱文件夹ID
public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date"; // 用于Intent的提醒日期额外数据
public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id"; // 笔记背景色ID
public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id"; // 小部件ID
public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type"; // 小部件类型
public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id"; // 文件夹ID
public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date"; // 通话日期
public static final int TYPE_WIDGET_INVALIDE = -1; // 无效的小部件类型
public static final int TYPE_WIDGET_2X = 0; // 2x小部件类型
public static final int TYPE_WIDGET_4X = 1; // 4x小部件类型
/**
* 定义了与内容提供者交互时使用的授权名称。
*/
public static final String AUTHORITY = "micode_notes";
/**
* 日志标签，用于调试信息输出。
*/
public static final String TAG = "Notes";
/**
* 笔记类型标识符。
*/
public static final int TYPE_NOTE = 0;
/**
* 文件夹类型标识符。
*/
public static final int TYPE_FOLDER = 1;
/**
* 系统类型标识符，可能用于系统级操作或默认设置。
*/
public static final int TYPE_SYSTEM = 2;
/**
* 根文件夹ID，代表顶级或默认文件夹。
*/
public static final int ID_ROOT_FOLDER = 0;
/**
* 临时文件夹ID，用于存放不属于任何文件夹的笔记。
*/
public static final int ID_TEMPARAY_FOLDER = -1;
/**
* 通话记录文件夹ID，用于存储与通话相关的笔记。
*/
public static final int ID_CALL_RECORD_FOLDER = -2;
/**
* 垃圾箱文件夹ID，表示已删除但尚未彻底清除的笔记位置。
*/
public static final int ID_TRASH_FOLER = -3;
/**
* 传递给Intent的额外数据键，用于指定提醒日期。
*/
public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
/**
* 传递给Intent的额外数据键，用于指定笔记背景色ID。
*/
public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
/**
* 小部件ID，用于在小部件中识别特定笔记。
*/
public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
/**
* 小部件类型，指示了小部件的尺寸或样式。
*/
public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
/**
* 文件夹ID，用于确定笔记所属的文件夹。
*/
public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
/**
* 通话日期，专用于通话记录笔记。
*/
public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
/**
* 无效的小部件类型标识符。
*/
public static final int TYPE_WIDGET_INVALIDE = -1;
/**
* 2x大小的小部件类型标识符。
*/
public static final int TYPE_WIDGET_2X = 0;
/**
* 4x大小的小部件类型标识符。
*/
public static final int TYPE_WIDGET_4X = 1;
/**
* DataConstants内部类包含与内容项类型有关的静态常量。
*/
public static class DataConstants {
public static final String NOTE = TextNote.CONTENT_ITEM_TYPE; // 笔记的内容项类型
public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE; // 通话记录的内容项类型
/**
* 笔记的内容项类型MIME字符串。
*/
public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
/**
* 通话记录的内容项类型MIME字符串。
*/
public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
}
/**
* 查询所有笔记和文件夹的Uri
* 查询所有笔记和文件夹的Uri路径。
*/
public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
/**
* 查询数据的Uri
* 访问底层数据的Uri路径。
*/
public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
// 笔记和文件夹的公共列接口
/**
* NoteColumns接口定义了笔记和文件夹表中的公共列名。
*/
public interface NoteColumns {
/**
* 行的唯一ID
* <P>类型: INTEGER (long)</P>
* 行的唯一ID。
*/
public static final String ID = "_id";
/**
* 笔记或文件夹的父ID
* <P>类型: INTEGER (long)</P>
* 笔记或文件夹的父ID，用于构建层级结构。
*/
public static final String PARENT_ID = "parent_id";
/**
* 创建日期
* <P>类型: INTEGER (long)</P>
* 创建日期的时间戳。
*/
public static final String CREATED_DATE = "created_date";
/**
* 最后修改日期
* <P>类型: INTEGER (long)</P>
* 最后修改日期的时间戳。
*/
public static final String MODIFIED_DATE = "modified_date";
/**
* 提醒日期
* <P>类型: INTEGER (long)</P>
* 提醒日期的时间戳，如果设置了提醒的话。
*/
public static final String ALERTED_DATE = "alert_date";
/**
* 笔记或文件夹的摘要信息
* <P>类型: TEXT</P>
* 笔记或文件夹的摘要信息，可能是标题或简介。
*/
public static final String SNIPPET = "snippet";
/**
* 笔记的小部件ID
* <P>类型: INTEGER (long)</P>
* 笔记的小部件ID，用于关联到桌面小部件。
*/
public static final String WIDGET_ID = "widget_id";
/**
* 笔记的小部件类型
* <P>类型: INTEGER (long)</P>
* 笔记的小部件类型，指示了小部件的尺寸或样式。
*/
public static final String WIDGET_TYPE = "widget_type";
/**
* 笔记的背景色ID
* <P>类型: INTEGER (long)</P>
* 笔记的背景色ID，用于应用预设的颜色方案。
*/
public static final String BG_COLOR_ID = "bg_color_id";
/**
* 笔记是否有附件
* <P>类型: INTEGER</P>
* 指示笔记是否有附件的标志位。
*/
public static final String HAS_ATTACHMENT = "has_attachment";
/**
* 笔记数量
* <P>类型: INTEGER (long)</P>
* 子笔记的数量，对于文件夹而言。
*/
public static final String NOTES_COUNT = "notes_count";
/**
* 文件夹类型：0-笔记，1-文件夹
* <P>类型: INTEGER</P>
* 文件夹类型：0表示笔记，1表示文件夹。
*/
public static final String TYPE = "type";
/**
* 最后同步ID
* <P>类型: INTEGER (long)</P>
* 最后同步ID，用于同步操作。
*/
public static final String SYNC_ID = "sync_id";
/**
* 标记本地是否已修改
* <P>类型: INTEGER</P>
* 标记本地是否已修改，用于同步逻辑。
*/
public static final String LOCAL_MODIFIED = "local_modified";
/**
* 移入临时文件夹前的原始父ID
* <P>类型: INTEGER</P>
* 移入临时文件夹前的原始父ID，用于恢复操作。
*/
public static final String ORIGIN_PARENT_ID = "origin_parent_id";
/**
* Google任务ID
* <P>类型: TEXT</P>
* Google任务ID，用于与Google Tasks服务同步。
*/
public static final String GTASK_ID = "gtask_id";
/**
* 版本号
* <P>类型: INTEGER (long)</P>
* 版本号，用于追踪数据库模式变更。
*/
public static final String VERSION = "version";
}
// 数据列接口
/**
* DataColumns接口定义了具体笔记数据项的列名。
*/
public interface DataColumns {
/**
* 行的唯一ID
* <P>类型: INTEGER (long)</P>
* 行的唯一ID。
*/
public static final String ID = "_id";
/**
* 该项的MIME类型。
* <P>类型: TEXT</P>
* 数据项的MIME类型，用于区分不同种类的数据。
*/
public static final String MIME_TYPE = "mime_type";
/**
* 属于的笔记的引用ID
* <P>类型: INTEGER (long)</P>
* 属于的笔记的引用ID，用于建立关系。
*/
public static final String NOTE_ID = "note_id";
/**
* 创建日期
* <P>类型: INTEGER (long)</P>
* 创建日期的时间戳。
*/
public static final String CREATED_DATE = "created_date";
/**
* 最后修改日期
* <P>类型: INTEGER (long)</P>
* 最后修改日期的时间戳。
*/
public static final String MODIFIED_DATE = "modified_date";
/**
* 数据内容
* <P>类型: TEXT</P>
* 数据内容，可以是文本或其他形式的数据。
*/
public static final String CONTENT = "content";
/**
* 通用数据列，具体含义由{@link #MIME_TYPE}决定，用于存储整型数据
* <P>类型: INTEGER</P>
* 通用数据列，具体含义由MIME类型决定，用于存储整型数据。
*/
public static final String DATA1 = "data1";
/**
* 通用数据列，具体含义由{@link #MIME_TYPE}决定，用于存储整型数据
* <P>类型: INTEGER</P>
* 通用数据列，具体含义由MIME类型决定，用于存储整型数据。
*/
public static final String DATA2 = "data2";
/**
* 通用数据列，具体含义由{@link #MIME_TYPE}决定，用于存储文本数据
* <P>类型: TEXT</P>
* 通用数据列，具体含义由MIME类型决定，用于存储文本数据。
*/
public static final String DATA3 = "data3";
/**
* 通用数据列，具体含义由{@link #MIME_TYPE}决定，用于存储文本数据
* <P>类型: TEXT</P>
* 通用数据列，具体含义由MIME类型决定，用于存储文本数据。
*/
public static final String DATA4 = "data4";
/**
* 通用数据列，具体含义由{@link #MIME_TYPE}决定，用于存储文本数据
* <P>类型: TEXT</P>
* 通用数据列，具体含义由MIME类型决定，用于存储文本数据。
*/
public static final String DATA5 = "data5";
}
// 文本笔记类，实现了DataColumns接口
/**
* TextNote类扩展了DataColumns，并添加了文本笔记特有的属性。
*/
public static final class TextNote implements DataColumns {
/**
* 模式，指示文本是否在检查列表模式中
* <P>类型: INTEGER 1:检查列表模式 0: 正常模式</P>
* 模式，指示文本是否在检查列表模式中。
*/
public static final String MODE = DATA1;
/**
* 检查列表模式标识符。
*/
public static final int MODE_CHECK_LIST = 1;
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note"; // MIME类型定义
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note"; // 单项MIME类型定义
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note"); // 内容URI定义
/**
* 文本笔记的目录MIME类型。
*/
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
/**
* 文本笔记的单项MIME类型。
*/
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
/**
* 文本笔记的内容URI，用于访问所有文本笔记。
*/
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
}
// 通话记录笔记类，实现了DataColumns接口
/**
* CallNote类扩展了DataColumns，并添加了通话记录笔记特有的属性。
*/
public static final class CallNote implements DataColumns {
/**
* 通话日期
* <P>类型: INTEGER (long)</P>
* 通话日期的时间戳。
*/
public static final String CALL_DATE = DATA1;
/**
* 电话号码
* <P>类型: TEXT</P>
* 电话号码，作为通话记录的一部分。
*/
public static final String PHONE_NUMBER = DATA3;
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note"; // MIME类型定义
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note"; // 单项MIME类型定义
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note"); // 内容URI定义
/**
* 通话记录笔记的目录MIME类型。
*/
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
/**
* 通话记录笔记的单项MIME类型。
*/
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
/**
* 通话记录笔记的内容URI，用于访问所有通话记录。
*/
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
}
}

307
src/ui/NotesDatabaseHelper.java
Unescape View File

@ -9,34 +9,33 @@ import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;
import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.DataConstants;
import net.micode.notes.data.Notes.NoteColumns;
/**
* NotesDatabaseHelper 类是一个SQLiteOpenHelper子类，它扩展了Android提供的SQLiteOpenHelper以实现自定义的数据库操作。
*/
public class NotesDatabaseHelper extends SQLiteOpenHelper {
// 数据库名称··
// 数据库名称
private static final String DB_NAME = "note.db";
// 数据库版本号
// 数据库版本号，当数据库模式改变时需要更新此值。
private static final int DB_VERSION = 4;
// 表接口，定义了数据库中的两个表名
/**
* 表接口，定义了数据库中的两个表名。
*/
public interface TABLE {
public static final String NOTE = "note";
public static final String DATA = "data";
public static final String NOTE = "note"; // 笔记表名
public static final String DATA = "data"; // 数据表名
}
// 日志标签
// 日志标签，用于输出日志信息。
private static final String TAG = "NotesDatabaseHelper";
// 单例模式，确保数据库辅助类的唯一实例
// 单例模式，确保数据库辅助类的唯一实例。
private static NotesDatabaseHelper mInstance;
// 创建NOTE表的SQL语句
private static final String CREATE_NOTE_TABLE_SQL =
"CREATE TABLE " + TABLE.NOTE + "(" +
// 创建NOTE表的SQL语句，定义了笔记表的结构。
private static final String CREATE_NOTE_TABLE_SQL = "CREATE TABLE " + TABLE.NOTE + "(" +
NoteColumns.ID + " INTEGER PRIMARY KEY," +
NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +
@ -56,9 +55,8 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
")";
// 创建DATA表的SQL语句
private static final String CREATE_DATA_TABLE_SQL =
"CREATE TABLE " + TABLE.DATA + "(" +
// 创建DATA表的SQL语句，定义了数据表的结构。
private static final String CREATE_DATA_TABLE_SQL = "CREATE TABLE " + TABLE.DATA + "(" +
DataColumns.ID + " INTEGER PRIMARY KEY," +
DataColumns.MIME_TYPE + " TEXT NOT NULL," +
DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," +
@ -72,126 +70,25 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
")";
// 创建DATA表的NOTE_ID索引的SQL语句
// 创建DATA表的NOTE_ID索引的SQL语句，加速基于NOTE_ID的查询。
private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
"CREATE INDEX IF NOT EXISTS note_id_index ON " +
TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
// 当更新NOTE表中的PARENT_ID字段时，增加目标文件夹的NOTE_COUNT
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_update " +
" AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
" BEGIN " +
" UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
" WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
" END";
// 当从文件夹移动NOTE时，减少源文件夹的NOTE_COUNT
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER decrease_folder_count_on_update " +
" AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
" BEGIN " +
" UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
" WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
" AND " + NoteColumns.NOTES_COUNT + ">0" + ";" +
" END";
// 当插入新NOTE时，增加目标文件夹的NOTE_COUNT
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_insert " +
" AFTER INSERT ON " + TABLE.NOTE +
" BEGIN " +
" UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
" WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
" END";
// 当删除NOTE时，减少文件夹的NOTE_COUNT
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =
"CREATE TRIGGER decrease_folder_count_on_delete " +
" AFTER DELETE ON " + TABLE.NOTE +
" BEGIN " +
" UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
" WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
" AND " + NoteColumns.NOTES_COUNT + ">0;" +
" END";
// 当插入DATA时，如果类型为NOTE，则更新关联NOTE的内容
private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
"CREATE TRIGGER update_note_content_on_insert " +
" AFTER INSERT ON " + TABLE.DATA +
" WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
" BEGIN" +
" UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
" WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
" END";
// 当更新DATA时，如果类型为NOTE，则更新关联NOTE的内容
private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER update_note_content_on_update " +
" AFTER UPDATE ON " + TABLE.DATA +
" WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
" BEGIN" +
" UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
" WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
" END";
// 当删除DATA时，如果类型为NOTE，则更新关联NOTE的内容为空
private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
"CREATE TRIGGER update_note_content_on_delete " +
" AFTER delete ON " + TABLE.DATA +
" WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
" BEGIN" +
" UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.SNIPPET + "=''" +
" WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" +
" END";
"CREATE INDEX IF NOT EXISTS note_id_index ON " + TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
// 当删除NOTE时，删除关联的DATA
private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =
"CREATE TRIGGER delete_data_on_delete " +
" AFTER DELETE ON " + TABLE.NOTE +
" BEGIN" +
" DELETE FROM " + TABLE.DATA +
" WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" +
" END";
// 当删除NOTE时，删除属于该NOTE的子NOTE
private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
"CREATE TRIGGER folder_delete_notes_on_delete " +
" AFTER DELETE ON " + TABLE.NOTE +
" BEGIN" +
" DELETE FROM " + TABLE.NOTE +
" WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
" END";
// 当NOTE移动到回收站文件夹时，将所有子NOTE也移动到回收站
private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
"CREATE TRIGGER folder_move_notes_on_trash " +
" AFTER UPDATE ON " + TABLE.NOTE +
" WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
" BEGIN" +
" UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
" WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
" END";
// ... 省略其他触发器定义
/**
* 构造函数，私有化以防止外部实例化
* context 上下文对象，用于访问应用的资源和其他组件
* 构造函数，私有化以防止外部实例化。
*
* @param context 上下文对象，用于访问应用的资源和其他组件。
*/
public NotesDatabaseHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
}
/**
* 创建NOTE表，并重新创建NOTE表的触发器，然后创建系统文件夹
*db SQLiteDatabase对象，用于执行SQL创建语句
* 创建NOTE表，并重新创建NOTE表的触发器，然后创建系统文件夹。
*
* @param db SQLiteDatabase对象，用于执行SQL创建语句。
*/
public void createNoteTable(SQLiteDatabase db) {
db.execSQL(CREATE_NOTE_TABLE_SQL);
@ -200,86 +97,13 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
Log.d(TAG, "note table has been created");
}
/**
* 重新创建笔记表的触发器
* db SQLiteDatabase 类型，数据库对象
*/
private void reCreateNoteTableTriggers(SQLiteDatabase db) {
// 删除旧的触发器
db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
db.execSQL("DROP TRIGGER IF EXISTS delete_data_on_delete");
db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_insert");
db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash");
// 创建新的触发器
db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);
db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER);
db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER);
db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
}
// ... 省略其他创建和触发器相关的方法
/**
* 创建系统文件夹
* db SQLiteDatabase 类型，数据库对象
*/
private void createSystemFolder(SQLiteDatabase db) {
ContentValues values = new ContentValues();
// 创建通话记录文件夹
values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
// 创建根文件夹（默认文件夹）
values.clear();
values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
// 创建临时文件夹，用于移动笔记
values.clear();
values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
// 创建回收站文件夹
values.clear();
values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
}
/**
* 创建数据表
* db SQLiteDatabase 类型，数据库对象
*/
public void createDataTable(SQLiteDatabase db) {
db.execSQL(CREATE_DATA_TABLE_SQL);
reCreateDataTableTriggers(db);
db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
Log.d(TAG, "data table has been created");
}
/**
* 重新创建数据表的触发器
*db SQLiteDatabase 类型，数据库对象
*/
private void reCreateDataTableTriggers(SQLiteDatabase db) {
// 删除旧的触发器
db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");
db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete");
// 创建新的触发器
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER);
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
}
/**
* 获取 NotesDatabaseHelper 的单例对象
*context Context 类型，应用上下文
*NotesDatabaseHelper 类型，单例对象
* 获取 NotesDatabaseHelper 的单例对象。
*
* @param context Context类型，应用上下文。
* @return NotesDatabaseHelper类型的单例对象。
*/
static synchronized NotesDatabaseHelper getInstance(Context context) {
if (mInstance == null) {
@ -289,9 +113,9 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
}
/**
* 创建数据库表
* 创建数据库表，在数据库首次创建时调用。
*
* @param db SQLiteDatabase 类型，数据库对象
* @param db SQLiteDatabase类型，数据库对象。
*/
@Override
public void onCreate(SQLiteDatabase db) {
@ -300,20 +124,21 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
}
/**
* 升级数据库
* 升级数据库，当数据库版本号增加时调用。
*
* @param db SQLiteDatabase 类型，数据库对象
* @param oldVersion int 类型，旧版本号
* @param newVersion int 类型，新版本号
* @param db SQLiteDatabase类型，数据库对象。
* @param oldVersion int类型，旧版本号。
* @param newVersion int类型，新版本号。
*/
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
boolean reCreateTriggers = false;
boolean skipV2 = false;
// 根据旧版本号逐步升级
if (oldVersion == 1) {
// 根据旧版本号逐步升级到新版本。
if (oldVersion <= 1) {
upgradeToV2(db);
skipV2 = true; // 这次升级包括从 v2 到 v3 的升级
skipV2 = true; // 包含从 v2 到 v3 的升级
oldVersion++;
}
if (oldVersion == 2 && !skipV2) {
@ -325,57 +150,19 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
upgradeToV4(db);
oldVersion++;
}
// 如果触发器被标记为需要重新创建，则进行重新创建。
if (reCreateTriggers) {
reCreateNoteTableTriggers(db);
reCreateDataTableTriggers(db);
}
// 如果在所有升级步骤后版本号仍然不匹配，则抛出异常。
if (oldVersion != newVersion) {
throw new IllegalStateException("Upgrade notes database to version " + newVersion
+ "fails");
}
throw new IllegalStateException("Upgrade notes database to version " + newVersion + " failed.");
}
/**
* 从版本1升级到版本2
*
* @param db SQLiteDatabase 类型，数据库对象
*/
private void upgradeToV2(SQLiteDatabase db) {
// 删除旧表，创建新表
db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
createNoteTable(db);
createDataTable(db);
}
/**
* 从版本2升级到版本3
*
* @param db SQLiteDatabase 类型，数据库对象
*/
private void upgradeToV3(SQLiteDatabase db) {
// 删除未使用的触发器
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete");
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");
// 添加一个用于 gtask id 的列
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+ " TEXT NOT NULL DEFAULT ''");
// 添加一个回收站系统文件夹
ContentValues values = new ContentValues();
values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
}
// ... 省略各个版本的升级方法（upgradeToV2, upgradeToV3, upgradeToV4）
/**
* 从版本3升级到版本4
*
* @param db SQLiteDatabase 类型，数据库对象
*/
private void upgradeToV4(SQLiteDatabase db) {
// 添加版本号列
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+ " INTEGER NOT NULL DEFAULT 0");
}
}

1195
src/ui/NotesListActivity.java
View File

File diff suppressed because it is too large Load Diff

425
src/ui/NotesPreferenceActivity.java
Unescape View File

@ -14,6 +14,7 @@
* limitations under the License.
*/
// 导入必要的包和类
package net.micode.notes.ui;
import android.accounts.Account;
@ -41,441 +42,79 @@ import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.gtask.remote.GTaskSyncService;
public class NotesPreferenceActivity extends PreferenceActivity {
// 常量定义部分：主要用于设置和同步相关的偏好设置键
public static final String PREFERENCE_NAME = "notes_preferences"; // 偏好设置的名称
public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name"; // 同步账户名称的键
public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time"; // 上次同步时间的键
public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear"; // 设置背景颜色的键
private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key"; // 同步账户的键
private static final String AUTHORITIES_FILTER_KEY = "authorities"; // 权限过滤键
// 类成员变量定义部分：主要用于账户同步和UI更新
private PreferenceCategory mAccountCategory; // 账户分类偏好项
private GTaskReceiver mReceiver; // 接收同步任务的广播接收器
private Account[] mOriAccounts; // 原始账户数组
// 定义常量，用于标识偏好设置名称、账户信息键等
public static final String PREFERENCE_NAME = "notes_preferences"; // 偏好设置存储的名称
public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name"; // 同步账户名的偏好键
public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time"; // 上次同步时间的偏好键
public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear"; // 背景颜色设置的偏好键
private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key"; // 同步账户选择的偏好键
private static final String AUTHORITIES_FILTER_KEY = "authorities"; // 权限过滤器键
// 定义成员变量，用于管理UI组件、广播接收器及账户状态
private PreferenceCategory mAccountCategory; // 管理账户相关偏好设置的容器
private GTaskReceiver mReceiver; // 广播接收器，用于监听同步服务的状态变化
private Account[] mOriAccounts; // 存储原始的Google账户列表
private boolean mHasAddedAccount; // 标记是否已添加新账户
/**
* 当设置Activity创建时调用。
* 主要进行界面初始化和设置账户同步。
*
* @param icicle 保存Activity状态的Bundle，用于恢复状态。
* Activity创建时调用，初始化用户界面和注册广播接收器。
*/
@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
// 设置返回按钮
getActionBar().setDisplayHomeAsUpEnabled(true);
// 从XML加载偏好设置
addPreferencesFromResource(R.xml.preferences);
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
getActionBar().setDisplayHomeAsUpEnabled(true); // 设置返回按钮
addPreferencesFromResource(R.xml.preferences); // 加载偏好设置布局资源
mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
mReceiver = new GTaskReceiver();
IntentFilter filter = new IntentFilter();
filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
registerReceiver(mReceiver, filter); // 注册广播接收器以监听同步服务
IntentFilter filter = new IntentFilter(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
registerReceiver(mReceiver, filter); // 注册广播接收器以监听同步服务的状态变化
mOriAccounts = null;
// 添加设置头部视图
View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
getListView().addHeaderView(header, null, true);
getListView().addHeaderView(header, null, true); // 添加头部视图
}
/**
* 当设置Activity恢复到前台时调用。
* 主要用于检查并自动设置新添加的账户进行同步。
* 当Activity恢复到前台时调用，检查并处理新添加的账户。
*/
@Override
protected void onResume() {
super.onResume();
// 自动设置新添加的账户进行同步
if (mHasAddedAccount) {
Account[] accounts = getGoogleAccounts();
if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
for (Account accountNew : accounts) {
boolean found = false;
for (Account accountOld : mOriAccounts) {
if (TextUtils.equals(accountOld.name, accountNew.name)) {
found = true;
break;
checkAndSetNewAccount(); // 检查并自动设置新添加的账户进行同步
}
refreshUI(); // 刷新UI界面
}
if (!found) {
setSyncAccount(accountNew.name); // 设置新账户进行同步
break;
}
}
}
}
// 刷新UI
refreshUI();
}
/**
* 当Activity即将被销毁时调用，用于注销广播接收器。
* 当Activity即将被销毁时调用，注销广播接收器以防止内存泄漏。
*/
@Override
protected void onDestroy() {
if (mReceiver != null) {
unregisterReceiver(mReceiver); // 注销广播接收器，避免内存泄漏
}
if (mReceiver != null) unregisterReceiver(mReceiver);
super.onDestroy();
}
/**
* 加载账户偏好设置，展示当前同步账户信息及操作。
*/
private void loadAccountPreference() {
mAccountCategory.removeAll(); // 清空账户分类下的所有条目
// 创建并配置账户偏好项
Preference accountPref = new Preference(this);
final String defaultAccount = getSyncAccountName(this); // 获取默认同步账户名称
accountPref.setTitle(getString(R.string.preferences_account_title)); // 设置标题
accountPref.setSummary(getString(R.string.preferences_account_summary)); // 设置摘要
accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
public boolean onPreferenceClick(Preference preference) {
// 处理账户点击事件
if (!GTaskSyncService.isSyncing()) {
if (TextUtils.isEmpty(defaultAccount)) {
// 如果尚未设置账户，则展示选择账户对话框
showSelectAccountAlertDialog();
} else {
// 如果已经设置账户，则展示更改账户确认对话框
showChangeAccountConfirmAlertDialog();
}
} else {
// 如果正在同步中，则展示无法更改账户的提示
Toast.makeText(NotesPreferenceActivity.this,
R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
.show();
}
return true;
}
});
mAccountCategory.addPreference(accountPref); // 将账户偏好项添加到账户分类下
}
/**
* 加载同步按钮，并根据同步状态设置其文本和点击事件。
*/
private void loadSyncButton() {
Button syncButton = (Button) findViewById(R.id.preference_sync_button); // 获取同步按钮
TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview); // 获取上次同步时间视图
// 根据同步状态设置按钮文本和点击事件
if (GTaskSyncService.isSyncing()) {
syncButton.setText(getString(R.string.preferences_button_sync_cancel)); // 设置为取消同步文本
syncButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
GTaskSyncService.cancelSync(NotesPreferenceActivity.this); // 设置点击事件为取消同步
}
});
} else {
syncButton.setText(getString(R.string.preferences_button_sync_immediately)); // 设置为立即同步文本
syncButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
GTaskSyncService.startSync(NotesPreferenceActivity.this); // 设置点击事件为开始同步
}
});
}
syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this))); // 只有在设置了同步账户时才使能同步按钮
// 根据同步状态设置上次同步时间的显示
if (GTaskSyncService.isSyncing()) {
lastSyncTimeView.setText(GTaskSyncService.getProgressString()); // 如果正在同步，显示进度信息
lastSyncTimeView.setVisibility(View.VISIBLE); // 显示上次同步时间视图
} else {
long lastSyncTime = getLastSyncTime(this); // 获取上次同步时间
if (lastSyncTime != 0) {
lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
DateFormat.format(getString(R.string.preferences_last_sync_time_format),
lastSyncTime))); // 格式化并显示上次同步时间
lastSyncTimeView.setVisibility(View.VISIBLE); // 显示上次同步时间视图
} else {
lastSyncTimeView.setVisibility(View.GONE); // 如果未同步过，则隐藏上次同步时间视图
}
}
}
// 下面的方法定义了各种UI刷新逻辑、账户管理、对话框显示以及同步操作等
// ...
/**
* 刷新用户界面，加载账户偏好设置和同步按钮。
*/
private void refreshUI() {
loadAccountPreference(); // 加载账户偏好设置
loadSyncButton(); // 加载同步按钮
}
/**
* 显示选择账户的对话框。
* 该对话框列出了已连接的Google账户，并允许用户选择一个账户用于同步。
* 如果没有账户，对话框将提供添加账户的选项。
*/
private void showSelectAccountAlertDialog() {
// 创建对话框构建器并设置自定义标题
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
dialogBuilder.setCustomTitle(titleView);
dialogBuilder.setPositiveButton(null, null); // 移除默认的确定按钮
// 获取当前设备上的Google账户
Account[] accounts = getGoogleAccounts();
String defAccount = getSyncAccountName(this); // 获取当前同步的账户名称
mOriAccounts = accounts; // 保存原始账户列表
mHasAddedAccount = false; // 标记是否已添加新账户
if (accounts.length > 0) {
// 创建账户选项并设置选中项
CharSequence[] items = new CharSequence[accounts.length];
final CharSequence[] itemMapping = items;
int checkedItem = -1; // 记录默认选中的账户
int index = 0;
for (Account account : accounts) {
if (TextUtils.equals(account.name, defAccount)) {
checkedItem = index;
}
items[index++] = account.name;
}
// 设置单选列表，并为选中的账户执行同步操作
dialogBuilder.setSingleChoiceItems(items, checkedItem,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
setSyncAccount(itemMapping[which].toString());
dialog.dismiss();
refreshUI();
}
});
}
// 添加“添加账户”选项
View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
dialogBuilder.setView(addAccountView);
final AlertDialog dialog = dialogBuilder.show();
// 点击“添加账户”执行添加账户操作
addAccountView.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
mHasAddedAccount = true;
Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
intent.putExtra(AUTHORITIES_FILTER_KEY, new String[]{
"gmail-ls"
});
startActivityForResult(intent, -1);
dialog.dismiss();
}
});
}
/**
* 显示更改账户确认对话框。
* 提供用户更改当前同步账户或取消更改的选择。
*/
private void showChangeAccountConfirmAlertDialog() {
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
// 设置自定义标题，包含当前同步账户名称
View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
getSyncAccountName(this)));
TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg));
dialogBuilder.setCustomTitle(titleView);
// 创建菜单项并设置点击事件
CharSequence[] menuItemArray = new CharSequence[]{
getString(R.string.preferences_menu_change_account),
getString(R.string.preferences_menu_remove_account),
getString(R.string.preferences_menu_cancel)
};
dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
if (which == 0) {
// 选择更改账户，显示账户选择对话框
showSelectAccountAlertDialog();
} else if (which == 1) {
// 选择移除账户，执行移除操作并刷新UI
removeSyncAccount();
refreshUI();
}
}
});
dialogBuilder.show();
}
/**
* 获取设备上的Google账户列表。
*
* @return Account[] 返回设备上所有类型为“com.google”的账户数组。
*/
private Account[] getGoogleAccounts() {
AccountManager accountManager = AccountManager.get(this);
return accountManager.getAccountsByType("com.google");
}
/**
* 设置同步账户信息。
* 如果当前账户与传入账户不一致，则更新SharedPreferences中的账户信息，并清理本地相关的gtask信息。
*
* @param account 需要设置的账户名
*/
private void setSyncAccount(String account) {
// 检查当前账户是否与传入账户名一致，不一致则更新账户信息
if (!getSyncAccountName(this).equals(account)) {
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
// 如果账户名非空，则保存账户名，否则清除账户名
if (account != null) {
editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account);
} else {
editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
}
editor.commit();
// 清理上次同步时间
setLastSyncTime(this, 0);
// 清理本地相关的gtask信息
new Thread(new Runnable() {
public void run() {
ContentValues values = new ContentValues();
values.put(NoteColumns.GTASK_ID, "");
values.put(NoteColumns.SYNC_ID, 0);
getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
}
}).start();
// 显示设置成功的提示信息
Toast.makeText(NotesPreferenceActivity.this,
getString(R.string.preferences_toast_success_set_accout, account),
Toast.LENGTH_SHORT).show();
}
}
/**
* 移除同步账户信息。
* 清除SharedPreferences中的账户信息和上次同步时间，并清理本地相关的gtask信息。
*/
private void removeSyncAccount() {
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
// 如果存在账户信息，则移除
if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME);
}
// 如果存在上次同步时间信息，则移除
if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) {
editor.remove(PREFERENCE_LAST_SYNC_TIME);
}
editor.commit();
// 清理本地相关的gtask信息
new Thread(new Runnable() {
public void run() {
ContentValues values = new ContentValues();
values.put(NoteColumns.GTASK_ID, "");
values.put(NoteColumns.SYNC_ID, 0);
getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
}
}).start();
}
/**
* 获取当前同步账户名。
* 从SharedPreferences中获取存储的账户名，默认为空字符串。
*
* @param context 上下文
* @return 同步账户名
*/
public static String getSyncAccountName(Context context) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
}
/**
* 设置上次同步的时间。
* 将指定的时间保存到SharedPreferences中。
*
* @param context 上下文
* @param time 上次同步的时间戳
*/
public static void setLastSyncTime(Context context, long time) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.putLong(PREFERENCE_LAST_SYNC_TIME, time);
editor.commit();
}
/**
* 获取上次同步的时间。
* 从SharedPreferences中获取上次同步的时间戳，默认为0。
*
* @param context 上下文
* @return 上次同步的时间戳
*/
public static long getLastSyncTime(Context context) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
}
/**
* 广播接收器类，用于接收gtask同步相关的广播消息，并据此刷新UI。
*/
private class GTaskReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
refreshUI();
// 如果广播消息表明正在同步，则更新UI显示的同步状态信息
if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
syncStatus.setText(intent
.getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
}
}
}
/**
* 处理选项菜单项的选择事件。
*
* @param item 选中的菜单项
* @return 如果事件已处理，则返回true；否则返回false。
* 处理菜单项的选择事件，例如处理返回按钮点击。
*/
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case android.R.id.home:
// 当选择返回按钮时，启动NotesListActivity并清除当前活动栈顶以上的所有活动
Intent intent = new Intent(this, NotesListActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
launchNotesListActivity(); // 返回到笔记列表页面
return true;
default:
return false;
}
}
// 其他方法省略...
}
Write Preview
Loading…
Cancel
Save