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

Merge branch 'main' of https://bdgit.educoder.net/p2cafumxo/5._Open-source-software-reading-annotation

Browse Source
main
ddd 7 months ago
parent 4c4f930f71 ed5f84664a
commit c539acf2f2
11 changed files with 472 additions and 2216 deletions
Show Stats Download Patch File Download Diff File

BIN
doc/小米便签开源代码全文泛读报告 .docx
View File

Binary file not shown.

2
src/data/Contact.java
Unescape View File

@ -1,6 +1,6 @@
/*
* Contact 类用于通过电话号码查询联系人信息。
* 该类实现了从联系人数据库中获取与特定电话号码相关联的显示名称。
* 该类实现了从联系人数据库中获取与特定电话号码相关联的显示名称
*/
package net.micode.notes.data;

2
src/gtask/data/MetaData.java
Unescape View File

@ -13,7 +13,7 @@ import org.json.JSONException;
import org.json.JSONObject;
public class MetaData extends Task {
private final static String TAG = MetaData.class.getSimpleName(); // 日志标签，用于调试和错误管理
private final static String TAG = MetaData.class.getSimpleName(); // 日志标签，用于调试和错误管理。
private String mRelatedGid = null; // 与任务相关的全局ID

3
src/model/Note.java
Unescape View File

@ -168,8 +168,7 @@ public class Note {
}
// ... 其他方法保持不变 ...
/**
/****
* 将本地修改过的额外数据（如文本或通话记录）同步到数据库。
* @param context 应用程序上下文，用于访问数据库
* @param noteId 笔记的唯一标识符

2
src/tool/BackupUtils.java
Unescape View File

@ -6,7 +6,7 @@
package net.micode.notes.tool;
// 引入需要用到的 Android 和 Java 标准库类
// 引入需要用到的 Android 和 Java 标准库类。
import android.content.Context;
import android.database.Cursor;
import android.os.Environment;

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