pi9s7qa6c
/
MiNotesPlusDemo
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

增加注释

Browse Source
master
qw1ko 3 years ago
parent 4c70348c82
commit 11b254df83
3 changed files with 117 additions and 76 deletions
Show Stats Download Patch File Download Diff File

37
Notes-master2/src/net/micode/notes/gtask/data/Node.java
Unescape View File

@ -30,54 +30,59 @@ public abstract class Node {//定义各种常量
private long mLastModified;//记录最后一次修改时间
private boolean mDeleted;//表征是否被删除
public Node() {
//mGid: 字符串类型，用于标识 Node 对象的唯一 ID。
//mName: 字符串类型，表示 Node 对象的名称。
//mLastModified: 长整型，表示 Node 对象最后一次修改的时间戳。
//mDeleted: 布尔型，表示 Node 对象是否已被删除。
public Node() {
mGid = null;
mName = "";
mLastModified = 0;
mDeleted = false;
}
//getCreateAction(int actionId): 返回一个 JSON 对象，用于创建一个新的 Node 对象。
public abstract JSONObject getCreateAction(int actionId);
//getUpdateAction(int actionId): 返回一个 JSON 对象，用于更新已有的 Node 对象。
public abstract JSONObject getUpdateAction(int actionId);
//setContentByRemoteJSON(JSONObject js): 从远程 JSON 对象中解析数据并设置 Node 对象的属性。
public abstract void setContentByRemoteJSON(JSONObject js);
//setContentByLocalJSON(JSONObject js): 从本地 JSON 对象中解析数据并设置 Node 对象的属性。
public abstract void setContentByLocalJSON(JSONObject js);
//getLocalJSONFromContent(): 返回一个本地 JSON 对象，包含了 Node 对象的所有属性。
public abstract JSONObject getLocalJSONFromContent();
//getSyncAction(Cursor c): 返回一个整型值，表示需要执行的同步操作类型。
public abstract int getSyncAction(Cursor c);
//setGid(String gid): 设置 mGid 属性的值。
public void setGid(String gid) {
this.mGid = gid;
}
//setName(String name): 设置 mName 属性的值。
public void setName(String name) {
this.mName = name;
}
//setLastModified(long lastModified): 设置 mLastModified 属性的值。
public void setLastModified(long lastModified) {
this.mLastModified = lastModified;
}
//setDeleted(boolean deleted): 设置 mDeleted 属性的值。
public void setDeleted(boolean deleted) {
this.mDeleted = deleted;
}
//getGid(): 返回 mGid 属性的值。
public String getGid() {
return this.mGid;
}
//getName(): 返回 mName 属性的值。
public String getName() {
return this.mName;
}
//getLastModified(): 返回 mLastModified 属性的值。
public long getLastModified() {
return this.mLastModified;
}
//getDeleted(): 返回 mDeleted 属性的值。
public boolean getDeleted() {
return this.mDeleted;
}

37
Notes-master2/src/net/micode/notes/gtask/data/SqlData.java
Unescape View File

@ -74,47 +74,66 @@ public class SqlData {
}
private void loadFromCursor(Cursor c) {
// 从 Cursor 对象中获取列索引为 DATA_ID_COLUMN 的长整型数据，并将其赋值给当前对象的 mDataId 属性
mDataId = c.getLong(DATA_ID_COLUMN);
// 从 Cursor 对象中获取列索引为 DATA_MIME_TYPE_COLUMN 的字符串数据，并将其赋值给当前对象的 mDataMimeType 属性
mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
// 从 Cursor 对象中获取列索引为 DATA_CONTENT_COLUMN 的字符串数据，并将其赋值给当前对象的 mDataContent 属性
mDataContent = c.getString(DATA_CONTENT_COLUMN);
// 从 Cursor 对象中获取列索引为 DATA_CONTENT_DATA_1_COLUMN 的长整型数据，并将其赋值给当前对象的 mDataContentData1 属性
mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
// 从 Cursor 对象中获取列索引为 DATA_CONTENT_DATA_3_COLUMN 的字符串数据，并将其赋值给当前对象的 mDataContentData3 属性
mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
}
public void setContent(JSONObject js) throws JSONException {
//如果传入的JSONObject对象中有DataColumns.ID这一项，则设置，否则设为INVALID_ID
// 如果传入的JSONObject对象中有DataColumns.ID这一项，则设置，否则设为INVALID_ID
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
// 如果当前是新增操作或数据ID已发生变化，将数据ID加入到待更新列表中
if (mIsCreate || mDataId != dataId) {
mDiffDataValues.put(DataColumns.ID, dataId);
}
// 更新当前数据ID
mDataId = dataId;
// 获取数据的MIME类型，如果不存在则设置为DataConstants.NOTE
String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
: DataConstants.NOTE;
// 如果当前是新增操作或数据的MIME类型已发生变化，将MIME类型加入到待更新列表中
if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
}
// 更新当前数据的MIME类型
mDataMimeType = dataMimeType;
// 获取数据的内容，如果不存在则设置为空字符串
String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
// 如果当前是新增操作或数据的内容已发生变化，将数据内容加入到待更新列表中
if (mIsCreate || !mDataContent.equals(dataContent)) {
mDiffDataValues.put(DataColumns.CONTENT, dataContent);
}
// 更新当前数据的内容
mDataContent = dataContent;
// 获取数据的DATA1，如果不存在则设置为0
long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
// 如果当前是新增操作或数据的DATA1已发生变化，将DATA1加入到待更新列表中
if (mIsCreate || mDataContentData1 != dataContentData1) {
mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
}
// 更新当前数据的DATA1
mDataContentData1 = dataContentData1;
// 获取数据的DATA3，如果不存在则设置为空字符串
String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
// 如果当前是新增操作或数据的DATA3已发生变化，将DATA3加入到待更新列表中
if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
}
// 更新当前数据的DATA3
mDataContentData3 = dataContentData3;
}
public JSONObject getContent() throws JSONException {//创建JSONObject对象。并将相关数据放入其中，并返回
if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet");
@ -129,14 +148,15 @@ public class SqlData {
return js;
}
public void commit(long noteId, boolean validateVersion, long version) {//commit函数用于把当前造作所做的修改保存到数据库
public void commit(long noteId, boolean validateVersion, long version) {
// 如果是新建数据，则需要把 noteId 设置进去，并插入到数据库中
if (mIsCreate) {
if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
mDiffDataValues.remove(DataColumns.ID);
}
// 把 noteId 设置进去
mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
// 插入到数据库中
Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
try {
mDataId = Long.valueOf(uri.getPathSegments().get(1));
@ -144,13 +164,14 @@ public class SqlData {
Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed");
}
} else {
} else { // 如果不是新建数据，则需要更新数据
if (mDiffDataValues.size() > 0) {
int result = 0;
// 如果不需要验证版本号，则直接更新数据库
if (!validateVersion) {
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
} else {
} else { // 如果需要验证版本号，则需要在更新前进行检查
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
" ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
@ -163,7 +184,7 @@ public class SqlData {
}
}
}
// 清空修改数据的 Map，并标记为非新建数据
mDiffDataValues.clear();
mIsCreate = false;
}

119
Notes-master2/src/net/micode/notes/gtask/data/SqlNote.java
Unescape View File

@ -169,6 +169,15 @@ public class SqlNote {
}
}
//具体地说，这个方法依次从Cursor对象中读取ID_COLUMN、ALERTED_DATE_COLUMN、BG_COLOR_ID_COLUMN、
//CREATED_DATE_COLUMN、HAS_ATTACHMENT_COLUMN、MODIFIED_DATE_COLUMN、PARENT_ID_COLUMN、SNIPPET_COLUMN、
//TYPE_COLUMN、WIDGET_ID_COLUMN、WIDGET_TYPE_COLUMN和VERSION_COLUMN对应的列的值，
//并将这些值设置为该类的成员变量mId、mAlertDate、mBgColorId、mCreatedDate、mHasAttachment、mModifiedDate、
//mParentId、mSnippet、mType、mWidgetId、mWidgetType和mVersion的值。
// oadFromCursor方法是一个私有方法，它有一个参数c，该参数是一个Cursor对象。
// 这个方法的作用是从Cursor对象中读取数据并将其设置为该类的成员变量的值。
private void loadFromCursor(Cursor c) {
mId = c.getLong(ID_COLUMN);
mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
@ -183,7 +192,7 @@ public class SqlNote {
mWidgetType = c.getInt(WIDGET_TYPE_COLUMN);
mVersion = c.getLong(VERSION_COLUMN);
}
//loadDataContent方法也是一个私有方法，它不接受任何参数。这个方法的作用是从数据库中读取笔记的数据内容。
private void loadDataContent() {
Cursor c = null;
mDataList.clear();
@ -213,24 +222,26 @@ public class SqlNote {
public boolean setContent(JSONObject js) {
try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
// 获取JSON对象中META_HEAD_NOTE字段对应的JSONObject对象，并赋值给note
if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
// 如果note的TYPE字段为TYPE_SYSTEM，打印warning信息
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) : "";
// 如果note的TYPE字段为TYPE_FOLDER，更新Java对象mSnippet和mType的值
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;
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) {
// 如果note的TYPE字段为TYPE_NOTE，更新Java对象的各个字段值
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
if (mIsCreate || mId != id) {
@ -238,43 +249,37 @@ public class SqlNote {
}
mId = id;
long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note
.getLong(NoteColumns.ALERTED_DATE) : 0;
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);
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);
}
mBgColorId = bgColorId;
long createDate = note.has(NoteColumns.CREATED_DATE) ? note
.getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
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;
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();
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;
long parentId = note.has(NoteColumns.PARENT_ID) ? note.getLong(NoteColumns.PARENT_ID) : 0;
if (mIsCreate || mParentId != parentId) {
mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
}
@ -308,6 +313,12 @@ public class SqlNote {
}
mWidgetType = widgetType;
/* 从 JSON 数据中解析出笔记和数据信息
@param jsonData 笔记和数据的 JSON 数据
@return 是否解析成功
*/
long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
if (mIsCreate || mOriginParent != originParent) {
@ -347,13 +358,14 @@ public class SqlNote {
try {
JSONObject js = new JSONObject();
if (mIsCreate) {
if (mIsCreate) { // 如果这个对象还没有被创建
Log.e(TAG, "it seems that we haven't created this in database yet");
return null;
}
// 创建一个名为 note 的 JSON 对象，并将这个对象的属性添加到里面
JSONObject note = new JSONObject();
if (mType == Notes.TYPE_NOTE) {
if (mType == Notes.TYPE_NOTE) { // 如果这个对象是一条笔记
note.put(NoteColumns.ID, mId);
note.put(NoteColumns.ALERTED_DATE, mAlertDate);
note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
@ -366,8 +378,9 @@ public class SqlNote {
note.put(NoteColumns.WIDGET_ID, mWidgetId);
note.put(NoteColumns.WIDGET_TYPE, mWidgetType);
note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 将这个 JSON 对象添加到 js 中
// 创建一个名为 dataArray 的 JSON 数组，并将每个 SqlData 对象的 content 属性添加到里面
JSONArray dataArray = new JSONArray();
for (SqlData sqlData : mDataList) {
JSONObject data = sqlData.getContent();
@ -375,84 +388,85 @@ public class SqlNote {
dataArray.put(data);
}
}
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
} else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); // 将这个 JSON 数组添加到 js 中
} 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);
js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 将这个 JSON 对象添加到 js 中
}
return js;
return js; // 返回 JSON 对象
} catch (JSONException e) {
Log.e(TAG, e.toString());
e.printStackTrace();
}
return null;
return null; // 如果出现异常返回 null
}
public void setParentId(long id) {
mParentId = id;
mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
public void setParentId(long id) { //设置笔记的父笔记ID
mParentId = id; //保存父笔记ID
mDiffNoteValues.put(NoteColumns.PARENT_ID, id); //将更改的值加入到 mDiffNoteValues 中
}
public void setGtaskId(String gid) {
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
public void setGtaskId(String gid) { //设置笔记的 Google 任务ID
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); //将更改的值加入到 mDiffNoteValues 中
}
public void setSyncId(long syncId) {
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
public void setSyncId(long syncId) { //设置笔记的同步ID
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); //将更改的值加入到 mDiffNoteValues 中
}
public void resetLocalModified() {
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
public void resetLocalModified() { //重置本地修改状态
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); //将更改的值加入到 mDiffNoteValues 中
}
public long getId() {
return mId;
public long getId() { //获取笔记ID
return mId; //返回笔记ID
}
public long getParentId() {
return mParentId;
public long getParentId() { //获取笔记的父笔记ID
return mParentId; //返回笔记的父笔记ID
}
public String getSnippet() {
return mSnippet;
public String getSnippet() { //获取笔记片段
return mSnippet; //返回笔记片段
}
public boolean isNoteType() {
return mType == Notes.TYPE_NOTE;
public boolean isNoteType() { //判断笔记是否为Note类型
return mType == Notes.TYPE_NOTE; //如果笔记类型是Note，则返回true，否则返回false
}
public void commit(boolean validateVersion) {
if (mIsCreate) {
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));
mId = Long.valueOf(uri.getPathSegments().get(1)); //获取新笔记ID
} catch (NumberFormatException e) {
Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed");
throw new ActionFailureException("create note failed"); //抛出异常，创建笔记失败
}
if (mId == 0) {
throw new IllegalStateException("Create thread id failed");
}
if (mType == Notes.TYPE_NOTE) {
if (mType == Notes.TYPE_NOTE) { //如果是笔记类型
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, false, -1);
sqlData.commit(mId, false, -1); //保存笔记的数据
}
}
} else {
} 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 ++;
if (mDiffNoteValues.size() > 0) { //如果有更改需要提交
mVersion ++; //更新版本号
int result = 0;
if (!validateVersion) {
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
@ -479,6 +493,7 @@ public class SqlNote {
}
// refresh local info
//loadFromCursor(mId) 方法是一个私有方法，它会查询指定 ID 的笔记记录，并将返回的 Cursor 对象的数据填充到NoteItem 的成员变量中
loadFromCursor(mId);
if (mType == Notes.TYPE_NOTE)
loadDataContent();

Write Preview
Loading…
Cancel
Save