pnju9rpvk
/
mijia_node
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

text #16

Closed
pnju9rpvk wants to merge 0 commits from Lulanjian into main
Conversation 0 Commits N/A Files Changed 35
35 changed files with 2339 additions and 2097 deletions
Show Stats Download Patch File Download Diff File

5
MiNotes-master/app/src/main/java/net/micode/notes/data/Notes.java
Unescape View File

@ -204,11 +204,6 @@ public class Notes {
public static final int MODE_CHECK_LIST = 1;// 待办清单模式标识
/**
* 字体加粗状态
*/
public static final String BOLD = DATA2;
// MIME类型定义
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";

453
MiNotes-master/app/src/main/java/net/micode/notes/gtask/data/SqlNote.java
Unescape View File

@ -37,13 +37,16 @@ import org.json.JSONObject;
import java.util.ArrayList;
/**
* 数据库笔记操作类
* 处理笔记（Note）的增删改查及同步逻辑，支持与Google任务（GTask）的数据交互
*/
public class SqlNote {
private static final String TAG = SqlNote.class.getSimpleName();
private static final int INVALID_ID = -99999; // 无效ID标识
private static final int INVALID_ID = -99999;
public static final String[] PROJECTION_NOTE = new String[] {
// 笔记查询投影字段（对应数据库表中的列）
public static final String[] PROJECTION_NOTE = 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,
@ -52,139 +55,133 @@ public class SqlNote {
NoteColumns.VERSION
};
// 各字段在投影中的索引位置（便于通过游标获取数据）
public static final int ID_COLUMN = 0;
public static final int ALERTED_DATE_COLUMN = 1;
public static final int BG_COLOR_ID_COLUMN = 2;
public static final int CREATED_DATE_COLUMN = 3;
public static final int HAS_ATTACHMENT_COLUMN = 4;
public static final int MODIFIED_DATE_COLUMN = 5;
public static final int NOTES_COUNT_COLUMN = 6;
public static final int PARENT_ID_COLUMN = 7;
public static final int SNIPPET_COLUMN = 8;
public static final int TYPE_COLUMN = 9;
public static final int WIDGET_ID_COLUMN = 10;
public static final int WIDGET_TYPE_COLUMN = 11;
public static final int SYNC_ID_COLUMN = 12;
public static final int LOCAL_MODIFIED_COLUMN = 13;
public static final int ORIGIN_PARENT_ID_COLUMN = 14;
public static final int GTASK_ID_COLUMN = 15;
public static final int VERSION_COLUMN = 16;
private Context mContext;
private ContentResolver mContentResolver;
private boolean mIsCreate;
private long mId;
private long mAlertDate;
private int mBgColorId;
private long mCreatedDate;
private int mHasAttachment;
private long mModifiedDate;
private long mParentId;
private String mSnippet;
private int mType;
private int mWidgetId;
private int mWidgetType;
private long mOriginParent;
private long mVersion;
private ContentValues mDiffNoteValues;
private ArrayList<SqlData> mDataList;
private Context mContext; // 上下文
private ContentResolver mContentResolver; // 内容解析器（用于操作ContentProvider）
private boolean mIsCreate; // 是否为新建笔记（未插入数据库）
private long mId; // 笔记ID
private long mAlertDate; // 提醒时间（时间戳）
private int mBgColorId; // 背景颜色ID（对应资源文件中的颜色）
private long mCreatedDate; // 创建时间（时间戳）
private int mHasAttachment; // 是否有附件（0-无，1-有）
private long mModifiedDate; // 修改时间（时间戳）
private long mParentId; // 父文件夹ID（0表示根目录）
private String mSnippet; // 笔记摘要（内容预览）
private int mType; // 类型（笔记、文件夹、系统文件夹等）
private int mWidgetId; // 小部件ID（关联桌面小部件）
private int mWidgetType; // 小部件类型（无效/文本/列表等）
private long mOriginParent; // 原始父文件夹ID（用于移动操作跟踪）
private long mVersion; // 版本号（用于数据同步冲突检测）
private ContentValues mDiffNoteValues; // 差异值（记录变更字段）
private ArrayList<SqlData> mDataList; // 关联的数据项列表（如文本内容、附件等）
/**
* 构造函数：创建新笔记（默认值初始化）
* @param context 上下文
*/
public SqlNote(Context context) {
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = true;
mId = INVALID_ID;
mAlertDate = 0;
// 默认背景颜色（从资源解析器获取）
mBgColorId = ResourceParser.getDefaultBgId(context);
mCreatedDate = System.currentTimeMillis();
mCreatedDate = System.currentTimeMillis(); // 当前时间戳
mHasAttachment = 0;
mModifiedDate = System.currentTimeMillis();
mParentId = 0;
mModifiedDate = System.currentTimeMillis(); // 当前时间戳
mParentId = 0; // 根目录
mSnippet = "";
mType = Notes.TYPE_NOTE;
mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
mType = Notes.TYPE_NOTE; // 默认类型为普通笔记
mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; // 无效小部件ID
mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 无效小部件类型
mOriginParent = 0;
mVersion = 0;
mDiffNoteValues = new ContentValues();
mDataList = new ArrayList<SqlData>();
}
/**
* 构造函数：从游标加载现有笔记数据
* @param context 上下文
* @param c 数据库游标（已查询到的笔记记录）
*/
public SqlNote(Context context, Cursor c) {
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = false;
loadFromCursor(c);
loadFromCursor(c); // 从游标加载基础字段
mDataList = new ArrayList<SqlData>();
if (mType == Notes.TYPE_NOTE)
loadDataContent();
if (mType == Notes.TYPE_NOTE) {
loadDataContent(); // 加载笔记关联的数据项（如文本内容）
}
mDiffNoteValues = new ContentValues();
}
/**
* 构造函数：通过ID加载现有笔记数据
* @param context 上下文
* @param id 笔记ID
*/
public SqlNote(Context context, long id) {
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = false;
loadFromCursor(id);
loadFromCursor(id); // 通过ID查询并加载数据
mDataList = new ArrayList<SqlData>();
if (mType == Notes.TYPE_NOTE)
loadDataContent();
if (mType == Notes.TYPE_NOTE) {
loadDataContent(); // 加载数据项
}
mDiffNoteValues = new ContentValues();
}
/**
* 从游标加载笔记基础字段（通过ID查询）
* @param id 笔记ID
*/
private void loadFromCursor(long id) {
Cursor c = null;
try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
new String[] {
String.valueOf(id)
}, null);
if (c != null) {
c.moveToNext();
loadFromCursor(c);
// 查询笔记表，条件为ID匹配
c = mContentResolver.query(
Notes.CONTENT_NOTE_URI,
PROJECTION_NOTE,
"(_id=?)",
new String[]{String.valueOf(id)},
null
);
if (c != null && c.moveToNext()) {
loadFromCursor(c); // 调用游标加载方法
} else {
Log.w(TAG, "loadFromCursor: cursor = null");
Log.w(TAG, "loadFromCursor: 游标为空或无数据");
}
} finally {
if (c != null)
c.close();
if (c != null) c.close(); // 关闭游标释放资源
}
}
/**
* 从游标加载笔记基础字段（直接通过游标数据）
* @param c 已定位到目标记录的游标
*/
private void loadFromCursor(Cursor c) {
mId = c.getLong(ID_COLUMN);
mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
@ -197,179 +194,138 @@ public class SqlNote {
mType = c.getInt(TYPE_COLUMN);
mWidgetId = c.getInt(WIDGET_ID_COLUMN);
mWidgetType = c.getInt(WIDGET_TYPE_COLUMN);
mVersion = c.getLong(VERSION_COLUMN);
mVersion = c.getLong(VERSION_COLUMN); // 版本号用于同步冲突检测
}
/**
* 加载笔记关联的数据项（如文本内容、附件等）
*/
private void loadDataContent() {
Cursor c = null;
mDataList.clear();
mDataList.clear(); // 清空现有数据项列表
try {
c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
"(note_id=?)", new String[] {
String.valueOf(mId)
}, null);
// 查询数据项表，条件为所属笔记ID
c = mContentResolver.query(
Notes.CONTENT_DATA_URI,
SqlData.PROJECTION_DATA,
"(note_id=?)",
new String[]{String.valueOf(mId)},
null
);
if (c != null) {
if (c.getCount() == 0) {
Log.w(TAG, "it seems that the note has not data");
Log.w(TAG, "该笔记无数据项");
return;
}
while (c.moveToNext()) {
// 每个数据项创建SqlData实例并添加到列表
SqlData data = new SqlData(mContext, c);
mDataList.add(data);
}
} else {
Log.w(TAG, "loadDataContent: cursor = null");
Log.w(TAG, "loadDataContent: 游标为空");
}
} finally {
if (c != null)
c.close();
if (c != null) c.close();
}
}
/**
* 从JSON对象设置笔记内容（支持普通笔记、文件夹、系统文件夹）
* @param js 包含笔记数据的JSON对象
* @return 是否设置成功
*/
public boolean setContent(JSONObject js) {
try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
Log.w(TAG, "cannot set system folder");
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
// for folder we can only update the snnipet and type
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : "";
if (mIsCreate || !mSnippet.equals(snippet)) {
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
}
mSnippet = snippet;
int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
: Notes.TYPE_NOTE;
if (mIsCreate || mType != type) {
mDiffNoteValues.put(NoteColumns.TYPE, type);
}
mType = type;
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
if (mIsCreate || mId != id) {
mDiffNoteValues.put(NoteColumns.ID, id);
}
mId = id;
long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note
.getLong(NoteColumns.ALERTED_DATE) : 0;
if (mIsCreate || mAlertDate != alertDate) {
mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);
}
mAlertDate = alertDate;
int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note
.getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
if (mIsCreate || mBgColorId != bgColorId) {
mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 提取笔记元数据
int type = note.getInt(NoteColumns.TYPE); // 获取笔记类型
// 系统文件夹禁止修改（直接返回）
if (type == Notes.TYPE_SYSTEM) {
Log.w(TAG, "无法修改系统文件夹");
return false;
} else if (type == Notes.TYPE_FOLDER) {
// 文件夹仅允许更新摘要和类型
String snippet = note.optString(NoteColumns.SNIPPET, "");
if (!mSnippet.equals(snippet)) { // 对比现有摘要
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); // 记录差异
mSnippet = snippet;
}
mBgColorId = bgColorId;
long createDate = note.has(NoteColumns.CREATED_DATE) ? note
.getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
if (mIsCreate || mCreatedDate != createDate) {
mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
}
mCreatedDate = createDate;
int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note
.getInt(NoteColumns.HAS_ATTACHMENT) : 0;
if (mIsCreate || mHasAttachment != hasAttachment) {
mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);
}
mHasAttachment = hasAttachment;
long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note
.getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();
if (mIsCreate || mModifiedDate != modifiedDate) {
mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
}
mModifiedDate = modifiedDate;
long parentId = note.has(NoteColumns.PARENT_ID) ? note
.getLong(NoteColumns.PARENT_ID) : 0;
if (mIsCreate || mParentId != parentId) {
mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
}
mParentId = parentId;
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : "";
if (mIsCreate || !mSnippet.equals(snippet)) {
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
}
mSnippet = snippet;
int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
: Notes.TYPE_NOTE;
if (mIsCreate || mType != type) {
mDiffNoteValues.put(NoteColumns.TYPE, type);
}
mType = type;
int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)
: AppWidgetManager.INVALID_APPWIDGET_ID;
if (mIsCreate || mWidgetId != widgetId) {
mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
int newType = note.optInt(NoteColumns.TYPE, Notes.TYPE_NOTE);
if (mType != newType) { // 对比类型
mDiffNoteValues.put(NoteColumns.TYPE, newType); // 记录差异
mType = newType;
}
mWidgetId = widgetId;
} else if (type == Notes.TYPE_NOTE) {
// 普通笔记处理（包含数据项）
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); // 提取数据项数组
int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
.getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
if (mIsCreate || mWidgetType != widgetType) {
mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
}
mWidgetType = widgetType;
long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
if (mIsCreate || mOriginParent != originParent) {
mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
// 基础字段更新
long id = note.optLong(NoteColumns.ID, INVALID_ID);
if (mId != id) {
mDiffNoteValues.put(NoteColumns.ID, id);
mId = id;
}
mOriginParent = originParent;
mAlertDate = note.optLong(NoteColumns.ALERTED_DATE, 0);
mBgColorId = note.optInt(NoteColumns.BG_COLOR_ID, ResourceParser.getDefaultBgId(mContext));
mCreatedDate = note.optLong(NoteColumns.CREATED_DATE, System.currentTimeMillis());
mHasAttachment = note.optInt(NoteColumns.HAS_ATTACHMENT, 0);
mModifiedDate = note.optLong(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
mParentId = note.optLong(NoteColumns.PARENT_ID, 0);
mSnippet = note.optString(NoteColumns.SNIPPET, "");
mType = note.optInt(NoteColumns.TYPE, Notes.TYPE_NOTE);
mWidgetId = note.optInt(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
mWidgetType = note.optInt(NoteColumns.WIDGET_TYPE, Notes.TYPE_WIDGET_INVALIDE);
mOriginParent = note.optLong(NoteColumns.ORIGIN_PARENT_ID, 0);
// 数据项处理（新增/更新）
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
JSONObject dataJson = dataArray.getJSONObject(i);
long dataId = dataJson.optLong(DataColumns.ID, INVALID_ID);
SqlData sqlData = null;
if (data.has(DataColumns.ID)) {
long dataId = data.getLong(DataColumns.ID);
for (SqlData temp : mDataList) {
if (dataId == temp.getId()) {
sqlData = temp;
}
// 查找已存在的数据项（通过ID匹配）
for (SqlData temp : mDataList) {
if (temp.getId() == dataId) {
sqlData = temp;
break;
}
}
// 不存在则创建新数据项
if (sqlData == null) {
sqlData = new SqlData(mContext);
mDataList.add(sqlData);
}
sqlData.setContent(data);
// 设置数据项内容（自动处理差异）
sqlData.setContent(dataJson);
}
}
} catch (JSONException e) {
Log.e(TAG, e.toString());
Log.e(TAG, "JSON解析异常: " + e.toString());
e.printStackTrace();
return false;
}
return true;
}
/**
* 将笔记内容转换为JSON对象（用于同步传输）
* @return JSON对象，包含笔记元数据和数据项
*/
public JSONObject getContent() {
try {
JSONObject js = new JSONObject();
if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet");
Log.e(TAG, "笔记尚未创建，无法生成JSON");
return null;
}
JSONObject note = new JSONObject();
if (mType == Notes.TYPE_NOTE) {
// 普通笔记：包含完整元数据和数据项
note.put(NoteColumns.ID, mId);
note.put(NoteColumns.ALERTED_DATE, mAlertDate);
note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
@ -384,6 +340,7 @@ public class SqlNote {
note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
// 数据项数组
JSONArray dataArray = new JSONArray();
for (SqlData sqlData : mDataList) {
JSONObject data = sqlData.getContent();
@ -393,113 +350,49 @@ public class SqlNote {
}
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
} else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
// 文件夹/系统文件夹：仅包含基础元数据
note.put(NoteColumns.ID, mId);
note.put(NoteColumns.TYPE, mType);
note.put(NoteColumns.SNIPPET, mSnippet);
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
}
return js;
} catch (JSONException e) {
Log.e(TAG, e.toString());
Log.e(TAG, "JSON生成异常: " + e.toString());
e.printStackTrace();
}
return null;
}
// ==================== 辅助设置方法（更新差异值） ====================
public void setParentId(long id) {
mParentId = id;
mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
mDiffNoteValues.put(NoteColumns.PARENT_ID, id); // 记录父ID变更
}
public void setGtaskId(String gid) {
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); // 记录GTask ID变更
}
public void setSyncId(long syncId) {
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); // 记录同步ID变更
}
public void resetLocalModified() {
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); // 重置本地修改标记
}
public long getId() {
return mId;
}
public long getParentId() {
return mParentId;
}
public String getSnippet() {
return mSnippet;
}
public boolean isNoteType() {
return mType == Notes.TYPE_NOTE;
}
// ==================== 基础属性访问器 ====================
public long getId() { return mId; }
public long getParentId() { return mParentId; }
public String getSnippet() { return mSnippet; }
public boolean isNoteType() { return mType == Notes.TYPE_NOTE; }
/**
* 提交变更到数据库（执行插入或更新操作）
* @param validateVersion 是否验证版本号（防止并发冲突）
*/
public void commit(boolean validateVersion) {
if (mIsCreate) {
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
mDiffNoteValues.remove(NoteColumns.ID);
}
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
try {
mId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed");
}
if (mId == 0) {
throw new IllegalStateException("Create thread id failed");
}
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, false, -1);
}
}
} else {
if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
Log.e(TAG, "No such note");
throw new IllegalStateException("Try to update note with invalid id");
}
if (mDiffNoteValues.size() > 0) {
mVersion ++;
int result = 0;
if (!validateVersion) {
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?)", new String[] {
String.valueOf(mId)
});
} else {
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
new String[] {
String.valueOf(mId), String.valueOf(mVersion)
});
}
if (result == 0) {
Log.w(TAG, "there is no update. maybe user updates note when syncing");
}
}
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, validateVersion, mVersion);
}
}
}
// refresh local info
loadFromCursor(mId);
if (mType == Notes.TYPE_NOTE)
loadDataContent();
mDiffNoteValues.clear();
mIsCreate = false;
}
}
// 新建笔记：插入到笔记表
if (mId == IN

567
MiNotes-master/app/src/main/java/net/micode/notes/gtask/remote/GTaskManager.java
View File

File diff suppressed because it is too large Load Diff

29
MiNotes-master/app/src/main/java/net/micode/notes/model/WorkingNote.java
Unescape View File

@ -56,8 +56,6 @@ public class WorkingNote {
private int mWidgetType;
// 文件夹ID
private long mFolderId;
// 字体加粗状态
private boolean mBoldState;
// 上下文
private Context mContext;
// 日志标签
@ -76,7 +74,6 @@ public class WorkingNote {
DataColumns.DATA2,
DataColumns.DATA3,
DataColumns.DATA4,
TextNote.BOLD,
};
// 笔记查询投影
@ -94,7 +91,6 @@ public class WorkingNote {
private static final int DATA_CONTENT_COLUMN = 1;
private static final int DATA_MIME_TYPE_COLUMN = 2;
private static final int DATA_MODE_COLUMN = 3;
private static final int DATA_BOLD_COLUMN = 7;
// 笔记列索引
private static final int NOTE_PARENT_ID_COLUMN = 0;
@ -179,7 +175,6 @@ public class WorkingNote {
mContent = cursor.getString(DATA_CONTENT_COLUMN);
mMode = cursor.getInt(DATA_MODE_COLUMN);
mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN));
mBoldState = (cursor.getInt(DATA_BOLD_COLUMN) == 1 ? true : false);
} else if (DataConstants.CALL_NOTE.equals(type)) {
// 通话记录笔记数据
mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN));
@ -477,30 +472,6 @@ public class WorkingNote {
return mWidgetType;
}
/**
* 设置字体加粗状态
* @param bold 是否加粗
*/
public void setBoldState(boolean bold) {
if (mBoldState != bold) {
mBoldState = bold;
mNote.setTextData(TextNote.BOLD, (mBoldState ? "1" : "0"));
mNote.setNoteValue(NoteColumns.SNIPPET, getContent());
if (mNoteSettingStatusListener != null) {
// 可选：添加一个回调接口方法来通知UI加粗状态已更改
// mNoteSettingStatusListener.onBoldStateChanged(bold);
}
}
}
/**
* 获取字体加粗状态
* @return 字体加粗状态
*/
public boolean getBoldState() {
return mBoldState;
}
/**
* 笔记设置变更监听器接口
*/

162
MiNotes-master/app/src/main/java/net/micode/notes/tool/BackupUtils.java
Unescape View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package net.micode.notes.tool;
package net.micode.notes.tool;// 啊啊年u不是丢弃为本次u我把从
import android.content.Context;
import android.database.Cursor;
@ -35,20 +35,12 @@ import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
/**
* 该类提供了将笔记数据备份为文本文件的功能。
*/
public class BackupUtils {
private static final String TAG = "BackupUtils";
// 单例模式实例
// Singleton stuff
private static BackupUtils sInstance;
/**
* 获取BackupUtils的单例实例。
*
* @param context 应用上下文
* @return BackupUtils的单例实例
*/
public static synchronized BackupUtils getInstance(Context context) {
if (sInstance == null) {
sInstance = new BackupUtils(context);
@ -57,71 +49,43 @@ public class BackupUtils {
}
/**
* 以下状态常量用于表示备份或恢复操作的状态。
* Following states are signs to represents backup or restore
* status
*/
// 当前SD卡未挂载
public static final int STATE_SD_CARD_UNMOUONTED = 0;
// 备份文件不存在
public static final int STATE_BACKUP_FILE_NOT_EXIST = 1;
// 数据格式不正确，可能被其他程序修改
public static final int STATE_DATA_DESTROIED = 2;
// 运行时异常导致备份或恢复失败
public static final int STATE_SYSTEM_ERROR = 3;
// 备份或恢复成功
public static final int STATE_SUCCESS = 4;
// Currently, the sdcard is not mounted
public static final int STATE_SD_CARD_UNMOUONTED = 0;
// The backup file not exist
public static final int STATE_BACKUP_FILE_NOT_EXIST = 1;
// The data is not well formated, may be changed by other programs
public static final int STATE_DATA_DESTROIED = 2;
// Some run-time exception which causes restore or backup fails
public static final int STATE_SYSTEM_ERROR = 3;
// Backup or restore success
public static final int STATE_SUCCESS = 4;
private TextExport mTextExport;
/**
* 构造函数，初始化TextExport对象。
*
* @param context 应用上下文
*/
private BackupUtils(Context context) {
mTextExport = new TextExport(context);
}
/**
* 检查外部存储是否可用。
*
* @return 如果外部存储已挂载返回true，否则返回false
*/
private static boolean externalStorageAvailable() {
return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
}
/**
* 将笔记数据导出为文本文件。
*
* @return 导出操作的状态码
*/
public int exportToText() {
return mTextExport.exportToText();
}
/**
* 获取导出的文本文件的名称。
*
* @return 导出的文本文件的名称
*/
public String getExportedTextFileName() {
return mTextExport.mFileName;
}
/**
* 获取导出的文本文件的目录。
*
* @return 导出的文本文件的目录
*/
public String getExportedTextFileDir() {
return mTextExport.mFileDirectory;
}
/**
* 内部类，负责将笔记数据导出为文本文件。
*/
private static class TextExport {
// 用于查询笔记的投影列
private static final String[] NOTE_PROJECTION = {
NoteColumns.ID,
NoteColumns.MODIFIED_DATE,
@ -129,16 +93,12 @@ public class BackupUtils {
NoteColumns.TYPE
};
// 笔记ID列的索引
private static final int NOTE_COLUMN_ID = 0;
// 笔记修改日期列的索引
private static final int NOTE_COLUMN_MODIFIED_DATE = 1;
// 笔记摘要列的索引
private static final int NOTE_COLUMN_SNIPPET = 2;
// 用于查询笔记数据的投影列
private static final String[] DATA_PROJECTION = {
DataColumns.CONTENT,
DataColumns.MIME_TYPE,
@ -148,36 +108,23 @@ public class BackupUtils {
DataColumns.DATA4,
};
// 笔记数据内容列的索引
private static final int DATA_COLUMN_CONTENT = 0;
// 笔记数据MIME类型列的索引
private static final int DATA_COLUMN_MIME_TYPE = 1;
// 通话记录日期列的索引
private static final int DATA_COLUMN_CALL_DATE = 2;
// 电话号码列的索引
private static final int DATA_COLUMN_PHONE_NUMBER = 4;
// 文本导出格式数组
private final String[] TEXT_FORMAT;
// 文件夹名称格式索引
private static final int FORMAT_FOLDER_NAME = 0;
// 笔记日期格式索引
private static final int FORMAT_NOTE_DATE = 1;
// 笔记内容格式索引
private static final int FORMAT_NOTE_CONTENT = 2;
private final String [] TEXT_FORMAT;
private static final int FORMAT_FOLDER_NAME = 0;
private static final int FORMAT_NOTE_DATE = 1;
private static final int FORMAT_NOTE_CONTENT = 2;
private Context mContext;
private String mFileName;
private String mFileDirectory;
/**
* 构造函数，初始化文本导出所需的资源。
*
* @param context 应用上下文
*/
public TextExport(Context context) {
TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
mContext = context;
@ -185,37 +132,28 @@ public class BackupUtils {
mFileDirectory = "";
}
/**
* 获取指定索引的文本格式。
*
* @param id 格式索引
* @return 对应的文本格式
*/
private String getFormat(int id) {
return TEXT_FORMAT[id];
}
/**
* 将指定文件夹下的笔记导出为文本。
*
* @param folderId 文件夹ID
* @param ps 打印流
* Export the folder identified by folder id to text
*/
private void exportFolderToText(String folderId, PrintStream ps) {
// 查询属于该文件夹的笔记
// Query notes belong to this folder
Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[]{
folderId
NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] {
folderId
}, null);
if (notesCursor != null) {
if (notesCursor.moveToFirst()) {
do {
// 打印笔记的最后修改日期
// Print note's last modified date
ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
mContext.getString(R.string.format_datetime_mdhm),
notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
// 查询属于该笔记的数据
// Query data belong to this note
String noteId = notesCursor.getString(NOTE_COLUMN_ID);
exportNoteToText(noteId, ps);
} while (notesCursor.moveToNext());
@ -225,15 +163,12 @@ public class BackupUtils {
}
/**
* 将指定笔记导出为文本。
*
* @param noteId 笔记ID
* @param ps 打印流
* Export note identified by id to a print stream
*/
private void exportNoteToText(String noteId, PrintStream ps) {
Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[]{
noteId
DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
noteId
}, null);
if (dataCursor != null) {
@ -241,7 +176,7 @@ public class BackupUtils {
do {
String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
if (DataConstants.CALL_NOTE.equals(mimeType)) {
// 打印电话号码
// Print phone number
String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER);
long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE);
String location = dataCursor.getString(DATA_COLUMN_CONTENT);
@ -250,11 +185,11 @@ public class BackupUtils {
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
phoneNumber));
}
// 打印通话日期
// Print call date
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
.format(mContext.getString(R.string.format_datetime_mdhm),
callDate)));
// 打印通话附件位置
// Print call attachment location
if (!TextUtils.isEmpty(location)) {
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
location));
@ -270,9 +205,9 @@ public class BackupUtils {
}
dataCursor.close();
}
// 在笔记之间打印换行符
// print a line separator between note
try {
ps.write(new byte[]{
ps.write(new byte[] {
Character.LINE_SEPARATOR, Character.LETTER_NUMBER
});
} catch (IOException e) {
@ -281,9 +216,7 @@ public class BackupUtils {
}
/**
* 将笔记数据导出为用户可读的文本文件。
*
* @return 导出操作的状态码
* Note will be exported as text which is user readable
*/
public int exportToText() {
if (!externalStorageAvailable()) {
@ -296,7 +229,7 @@ public class BackupUtils {
Log.e(TAG, "get print stream error");
return STATE_SYSTEM_ERROR;
}
// 首先导出文件夹及其笔记
// First export folder and its notes
Cursor folderCursor = mContext.getContentResolver().query(
Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION,
@ -307,9 +240,9 @@ public class BackupUtils {
if (folderCursor != null) {
if (folderCursor.moveToFirst()) {
do {
// 打印文件夹名称
// Print folder's name
String folderName = "";
if (folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {
if(folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {
folderName = mContext.getString(R.string.call_record_folder_name);
} else {
folderName = folderCursor.getString(NOTE_COLUMN_SNIPPET);
@ -324,11 +257,11 @@ public class BackupUtils {
folderCursor.close();
}
// 导出根文件夹下的笔记
// Export notes in root's folder
Cursor noteCursor = mContext.getContentResolver().query(
Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION,
NoteColumns.TYPE + "=" + Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID
NoteColumns.TYPE + "=" + +Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID
+ "=0", null, null);
if (noteCursor != null) {
@ -337,7 +270,7 @@ public class BackupUtils {
ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
mContext.getString(R.string.format_datetime_mdhm),
noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
// 查询属于该笔记的数据
// Query data belong to this note
String noteId = noteCursor.getString(NOTE_COLUMN_ID);
exportNoteToText(noteId, ps);
} while (noteCursor.moveToNext());
@ -350,9 +283,7 @@ public class BackupUtils {
}
/**
* 获取指向导出文本文件的打印流。
*
* @return 打印流，如果获取失败返回null
* Get a print stream pointed to the file {@generateExportedTextFile}
*/
private PrintStream getExportToTextPrintStream() {
File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
@ -379,12 +310,7 @@ public class BackupUtils {
}
/**
* 生成用于存储导入数据的文本文件。
*
* @param context 应用上下文
* @param filePathResId 文件路径资源ID
* @param fileNameFormatResId 文件名格式资源ID
* @return 生成的文件，如果生成失败返回null
* Generate the text file to store imported data
*/
private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
StringBuilder sb = new StringBuilder();
@ -413,4 +339,6 @@ public class BackupUtils {
return null;
}
}
}

148
MiNotes-master/app/src/main/java/net/micode/notes/tool/DataUtils.java
Unescape View File

@ -34,19 +34,9 @@ import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
import java.util.ArrayList;
import java.util.HashSet;
/**
* 该类提供了与笔记数据操作相关的工具方法，包括批量删除、移动笔记等。
*/
public class DataUtils {
public static final String TAG = "DataUtils";
/**
* 批量删除笔记。
*
* @param resolver 内容解析器
* @param ids 要删除的笔记ID集合
* @return 如果删除成功返回true，否则返回false
*/
public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
if (ids == null) {
Log.d(TAG, "the ids is null");
@ -59,12 +49,12 @@ public class DataUtils {
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
for (long id : ids) {
if (id == Notes.ID_ROOT_FOLDER) {
if(id == Notes.ID_ROOT_FOLDER) {
Log.e(TAG, "Don't delete system folder root");
continue;
}
ContentProviderOperation.Builder builder = ContentProviderOperation
.newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
.newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
operationList.add(builder.build());
}
try {
@ -82,14 +72,6 @@ public class DataUtils {
return false;
}
/**
* 将笔记移动到指定文件夹。
*
* @param resolver 内容解析器
* @param id 笔记ID
* @param srcFolderId 源文件夹ID
* @param desFolderId 目标文件夹ID
*/
public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
ContentValues values = new ContentValues();
values.put(NoteColumns.PARENT_ID, desFolderId);
@ -98,16 +80,8 @@ public class DataUtils {
resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
}
/**
* 批量将笔记移动到指定文件夹。
*
* @param resolver 内容解析器
* @param ids 要移动的笔记ID集合
* @param folderId 目标文件夹ID
* @return 如果移动成功返回true，否则返回false
*/
public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
long folderId) {
long folderId) {
if (ids == null) {
Log.d(TAG, "the ids is null");
return true;
@ -116,7 +90,7 @@ public class DataUtils {
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
for (long id : ids) {
ContentProviderOperation.Builder builder = ContentProviderOperation
.newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
.newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
builder.withValue(NoteColumns.PARENT_ID, folderId);
builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
operationList.add(builder.build());
@ -138,21 +112,18 @@ public class DataUtils {
}
/**
* 获取用户文件夹的数量（不包括系统文件夹）。
*
* @param resolver 内容解析器
* @return 用户文件夹的数量
* Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}}
*/
public static int getUserFolderCount(ContentResolver resolver) {
Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
new String[]{"COUNT(*)"},
Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI,
new String[] { "COUNT(*)" },
NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?",
new String[]{String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)},
new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)},
null);
int count = 0;
if (cursor != null) {
if (cursor.moveToFirst()) {
if(cursor != null) {
if(cursor.moveToFirst()) {
try {
count = cursor.getInt(0);
} catch (IndexOutOfBoundsException e) {
@ -165,19 +136,11 @@ public class DataUtils {
return count;
}
/**
* 检查笔记是否在数据库中可见。
*
* @param resolver 内容解析器
* @param noteId 笔记ID
* @param type 笔记类型
* @return 如果笔记可见返回true，否则返回false
*/
public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
null,
NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER,
new String[]{String.valueOf(type)},
new String [] {String.valueOf(type)},
null);
boolean exist = false;
@ -190,13 +153,6 @@ public class DataUtils {
return exist;
}
/**
* 检查笔记是否存在于数据库中。
*
* @param resolver 内容解析器
* @param noteId 笔记ID
* @return 如果笔记存在返回true，否则返回false
*/
public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
null, null, null, null);
@ -211,13 +167,6 @@ public class DataUtils {
return exist;
}
/**
* 检查数据是否存在于数据库中。
*
* @param resolver 内容解析器
* @param dataId 数据ID
* @return 如果数据存在返回true，否则返回false
*/
public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
null, null, null, null);
@ -232,22 +181,15 @@ public class DataUtils {
return exist;
}
/**
* 检查可见文件夹名称是否已存在。
*
* @param resolver 内容解析器
* @param name 文件夹名称
* @return 如果文件夹名称已存在返回true，否则返回false
*/
public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
" AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +
" AND " + NoteColumns.SNIPPET + "=?",
new String[]{name}, null);
" AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +
" AND " + NoteColumns.SNIPPET + "=?",
new String[] { name }, null);
boolean exist = false;
if (cursor != null) {
if (cursor.getCount() > 0) {
if(cursor != null) {
if(cursor.getCount() > 0) {
exist = true;
}
cursor.close();
@ -255,18 +197,11 @@ public class DataUtils {
return exist;
}
/**
* 获取指定文件夹下的笔记小部件属性集合。
*
* @param resolver 内容解析器
* @param folderId 文件夹ID
* @return 笔记小部件属性集合
*/
public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
new String[]{NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE},
new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
NoteColumns.PARENT_ID + "=?",
new String[]{String.valueOf(folderId)},
new String[] { String.valueOf(folderId) },
null);
HashSet<AppWidgetAttribute> set = null;
@ -289,18 +224,11 @@ public class DataUtils {
return set;
}
/**
* 根据笔记ID获取通话号码。
*
* @param resolver 内容解析器
* @param noteId 笔记ID
* @return 通话号码，如果未找到返回空字符串
*/
public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
new String[]{CallNote.PHONE_NUMBER},
new String [] { CallNote.PHONE_NUMBER },
CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
new String[]{String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE},
new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE },
null);
if (cursor != null && cursor.moveToFirst()) {
@ -315,20 +243,12 @@ public class DataUtils {
return "";
}
/**
* 根据电话号码和通话日期获取笔记ID。
*
* @param resolver 内容解析器
* @param phoneNumber 电话号码
* @param callDate 通话日期
* @return 笔记ID，如果未找到返回0
*/
public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
new String[]{CallNote.NOTE_ID},
new String [] { CallNote.NOTE_ID },
CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
+ CallNote.PHONE_NUMBER + ",?)",
new String[]{String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber},
+ CallNote.PHONE_NUMBER + ",?)",
new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber },
null);
if (cursor != null) {
@ -344,19 +264,11 @@ public class DataUtils {
return 0;
}
/**
* 根据笔记ID获取笔记摘要。
*
* @param resolver 内容解析器
* @param noteId 笔记ID
* @return 笔记摘要
* @throws IllegalArgumentException 如果未找到笔记
*/
public static String getSnippetById(ContentResolver resolver, long noteId) {
Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
new String[]{NoteColumns.SNIPPET},
new String [] { NoteColumns.SNIPPET },
NoteColumns.ID + "=?",
new String[]{String.valueOf(noteId)},
new String [] { String.valueOf(noteId)},
null);
if (cursor != null) {
@ -370,12 +282,6 @@ public class DataUtils {
throw new IllegalArgumentException("Note is not found with id: " + noteId);
}
/**
* 格式化笔记摘要，去除首尾空格并截取第一行。
*
* @param snippet 笔记摘要
* @return 格式化后的笔记摘要
*/
public static String getFormattedSnippet(String snippet) {
if (snippet != null) {
snippet = snippet.trim();
@ -386,4 +292,4 @@ public class DataUtils {
}
return snippet;
}
}
}

52
MiNotes-master/app/src/main/java/net/micode/notes/tool/GTaskStringUtils.java
Unescape View File

@ -16,146 +16,98 @@
package net.micode.notes.tool;
/**
* 该类包含与Google任务（GTask）相关的JSON字符串常量，用于在应用中处理GTask的JSON数据。
*/
public class GTaskStringUtils {
// 定义GTask JSON数据中的动作ID字段
public final static String GTASK_JSON_ACTION_ID = "action_id";
// 定义GTask JSON数据中的动作列表字段
public final static String GTASK_JSON_ACTION_LIST = "action_list";
// 定义GTask JSON数据中的动作类型字段
public final static String GTASK_JSON_ACTION_TYPE = "action_type";
// 定义GTask JSON数据中的创建动作类型
public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
// 定义GTask JSON数据中的获取所有动作类型
public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
// 定义GTask JSON数据中的移动动作类型
public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
// 定义GTask JSON数据中的更新动作类型
public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
// 定义GTask JSON数据中的创建者ID字段
public final static String GTASK_JSON_CREATOR_ID = "creator_id";
// 定义GTask JSON数据中的子实体字段
public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
// 定义GTask JSON数据中的客户端版本字段
public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
// 定义GTask JSON数据中的完成状态字段
public final static String GTASK_JSON_COMPLETED = "completed";
// 定义GTask JSON数据中的当前列表ID字段
public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
// 定义GTask JSON数据中的默认列表ID字段
public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
// 定义GTask JSON数据中的删除状态字段
public final static String GTASK_JSON_DELETED = "deleted";
// 定义GTask JSON数据中的目标列表字段
public final static String GTASK_JSON_DEST_LIST = "dest_list";
// 定义GTask JSON数据中的目标父级字段
public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
// 定义GTask JSON数据中的目标父级类型字段
public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
// 定义GTask JSON数据中的实体增量字段
public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
// 定义GTask JSON数据中的实体类型字段
public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
// 定义GTask JSON数据中的获取已删除项字段
public final static String GTASK_JSON_GET_DELETED = "get_deleted";
// 定义GTask JSON数据中的ID字段
public final static String GTASK_JSON_ID = "id";
// 定义GTask JSON数据中的索引字段
public final static String GTASK_JSON_INDEX = "index";
// 定义GTask JSON数据中的最后修改时间字段
public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
// 定义GTask JSON数据中的最新同步点字段
public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
// 定义GTask JSON数据中的列表ID字段
public final static String GTASK_JSON_LIST_ID = "list_id";
// 定义GTask JSON数据中的列表集合字段
public final static String GTASK_JSON_LISTS = "lists";
// 定义GTask JSON数据中的名称字段
public final static String GTASK_JSON_NAME = "name";
// 定义GTask JSON数据中的新ID字段
public final static String GTASK_JSON_NEW_ID = "new_id";
// 定义GTask JSON数据中的备注字段
public final static String GTASK_JSON_NOTES = "notes";
// 定义GTask JSON数据中的父级ID字段
public final static String GTASK_JSON_PARENT_ID = "parent_id";
// 定义GTask JSON数据中的前一个兄弟ID字段
public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
// 定义GTask JSON数据中的结果字段
public final static String GTASK_JSON_RESULTS = "results";
// 定义GTask JSON数据中的源列表字段
public final static String GTASK_JSON_SOURCE_LIST = "source_list";
// 定义GTask JSON数据中的任务集合字段
public final static String GTASK_JSON_TASKS = "tasks";
// 定义GTask JSON数据中的类型字段
public final static String GTASK_JSON_TYPE = "type";
// 定义GTask JSON数据中的组类型
public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
// 定义GTask JSON数据中的任务类型
public final static String GTASK_JSON_TYPE_TASK = "TASK";
// 定义GTask JSON数据中的用户字段
public final static String GTASK_JSON_USER = "user";
// 定义MIUI文件夹前缀
public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]";
// 定义默认文件夹名称
public final static String FOLDER_DEFAULT = "Default";
// 定义通话记录文件夹名称
public final static String FOLDER_CALL_NOTE = "Call_Note";
// 定义元数据文件夹名称
public final static String FOLDER_META = "METADATA";
// 定义元数据头中的GTask ID字段
public final static String META_HEAD_GTASK_ID = "meta_gid";
// 定义元数据头中的备注字段
public final static String META_HEAD_NOTE = "meta_note";
// 定义元数据头中的数据字段
public final static String META_HEAD_DATA = "meta_data";
// 定义元数据备注名称
public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE";
}
}

237
MiNotes-master/app/src/main/java/net/micode/notes/tool/ResourceParser.java
Unescape View File

@ -22,86 +22,49 @@ import android.preference.PreferenceManager;
import net.micode.notes.R;
import net.micode.notes.ui.NotesPreferenceActivity;
/**
* 该类用于解析应用中的资源，包括背景颜色、字体大小等。
*/
public class ResourceParser {
// 定义黄色背景颜色的常量
public static final int YELLOW = 0;
// 定义蓝色背景颜色的常量
public static final int BLUE = 1;
// 定义白色背景颜色的常量
public static final int WHITE = 2;
// 定义绿色背景颜色的常量
public static final int GREEN = 3;
// 定义红色背景颜色的常量
public static final int RED = 4;
public static final int YELLOW = 0;
public static final int BLUE = 1;
public static final int WHITE = 2;
public static final int GREEN = 3;
public static final int RED = 4;
// 定义默认背景颜色为黄色
public static final int BG_DEFAULT_COLOR = YELLOW;
// 定义小字体大小的常量
public static final int TEXT_SMALL = 0;
// 定义中等字体大小的常量
public static final int TEXT_MEDIUM = 1;
// 定义大字体大小的常量
public static final int TEXT_LARGE = 2;
// 定义超大字体大小的常量
public static final int TEXT_SUPER = 3;
public static final int TEXT_SMALL = 0;
public static final int TEXT_MEDIUM = 1;
public static final int TEXT_LARGE = 2;
public static final int TEXT_SUPER = 3;
// 定义默认字体大小为中等
public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
/**
* 内部类，用于管理笔记编辑界面的背景资源。
*/
public static class NoteBgResources {
// 笔记编辑背景资源数组
private final static int[] BG_EDIT_RESOURCES = new int[]{
R.drawable.edit_yellow,
R.drawable.edit_blue,
R.drawable.edit_white,
R.drawable.edit_green,
R.drawable.edit_red
private final static int [] BG_EDIT_RESOURCES = new int [] {
R.drawable.edit_yellow,
R.drawable.edit_blue,
R.drawable.edit_white,
R.drawable.edit_green,
R.drawable.edit_red
};
// 笔记编辑标题背景资源数组
private final static int[] BG_EDIT_TITLE_RESOURCES = new int[]{
R.drawable.edit_title_yellow,
R.drawable.edit_title_blue,
R.drawable.edit_title_white,
R.drawable.edit_title_green,
R.drawable.edit_title_red
private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
R.drawable.edit_title_yellow,
R.drawable.edit_title_blue,
R.drawable.edit_title_white,
R.drawable.edit_title_green,
R.drawable.edit_title_red
};
/**
* 根据ID获取笔记编辑背景资源。
*
* @param id 背景资源ID
* @return 对应的背景资源ID
*/
public static int getNoteBgResource(int id) {
return BG_EDIT_RESOURCES[id];
}
/**
* 根据ID获取笔记编辑标题背景资源。
*
* @param id 标题背景资源ID
* @return 对应的标题背景资源ID
*/
public static int getNoteTitleBgResource(int id) {
return BG_EDIT_TITLE_RESOURCES[id];
}
}
/**
* 获取默认的背景ID。
*
* @param context 应用上下文
* @return 默认的背景ID
*/
public static int getDefaultBgId(Context context) {
if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
@ -111,162 +74,99 @@ public class ResourceParser {
}
}
/**
* 内部类，用于管理笔记列表项的背景资源。
*/
public static class NoteItemBgResources {
// 笔记列表第一项背景资源数组
private final static int[] BG_FIRST_RESOURCES = new int[]{
R.drawable.list_yellow_up,
R.drawable.list_blue_up,
R.drawable.list_white_up,
R.drawable.list_green_up,
R.drawable.list_red_up
private final static int [] BG_FIRST_RESOURCES = new int [] {
R.drawable.list_yellow_up,
R.drawable.list_blue_up,
R.drawable.list_white_up,
R.drawable.list_green_up,
R.drawable.list_red_up
};
// 笔记列表中间项背景资源数组
private final static int[] BG_NORMAL_RESOURCES = new int[]{
R.drawable.list_yellow_middle,
R.drawable.list_blue_middle,
R.drawable.list_white_middle,
R.drawable.list_green_middle,
R.drawable.list_red_middle
private final static int [] BG_NORMAL_RESOURCES = new int [] {
R.drawable.list_yellow_middle,
R.drawable.list_blue_middle,
R.drawable.list_white_middle,
R.drawable.list_green_middle,
R.drawable.list_red_middle
};
// 笔记列表最后一项背景资源数组
private final static int[] BG_LAST_RESOURCES = new int[]{
R.drawable.list_yellow_down,
R.drawable.list_blue_down,
R.drawable.list_white_down,
R.drawable.list_green_down,
R.drawable.list_red_down,
private final static int [] BG_LAST_RESOURCES = new int [] {
R.drawable.list_yellow_down,
R.drawable.list_blue_down,
R.drawable.list_white_down,
R.drawable.list_green_down,
R.drawable.list_red_down,
};
// 笔记列表单项背景资源数组
private final static int[] BG_SINGLE_RESOURCES = new int[]{
R.drawable.list_yellow_single,
R.drawable.list_blue_single,
R.drawable.list_white_single,
R.drawable.list_green_single,
R.drawable.list_red_single
private final static int [] BG_SINGLE_RESOURCES = new int [] {
R.drawable.list_yellow_single,
R.drawable.list_blue_single,
R.drawable.list_white_single,
R.drawable.list_green_single,
R.drawable.list_red_single
};
/**
* 根据ID获取笔记列表第一项背景资源。
*
* @param id 背景资源ID
* @return 对应的背景资源ID
*/
public static int getNoteBgFirstRes(int id) {
return BG_FIRST_RESOURCES[id];
}
/**
* 根据ID获取笔记列表最后一项背景资源。
*
* @param id 背景资源ID
* @return 对应的背景资源ID
*/
public static int getNoteBgLastRes(int id) {
return BG_LAST_RESOURCES[id];
}
/**
* 根据ID获取笔记列表单项背景资源。
*
* @param id 背景资源ID
* @return 对应的背景资源ID
*/
public static int getNoteBgSingleRes(int id) {
return BG_SINGLE_RESOURCES[id];
}
/**
* 根据ID获取笔记列表中间项背景资源。
*
* @param id 背景资源ID
* @return 对应的背景资源ID
*/
public static int getNoteBgNormalRes(int id) {
return BG_NORMAL_RESOURCES[id];
}
/**
* 获取文件夹背景资源。
*
* @return 文件夹背景资源ID
*/
public static int getFolderBgRes() {
return R.drawable.list_folder;
}
}
/**
* 内部类，用于管理小部件的背景资源。
*/
public static class WidgetBgResources {
// 2x小部件背景资源数组
private final static int[] BG_2X_RESOURCES = new int[]{
R.drawable.widget_2x_yellow,
R.drawable.widget_2x_blue,
R.drawable.widget_2x_white,
R.drawable.widget_2x_green,
R.drawable.widget_2x_red,
private final static int [] BG_2X_RESOURCES = new int [] {
R.drawable.widget_2x_yellow,
R.drawable.widget_2x_blue,
R.drawable.widget_2x_white,
R.drawable.widget_2x_green,
R.drawable.widget_2x_red,
};
/**
* 根据ID获取2x小部件背景资源。
*
* @param id 背景资源ID
* @return 对应的背景资源ID
*/
public static int getWidget2xBgResource(int id) {
return BG_2X_RESOURCES[id];
}
// 4x小部件背景资源数组
private final static int[] BG_4X_RESOURCES = new int[]{
R.drawable.widget_4x_yellow,
R.drawable.widget_4x_blue,
R.drawable.widget_4x_white,
R.drawable.widget_4x_green,
R.drawable.widget_4x_red
private final static int [] BG_4X_RESOURCES = new int [] {
R.drawable.widget_4x_yellow,
R.drawable.widget_4x_blue,
R.drawable.widget_4x_white,
R.drawable.widget_4x_green,
R.drawable.widget_4x_red
};
/**
* 根据ID获取4x小部件背景资源。
*
* @param id 背景资源ID
* @return 对应的背景资源ID
*/
public static int getWidget4xBgResource(int id) {
return BG_4X_RESOURCES[id];
}
}
/**
* 内部类，用于管理文本外观资源。
*/
public static class TextAppearanceResources {
// 文本外观资源数组
private final static int[] TEXTAPPEARANCE_RESOURCES = new int[]{
R.style.TextAppearanceNormal,
R.style.TextAppearanceMedium,
R.style.TextAppearanceLarge,
R.style.TextAppearanceSuper
private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
R.style.TextAppearanceNormal,
R.style.TextAppearanceMedium,
R.style.TextAppearanceLarge,
R.style.TextAppearanceSuper
};
/**
* 根据ID获取文本外观资源。
* 如果ID超出资源数组长度，返回默认字体大小对应的资源。
*
* @param id 文本外观资源ID
* @return 对应的文本外观资源ID
*/
public static int getTexAppearanceResource(int id) {
/**
* HACKME: 修复将资源ID存储在共享偏好中的错误。
* 如果ID大于资源数组的长度，返回默认字体大小对应的资源。
* HACKME: Fix bug of store the resource id in shared preference.
* The id may larger than the length of resources, in this case,
* return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
*/
if (id >= TEXTAPPEARANCE_RESOURCES.length) {
return BG_DEFAULT_FONT_SIZE;
@ -274,13 +174,8 @@ public class ResourceParser {
return TEXTAPPEARANCE_RESOURCES[id];
}
/**
* 获取文本外观资源数组的长度。
*
* @return 文本外观资源数组的长度
*/
public static int getResourcesSize() {
return TEXTAPPEARANCE_RESOURCES.length;
}
}
}
}

60
MiNotes-master/app/src/main/java/net/micode/notes/ui/AlarmAlertActivity.java
Unescape View File

@ -40,25 +40,20 @@ import net.micode.notes.tool.DataUtils;
import java.io.IOException;
/**
* 闹钟提醒活动，当闹钟触发时显示的界面
*/
public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
private long mNoteId; // 关联的笔记ID
private String mSnippet; // 笔记内容片段
private static final int SNIPPET_PREW_MAX_LEN = 60; // 预览文本最大长度
MediaPlayer mPlayer; // 媒体播放器用于播放闹铃
private long mNoteId;
private String mSnippet;
private static final int SNIPPET_PREW_MAX_LEN = 60;
MediaPlayer mPlayer;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE); // 无标题栏
// 设置窗口属性，在锁屏时也能显示
requestWindowFeature(Window.FEATURE_NO_TITLE);
final Window win = getWindow();
win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
// 如果屏幕关闭，则唤醒屏幕
if (!isScreenOn()) {
win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
| WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
@ -66,12 +61,11 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
| WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
}
// 从Intent获取笔记数据
Intent intent = getIntent();
try {
mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
// 截取过长文本
mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0,
SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
: mSnippet;
@ -81,49 +75,50 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
}
mPlayer = new MediaPlayer();
// 检查笔记是否仍然存在
if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
showActionDialog(); // 显示操作对话框
playAlarmSound(); // 播放闹铃声音
showActionDialog();
playAlarmSound();
} else {
finish(); // 笔记不存在则结束活动
finish();
}
}
// 检查屏幕是否亮着
private boolean isScreenOn() {
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
return pm.isScreenOn();
}
// 播放闹铃声音
private void playAlarmSound() {
// 获取默认闹铃铃声
Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
// 检查静音模式设置
int silentModeStreams = Settings.System.getInt(getContentResolver(),
Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
// 设置音频流类型
if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {
mPlayer.setAudioStreamType(silentModeStreams);
} else {
mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);
}
// 准备并播放声音
try {
mPlayer.setDataSource(this, url);
mPlayer.prepare();
mPlayer.setLooping(true); // 循环播放
mPlayer.setLooping(true);
mPlayer.start();
} catch (Exception e) {
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalStateException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 显示操作对话框
private void showActionDialog() {
AlertDialog.Builder dialog = new AlertDialog.Builder(this);
dialog.setTitle(R.string.app_name);
@ -135,10 +130,9 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
dialog.show().setOnDismissListener(this);
}
// 对话框按钮点击事件
public void onClick(DialogInterface dialog, int which) {
switch (which) {
case DialogInterface.BUTTON_NEGATIVE: // 进入笔记
case DialogInterface.BUTTON_NEGATIVE:
Intent intent = new Intent(this, NoteEditActivity.class);
intent.setAction(Intent.ACTION_VIEW);
intent.putExtra(Intent.EXTRA_UID, mNoteId);
@ -149,13 +143,11 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
}
}
// 对话框关闭事件
public void onDismiss(DialogInterface dialog) {
stopAlarmSound(); // 停止闹铃
finish(); // 结束活动
stopAlarmSound();
finish();
}
// 停止闹铃声音
private void stopAlarmSound() {
if (mPlayer != null) {
mPlayer.stop();
@ -163,4 +155,4 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
mPlayer = null;
}
}
}
}

16
MiNotes-master/app/src/main/java/net/micode/notes/ui/AlarmInitReceiver.java
Unescape View File

@ -28,23 +28,19 @@ import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
/**
* 初始化闹钟的广播接收器，通常在设备启动后运行
*/
public class AlarmInitReceiver extends BroadcastReceiver {
// 查询笔记的投影(需要哪些列)
private static final String [] PROJECTION = new String [] {
NoteColumns.ID,
NoteColumns.ALERTED_DATE
};
private static final int COLUMN_ID = 0; // ID列索引
private static final int COLUMN_ALERTED_DATE = 1; // 提醒日期列索引
private static final int COLUMN_ID = 0;
private static final int COLUMN_ALERTED_DATE = 1;
@Override
public void onReceive(Context context, Intent intent) {
long currentDate = System.currentTimeMillis();
// 查询所有设置了未来提醒的笔记
Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
PROJECTION,
NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
@ -55,10 +51,8 @@ public class AlarmInitReceiver extends BroadcastReceiver {
if (c.moveToFirst()) {
do {
long alertDate = c.getLong(COLUMN_ALERTED_DATE);
// 为每个笔记创建闹钟
Intent sender = new Intent(context, AlarmReceiver.class);
sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
c.getLong(COLUMN_ID)));
sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
AlarmManager alermManager = (AlarmManager) context
.getSystemService(Context.ALARM_SERVICE);
@ -68,4 +62,4 @@ public class AlarmInitReceiver extends BroadcastReceiver {
c.close();
}
}
}
}

4
MiNotes-master/app/src/main/java/net/micode/notes/ui/AlarmReceiver.java
Unescape View File

@ -20,13 +20,9 @@ import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
/**
* 闹钟触发时接收广播并启动闹钟提醒活动
*/
public class AlarmReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
// 启动闹钟提醒活动
intent.setClass(context, AlarmAlertActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent);

398
MiNotes-master/app/src/main/java/net/micode/notes/ui/DateTimePicker.java
Unescape View File

@ -21,136 +21,93 @@ import java.util.Calendar;
import net.micode.notes.R;
import android.content.Context;
import android.text.format.DateFormat;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.NumberPicker;
/**
* DateTimePicker类继承自FrameLayout，用于创建一个日期和时间选择器，
* 允许用户通过滚动选择日期和时间，并提供了日期和时间变化的回调接口。
*/
public class DateTimePicker extends FrameLayout {
// 默认启用状态
private static final boolean DEFAULT_ENABLE_STATE = true;
// 半天的小时数
private static final int HOURS_IN_HALF_DAY = 12;
// 一天的小时数
private static final int HOURS_IN_ALL_DAY = 24;
// 一周的天数
private static final int DAYS_IN_ALL_WEEK = 7;
// 日期选择器的最小取值
private static final int DATE_SPINNER_MIN_VAL = 0;
// 日期选择器的最大取值
private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
// 24小时制小时选择器的最小取值
private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
// 24小时制小时选择器的最大取值
private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
// 12小时制小时选择器的最小取值
private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
// 12小时制小时选择器的最大取值
private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
// 分钟选择器的最小取值
private static final int MINUT_SPINNER_MIN_VAL = 0;
// 分钟选择器的最大取值
private static final int MINUT_SPINNER_MAX_VAL = 59;
// 上午/下午选择器的最小取值
private static final int AMPM_SPINNER_MIN_VAL = 0;
// 上午/下午选择器的最大取值
private static final int AMPM_SPINNER_MAX_VAL = 1;
// 日期选择器
private final NumberPicker mDateSpinner;
// 小时选择器
private final NumberPicker mHourSpinner;
// 分钟选择器
private final NumberPicker mMinuteSpinner;
// 上午/下午选择器
private final NumberPicker mAmPmSpinner;
// 日历对象，用于存储当前日期和时间
private Calendar mDate;
// 日期显示值数组
private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
// 是否为上午
private boolean mIsAm;
// 是否为24小时制
private boolean mIs24HourView;
// 是否启用
private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
// 是否正在初始化
private boolean mInitialising;
// 日期和时间变化监听器
private OnDateTimeChangedListener mOnDateTimeChangedListener;
/**
* 日期选择器值变化监听器，当日期选择器的值发生变化时调用
*/
private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
// 根据新值和旧值的差值更新日期
mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);
// 更新日期选择器的显示
updateDateControl();
// 调用日期和时间变化的回调方法
onDateTimeChanged();
}
};
/**
* 小时选择器值变化监听器，当小时选择器的值发生变化时调用
*/
private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
boolean isDateChanged = false;
// 创建一个新的日历对象
Calendar cal = Calendar.getInstance();
if (!mIs24HourView) {
if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
// 从下午11点到凌晨12点，日期加1
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
} else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
// 从凌晨12点到上午11点，日期减1
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true;
}
if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
// 切换上午/下午状态
mIsAm = !mIsAm;
// 更新上午/下午选择器的显示
updateAmPmControl();
}
} else {
if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
// 从23点到0点，日期加1
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
} else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
// 从0点到23点，日期减1
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true;
}
}
// 计算新的小时数
int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
// 设置日历对象的小时数
mDate.set(Calendar.HOUR_OF_DAY, newHour);
// 调用日期和时间变化的回调方法
onDateTimeChanged();
if (isDateChanged) {
// 如果日期发生变化，更新日历对象的年、月、日
setCurrentYear(cal.get(Calendar.YEAR));
setCurrentMonth(cal.get(Calendar.MONTH));
setCurrentDay(cal.get(Calendar.DAY_OF_MONTH));
@ -158,347 +115,376 @@ public class DateTimePicker extends FrameLayout {
}
};
/**
* 分钟选择器值变化监听器，当分钟选择器的值发生变化时调用
*/
private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
// 获取分钟选择器的最小和最大取值
int minValue = mMinuteSpinner.getMinValue();
int maxValue = mMinuteSpinner.getMaxValue();
int offset = 0;
if (oldVal == maxValue && newVal == minValue) {
// 从59分钟到0分钟，小时数加1
offset += 1;
} else if (oldVal == minValue && newVal == maxValue) {
// 从0分钟到59分钟，小时数减1
offset -= 1;
}
if (offset != 0) {
// 根据偏移量更新日历对象的小时数
mDate.add(Calendar.HOUR_OF_DAY, offset);
// 更新小时选择器的显示
mHourSpinner.setValue(getCurrentHour());
// 更新日期选择器的显示
updateDateControl();
int newHour = getCurrentHourOfDay();
if (newHour >= HOURS_IN_HALF_DAY) {
// 如果小时数大于等于12，设置为下午
mIsAm = false;
// 更新上午/下午选择器的显示
updateAmPmControl();
} else {
// 如果小时数小于12，设置为上午
mIsAm = true;
// 更新上午/下午选择器的显示
updateAmPmControl();
}
}
// 设置日历对象的分钟数
mDate.set(Calendar.MINUTE, newVal);
// 调用日期和时间变化的回调方法
onDateTimeChanged();
}
};
/**
* 上午/下午选择器值变化监听器，当上午/下午选择器的值发生变化时调用
*/
private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
// 切换上午/下午状态
mIsAm = !mIsAm;
if (mIsAm) {
// 从下午切换到上午，小时数减12
mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
} else {
// 从上午切换到下午，小时数加12
mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
}
// 更新上午/下午选择器的显示
updateAmPmControl显示
updateAmPmControl();
// 调用日期和时间变化的回调方法
onDateTimeChanged();
}
};
/**
* 日期和时间变化监听器接口，用于监听日期和时间的变化
*/
public interface OnDateTimeChangedListener {
/**
* 当日期和时间发生变化时调用
* @param view 日期和时间选择器视图
* @param year 年份
* @param month 月份
* @param dayOfMonth 日期
* @param hourOfDay 小时数
* @param minute 分钟数
*/
void onDateTimeChanged(DateTimePicker view, int year, int month,
int dayOfMonth, int hourOfDay, int minute);
}
/**
* 构造函数，使用当前时间初始化日期和时间选择器
* @param context 上下文对象
*/
public DateTimePicker(Context context) {
this(context, System.currentTimeMillis());
}
/**
* 构造函数，使用指定的时间初始化日期和时间选择器
* @param context 上下文对象
* @param date 指定的时间（毫秒）
*/
public DateTimePicker(Context context, long date) {
this(context, date, DateFormat.is24HourFormat(context));
}
/**
* 构造函数，使用指定的时间和是否为24小时制初始化日期和时间选择器
* @param context 上下文对象
* @param date 指定的时间（毫秒）
* @param is24HourView 是否为24小时制
*/
public DateTimePicker(Context context, long date, boolean is24HourView) {
super(context);
// 初始化日历对象
mDate = Calendar.getInstance();
mInitialising = true;
// 判断当前小时数是否大于等于12，确定是否为下午
mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
// 加载布局
inflate(context, R.layout.datetime_picker, this);
// 获取日期选择器
mDateSpinner = (NumberPicker) findViewById(R.id.date);
// 设置日期选择器的最小和最大取值
mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
// 设置日期选择器的值变化监听器
mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);
// 获取小时选择器
mHourSpinner = (NumberPicker) findViewById(R.id.hour);
// 设置小时选择器的值变化监听器
mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
// 获取分钟选择器
mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);
// 设置分钟选择器的最小和最大取值
mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
// 设置分钟选择器的长按更新间隔
mMinuteSpinner.setOnLongPressUpdateInterval(100);
// 设置分钟选择器的值变化监听器
mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
// 获取上午/下午显示字符串数组
String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
// 获取上午/下午选择器
mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
// 设置上午/下午选择器的最小和最大取值
mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);
// 设置上午/下午选择器的显示值
mAmPmSpinner.setDisplayedValues(stringsForAmPm);
// 设置上午/下午选择器的值变化监听器
mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
// 更新日期选择器的显示
// update controls to initial state
updateDateControl();
// 更新小时选择器的显示
updateHourControl();
// 更新上午/下午选择器的显示
updateAmPmControl();
// 设置是否为24小时制
set24HourView(is24HourView);
// 设置当前日期和时间
// set to current time
setCurrentDate(date);
// 设置启用状态
setEnabled(isEnabled());
// 设置内容描述
// set the content descriptions
mInitialising = false;
}
/**
* 设置启用状态
* @param enabled 是否启用
*/
@Override
public void setEnabled(boolean enabled) {
if (mIsEnabled == enabled) {
return;
}
super.setEnabled(enabled);
// 设置日期选择器的启用状态
mDateSpinner.setEnabled(enabled);
// 设置分钟选择器的启用状态
mMinuteSpinner.setEnabled(enabled);
// 设置小时选择器的启用状态
mHourSpinner.setEnabled(enabled);
// 设置上午/下午选择器的启用状态
mAmPmSpinner.setEnabled(enabled);
mIsEnabled = enabled;
}
/**
* 获取启用状态
* @return 是否启用
*/
@Override
public boolean isEnabled() {
return mIsEnabled;
}
/**
* 获取当前日期和时间的毫秒数
* @return 当前日期和时间的毫秒数
* Get the current date in millis
*
* @return the current date in millis
*/
public long getCurrentDateInTimeMillis() {
return mDate.getTimeInMillis();
}
/**
* 设置当前日期和时间
* @param date 指定的时间（毫秒）
* Set the current date
*
* @param date The current date in millis
*/
public void setCurrentDate(long date) {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(date);
// 设置当前日期和时间的年、月、日、小时、分钟
setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH),
cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE));
}
/**
* 设置当前日期和时间
* @param year 年份
* @param month 月份
* Set the current date
*
* @param year The current year
* @param month The current month
* @param dayOfMonth The current dayOfMonth
* @param hourOfDay The current hourOfDay
* @param minute The current minute
*/
public void setCurrentDate(int year, int month, int dayOfMonth, int hourOfDay, int minute) {
mDate.set(Calendar.YEAR, year);
mDate.set(Calendar.MONTH, month);
mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
mDate.set(Calendar.MINUTE, minute);
mDate.set(Calendar.SECOND, 0);
mDate.set(Calendar.MILLISECOND, 0);
public void setCurrentDate(int year, int month,
int dayOfMonth, int hourOfDay, int minute) {
setCurrentYear(year);
setCurrentMonth(month);
setCurrentDay(dayOfMonth);
updateHourControl();
setCurrentHour(hourOfDay);
setCurrentMinute(minute);
}
/**
* Get current year
*
* @return The current year
*/
public int getCurrentYear() {
return mDate.get(Calendar.YEAR);
}
/**
* Set current year
*
* @param year The current year
*/
public void setCurrentYear(int year) {
if (!mInitialising && year == getCurrentYear()) {
return;
}
mDate.set(Calendar.YEAR, year);
updateDateControl();
updateHourControl();
updateAmPmControl();
onDateTimeChanged();
}
/**
* 更新日期选择器的显示
* Get current month in the year
*
* @return The current month in the year
*/
private void updateDateControl() {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(mDate.getTimeInMillis());
int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
mDateSpinner.setValue(dayOfWeek - 1);
public int getCurrentMonth() {
return mDate.get(Calendar.MONTH);
}
/**
* 更新小时选择器的显示
* Set current month in the year
*
* @param month The month in the year
*/
private void updateHourControl() {
int hour = getCurrentHour();
mHourSpinner.setValue(hour);
public void setCurrentMonth(int month) {
if (!mInitialising && month == getCurrentMonth()) {
return;
}
mDate.set(Calendar.MONTH, month);
updateDateControl();
onDateTimeChanged();
}
/**
* 更新上午/下午选择器的显示
* Get current day of the month
*
* @return The day of the month
*/
private void updateAmPmControl() {
mAmPmSpinner.setValue(mIsAm ? 0 : 1);
public int getCurrentDay() {
return mDate.get(Calendar.DAY_OF_MONTH);
}
/**
* 获取当前小时数
* @return 当前小时数
* Set current day of the month
*
* @param dayOfMonth The day of the month
*/
private int getCurrentHour() {
int hour = mDate.get(Calendar.HOUR);
if (hour == 0) {
hour = 12;
public void setCurrentDay(int dayOfMonth) {
if (!mInitialising && dayOfMonth == getCurrentDay()) {
return;
}
return hour;
mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
updateDateControl();
onDateTimeChanged();
}
/**
* 获取当前小时数（24小时制）
* @return 当前小时数（24小时制）
* Get current hour in 24 hour mode, in the range (0~23)
* @return The current hour in 24 hour mode
*/
private int getCurrentHourOfDay() {
public int getCurrentHourOfDay() {
return mDate.get(Calendar.HOUR_OF_DAY);
}
private int getCurrentHour() {
if (mIs24HourView){
return getCurrentHourOfDay();
} else {
int hour = getCurrentHourOfDay();
if (hour > HOURS_IN_HALF_DAY) {
return hour - HOURS_IN_HALF_DAY;
} else {
return hour == 0 ? HOURS_IN_HALF_DAY : hour;
}
}
}
/**
* 设置当前年份
* @param year 年份
* Set current hour in 24 hour mode, in the range (0~23)
*
* @param hourOfDay
*/
private void setCurrentYear(int year) {
mDate.set(Calendar.YEAR, year);
public void setCurrentHour(int hourOfDay) {
if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
return;
}
mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
if (!mIs24HourView) {
if (hourOfDay >= HOURS_IN_HALF_DAY) {
mIsAm = false;
if (hourOfDay > HOURS_IN_HALF_DAY) {
hourOfDay -= HOURS_IN_HALF_DAY;
} else if (hourOfDay == HOURS_IN_HALF_DAY) {
hourOfDay = HOURS_IN_HALF_DAY;
}
} else {
mIsAm = true;
if (hourOfDay == 0) {
hourOfDay = HOURS_IN_HALF_DAY;
}
}
updateAmPmControl();
mHourSpinner.setValue(hourOfDay);
} else {
mHourSpinner.setValue(hourOfDay);
}
onDateTimeChanged();
}
/**
* 设置当前月份
* @param month 月份
* Get currentMinute
*
* @return The Current Minute
*/
private void setCurrentMonth(int month) {
mDate.set(Calendar.MONTH, month);
public int getCurrentMinute() {
return mDate.get(Calendar.MINUTE);
}
/**
* 设置当前日期
* @param dayOfMonth 日期
* Set current minute
*/
private void setCurrentDay(int dayOfMonth) {
mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
public void setCurrentMinute(int minute) {
if (!mInitialising && minute == getCurrentMinute()) {
return;
}
mMinuteSpinner.setValue(minute);
mDate.set(Calendar.MINUTE, minute);
onDateTimeChanged();
}
/**
* 设置是否为24小时制
* @param is24HourView 是否为24小时制
* @return true if this is in 24 hour view else false.
*/
public boolean is24HourView () {
return mIs24HourView;
}
/**
* Set whether in 24 hour or AM/PM mode.
*
* @param is24HourView True for 24 hour mode. False for AM/PM mode.
*/
public void set24HourView(boolean is24HourView) {
if (mIs24HourView == is24HourView) {
return;
}
mIs24HourView = is24HourView;
mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);
int hour = getCurrentHourOfDay();
updateHourControl();
setCurrentHour(hour);
updateAmPmControl();
}
private void updateDateControl() {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1);
mDateSpinner.setDisplayedValues(null);
for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) {
cal.add(Calendar.DAY_OF_YEAR, 1);
mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);
}
mDateSpinner.setDisplayedValues(mDateDisplayValues);
mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);
mDateSpinner.invalidate();
}
private void updateAmPmControl() {
if (mIs24HourView) {
mAmPmSpinner.setVisibility(View.GONE);
} else {
int index = mIsAm ? Calendar.AM : Calendar.PM;
mAmPmSpinner.setValue(index);
mAmPmSpinner.setVisibility(View.VISIBLE);
}
}
private void updateHourControl() {
if (mIs24HourView) {
mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);
mAmPmSpinner.setVisibility(View.GONE);
} else {
mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);
mAmPmSpinner.setVisibility(View.VISIBLE);
}
updateHourControl();
}
/**
* 调用日期和时间变化的回调方法
* Set the callback that indicates the 'Set' button has been pressed.
* @param callback the callback, if null will do nothing
*/
public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {
mOnDateTimeChangedListener = callback;
}
private void onDateTimeChanged() {
if (!mInitialising && mOnDateTimeChangedListener != null) {
mOnDateTimeChangedListener.onDateTimeChanged(this, mDate.get(Calendar.YEAR),
mDate.get(Calendar.MONTH), mDate.get(Calendar.DAY_OF_MONTH),
mDate.get(Calendar.HOUR_OF_DAY), mDate.get(Calendar.MINUTE));
if (mOnDateTimeChangedListener != null) {
mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),
getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute());
}
}
/**
* 设置日期和时间变化监听器
* @param listener 监听器对象
*/
public void setOnDateTimeChangedListener(OnDateTimeChangedListener listener) {
mOnDateTimeChangedListener {insert\_element\_6\_PSBsaXN0ZW5lcjsKICAgIH0KfQpgYGAKCg==}###
}

35
MiNotes-master/app/src/main/java/net/micode/notes/ui/DateTimePickerDialog.java
Unescape View File

@ -29,16 +29,13 @@ import android.content.DialogInterface.OnClickListener;
import android.text.format.DateFormat;
import android.text.format.DateUtils;
/**
* 日期时间选择对话框
*/
public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
private Calendar mDate = Calendar.getInstance(); // 当前日期
private boolean mIs24HourView; // 是否24小时制
private OnDateTimeSetListener mOnDateTimeSetListener; // 日期时间设置回调
private DateTimePicker mDateTimePicker; // 日期时间选择器
// 日期时间设置回调接口
private Calendar mDate = Calendar.getInstance();
private boolean mIs24HourView;
private OnDateTimeSetListener mOnDateTimeSetListener;
private DateTimePicker mDateTimePicker;
public interface OnDateTimeSetListener {
void OnDateTimeSet(AlertDialog dialog, long date);
}
@ -46,56 +43,48 @@ public class DateTimePickerDialog extends AlertDialog implements OnClickListener
public DateTimePickerDialog(Context context, long date) {
super(context);
mDateTimePicker = new DateTimePicker(context);
setView(mDateTimePicker); // 设置自定义视图
// 日期时间变化监听器
setView(mDateTimePicker);
mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
public void onDateTimeChanged(DateTimePicker view, int year, int month,
int dayOfMonth, int hourOfDay, int minute) {
// 更新日期对象
mDate.set(Calendar.YEAR, year);
mDate.set(Calendar.MONTH, month);
mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
mDate.set(Calendar.MINUTE, minute);
updateTitle(mDate.getTimeInMillis()); // 更新标题显示
updateTitle(mDate.getTimeInMillis());
}
});
// 初始化日期
mDate.setTimeInMillis(date);
mDate.set(Calendar.SECOND, 0);
mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
// 设置按钮
setButton(context.getString(R.string.datetime_dialog_ok), this);
setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
// 设置时间显示格式
set24HourView(DateFormat.is24HourFormat(this.getContext()));
updateTitle(mDate.getTimeInMillis());
}
// 设置24小时制显示
public void set24HourView(boolean is24HourView) {
mIs24HourView = is24HourView;
}
// 设置日期时间设置监听器
public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
mOnDateTimeSetListener = callBack;
}
// 更新对话框标题显示
private void updateTitle(long date) {
int flag = DateUtils.FORMAT_SHOW_YEAR | DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_TIME;
int flag =
DateUtils.FORMAT_SHOW_YEAR |
DateUtils.FORMAT_SHOW_DATE |
DateUtils.FORMAT_SHOW_TIME;
flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
}
// 确定按钮点击事件
public void onClick(DialogInterface arg0, int arg1) {
if (mOnDateTimeSetListener != null) {
mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
}
}
}

20
MiNotes-master/app/src/main/java/net/micode/notes/ui/DropdownMenu.java
Unescape View File

@ -27,22 +27,17 @@ import android.widget.PopupMenu.OnMenuItemClickListener;
import net.micode.notes.R;
/**
* 下拉菜单组件
*/
public class DropdownMenu {
private Button mButton; // 触发按钮
private PopupMenu mPopupMenu; // 弹出菜单
private Menu mMenu; // 菜单对象
private Button mButton;
private PopupMenu mPopupMenu;
private Menu mMenu;
public DropdownMenu(Context context, Button button, int menuId) {
mButton = button;
mButton.setBackgroundResource(R.drawable.dropdown_icon); // 设置下拉图标
mPopupMenu = new PopupMenu(context, mButton); // 创建弹出菜单
mButton.setBackgroundResource(R.drawable.dropdown_icon);
mPopupMenu = new PopupMenu(context, mButton);
mMenu = mPopupMenu.getMenu();
// 从菜单资源填充菜单
mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
// 按钮点击显示菜单
mButton.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
mPopupMenu.show();
@ -50,20 +45,17 @@ public class DropdownMenu {
});
}
// 设置菜单项点击监听器
public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
if (mPopupMenu != null) {
mPopupMenu.setOnMenuItemClickListener(listener);
}
}
// 查找菜单项
public MenuItem findItem(int id) {
return mMenu.findItem(id);
}
// 设置按钮文本
public void setTitle(CharSequence title) {
mButton.setText(title);
}
}
}

54
MiNotes-master/app/src/main/java/net/micode/notes/ui/FoldersListAdapter.java
Unescape View File

@ -28,97 +28,53 @@ import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
/**
* FoldersListAdapter类继承自CursorAdapter，用于将数据库中的文件夹数据绑定到ListView的每个项上，
* 显示文件夹的名称。
*/
public class FoldersListAdapter extends CursorAdapter {
// 查询数据库时使用的投影列数组，指定要查询的列
public static final String [] PROJECTION = {
NoteColumns.ID,
NoteColumns.SNIPPET
};
// 定义各列在投影数组中的索引，方便从游标中获取数据
public static final int ID_COLUMN = 0;
public static final int NAME_COLUMN = 1;
/**
* 构造函数，初始化适配器
* @param context 上下文对象
* @param c 数据库游标
*/
public FoldersListAdapter(Context context, Cursor c) {
super(context, c);
// TODO Auto-generated constructor stub
}
/**
* 创建新的列表项视图
* @param context 上下文对象
* @param cursor 数据库游标
* @param parent 父视图
* @return 新的列表项视图
*/
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
return new FolderListItem(context);
}
/**
* 将数据绑定到列表项视图上
* @param view 列表项视图
* @param context 上下文对象
* @param cursor 数据库游标
*/
@Override
public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof FolderListItem) {
// 如果是根文件夹，显示特定的名称，否则显示文件夹的摘要作为名称
String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
.getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
// 将文件夹名称绑定到列表项视图上
((FolderListItem) view).bind(folderName);
}
}
/**
* 获取指定位置的文件夹名称
* @param context 上下文对象
* @param position 列表项的位置
* @return 文件夹名称
*/
public String getFolderName(Context context, int position) {
// 获取指定位置的游标
Cursor cursor = (Cursor) getItem(position);
return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
.getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
}
/**
* 文件夹列表项的内部类，用于显示文件夹名称
*/
private class FolderListItem extends LinearLayout {
// 显示文件夹名称的TextView
private TextView mName;
/**
* 构造函数，初始化文件夹列表项视图
* @param context 上下文对象
*/
public FolderListItem(Context context) {
super(context);
// 加载文件夹列表项的布局
inflate(context, R.layout.folder_list_item, this);
// 获取显示文件夹名称的TextView
mName = (TextView) findViewById(R.id.tv_folder_name);
}
/**
* 将文件夹名称绑定到TextView上
* @param name 文件夹名称
*/
public void bind(String name) {
mName.setText(name){insert\_element\_7\_OwogICAgICAgIH0KICAgIH0KfQo=}```
mName.setText(name);
}
}
###
}

737
MiNotes-master/app/src/main/java/net/micode/notes/ui/NoteEditActivity.java
Unescape View File

@ -72,27 +72,19 @@ import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* NoteEditActivity类用于处理笔记的编辑操作，包括初始化界面、加载笔记数据、处理用户输入等。
*/
public class NoteEditActivity extends Activity implements OnClickListener,
NoteSettingChangedListener, OnTextViewChangeListener {
/**
* 头部视图的ViewHolder类，用于存储头部视图的控件引用
*/
private class HeadViewHolder {
// 显示修改日期的TextView
public TextView tvModified;
// 显示提醒图标的ImageView
public ImageView ivAlertIcon;
// 显示提醒日期的TextView
public TextView tvAlertDate;
// 设置背景颜色的ImageView
public ImageView ibSetBgColor;
}
// 背景颜色选择按钮与颜色ID的映射
private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
static {
sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
@ -102,7 +94,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
}
// 背景颜色ID与选择状态图标ID的映射
private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
@ -112,7 +103,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
}
// 字体大小选择按钮与字体大小ID的映射
private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
static {
sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
@ -121,7 +111,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
}
// 字体大小ID与选择状态图标ID的映射
private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
@ -132,72 +121,57 @@ public class NoteEditActivity extends Activity implements OnClickListener,
private static final String TAG = "NoteEditActivity";
// 头部视图的ViewHolder
private HeadViewHolder mNoteHeaderHolder;
// 头部视图面板
private View mHeadViewPanel;
// 背景颜色选择器视图
private View mNoteBgColorSelector;
// 字体大小选择器视图
private View mFontSizeSelector;
// 笔记编辑器
private EditText mNoteEditor;
// 笔记编辑器面板
private View mNoteEditorPanel;
// 工作笔记对象
private WorkingNote mWorkingNote;
// 共享偏好设置
private SharedPreferences mSharedPrefs;
// 字体大小ID
private int mFontSizeId;
private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;
// 已选中和未选中标记
public static final String TAG_CHECKED = String.valueOf('\u221A');
public static final String TAG_UNCHECKED = String.valueOf('\u25A1');
// 编辑文本列表
private LinearLayout mEditTextList;
// 用户查询关键字
private String mUserQuery;
// 正则表达式模式
private Pattern mPattern;
/**
* 活动创建时调用，初始化界面和资源
* @param savedInstanceState 保存的实例状态
*/
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 设置布局
this.setContentView(R.layout.note_edit);
// 如果保存的实例状态为空且初始化活动状态失败，则关闭活动
if (savedInstanceState == null && !initActivityState(getIntent())) {
finish();
return;
}
// 初始化资源
initResources();
}
/**
* 恢复活动状态时调用，恢复之前保存的状态
* @param savedInstanceState 保存的实例状态
* Current activity may be killed when the memory is low. Once it is killed, for another time
* user load this activity, we should restore the former state
*/
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) {
// 创建一个查看笔记的意图
Intent intent = new Intent(Intent.ACTION_VIEW);
// 从保存的状态中获取笔记ID
intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID));
// 初始化活动状态
if (!initActivityState(intent)) {
finish();
return;
@ -206,36 +180,31 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* 初始化活动状态，根据意图加载笔记数据
* @param intent 意图对象
* @return 初始化是否成功
*/
private boolean initActivityState(Intent intent) {
/**
* If the user specified the {@link Intent#ACTION_VIEW} but not provided with id,
* then jump to the NotesListActivity
*/
mWorkingNote = null;
// 如果意图动作是查看笔记
if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
// 获取笔记ID
long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
mUserQuery = "";
// 如果意图包含搜索结果信息
/**
* Starting from the searched result
*/
if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);
}
// 检查笔记是否在数据库中可见
if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {
// 笔记不可见，跳转到笔记列表活动
Intent jump = new Intent(this, NotesListActivity.class);
startActivity(jump);
// 显示笔记不存在的提示信息
showToast(R.string.error_note_not_exist);
finish();
return false;
} else {
// 加载笔记数据
mWorkingNote = WorkingNote.load(this, noteId);
if (mWorkingNote == null) {
Log.e(TAG, "load note failed with note id" + noteId);
@ -243,25 +212,20 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return false;
}
}
// 设置软键盘状态
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
| WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
} else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) {
// 新建笔记
// 获取文件夹ID
// New note
long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0);
// 获取小部件ID
int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
AppWidgetManager.INVALID_APPWIDGET_ID);
// 获取小部件类型
int widgetType = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_TYPE,
Notes.TYPE_WIDGET_INVALIDE);
// 获取背景资源ID
int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID,
ResourceParser.getDefaultBgId(this));
// 解析通话记录笔记
// Parse call-record note
String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0);
if (callDate != 0 && phoneNumber != null) {
@ -269,19 +233,668 @@ public class NoteEditActivity extends Activity implements OnClickListener,
Log.w(TAG, "The call record number is null");
}
long noteId = 0;
// 根据电话号码和通话日期获取笔记ID
if ((noteId = DataUtils.getNoteIdByPhoneNumberAndCallDate(getContentResolver(),
phoneNumber, callDate)) > 0) {
// 加载通话记录笔记
mWorkingNote = WorkingNote.load(this, noteId);
if (mWorkingNote == null) {
Log.e(TAG, "load call note failed with note id" + noteId);
finish();
return false;
}
} else {
mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId,
widgetType, bgResId);
mWorkingNote.convertToCallNote(phoneNumber, callDate);
}
} else {
mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, widgetType,
bgResId);
}
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
| WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
} else {
Log.e(TAG, "Intent not specified action, should not support");
finish();
return false;
}
mWorkingNote.setOnSettingStatusChangedListener(this);
return true;
}
@Override
protected void onResume() {
super.onResume();
initNoteScreen();
}
private void initNoteScreen() {
mNoteEditor.setTextAppearance(this, TextAppearanceResources
.getTexAppearanceResource(mFontSizeId));
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
switchToListMode(mWorkingNote.getContent());
} else {
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
mNoteEditor.setSelection(mNoteEditor.getText().length());
}
for (Integer id : sBgSelectorSelectionMap.keySet()) {
findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE);
}
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this,
mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE
| DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME
| DateUtils.FORMAT_SHOW_YEAR));
/**
* TODO: Add the menu for setting alert. Currently disable it because the DateTimePicker
* is not ready
*/
showAlertHeader();
}
private void showAlertHeader() {
if (mWorkingNote.hasClockAlert()) {
long time = System.currentTimeMillis();
if (time > mWorkingNote.getAlertDate()) {
mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired);
} else {
mNoteHeaderHolder.tvAlertDate.setText(DateUtils.getRelativeTimeSpanString(
mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS));
}
mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE);
mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE);
} else {
mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE);
mNoteHeaderHolder.ivAlertIcon.setVisibility(View.GONE);
};
}
@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
initActivityState(intent);
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
/**
* For new note without note id, we should firstly save it to
* generate a id. If the editing note is not worth saving, there
* is no id which is equivalent to create new note
*/
if (!mWorkingNote.existInDatabase()) {
saveNote();
}
outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId());
Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
&& !inRangeOfView(mNoteBgColorSelector, ev)) {
mNoteBgColorSelector.setVisibility(View.GONE);
return true;
}
if (mFontSizeSelector.getVisibility() == View.VISIBLE
&& !inRangeOfView(mFontSizeSelector, ev)) {
mFontSizeSelector.setVisibility(View.GONE);
return true;
}
return super.dispatchTouchEvent(ev);
}
private boolean inRangeOfView(View view, MotionEvent ev) {
int []location = new int[2];
view.getLocationOnScreen(location);
int x = location[0];
int y = location[1];
if (ev.getX() < x
|| ev.getX() > (x + view.getWidth())
|| ev.getY() < y
|| ev.getY() > (y + view.getHeight())) {
return false;
}
return true;
}
private void initResources() {
mHeadViewPanel = findViewById(R.id.note_title);
mNoteHeaderHolder = new HeadViewHolder();
mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date);
mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon);
mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date);
mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color);
mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this);
mNoteEditor = (EditText) findViewById(R.id.note_edit_view);
mNoteEditorPanel = findViewById(R.id.sv_note_edit);
mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector);
for (int id : sBgSelectorBtnsMap.keySet()) {
ImageView iv = (ImageView) findViewById(id);
iv.setOnClickListener(this);
}
mFontSizeSelector = findViewById(R.id.font_size_selector);
for (int id : sFontSizeBtnsMap.keySet()) {
View view = findViewById(id);
view.setOnClickListener(this);
};
mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
/**
* HACKME: Fix bug of store the resource id in shared preference.
* The id may larger than the length of resources, in this case,
* return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
*/
if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {
mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
}
mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
}
@Override
protected void onPause() {
super.onPause();
if(saveNote()) {
Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length());
}
clearSettingState();
}
private void updateWidget() {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
intent.setClass(this, NoteWidgetProvider_2x.class);
} else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) {
intent.setClass(this, NoteWidgetProvider_4x.class);
} else {
Log.e(TAG, "Unspported widget type");
return;
}
intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
mWorkingNote.getWidgetId()
});
sendBroadcast(intent);
setResult(RESULT_OK, intent);
}
public void onClick(View v) {
int id = v.getId();
if (id == R.id.btn_set_bg_color) {
mNoteBgColorSelector.setVisibility(View.VISIBLE);
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
- View.VISIBLE);
} else if (sBgSelectorBtnsMap.containsKey(id)) {
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.GONE);
mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id));
mNoteBgColorSelector.setVisibility(View.GONE);
} else if (sFontSizeBtnsMap.containsKey(id)) {
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE);
mFontSizeId = sFontSizeBtnsMap.get(id);
mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit();
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
getWorkingText();
switchToListMode(mWorkingNote.getContent());
} else {
mNoteEditor.setTextAppearance(this,
TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
}
mFontSizeSelector.setVisibility(View.GONE);
}
}
@Override
public void onBackPressed() {
if(clearSettingState()) {
return;
}
saveNote();
super.onBackPressed();
}
private boolean clearSettingState() {
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
mNoteBgColorSelector.setVisibility(View.GONE);
return true;
} else if (mFontSizeSelector.getVisibility() == View.VISIBLE) {
mFontSizeSelector.setVisibility(View.GONE);
return true;
}
return false;
}
public void onBackgroundColorChanged() {
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.VISIBLE);
mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
if (isFinishing()) {
return true;
}
clearSettingState();
menu.clear();
if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {
getMenuInflater().inflate(R.menu.call_note_edit, menu);
} else {
getMenuInflater().inflate(R.menu.note_edit, menu);
}
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_normal_mode);
} else {
menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_list_mode);
}
if (mWorkingNote.hasClockAlert()) {
menu.findItem(R.id.menu_alert).setVisible(false);
} else {
menu.findItem(R.id.menu_delete_remind).setVisible(false);
}
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.menu_new_note:
createNewNote();
break;
case R.id.menu_delete:
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(getString(R.string.alert_title_delete));
builder.setIcon(android.R.drawable.ic_dialog_alert);
builder.setMessage(getString(R.string.alert_message_delete_note));
builder.setPositiveButton(android.R.string.ok,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
deleteCurrentNote();
finish();
}
});
builder.setNegativeButton(android.R.string.cancel, null);
builder.show();
break;
case R.id.menu_font_size:
mFontSizeSelector.setVisibility(View.VISIBLE);
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
break;
case R.id.menu_list_mode:
mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?
TextNote.MODE_CHECK_LIST : 0);
break;
case R.id.menu_share:
getWorkingText();
sendTo(this, mWorkingNote.getContent());
break;
case R.id.menu_send_to_desktop:
sendToDesktop();
break;
case R.id.menu_alert:
setReminder();
break;
case R.id.menu_delete_remind:
mWorkingNote.setAlertDate(0, false);
break;
default:
break;
}
return true;
}
}
private void setReminder() {
DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
public void OnDateTimeSet(AlertDialog dialog, long date) {
mWorkingNote.setAlertDate(date , true);
}
});
d.show();
}
/**
* Share note to apps that support {@link Intent#ACTION_SEND} action
* and {@text/plain} type
*/
private void sendTo(Context context, String info) {
Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_TEXT, info);
intent.setType("text/plain");
context.startActivity(intent);
}
private void createNewNote() {
// Firstly, save current editing notes
saveNote();
// For safety, start a new NoteEditActivity
finish();
Intent intent = new Intent(this, NoteEditActivity.class);
intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mWorkingNote.getFolderId());
startActivity(intent);
}
private void deleteCurrentNote() {
if (mWorkingNote.existInDatabase()) {
HashSet<Long> ids = new HashSet<Long>();
long id = mWorkingNote.getNoteId();
if (id != Notes.ID_ROOT_FOLDER) {
ids.add(id);
} else {
Log.d(TAG, "Wrong note id, should not happen");
}
if (!isSyncMode()) {
if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) {
Log.e(TAG, "Delete Note error");
}
} else {
if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {
Log.e(TAG, "Move notes to trash folder error, should not happens");
}
}
}
mWorkingNote.markDeleted(true);
}
private boolean isSyncMode() {
return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
}
public void onClockAlertChanged(long date, boolean set) {
/**
* User could set clock to an unsaved note, so before setting the
* alert clock, we should save the note first
*/
if (!mWorkingNote.existInDatabase()) {
saveNote();
}
if (mWorkingNote.getNoteId() > 0) {
Intent intent = new Intent(this, AlarmReceiver.class);
intent.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mWorkingNote.getNoteId()));
int requestCode = (int) mWorkingNote.getNoteId();
PendingIntent pendingIntent = PendingIntent.getBroadcast(this, requestCode, intent, PendingIntent.FLAG_UPDATE_CURRENT);
AlarmManager alarmManager = ((AlarmManager) getSystemService(ALARM_SERVICE));
showAlertHeader();
if(!set) {
alarmManager.cancel(pendingIntent);
} else {
// 兼容Android 6.0+，使用setExactAndAllowWhileIdle
alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, date, pendingIntent);
}
} else {
/**
* There is the condition that user has input nothing (the note is
* not worthy saving), we have no note id, remind the user that he
* should input something
*/
Log.e(TAG, "Clock alert setting error");
showToast(R.string.error_note_empty_for_clock);
}
}
public void onWidgetChanged() {
updateWidget();
}
public void onEditTextDelete(int index, String text) {
int childCount = mEditTextList.getChildCount();
if (childCount == 1) {
return;
}
for (int i = index + 1; i < childCount; i++) {
((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
.setIndex(i - 1);
}
mEditTextList.removeViewAt(index);
NoteEditText edit = null;
if(index == 0) {
edit = (NoteEditText) mEditTextList.getChildAt(0).findViewById(
R.id.et_edit_text);
} else {
edit = (NoteEditText) mEditTextList.getChildAt(index - 1).findViewById(
R.id.et_edit_text);
}
int length = edit.length();
edit.append(text);
edit.requestFocus();
edit.setSelection(length);
}
public void onEditTextEnter(int index, String text) {
/**
* Should not happen, check for debug
*/
if(index > mEditTextList.getChildCount()) {
Log.e(TAG, "Index out of mEditTextList boundrary, should not happen");
}
View view = getListItem(text, index);
mEditTextList.addView(view, index);
NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
edit.requestFocus();
edit.setSelection(0);
for (int i = index + 1; i < mEditTextList.getChildCount(); i++) {
((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
.setIndex(i);
}
}
private void switchToListMode(String text) {
mEditTextList.removeAllViews();
String[] items = text.split("\n");
int index = 0;
for (String item : items) {
if(!TextUtils.isEmpty(item)) {
mEditTextList.addView(getListItem(item, index));
index++;
}
}
mEditTextList.addView(getListItem("", index));
mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus();
mNoteEditor.setVisibility(View.GONE);
mEditTextList.setVisibility(View.VISIBLE);
}
private Spannable getHighlightQueryResult(String fullText, String userQuery) {
SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
if (!TextUtils.isEmpty(userQuery)) {
mPattern = Pattern.compile(userQuery);
Matcher m = mPattern.matcher(fullText);
int start = 0;
while (m.find(start)) {
spannable.setSpan(
new BackgroundColorSpan(this.getResources().getColor(
R.color.user_query_highlight)), m.start(), m.end(),
Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
start = m.end();
}
}
return spannable;
}
private View getListItem(String item, int index) {
View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);
final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
edit.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item));
cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
if (isChecked) {
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
} else {
edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
}
}
});
if (item.startsWith(TAG_CHECKED)) {
cb.setChecked(true);
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
item = item.substring(TAG_CHECKED.length(), item.length()).trim();
} else if (item.startsWith(TAG_UNCHECKED)) {
cb.setChecked(false);
edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
item = item.substring(TAG_UNCHECKED.length(), item.length()).trim();
}
edit.setOnTextViewChangeListener(this);
edit.setIndex(index);
edit.setText(getHighlightQueryResult(item, mUserQuery));
return view;
}
public void onTextChange(int index, boolean hasText) {
if (index >= mEditTextList.getChildCount()) {
Log.e(TAG, "Wrong index, should not happen");
return;
}
if(hasText) {
mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.VISIBLE);
} else {
mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.GONE);
}
}
public void onCheckListModeChanged(int oldMode, int newMode) {
if (newMode == TextNote.MODE_CHECK_LIST) {
switchToListMode(mNoteEditor.getText().toString());
} else {
if (!getWorkingText()) {
mWorkingNote.setWorkingText(mWorkingNote.getContent().replace(TAG_UNCHECKED + " ",
""));
}
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
mEditTextList.setVisibility(View.GONE);
mNoteEditor.setVisibility(View.VISIBLE);
}
}
private boolean getWorkingText() {
boolean hasChecked = false;
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < mEditTextList.getChildCount(); i++) {
View view = mEditTextList.getChildAt(i);
NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
if (!TextUtils.isEmpty(edit.getText())) {
if (((CheckBox) view.findViewById(R.id.cb_edit_item)).isChecked()) {
sb.append(TAG_CHECKED).append(" ").append(edit.getText()).append("\n");
hasChecked = true;
} else {
sb.append(TAG_UNCHECKED).append(" ").append(edit.getText()).append("\n");
}
}
}
mWorkingNote.setWorkingText(sb.toString());
} else {
mWorkingNote.setWorkingText(mNoteEditor.getText().toString());
}
return hasChecked;
}
private boolean saveNote() {
getWorkingText();
boolean saved = mWorkingNote.saveNote();
if (saved) {
/**
* There are two modes from List view to edit view, open one note,
* create/edit a node. Opening node requires to the original
* position in the list when back from edit view, while creating a
* new node requires to the top of the list. This code
* {@link #RESULT_OK} is used to identify the create/edit state
*/
setResult(RESULT_OK);
}
return saved;
}
private void sendToDesktop() {
/**
* Before send message to home, we should make sure that current
* editing note is exists in databases. So, for new note, firstly
* save it
*/
if (!mWorkingNote.existInDatabase()) {
saveNote();
}
if (mWorkingNote.getNoteId() > 0) {
Intent sender = new Intent();
Intent shortcutIntent = new Intent(this, NoteEditActivity.class);
shortcutIntent.setAction(Intent.ACTION_VIEW);
shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId());
sender.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);
sender.putExtra(Intent.EXTRA_SHORTCUT_NAME,
makeShortcutIconTitle(mWorkingNote.getContent()));
sender.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE,
Intent.ShortcutIconResource.fromContext(this, R.drawable.icon_app));
sender.putExtra("duplicate", true);
sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT");
showToast(R.string.info_note_enter_desktop);
sendBroadcast(sender);
} else {
/**
* There is the condition that user has input nothing (the note is
* not worthy saving), we have no note id, remind the user that he
* should input something
*/
Log.e(TAG, "Send to desktop error");
showToast(R.string.error_note_empty_for_send_to_desktop);
}
}
private String makeShortcutIconTitle(String content) {
content = content.replace(TAG_CHECKED, "");
content = content.replace(TAG_UNCHECKED, "");
return content.length() > SHORTCUT_ICON_TITLE_MAX_LEN ? content.substring(0,
SHORTCUT_ICON_TITLE_MAX_LEN) : content;
}
private void showToast(int resId) {
showToast(resId, Toast.LENGTH_SHORT);
}
private void showToast(int resId, int duration) {
Toast.makeText(this, resId, duration).show();
}
public void OnOpenMenu(View view) {
clearSettingState();
showPopupMenu(view);
}
private void showPopupMenu(View anchor) {
PopupMenu popupMenu = new PopupMenu(this, anchor);
// 根据便签类型加载不同菜单
if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {
popupMenu.getMenuInflater().inflate(R.menu.call_note_edit, popupMenu.getMenu());
} else {
popupMenu.getMenuInflater().inflate(R.menu.note_edit, popupMenu.getMenu());
}
// 设置菜单项点击事件
popupMenu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
@Override
public boolean onMenuItemClick(MenuItem item) {
return onOptionsItemSelected(item); // 复用原有逻辑
}
});
popupMenu.show();
}
}

95
MiNotes-master/app/src/main/java/net/micode/notes/ui/NoteEditText.java
Unescape View File

@ -37,23 +37,15 @@ import net.micode.notes.R;
import java.util.HashMap;
import java.util.Map;
/**
* NoteEditText类继承自EditText，用于处理笔记编辑时的文本输入，
* 扩展了一些功能，如处理按键事件、触摸事件、上下文菜单等，并提供了文本变化的回调接口。
*/
public class NoteEditText extends EditText {
private static final String TAG = "NoteEditText";
// 编辑文本在列表中的索引
private int mIndex;
// 删除操作前的选择起始位置
private int mSelectionStartBeforeDelete;
// 定义支持的链接协议
private static final String SCHEME_TEL = "tel:" ;
private static final String SCHEME_HTTP = "http:" ;
private static final String SCHEME_EMAIL = "mailto:" ;
// 协议与对应的操作资源ID映射
private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
static {
sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
@ -62,103 +54,66 @@ public class NoteEditText extends EditText {
}
/**
* 文本视图变化监听器接口，用于处理编辑文本的删除、插入和文本变化事件
* Call by the {@link NoteEditActivity} to delete or add edit text
*/
public interface OnTextViewChangeListener {
/**
* 当按下删除键且文本为空时，删除当前编辑文本
* @param index 编辑文本的索引
* @param text 编辑文本的内容
* Delete current edit text when {@link KeyEvent#KEYCODE_DEL} happens
* and the text is null
*/
void onEditTextDelete(int index, String text);
/**
* 当按下回车键时，在当前编辑文本后插入新的编辑文本
* @param index 新编辑文本的索引
* @param text 要插入的文本
* Add edit text after current edit text when {@link KeyEvent#KEYCODE_ENTER}
* happen
*/
void onEditTextEnter(int index, String text);
/**
* 当文本内容变化时，隐藏或显示选项
* @param index 编辑文本的索引
* @param hasText 是否有文本内容
* Hide or show item option when text change
*/
void onTextChange(int index, boolean hasText);
}
// 文本视图变化监听器
private OnTextViewChangeListener mOnTextViewChangeListener;
/**
* 构造函数，使用默认属性
* @param context 上下文对象
*/
public NoteEditText(Context context) {
super(context, null);
mIndex = 0;
}
/**
* 设置编辑文本的索引
* @param index 索引值
*/
public void setIndex(int index) {
mIndex = index;
}
/**
* 设置文本视图变化监听器
* @param listener 监听器对象
*/
public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
mOnTextViewChangeListener = listener;
}
/**
* 构造函数，使用属性集
* @param context 上下文对象
* @param attrs 属性集
*/
public NoteEditText(Context context, AttributeSet attrs) {
super(context, attrs, android.R.attr.editTextStyle);
}
/**
* 构造函数，使用属性集和默认样式
* @param context 上下文对象
* @param attrs 属性集
* @param defStyle 默认样式
*/
public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
// TODO Auto-generated constructor stub
}
/**
* 处理触摸事件，根据触摸位置设置文本选择
* @param event 触摸事件
* @return 是否处理该事件
*/
@Override
public boolean onTouchEvent(MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
// 获取触摸点的坐标
int x = (int) event.getX();
int y = (int) event.getY();
// 调整坐标以适应文本布局
x -= getTotalPaddingLeft();
y -= getTotalPaddingTop();
x += getScrollX();
y += getScrollY();
// 获取文本布局
Layout layout = getLayout();
// 根据坐标获取行号和偏移量
int line = layout.getLineForVertical(y);
int off = layout.getOffsetForHorizontal(line, x);
// 设置文本选择位置
Selection.setSelection(getText(), off);
break;
}
@ -166,12 +121,6 @@ public class NoteEditText extends EditText {
return super.onTouchEvent(event);
}
/**
* 处理按键按下事件，记录删除操作前的选择起始位置
* @param keyCode 按键码
* @param event 按键事件
* @return 是否处理该事件
*/
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
switch (keyCode) {
@ -189,18 +138,11 @@ public class NoteEditText extends EditText {
return super.onKeyDown(keyCode, event);
}
/**
* 处理按键抬起事件，根据按键码调用相应的监听器方法
* @param keyCode 按键码
* @param event 按键事件
* @return 是否处理该事件
*/
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
switch(keyCode) {
case KeyEvent.KEYCODE_DEL:
if (mOnTextViewChangeListener != null) {
// 如果选择起始位置为0且不是第一个编辑文本，则删除当前编辑文本
if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
return true;
@ -211,13 +153,9 @@ public class NoteEditText extends EditText {
break;
case KeyEvent.KEYCODE_ENTER:
if (mOnTextViewChangeListener != null) {
// 获取选择起始位置
int selectionStart = getSelectionStart();
// 获取选择位置之后的文本
String text = getText().subSequence(selectionStart, length()).toString();
// 设置当前编辑文本为选择位置之前的文本
setText(getText().subSequence(0, selectionStart));
// 在当前编辑文本后插入新的编辑文本
mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
} else {
Log.d(TAG, "OnTextViewChangeListener was not seted");
@ -229,17 +167,10 @@ public class NoteEditText extends EditText {
return super.onKeyUp(keyCode, event);
}
/**
* 处理焦点变化事件，根据焦点状态和文本内容调用监听器方法
* @param focused 是否获得焦点
* @param direction 焦点变化方向
* @param previouslyFocusedRect 之前聚焦的矩形区域
*/
@Override
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
if (mOnTextViewChangeListener != null) {
if (!focused && TextUtils.isEmpty(getText())) {
// 失去焦点且文本为空时，调用文本变化监听器
mOnTextViewChangeListener.onTextChange(mIndex, false);
} else {
mOnTextViewChangeListener.onTextChange(mIndex, true);
@ -248,25 +179,18 @@ public class NoteEditText extends EditText {
super.onFocusChanged(focused, direction, previouslyFocusedRect);
}
/**
* 创建上下文菜单，处理链接相关的菜单项
* @param menu 上下文菜单
*/
@Override
protected void onCreateContextMenu(ContextMenu menu) {
if (getText() instanceof Spanned) {
// 获取选择的起始和结束位置
int selStart = getSelectionStart();
int selEnd = getSelectionEnd();
int min = Math.min(selStart, selEnd);
int max = Math.max(selStart, selEnd);
// 获取选择范围内的URLSpan
final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
if (urls.length == 1) {
int defaultResId = 0;
// 根据链接协议获取对应的操作资源ID
for(String schema: sSchemaActionResMap.keySet()) {
if(urls[0].getURL().indexOf(schema) >= 0) {
defaultResId = sSchemaActionResMap.get(schema);
@ -278,11 +202,10 @@ public class NoteEditText extends EditText {
defaultResId = R.string.note_link_other;
}
// 添加菜单项并设置点击监听器
menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
// 处理链接点击事件
// goto a new intent
urls[0].onClick(NoteEditText.this);
return true;
}
@ -291,4 +214,4 @@ public class NoteEditText extends EditText {
}
super.onCreateContextMenu(menu);
}
}
}

118
MiNotes-master/app/src/main/java/net/micode/notes/ui/NoteItemData.java
Unescape View File

@ -25,12 +25,8 @@ import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.tool.DataUtils;
/**
* NoteItemData类用于封装笔记项的数据，从数据库游标中提取并存储笔记的各种信息，
* 如笔记ID、提醒日期、背景颜色、创建日期等，同时提供了获取这些信息的方法。
*/
public class NoteItemData {
// 查询数据库时使用的投影列数组，指定要查询的列
static final String [] PROJECTION = new String [] {
NoteColumns.ID,
NoteColumns.ALERTED_DATE,
@ -46,7 +42,6 @@ public class NoteItemData {
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;
@ -60,7 +55,6 @@ public class NoteItemData {
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;
@ -76,18 +70,12 @@ public class NoteItemData {
private String mName;
private String mPhoneNumber;
// 标记笔记项在列表中的位置信息
private boolean mIsLastItem;
private boolean mIsFirstItem;
private boolean mIsOnlyOneItem;
private boolean mIsOneNoteFollowingFolder;
private boolean mIsMultiNotesFollowingFolder;
/**
* 构造函数，从游标中提取笔记数据并初始化对象的属性
* @param context 上下文对象
* @param cursor 数据库游标，包含笔记数据
*/
public NoteItemData(Context context, Cursor cursor) {
mId = cursor.getLong(ID_COLUMN);
mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
@ -98,7 +86,6 @@ public class NoteItemData {
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, "");
mType = cursor.getInt(TYPE_COLUMN);
@ -106,12 +93,9 @@ public class NoteItemData {
mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
mPhoneNumber = "";
// 如果笔记的父ID是通话记录文件夹的ID
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;
@ -122,14 +106,9 @@ public class NoteItemData {
if (mName == null) {
mName = "";
}
// 检查笔记项在列表中的位置
checkPostion(cursor);
}
/**
* 检查笔记项在列表中的位置，设置相应的标记
* @param cursor 数据库游标
*/
private void checkPostion(Cursor cursor) {
mIsLastItem = cursor.isLast() ? true : false;
mIsFirstItem = cursor.isFirst() ? true : false;
@ -137,18 +116,14 @@ public class NoteItemData {
mIsMultiNotesFollowingFolder = false;
mIsOneNoteFollowingFolder = false;
// 如果笔记类型是普通笔记且不是第一项
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;
} else {
// 后续只有一条笔记跟随文件夹
mIsOneNoteFollowingFolder = true;
}
}
@ -159,180 +134,91 @@ public class NoteItemData {
}
}
/**
* 判断是否是文件夹后跟随的第一条笔记
* @return 如果是返回true，否则返回false
*/
public boolean isOneFollowingFolder() {
return mIsOneNoteFollowingFolder;
}
/**
* 判断是否是文件夹后跟随的多条笔记之一
* @return 如果是返回true，否则返回false
*/
public boolean isMultiFollowingFolder() {
return mIsMultiNotesFollowingFolder;
}
/**
* 判断是否是列表中的最后一项
* @return 如果是返回true，否则返回false
*/
public boolean isLast() {
return mIsLastItem;
}
/**
* 获取通话记录的联系人姓名
* @return 联系人姓名
*/
public String getCallName() {
return mName;
}
/**
* 判断是否是列表中的第一项
* @return 如果是返回true，否则返回false
*/
public boolean isFirst() {
return mIsFirstItem;
}
/**
* 判断列表中是否只有一项
* @return 如果是返回true，否则返回false
*/
public boolean isSingle() {
return mIsOnlyOneItem;
}
/**
* 获取笔记的ID
* @return 笔记ID
*/
public long getId() {
return mId;
}
/**
* 获取笔记的提醒日期
* @return 提醒日期
*/
public long getAlertDate() {
return mAlertDate;
}
/**
* 获取笔记的创建日期
* @return 创建日期
*/
public long getCreatedDate() {
return mCreatedDate;
}
/**
* 判断笔记是否有附件
* @return 如果有附件返回true，否则返回false
*/
public boolean hasAttachment() {
return mHasAttachment;
}
/**
* 获取笔记的修改日期
* @return 修改日期
*/
public long getModifiedDate() {
return mModifiedDate;
}
/**
* 获取笔记的背景颜色ID
* @return 背景颜色ID
*/
public int getBgColorId() {
return mBgColorId;
}
/**
* 获取笔记的父ID
* @return 父ID
*/
public long getParentId() {
return mParentId;
}
/**
* 获取笔记所在文件夹中的笔记数量
* @return 笔记数量
*/
public int getNotesCount() {
return mNotesCount;
}
/**
* 获取笔记所在文件夹的ID
* @return 文件夹ID
*/
public long getFolderId () {
return mParentId;
}
/**
* 获取笔记的类型
* @return 笔记类型
*/
public int getType() {
return mType;
}
/**
* 获取笔记小部件的类型
* @return 小部件类型
*/
public int getWidgetType() {
return mWidgetType;
}
/**
* 获取笔记小部件的ID
* @return 小部件ID
*/
public int getWidgetId() {
return mWidgetId;
}
/**
* 获取笔记的摘要
* @return 笔记摘要
*/
public String getSnippet() {
return mSnippet;
}
/**
* 判断笔记是否有提醒
* @return 如果有提醒返回true，否则返回false
*/
public boolean hasAlert() {
return (mAlertDate > 0);
}
/**
* 判断笔记是否是通话记录笔记
* @return 如果是通话记录笔记返回true，否则返回false
*/
public boolean isCallRecord() {
return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
}
/**
* 从游标中获取笔记的类型
* @param cursor 数据库游标
* @return 笔记类型
*/
public static int getNoteType(Cursor cursor) {
return cursor.getInt(TYPE_COLUMN);
}
}
}

850
MiNotes-master/app/src/main/java/net/micode/notes/ui/NotesListActivity.java
View File

File diff suppressed because it is too large Load Diff

98
MiNotes-master/app/src/main/java/net/micode/notes/ui/NotesListAdapter.java
Unescape View File

@ -30,35 +30,19 @@ import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
/**
* NotesListAdapter类继承自CursorAdapter，用于将数据库中的笔记数据绑定到ListView的每个项上，
* 同时处理列表项的选择状态、全选、获取选中项等操作。
*/
public class NotesListAdapter extends CursorAdapter {
private static final String TAG = "NotesListAdapter";
// 上下文对象
private Context mContext;
// 存储列表项的选择状态，键为列表项的位置，值为是否选中
private HashMap<Integer, Boolean> mSelectedIndex;
// 笔记的数量
private int mNotesCount;
// 是否处于选择模式
private boolean mChoiceMode;
/**
* 存储小部件属性的内部类
*/
public static class AppWidgetAttribute {
// 小部件ID
public int widgetId;
// 小部件类型
public int widgetType;
};
/**
* 构造函数，初始化适配器
* @param context 上下文对象
*/
public NotesListAdapter(Context context) {
super(context, null);
mSelectedIndex = new HashMap<Integer, Boolean>();
@ -66,74 +50,38 @@ public class NotesListAdapter extends CursorAdapter {
mNotesCount = 0;
}
/**
* 创建新的列表项视图
* @param context 上下文对象
* @param cursor 数据库游标
* @param parent 父视图
* @return 新的列表项视图
*/
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
return new NotesListItem(context);
}
/**
* 将数据绑定到列表项视图上
* @param view 列表项视图
* @param context 上下文对象
* @param cursor 数据库游标
*/
@Override
public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof NotesListItem) {
// 创建笔记项数据对象
NoteItemData itemData = new NoteItemData(context, cursor);
// 将数据绑定到列表项视图上
((NotesListItem) view).bind(context, itemData, mChoiceMode,
isSelectedItem(cursor.getPosition()));
}
}
/**
* 设置列表项的选择状态
* @param position 列表项的位置
* @param checked 是否选中
*/
public void setCheckedItem(final int position, final boolean checked) {
mSelectedIndex.put(position, checked);
// 通知适配器数据发生变化
notifyDataSetChanged();
}
/**
* 判断是否处于选择模式
* @return 如果处于选择模式返回true，否则返回false
*/
public boolean isInChoiceMode() {
return mChoiceMode;
}
/**
* 设置选择模式
* @param mode 是否开启选择模式
*/
public void setChoiceMode(boolean mode) {
// 清空选择状态
mSelectedIndex.clear();
mChoiceMode = mode;
}
/**
* 全选或全不选列表项
* @param checked 是否全选
*/
public void selectAll(boolean checked) {
// 获取数据库游标
Cursor cursor = getCursor();
for (int i = 0; i < getCount(); i++) {
if (cursor.moveToPosition(i)) {
// 如果是普通笔记类型，则设置选择状态
if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
setCheckedItem(i, checked);
}
@ -141,15 +89,10 @@ public class NotesListAdapter extends CursorAdapter {
}
}
/**
* 获取选中项的ID集合
* @return 选中项的ID集合
*/
public HashSet<Long> getSelectedItemIds() {
HashSet<Long> itemSet = new HashSet<Long>();
for (Integer position : mSelectedIndex.keySet()) {
if (mSelectedIndex.get(position) == true) {
// 获取列表项的ID
Long id = getItemId(position);
if (id == Notes.ID_ROOT_FOLDER) {
Log.d(TAG, "Wrong item id, should not happen");
@ -162,24 +105,15 @@ public class NotesListAdapter extends CursorAdapter {
return itemSet;
}
/**
* 获取选中项的小部件属性集合
* @return 选中项的小部件属性集合
*/
public HashSet<AppWidgetAttribute> getSelectedWidget() {
HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
for (Integer position : mSelectedIndex.keySet()) {
if (mSelectedIndex.get(position) == true) {
// 获取列表项对应的游标
Cursor c = (Cursor) getItem(position);
if (c != null) {
// 创建小部件属性对象
AppWidgetAttribute widget = new AppWidgetAttribute();
// 创建笔记项数据对象
NoteItemData item = new NoteItemData(mContext, c);
// 设置小部件ID
widget.widgetId = item.getWidgetId();
// 设置小部件类型
widget.widgetType = item.getWidgetType();
itemSet.add(widget);
/**
@ -194,17 +128,11 @@ public class NotesListAdapter extends CursorAdapter {
return itemSet;
}
/**
* 获取选中项的数量
* @return 选中项的数量
*/
public int getSelectedCount() {
// 获取选择状态的集合
Collection<Boolean> values = mSelectedIndex.values();
if (null == values) {
return 0;
}
// 遍历集合，统计选中项的数量
Iterator<Boolean> iter = values.iterator();
int count = 0;
while (iter.hasNext()) {
@ -215,21 +143,11 @@ public class NotesListAdapter extends CursorAdapter {
return count;
}
/**
* 判断是否全选
* @return 如果全选返回true，否则返回false
*/
public boolean isAllSelected() {
// 获取选中项的数量
int checkedCount = getSelectedCount();
return (checkedCount != 0 && checkedCount == mNotesCount);
}
/**
* 判断指定位置的列表项是否选中
* @param position 列表项的位置
* @return 如果选中返回true，否则返回false
*/
public boolean isSelectedItem(final int position) {
if (null == mSelectedIndex.get(position)) {
return false;
@ -237,35 +155,23 @@ public class NotesListAdapter extends CursorAdapter {
return mSelectedIndex.get(position);
}
/**
* 当内容发生变化时调用，重新计算笔记数量
*/
@Override
protected void onContentChanged() {
super.onContentChanged();
calcNotesCount();
}
/**
* 更换游标时调用，重新计算笔记数量
* @param cursor 新的数据库游标
*/
@Override
public void changeCursor(Cursor cursor) {
super.changeCursor(cursor);
calcNotesCount();
}
/**
* 计算笔记的数量
*/
private void calcNotesCount() {
mNotesCount = 0;
for (int i = 0; i < getCount(); i++) {
// 获取列表项对应的游标
Cursor c = (Cursor) getItem(i);
if (c != null) {
// 如果是普通笔记类型，则增加笔记数量
if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
mNotesCount++;
}
@ -275,4 +181,4 @@ public class NotesListAdapter extends CursorAdapter {
}
}
}
}
}

33
MiNotes-master/app/src/main/java/net/micode/notes/ui/NotesListItem.java
Unescape View File

@ -30,22 +30,17 @@ import net.micode.notes.tool.DataUtils;
import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
/**
* 笔记列表项视图
*/
public class NotesListItem extends LinearLayout {
private ImageView mAlert; // 提醒图标
private TextView mTitle; // 标题
private TextView mTime; // 时间
private TextView mCallName; // 通话记录名称
private NoteItemData mItemData; // 笔记数据
private CheckBox mCheckBox; // 复选框
private ImageView mAlert;
private TextView mTitle;
private TextView mTime;
private TextView mCallName;
private NoteItemData mItemData;
private CheckBox mCheckBox;
public NotesListItem(Context context) {
super(context);
// 加载布局
inflate(context, R.layout.note_item, this);
// 初始化视图
mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
mTitle = (TextView) findViewById(R.id.tv_title);
mTime = (TextView) findViewById(R.id.tv_time);
@ -53,9 +48,7 @@ public class NotesListItem extends LinearLayout {
mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
}
// 绑定数据到视图
public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
// 设置复选框可见性
if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
mCheckBox.setVisibility(View.VISIBLE);
mCheckBox.setChecked(checked);
@ -64,9 +57,7 @@ public class NotesListItem extends LinearLayout {
}
mItemData = data;
// 根据笔记类型设置不同显示
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
// 通话记录文件夹
mCallName.setVisibility(View.GONE);
mAlert.setVisibility(View.VISIBLE);
mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
@ -74,12 +65,10 @@ public class NotesListItem extends LinearLayout {
+ context.getString(R.string.format_folder_files_count, data.getNotesCount()));
mAlert.setImageResource(R.drawable.call_record);
} else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
// 通话记录
mCallName.setVisibility(View.VISIBLE);
mCallName.setText(data.getCallName());
mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
// 设置提醒图标
if (data.hasAlert()) {
mAlert.setImageResource(R.drawable.clock);
mAlert.setVisibility(View.VISIBLE);
@ -87,20 +76,16 @@ public class NotesListItem extends LinearLayout {
mAlert.setVisibility(View.GONE);
}
} else {
// 普通笔记或文件夹
mCallName.setVisibility(View.GONE);
mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
if (data.getType() == Notes.TYPE_FOLDER) {
// 文件夹
mTitle.setText(data.getSnippet()
+ context.getString(R.string.format_folder_files_count,
data.getNotesCount()));
mAlert.setVisibility(View.GONE);
} else {
// 普通笔记
mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
// 设置提醒图标
if (data.hasAlert()) {
mAlert.setImageResource(R.drawable.clock);
mAlert.setVisibility(View.VISIBLE);
@ -109,14 +94,11 @@ public class NotesListItem extends LinearLayout {
}
}
}
// 设置相对时间显示
mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
// 设置背景
setBackground(data);
}
// 根据笔记位置设置不同背景
private void setBackground(NoteItemData data) {
int id = data.getBgColorId();
if (data.getType() == Notes.TYPE_NOTE) {
@ -134,8 +116,7 @@ public class NotesListItem extends LinearLayout {
}
}
// 获取笔记数据
public NoteItemData getItemData() {
return mItemData;
}
}
}

94
MiNotes-master/app/src/main/java/net/micode/notes/ui/NotesPreferenceActivity.java
Unescape View File

@ -48,45 +48,42 @@ 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";
private PreferenceCategory mAccountCategory; // 账户分类
private GTaskReceiver mReceiver; // 同步任务广播接收器
private Account[] mOriAccounts; // 原始账户列表
private boolean mHasAddedAccount; // 是否添加了新账户
private PreferenceCategory mAccountCategory;
private GTaskReceiver mReceiver;
private Account[] mOriAccounts;
private boolean mHasAddedAccount;
@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
// 启用返回按钮
/* using the app icon for navigation */
getActionBar().setDisplayHomeAsUpEnabled(true);
// 从XML加载偏好设置
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);
mOriAccounts = null;
// 添加设置头部视图
View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
getListView().addHeaderView(header, null, true);
}
@ -94,7 +91,9 @@ public class NotesPreferenceActivity extends PreferenceActivity {
@Override
protected void onResume() {
super.onResume();
// 如果用户添加了新账户，自动设置同步账户
// need to set sync account automatically if user has added a new
// account
if (mHasAddedAccount) {
Account[] accounts = getGoogleAccounts();
if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
@ -113,20 +112,20 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
}
}
refreshUI(); // 刷新UI
refreshUI();
}
@Override
protected void onDestroy() {
if (mReceiver != null) {
unregisterReceiver(mReceiver); // 注销广播接收器
unregisterReceiver(mReceiver);
}
super.onDestroy();
}
// 加载账户偏好设置
private void loadAccountPreference() {
mAccountCategory.removeAll(); // 清除现有项
mAccountCategory.removeAll();
Preference accountPref = new Preference(this);
final String defaultAccount = getSyncAccountName(this);
@ -136,10 +135,11 @@ public class NotesPreferenceActivity extends PreferenceActivity {
public boolean onPreferenceClick(Preference preference) {
if (!GTaskSyncService.isSyncing()) {
if (TextUtils.isEmpty(defaultAccount)) {
// 首次设置账户
// the first time to set account
showSelectAccountAlertDialog();
} else {
// 已设置账户，提示风险
// if the account has already been set, we need to promp
// user about the risk
showChangeAccountConfirmAlertDialog();
}
} else {
@ -150,15 +150,15 @@ public class NotesPreferenceActivity extends PreferenceActivity {
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);
// 根据同步状态设置按钮
// set button state
if (GTaskSyncService.isSyncing()) {
syncButton.setText(getString(R.string.preferences_button_sync_cancel));
syncButton.setOnClickListener(new View.OnClickListener() {
@ -176,7 +176,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
// 设置最后同步时间显示
// set last sync time
if (GTaskSyncService.isSyncing()) {
lastSyncTimeView.setText(GTaskSyncService.getProgressString());
lastSyncTimeView.setVisibility(View.VISIBLE);
@ -193,17 +193,14 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
}
// 刷新UI
private void refreshUI() {
loadAccountPreference();
loadSyncButton();
}
// 显示选择账户对话框
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));
@ -220,7 +217,6 @@ public class NotesPreferenceActivity extends PreferenceActivity {
mHasAddedAccount = false;
if (accounts.length > 0) {
// 创建账户选择列表
CharSequence[] items = new CharSequence[accounts.length];
final CharSequence[] itemMapping = items;
int checkedItem = -1;
@ -241,7 +237,6 @@ public class NotesPreferenceActivity extends PreferenceActivity {
});
}
// 添加"添加账户"视图
View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
dialogBuilder.setView(addAccountView);
@ -249,20 +244,19 @@ public class NotesPreferenceActivity extends PreferenceActivity {
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" });
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,
@ -271,7 +265,6 @@ public class NotesPreferenceActivity extends PreferenceActivity {
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),
@ -280,9 +273,9 @@ public class NotesPreferenceActivity extends PreferenceActivity {
dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
if (which == 0) {
showSelectAccountAlertDialog(); // 更改账户
showSelectAccountAlertDialog();
} else if (which == 1) {
removeSyncAccount(); // 移除账户
removeSyncAccount();
refreshUI();
}
}
@ -290,13 +283,11 @@ public class NotesPreferenceActivity extends PreferenceActivity {
dialogBuilder.show();
}
// 获取Google账户列表
private Account[] getGoogleAccounts() {
AccountManager accountManager = AccountManager.get(this);
return accountManager.getAccountsByType("com.google");
}
// 设置同步账户
private void setSyncAccount(String account) {
if (!getSyncAccountName(this).equals(account)) {
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
@ -308,10 +299,10 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
editor.commit();
// 清除最后同步时间
// clean up last sync time
setLastSyncTime(this, 0);
// 清除本地GTask相关信息
// clean up local gtask related info
new Thread(new Runnable() {
public void run() {
ContentValues values = new ContentValues();
@ -327,7 +318,6 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
}
// 移除同步账户
private void removeSyncAccount() {
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
@ -339,7 +329,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
editor.commit();
// 清除本地GTask相关信息
// clean up local gtask related info
new Thread(new Runnable() {
public void run() {
ContentValues values = new ContentValues();
@ -350,14 +340,12 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}).start();
}
// 获取同步账户名称
public static String getSyncAccountName(Context context) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
}
// 设置最后同步时间
public static void setLastSyncTime(Context context, long time) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
@ -366,31 +354,29 @@ public class NotesPreferenceActivity extends PreferenceActivity {
editor.commit();
}
// 获取最后同步时间
public static long getLastSyncTime(Context context) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
}
// 同步任务广播接收器
private class GTaskReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
refreshUI(); // 刷新UI
// 更新同步状态显示
refreshUI();
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));
}
}
}
// 选项菜单选择处理
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case android.R.id.home: // 返回按钮
case android.R.id.home:
Intent intent = new Intent(this, NotesListActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
@ -399,4 +385,4 @@ public class NotesPreferenceActivity extends PreferenceActivity {
return false;
}
}
}
}

88
MiNotes-master/app/src/main/java/net/micode/notes/widget/NoteWidgetProvider.java
Unescape View File

@ -32,42 +32,24 @@ import net.micode.notes.tool.ResourceParser;
import net.micode.notes.ui.NoteEditActivity;
import net.micode.notes.ui.NotesListActivity;
/**
* NoteWidgetProvider 是一个抽象类，继承自 AppWidgetProvider，用于处理便签小部件的相关操作。
* 该类提供了小部件删除、更新等功能的实现，同时定义了一些抽象方法，由具体的子类实现。
*/
public abstract class NoteWidgetProvider extends AppWidgetProvider {
// 定义查询便签信息时使用的投影，指定要查询的列
public static final String [] PROJECTION = new String [] {
NoteColumns.ID,
NoteColumns.BG_COLOR_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;
// 日志标签，用于在日志中标识该类的输出信息
private static final String TAG = "NoteWidgetProvider";
/**
* 当小部件被删除时调用此方法。
* 该方法会将被删除小部件对应的便签的 widget_id 字段设置为无效值。
*
* @param context 上下文对象，用于获取 ContentResolver 进行数据库操作
* @param appWidgetIds 被删除的小部件的 ID 数组
*/
@Override
public void onDeleted(Context context, int[] appWidgetIds) {
// 创建 ContentValues 对象，用于存储要更新的数据
ContentValues values = new ContentValues();
// 将便签的 widget_id 字段设置为无效值
values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
// 遍历被删除的小部件 ID 数组
for (int i = 0; i < appWidgetIds.length; i++) {
// 更新数据库中对应 widget_id 的便签信息
context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
values,
NoteColumns.WIDGET_ID + "=?",
@ -75,14 +57,6 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
}
}
/**
* 根据小部件 ID 获取便签小部件的信息。
* 该方法会查询数据库，获取指定小部件 ID 对应的便签信息。
*
* @param context 上下文对象，用于获取 ContentResolver 进行数据库查询
* @param widgetId 小部件的 ID
* @return 返回一个 Cursor 对象，包含查询结果
*/
private Cursor getNoteWidgetInfo(Context context, int widgetId) {
return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
PROJECTION,
@ -91,128 +65,68 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
null);
}
/**
* 更新小部件的信息，不开启隐私模式。
* 该方法会调用重载的 update 方法，传入 false 表示不开启隐私模式。
*
* @param context 上下文对象，用于获取资源和进行数据库操作
* @param appWidgetManager 小部件管理器，用于更新小部件的视图
* @param appWidgetIds 要更新的小部件的 ID 数组
*/
protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
update(context, appWidgetManager, appWidgetIds, false);
}
/**
* 更新小部件的信息，可选择是否开启隐私模式。
* 该方法会遍历小部件 ID 数组，根据小部件 ID 查询便签信息，更新小部件的视图。
*
* @param context 上下文对象，用于获取资源和进行数据库操作
* @param appWidgetManager 小部件管理器，用于更新小部件的视图
* @param appWidgetIds 要更新的小部件的 ID 数组
* @param privacyMode 是否开启隐私模式
*/
private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
boolean privacyMode) {
// 遍历要更新的小部件 ID 数组
for (int i = 0; i < appWidgetIds.length; i++) {
// 检查小部件 ID 是否有效
if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
// 获取默认的背景颜色 ID
int bgId = ResourceParser.getDefaultBgId(context);
// 初始化便签的摘要信息
String snippet = "";
// 创建一个 Intent 对象，用于启动便签编辑活动
Intent intent = new Intent(context, NoteEditActivity.class);
// 设置 Intent 的标志，确保活动以单顶模式启动
intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
// 将小部件 ID 作为额外信息添加到 Intent 中
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
// 将小部件类型作为额外信息添加到 Intent 中
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
// 根据小部件 ID 查询便签信息
Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
if (c != null && c.moveToFirst()) {
// 检查查询结果是否包含多个便签，如果是则记录错误信息并关闭 Cursor
if (c.getCount() > 1) {
Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
c.close();
return;
}
// 获取便签的摘要信息
snippet = c.getString(COLUMN_SNIPPET);
// 获取便签的背景颜色 ID
bgId = c.getInt(COLUMN_BG_COLOR_ID);
// 将便签的 ID 作为额外信息添加到 Intent 中
intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
// 设置 Intent 的动作，用于查看便签
intent.setAction(Intent.ACTION_VIEW);
} else {
// 如果没有查询到便签信息，设置默认的摘要信息
snippet = context.getResources().getString(R.string.widget_havenot_content);
// 设置 Intent 的动作，用于插入或编辑便签
intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
}
// 关闭 Cursor，释放资源
if (c != null) {
c.close();
}
// 创建 RemoteViews 对象，用于更新小部件的视图
RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
// 设置小部件的背景图片资源
rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
// 将背景颜色 ID 作为额外信息添加到 Intent 中
intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
/**
* Generate the pending intent to start host for the widget
*/
PendingIntent pendingIntent = null;
if (privacyMode) {
// 如果开启隐私模式，设置小部件的文本为隐私模式提示信息
rv.setTextViewText(R.id.widget_text,
context.getString(R.string.widget_under_visit_mode));
// 创建一个 PendingIntent 对象，用于启动便签列表活动
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 = PendingIntent.getActivity(context, appWidgetIds[i], intent,
PendingIntent.FLAG_UPDATE_CURRENT);
}
// 设置小部件文本的点击事件，关联 PendingIntent
rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
// 更新指定 ID 的小部件的视图
appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
}
}
}
/**
* 获取背景资源的 ID，由具体的子类实现。
*
* @param bgId 背景颜色的 ID
* @return 返回背景资源的 ID
*/
protected abstract int getBgResourceId(int bgId);
/**
* 获取小部件的布局 ID，由具体的子类实现。
*
* @return 返回小部件的布局 ID
*/
protected abstract int getLayoutId();
/**
* 获取小部件的类型，由具体的子类实现。
*
* @return 返回小部件的类型
*/
protected abstract int getWidgetType();
}
}

32
MiNotes-master/app/src/main/java/net/micode/notes/widget/NoteWidgetProvider_2x.java
Unescape View File

@ -23,53 +23,25 @@ import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.tool.ResourceParser;
/**
* NoteWidgetProvider_2x 是 NoteWidgetProvider 的子类，用于处理 2x 大小的便签小部件。
* 该类实现了 NoteWidgetProvider 中的抽象方法，提供了 2x 小部件的布局、背景资源和类型信息。
*/
public class NoteWidgetProvider_2x extends NoteWidgetProvider {
/**
* 当小部件需要更新时调用此方法。
* 该方法会调用父类的 update 方法，更新 2x 小部件的信息。
*
* @param context 上下文对象，用于获取资源和进行数据库操作
* @param appWidgetManager 小部件管理器，用于更新小部件的视图
* @param appWidgetIds 要更新的小部件的 ID 数组
*/
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
super.update(context, appWidgetManager, appWidgetIds);
}
/**
* 获取 2x 小部件的布局 ID。
*
* @return 返回 2x 小部件的布局 ID
*/
@Override
protected int getLayoutId() {
return R.layout.widget_2x;
}
/**
* 获取 2x 小部件的背景资源 ID。
* 该方法会调用 ResourceParser 类的方法，根据背景颜色 ID 获取对应的背景资源 ID。
*
* @param bgId 背景颜色的 ID
* @return 返回 2x 小部件的背景资源 ID
*/
@Override
protected int getBgResourceId(int bgId) {
return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
}
/**
* 获取 2x 小部件的类型。
*
* @return 返回 2x 小部件的类型
*/
@Override
protected int getWidgetType() {
return Notes.TYPE_WIDGET_2X;
}
}
}

32
MiNotes-master/app/src/main/java/net/micode/notes/widget/NoteWidgetProvider_4x.java
Unescape View File

@ -23,52 +23,24 @@ import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.tool.ResourceParser;
/**
* NoteWidgetProvider_4x 是 NoteWidgetProvider 的子类，用于处理 4x 大小的便签小部件。
* 该类实现了 NoteWidgetProvider 中的抽象方法，提供了 4x 小部件的布局、背景资源和类型信息。
*/
public class NoteWidgetProvider_4x extends NoteWidgetProvider {
/**
* 当小部件需要更新时调用此方法。
* 该方法会调用父类的 update 方法，更新 4x 小部件的信息。
*
* @param context 上下文对象，用于获取资源和进行数据库操作
* @param appWidgetManager 小部件管理器，用于更新小部件的视图
* @param appWidgetIds 要更新的小部件的 ID 数组
*/
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
super.update(context, appWidgetManager, appWidgetIds);
}
/**
* 获取 4x 小部件的布局 ID。
*
* @return 返回 4x 小部件的布局 ID
*/
protected int getLayoutId() {
return R.layout.widget_4x;
}
/**
* 获取 4x 小部件的背景资源 ID。
* 该方法会调用 ResourceParser 类的方法，根据背景颜色 ID 获取对应的背景资源 ID。
*
* @param bgId 背景颜色的 ID
* @return 返回 4x 小部件的背景资源 ID
*/
@Override
protected int getBgResourceId(int bgId) {
return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
}
/**
* 获取 4x 小部件的类型。
*
* @return 返回 4x 小部件的类型
*/
@Override
protected int getWidgetType() {
return Notes.TYPE_WIDGET_4X;
}
}
}

4
MiNotes-master/app/src/main/res/drawable/edit_red.xml
Unescape View File

@ -1,4 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
<solid android:color="#FFEBEE" />
</shape>

4
MiNotes-master/app/src/main/res/drawable/list_background.xml
Unescape View File

@ -1,4 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
<solid android:color="#FFFFFF" />
</shape>

4
MiNotes-master/app/src/main/res/menu/note_edit.xml
Unescape View File

@ -30,10 +30,6 @@
android:id="@+id/menu_font_size"
android:title="@string/menu_font_size"/>
<item
android:id="@+id/menu_bold"
android:title="@string/menu_bold"/>
<item
android:id="@+id/menu_list_mode"
android:title="@string/menu_list_mode" />

7
MiNotes-master/app/src/main/res/values/strings.xml
Unescape View File

@ -57,8 +57,6 @@
<string name="menu_font_normal">Medium</string>
<string name="menu_font_large">Large</string>
<string name="menu_font_super">Super</string>
<string name="menu_bold">Bold</string>
<string name="menu_unbold">Unbold</string>
<string name="menu_list_mode">Enter check list</string>
<string name="menu_normal_mode">Leave check list</string>
<string name="menu_folder_view">View folder</string>
@ -134,9 +132,4 @@
<item quantity="other"><xliff:g id="number" example="15">%1$s</xliff:g> results for \"<xliff:g id="search" example="???">%2$s</xliff:g>\"</item>
</plurals>
<plurals name="note_count">
<item quantity="one"><xliff:g id="number" example="1">%1$s</xliff:g> note</item>
<item quantity="other"><xliff:g id="number" example="15">%1$s</xliff:g> notes</item>
</plurals>
</resources>

BIN
小米便签开源软件维护方案及成果.docx
View File

Binary file not shown.

BIN
文档模板-开源代码质量分析报告模板.docx
View File

Binary file not shown.

BIN
文档模板-开源软件维护方案及成果模板.docx
View File

Binary file not shown.

BIN
文档模板-软件设计规格说明书模板.doc
View File

Binary file not shown.

BIN
文档模板-软件需求构思及描述模板.docx
View File

Binary file not shown.

BIN
文档模板-软件需求规格说明书模板.docx
View File

Binary file not shown.
Write Preview
Loading…
Cancel
Save