pl8qemw3k
/
GPL_Project
1
0
Fork 0
Code Issues Pull Requests 2 Projects Releases Wiki Activity

代码注释

Browse Source
jjy_branch
jinjiayi 2 years ago
parent 217d5e9c14
commit c98264c94d
4 changed files with 431 additions and 223 deletions
Show Stats Download Patch File Download Diff File

169
doc/标注/210340054_金佳艺/SqlNote.java
Unescape View File

@ -13,7 +13,7 @@ RANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//sqlNote代码注释
/* sqlNote：用于支持软件最底层的数据库的相关操作，note是data的子父集。
用来实现数据库中管理便签的数据，
方法包括提取便签内容、从数据库中获取便签数据、设置便签内容、向数据库提交便签。
@ -43,8 +43,12 @@ import java.util.ArrayList;
public class SqlNote {
/*
* 功能描述：得到类的简写名称存入字符串TAG中
* 实现过程：调用getSimpleName ()函数
*/
private static final String TAG = SqlNote.class.getSimpleName();
//定义一个标识便于后面数据的输入输出
private static final int INVALID_ID = -99999;
public static final String[] PROJECTION_NOTE = new String[] {
@ -55,7 +59,7 @@ public class SqlNote {
NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID,
NoteColumns.VERSION
};
//设置17个列的编号
public static final int ID_COLUMN = 0;
public static final int ALERTED_DATE_COLUMN = 1;
@ -89,12 +93,12 @@ public class SqlNote {
public static final int GTASK_ID_COLUMN = 15;
public static final int VERSION_COLUMN = 16;
//定义了17个内部变量。12个可以从content中获得，5个需要初始化为0或new
private Context mContext;
private ContentResolver mContentResolver;
private ContentResolver mContentResolver; //定义了一个私有全局变量
private boolean mIsCreate;
private boolean mIsCreate; //后续选择生成
private long mId;
@ -126,16 +130,21 @@ public class SqlNote {
private ArrayList<SqlData> mDataList;
public SqlNote(Context context) {
/*
* 功能描述：构造函数
* 参数注解： mIsCreate用于标示构造方式
*/
//构造函数只有context，对所有的变量进行初始化
public SqlNote(Context context) { //构造函数进行初始化
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = true;
mId = INVALID_ID;
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();
mModifiedDate = System.currentTimeMillis();//最后一次修改时间初始化为创建时间
mParentId = 0;
mSnippet = "";
mType = Notes.TYPE_NOTE;
@ -143,21 +152,32 @@ public class SqlNote {
mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
mOriginParent = 0;
mVersion = 0;
mDiffNoteValues = new ContentValues();
mDiffNoteValues = new ContentValues(); //创建内容
mDataList = new ArrayList<SqlData>();
}
/*
* 功能描述：构造函数
* 参数注解： mIsCreate用于标示构造方式
*/
//构造函数有context和一个数据库的cursor，多数变量通过cursor指向的一条记录直接进行初始化
public SqlNote(Context context, Cursor c) {
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = false;
loadFromCursor(c);
mContentResolver = context.getContentResolver(); //获取程序之间的数据共享
mIsCreate = false; //记录当前数据创建方式
loadFromCursor(c); //从光标处载入数据
mDataList = new ArrayList<SqlData>();
if (mType == Notes.TYPE_NOTE)
loadDataContent();
mDiffNoteValues = new ContentValues();
}
/*
* 功能描述：构造函数
* 参数注解： mIsCreate用于标示构造方式
*/
public SqlNote(Context context, long id) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -170,16 +190,21 @@ public class SqlNote {
}
/*
*功能描述：通过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);
}, null);//通过id获取对应的ContentResolver中的cursor
if (c != null) {
c.moveToNext();
loadFromCursor(c);
//加载数据进行初始化
//使函数SqlNote(Context context, long id)与SqlNote(Context context, long id)的实现方式基本相同
} else {
Log.w(TAG, "loadFromCursor: cursor = null");
}
@ -189,7 +214,9 @@ public class SqlNote {
}
}
//功能描述：通过游标从光标处加载数据
private void loadFromCursor(Cursor c) {
//直接从一条记录中的获得以下变量的初始值
mId = c.getLong(ID_COLUMN);
mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
mBgColorId = c.getInt(BG_COLOR_ID_COLUMN);
@ -204,6 +231,7 @@ public class SqlNote {
mVersion = c.getLong(VERSION_COLUMN);
}
//功能描述：通过content机制获取共享数据并加载到数据库当前游标处
private void loadDataContent() {
Cursor c = null;
mDataList.clear();
@ -230,67 +258,69 @@ public class SqlNote {
}
}
//功能描述：通过设置content机制用于共享的数据信息
public boolean setContent(JSONObject js) {
try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); //创建一个JSONObject对象
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
//对于文件夹，只能更新snnipet并键入
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : "";
.getString(NoteColumns.SNIPPET) : ""; //如果共享数据存在摘要，需要将其赋给声明的snippct变量，否则变量为空
if (mIsCreate || !mSnippet.equals(snippet)) {
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
}
} //如果SQLNote采用的是第一种构造方式，或snippet为空，则将snippet键值存入contenttvalue中
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);
}
} //判断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);
}
} //如果仅通过上下文对Note进行数据库修改，或该标记日与原标记日不同
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);
}
} //判断背景颜色是否一致
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;
.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();
.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
@ -301,24 +331,24 @@ public class SqlNote {
mParentId = parentId;
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : "";
.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);
}
} //判断控件id是否一致
mWidgetId = widgetId;
int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
@ -363,30 +393,33 @@ public class SqlNote {
return true;
}
public JSONObject getContent() {
//功能描述：获取content机制提供的数据并加载到note中
public JSONObject getContent() { //获取content机制提供的数据并加载到note中
try {
JSONObject js = new JSONObject();
if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet");
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);
note.put(NoteColumns.CREATED_DATE, mCreatedDate);
if (mType == Notes.TYPE_NOTE) { //类型为note时//判断类型是否note类型
note.put(NoteColumns.ID, mId); //设置以下12个内部变量
note.put(NoteColumns.ALERTED_DATE, mAlertDate);//提醒时间
note.put(NoteColumns.BG_COLOR_ID, mBgColorId);//背景颜色
note.put(NoteColumns.CREATED_DATE, mCreatedDate);//创建日期
note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment);
note.put(NoteColumns.MODIFIED_DATE, mModifiedDate);
note.put(NoteColumns.MODIFIED_DATE, mModifiedDate);//修改日期
note.put(NoteColumns.PARENT_ID, mParentId);
note.put(NoteColumns.SNIPPET, mSnippet);
note.put(NoteColumns.TYPE, mType);
note.put(NoteColumns.SNIPPET, mSnippet);//摘要
note.put(NoteColumns.TYPE, mType);//类型
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);
note.put(NoteColumns.WIDGET_TYPE, mWidgetType);//小部件类型
note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);//最初的父类
js.put(GTaskStringUtils.META_HEAD_NOTE, note);;//将这个便签存入元数据中
JSONArray dataArray = new JSONArray();
for (SqlData sqlData : mDataList) {
@ -396,12 +429,13 @@ public class SqlNote {
}
}
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
} else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
} 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);
}
//对于文件夹类型或者系统文件夹类型，将id，类型，以及摘要，存入jsonobject,然后对应META_HEAD_NOTE键，存入共享，其实也只有那么多可以传输
return js;
} catch (JSONException e) {
@ -411,70 +445,88 @@ public class SqlNote {
return null;
}
//功能描述：给当前id设置父id
public void setParentId(long id) {
mParentId = id;
mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
}
//功能描述：给当前id设置Gtaskid
public void setGtaskId(String gid) {
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
}
//功能描述：给当前id设置同步id
public void setSyncId(long syncId) {
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
}
//功能描述：将本地修改初始化，即撤销当前所有修改
public void resetLocalModified() {
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
}
//功能描述：获得当前id
public long getId() {
return mId;
}
//功能描述：获得当前id的父id
public long getParentId() {
return mParentId;
}
//功能描述：获取小片段，即用于显示的部分便签内容
public String getSnippet() {
return mSnippet;
}
//功能描述：判断是否为便签类型
public boolean isNoteType() {
return mType == Notes.TYPE_NOTE;
}
//功能描述：commit函数，作用于把当前所做的修改传送并保存在数据库中
public void commit(boolean validateVersion) {
if (mIsCreate) {
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
mDiffNoteValues.remove(NoteColumns.ID);
//如果是一个无效的id并且还含有这个id，就将它移除
}
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
//插入便签的uri
try {
mId = Long.valueOf(uri.getPathSegments().get(1));
//强制转换path为id ，Long型
} catch (NumberFormatException e) {
Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed");
}
} //捕获异常，转换出错，显示错误“获取note的id出现错误”
if (mId == 0) {
throw new IllegalStateException("Create thread id failed");
}
} //创建线程 id 失败
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {
if (mType == Notes.TYPE_NOTE) { //对于note类型，引用sqlData.commit
for (SqlData sqlData : mDataList) { //直接使用sqldata中实现
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");
Log.e(TAG, "No such note"); //判断是否含有这个便签
throw new IllegalStateException("Try to update note with invalid id");
//如果没有就是无效id
}
if (mDiffNoteValues.size() > 0) {
mVersion ++;
int result = 0;
if (!validateVersion) {
if (!validateVersion) { //构造字符串
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?)", new String[] {
String.valueOf(mId)
@ -488,22 +540,23 @@ public class SqlNote {
}
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);
}
}
} //对note类型，还是对其中的data引用commit，从而实现目的
}
// refresh local info
//刷新本地信息
loadFromCursor(mId);
if (mType == Notes.TYPE_NOTE)
loadDataContent();
loadDataContent(); //如果是便签类型，获取共享数据并加载到数据库
mDiffNoteValues.clear();
mIsCreate = false;
mDiffNoteValues.clear(); //清空共享数据
mIsCreate = false; //重置
}
}

169
src/Xiaominotes/app/src/main/java/net/micode/notes/gtask/data/SqlNote.java
Unescape View File

@ -13,7 +13,7 @@ RANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//sqlNote代码注释
/* sqlNote：用于支持软件最底层的数据库的相关操作，note是data的子父集。
用来实现数据库中管理便签的数据，
方法包括提取便签内容、从数据库中获取便签数据、设置便签内容、向数据库提交便签。
@ -43,8 +43,12 @@ import java.util.ArrayList;
public class SqlNote {
/*
* 功能描述：得到类的简写名称存入字符串TAG中
* 实现过程：调用getSimpleName ()函数
*/
private static final String TAG = SqlNote.class.getSimpleName();
//定义一个标识便于后面数据的输入输出
private static final int INVALID_ID = -99999;
public static final String[] PROJECTION_NOTE = new String[] {
@ -55,7 +59,7 @@ public class SqlNote {
NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID,
NoteColumns.VERSION
};
//设置17个列的编号
public static final int ID_COLUMN = 0;
public static final int ALERTED_DATE_COLUMN = 1;
@ -89,12 +93,12 @@ public class SqlNote {
public static final int GTASK_ID_COLUMN = 15;
public static final int VERSION_COLUMN = 16;
//定义了17个内部变量。12个可以从content中获得，5个需要初始化为0或new
private Context mContext;
private ContentResolver mContentResolver;
private ContentResolver mContentResolver; //定义了一个私有全局变量
private boolean mIsCreate;
private boolean mIsCreate; //后续选择生成
private long mId;
@ -126,16 +130,21 @@ public class SqlNote {
private ArrayList<SqlData> mDataList;
public SqlNote(Context context) {
/*
* 功能描述：构造函数
* 参数注解： mIsCreate用于标示构造方式
*/
//构造函数只有context，对所有的变量进行初始化
public SqlNote(Context context) { //构造函数进行初始化
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = true;
mId = INVALID_ID;
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();
mModifiedDate = System.currentTimeMillis();//最后一次修改时间初始化为创建时间
mParentId = 0;
mSnippet = "";
mType = Notes.TYPE_NOTE;
@ -143,21 +152,32 @@ public class SqlNote {
mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
mOriginParent = 0;
mVersion = 0;
mDiffNoteValues = new ContentValues();
mDiffNoteValues = new ContentValues(); //创建内容
mDataList = new ArrayList<SqlData>();
}
/*
* 功能描述：构造函数
* 参数注解： mIsCreate用于标示构造方式
*/
//构造函数有context和一个数据库的cursor，多数变量通过cursor指向的一条记录直接进行初始化
public SqlNote(Context context, Cursor c) {
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = false;
loadFromCursor(c);
mContentResolver = context.getContentResolver(); //获取程序之间的数据共享
mIsCreate = false; //记录当前数据创建方式
loadFromCursor(c); //从光标处载入数据
mDataList = new ArrayList<SqlData>();
if (mType == Notes.TYPE_NOTE)
loadDataContent();
mDiffNoteValues = new ContentValues();
}
/*
* 功能描述：构造函数
* 参数注解： mIsCreate用于标示构造方式
*/
public SqlNote(Context context, long id) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -170,16 +190,21 @@ public class SqlNote {
}
/*
*功能描述：通过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);
}, null);//通过id获取对应的ContentResolver中的cursor
if (c != null) {
c.moveToNext();
loadFromCursor(c);
//加载数据进行初始化
//使函数SqlNote(Context context, long id)与SqlNote(Context context, long id)的实现方式基本相同
} else {
Log.w(TAG, "loadFromCursor: cursor = null");
}
@ -189,7 +214,9 @@ public class SqlNote {
}
}
//功能描述：通过游标从光标处加载数据
private void loadFromCursor(Cursor c) {
//直接从一条记录中的获得以下变量的初始值
mId = c.getLong(ID_COLUMN);
mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
mBgColorId = c.getInt(BG_COLOR_ID_COLUMN);
@ -204,6 +231,7 @@ public class SqlNote {
mVersion = c.getLong(VERSION_COLUMN);
}
//功能描述：通过content机制获取共享数据并加载到数据库当前游标处
private void loadDataContent() {
Cursor c = null;
mDataList.clear();
@ -230,67 +258,69 @@ public class SqlNote {
}
}
//功能描述：通过设置content机制用于共享的数据信息
public boolean setContent(JSONObject js) {
try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); //创建一个JSONObject对象
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
//对于文件夹，只能更新snnipet并键入
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : "";
.getString(NoteColumns.SNIPPET) : ""; //如果共享数据存在摘要，需要将其赋给声明的snippct变量，否则变量为空
if (mIsCreate || !mSnippet.equals(snippet)) {
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
}
} //如果SQLNote采用的是第一种构造方式，或snippet为空，则将snippet键值存入contenttvalue中
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);
}
} //判断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);
}
} //如果仅通过上下文对Note进行数据库修改，或该标记日与原标记日不同
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);
}
} //判断背景颜色是否一致
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;
.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();
.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
@ -301,24 +331,24 @@ public class SqlNote {
mParentId = parentId;
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : "";
.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);
}
} //判断控件id是否一致
mWidgetId = widgetId;
int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
@ -363,30 +393,33 @@ public class SqlNote {
return true;
}
public JSONObject getContent() {
//功能描述：获取content机制提供的数据并加载到note中
public JSONObject getContent() { //获取content机制提供的数据并加载到note中
try {
JSONObject js = new JSONObject();
if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet");
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);
note.put(NoteColumns.CREATED_DATE, mCreatedDate);
if (mType == Notes.TYPE_NOTE) { //类型为note时//判断类型是否note类型
note.put(NoteColumns.ID, mId); //设置以下12个内部变量
note.put(NoteColumns.ALERTED_DATE, mAlertDate);//提醒时间
note.put(NoteColumns.BG_COLOR_ID, mBgColorId);//背景颜色
note.put(NoteColumns.CREATED_DATE, mCreatedDate);//创建日期
note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment);
note.put(NoteColumns.MODIFIED_DATE, mModifiedDate);
note.put(NoteColumns.MODIFIED_DATE, mModifiedDate);//修改日期
note.put(NoteColumns.PARENT_ID, mParentId);
note.put(NoteColumns.SNIPPET, mSnippet);
note.put(NoteColumns.TYPE, mType);
note.put(NoteColumns.SNIPPET, mSnippet);//摘要
note.put(NoteColumns.TYPE, mType);//类型
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);
note.put(NoteColumns.WIDGET_TYPE, mWidgetType);//小部件类型
note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);//最初的父类
js.put(GTaskStringUtils.META_HEAD_NOTE, note);;//将这个便签存入元数据中
JSONArray dataArray = new JSONArray();
for (SqlData sqlData : mDataList) {
@ -396,12 +429,13 @@ public class SqlNote {
}
}
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
} else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
} 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);
}
//对于文件夹类型或者系统文件夹类型，将id，类型，以及摘要，存入jsonobject,然后对应META_HEAD_NOTE键，存入共享，其实也只有那么多可以传输
return js;
} catch (JSONException e) {
@ -411,70 +445,88 @@ public class SqlNote {
return null;
}
//功能描述：给当前id设置父id
public void setParentId(long id) {
mParentId = id;
mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
}
//功能描述：给当前id设置Gtaskid
public void setGtaskId(String gid) {
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
}
//功能描述：给当前id设置同步id
public void setSyncId(long syncId) {
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
}
//功能描述：将本地修改初始化，即撤销当前所有修改
public void resetLocalModified() {
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
}
//功能描述：获得当前id
public long getId() {
return mId;
}
//功能描述：获得当前id的父id
public long getParentId() {
return mParentId;
}
//功能描述：获取小片段，即用于显示的部分便签内容
public String getSnippet() {
return mSnippet;
}
//功能描述：判断是否为便签类型
public boolean isNoteType() {
return mType == Notes.TYPE_NOTE;
}
//功能描述：commit函数，作用于把当前所做的修改传送并保存在数据库中
public void commit(boolean validateVersion) {
if (mIsCreate) {
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
mDiffNoteValues.remove(NoteColumns.ID);
//如果是一个无效的id并且还含有这个id，就将它移除
}
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
//插入便签的uri
try {
mId = Long.valueOf(uri.getPathSegments().get(1));
//强制转换path为id ，Long型
} catch (NumberFormatException e) {
Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed");
}
} //捕获异常，转换出错，显示错误“获取note的id出现错误”
if (mId == 0) {
throw new IllegalStateException("Create thread id failed");
}
} //创建线程 id 失败
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {
if (mType == Notes.TYPE_NOTE) { //对于note类型，引用sqlData.commit
for (SqlData sqlData : mDataList) { //直接使用sqldata中实现
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");
Log.e(TAG, "No such note"); //判断是否含有这个便签
throw new IllegalStateException("Try to update note with invalid id");
//如果没有就是无效id
}
if (mDiffNoteValues.size() > 0) {
mVersion ++;
int result = 0;
if (!validateVersion) {
if (!validateVersion) { //构造字符串
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?)", new String[] {
String.valueOf(mId)
@ -488,22 +540,23 @@ public class SqlNote {
}
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);
}
}
} //对note类型，还是对其中的data引用commit，从而实现目的
}
// refresh local info
//刷新本地信息
loadFromCursor(mId);
if (mType == Notes.TYPE_NOTE)
loadDataContent();
loadDataContent(); //如果是便签类型，获取共享数据并加载到数据库
mDiffNoteValues.clear();
mIsCreate = false;
mDiffNoteValues.clear(); //清空共享数据
mIsCreate = false; //重置
}
}

154
src/Xiaominotes/app/src/main/java/net/micode/notes/gtask/data/Task.java
Unescape View File

@ -13,7 +13,8 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//Task代码注释
//主要作用：同步任务，将创建、更新和同步动作包装成JSON对象，同时使用本地和远程的JSON对结点内容进行设置，从而获取同步信息，实现本地和远程的信息同步
package net.micode.notes.gtask.data;
import android.database.Cursor;
@ -32,59 +33,60 @@ import org.json.JSONException;
import org.json.JSONObject;
public class Task extends Node {
public class Task extends Node { //定义一个Task类,继承Node类
private static final String TAG = Task.class.getSimpleName();
//调用函数得到类简写名称并存入字符串TAG内
private boolean mCompleted; //判断当前任务是否完成
private boolean mCompleted;
private String mNotes;
private String mNotes; //在实例中存储数据的类型，表示任务的注释信息
private JSONObject mMetaInfo;
private JSONObject mMetaInfo; //将在实例中存储数据的类型
private Task mPriorSibling;
private Task mPriorSibling; //对应的优先兄弟Task的指针
private TaskList mParent;
private TaskList mParent; //所在的任务列表的指针
public Task() {
super();
mCompleted = false;
mNotes = null;
mPriorSibling = null;
mParent = null;
mPriorSibling = null; //TaskList中当前Task前面的Task的指针
mParent = null; //当前Task所在的TaskList
mMetaInfo = null;
}
public JSONObject getCreateAction(int actionId) {
//getCreateAction方法接收一个整型参数actionId，将该参数作为返回JSONObject对象的action_id属性值。
JSONObject js = new JSONObject();
try {
// action_type
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, //存入当前task指针
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
//发送对actiontype的请求
// action_id
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// index
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
// index 父任务列表中的索引
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this)); //设置索引
// entity_delta
JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); //获取任务名
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); //对任务创建id进行判空操作
entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, //实体类数据
GTaskStringUtils.GTASK_JSON_TYPE_TASK);
if (getNotes() != null) {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
}
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} //若存在文本输入放入实体内
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); //讲实体存入js
// parent_id
js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid()); //父类id类型
// dest_parent_type
js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
GTaskStringUtils.GTASK_JSON_TYPE_GROUP); //所在列表的id存入父id
// list_id
js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
@ -93,23 +95,26 @@ public class Task extends Node {
if (mPriorSibling != null) {
js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
}
//如果该任务在兄弟任务中不是第一个，则设置prior_sibling_id属性值为前一个兄弟任务的gid
//将其优先存入ID序列中
} catch (JSONException e) {
Log.e(TAG, e.toString());
Log.e(TAG, e.toString()); //e.toString()获取异常类型和异常详细消息
e.printStackTrace();
throw new ActionFailureException("fail to generate task-create jsonobject");
}
} //抛出异常处理机制
return js;
}
public JSONObject getUpdateAction(int actionId) {
public JSONObject getUpdateAction(int actionId) { //更新action
//getUpdateAction方法接收一个整型参数actionId，将该参数作为返回JSONObject对象的action_id属性值
JSONObject js = new JSONObject();
try {
// action_type
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
//action_type属性值为update，表示更新操作
// action_id
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
@ -122,26 +127,31 @@ public class Task extends Node {
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
if (getNotes() != null) {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
}
}//如果存在 notes ，则将其也放入 entity 中
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
//deleted属性表示任务是否被删除，如果该值为true，则该任务会被移除
} catch (JSONException e) {
} catch (JSONException e) { //获取异常
Log.e(TAG, e.toString());
e.printStackTrace();
e.printStackTrace(); //命令行打印异常信息在程序中出错的位置及原因
throw new ActionFailureException("fail to generate task-update jsonobject");
}
} //生成任务更新的数据传输失败
return js;
}
public void setContentByRemoteJSON(JSONObject js) {
public void setContentByRemoteJSON(JSONObject js) //通过云端传输数据设置内容
//定义了一个setContentByRemoteJSON方法，该方法从远程JSON对象中获取任务的属性值，并将这些属性值设置到本地任务对象中
//表示从远程服务器获取的任务信息
{
if (js != null) {
try {
// id
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
}
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { //如果js指针指向的目标存在
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); //利用类自身的set函数，并且使用了JSONObject的get类型函数
} //判断记录是否被删除
// last_modified
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
@ -166,34 +176,35 @@ public class Task extends Node {
// completed
if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
}
} catch (JSONException e) {
Log.e(TAG, e.toString());
e.printStackTrace();
} //记录已经完成的
} catch (JSONException e) { //抛出异常
Log.e(TAG, e.toString()); //获取异常类型和异常信息
e.printStackTrace(); //打印
throw new ActionFailureException("fail to get task content from jsonobject");
}
}
}
public void setContentByLocalJSON(JSONObject js) {
public void setContentByLocalJSON(JSONObject js) { //通过本地的jsonobject获取内容
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
|| !js.has(GTaskStringUtils.META_HEAD_DATA)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
|| !js.has(GTaskStringUtils.META_HEAD_DATA)) { //如果js不存在或者js没有元数据的开头或者js指针没有元数据
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); //反馈给用户出错信息
}
try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
Log.e(TAG, "invalid type");
if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) { //note类型不匹配
Log.e(TAG, "invalid type"); //无效
return;
}
for (int i = 0; i < dataArray.length(); i++) {
//遍历 dataArray 查找与数据库中DataConstants.NOTE 记录信息一致的 data
JSONObject data = dataArray.getJSONObject(i);
if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
setName(data.getString(DataColumns.CONTENT));
setName(data.getString(DataColumns.CONTENT)); //判断两个字符串是否相等
break;
}
}
@ -204,8 +215,8 @@ public class Task extends Node {
}
}
public JSONObject getLocalJSONFromContent() {
String name = getName();
public JSONObject getLocalJSONFromContent() { //从content获取本地json
String name = getName(); //获取名称
try {
if (mMetaInfo == null) {
// new task created from web
@ -213,21 +224,22 @@ public class Task extends Node {
Log.w(TAG, "the note seems to be an empty one");
return null;
}
//若命名为空则创建一个新的
JSONObject js = new JSONObject();
JSONObject note = new JSONObject();
JSONArray dataArray = new JSONArray();
JSONObject data = new JSONObject();
JSONObject data = new JSONObject(); //对四个指针进行初始化
data.put(DataColumns.CONTENT, name);
dataArray.put(data);
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); //元数据类型信息非空，则进行同步更新操作
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
js.put(GTaskStringUtils.META_HEAD_NOTE, note); //实现数据同步
return js;
} else {
} else { //否则将元数据同步至数据中
// synced task
JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); //同步任务
JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA); //同步数据
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
@ -235,7 +247,7 @@ public class Task extends Node {
data.put(DataColumns.CONTENT, getName());
break;
}
}
}//通过循环查找与数据库中DataConstants.NOTE 记录信息一致的 data
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
return mMetaInfo;
@ -247,7 +259,7 @@ public class Task extends Node {
}
}
public void setMetaInfo(MetaData metaData) {
public void setMetaInfo(MetaData metaData) { //设置元数据信息
if (metaData != null && metaData.getNotes() != null) {
try {
mMetaInfo = new JSONObject(metaData.getNotes());
@ -255,30 +267,30 @@ public class Task extends Node {
Log.w(TAG, e.toString());
mMetaInfo = null;
}
}
} //如果元数据非空且其 notes 非空，则修改元数据类型信息
}
public int getSyncAction(Cursor c) {
public int getSyncAction(Cursor c) { //实现同步操作
try {
JSONObject noteInfo = null;
JSONObject noteInfo = null; //新建一个 JSONObject 的对象实体
if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
}
} //元数据信息不为空并且元数据信息还含有“META_HEAD_NOTE”，说明便签存在
if (noteInfo == null) {
Log.w(TAG, "it seems that note meta has been deleted");
return SYNC_ACTION_UPDATE_REMOTE;
}
} //云端便签 id 已被删除，不存在，返回更新本地数据的同步行为
if (!noteInfo.has(NoteColumns.ID)) {
Log.w(TAG, "remote note id seems to be deleted");
return SYNC_ACTION_UPDATE_LOCAL;
}
} //匹配note的id
// validate the note id now
if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
Log.w(TAG, "note id doesn't match");
return SYNC_ACTION_UPDATE_LOCAL;
return SYNC_ACTION_UPDATE_LOCAL; //判断修改后的ID匹配是否成功，成功则返回无同步操作，未成功则应用云端到本地，返回本地同步更新操作
}
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
@ -293,10 +305,12 @@ public class Task extends Node {
} else {
// validate gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match");
//判断gtask的id与获取的id是否匹配
Log.e(TAG, "gtask id doesn't match"); //错误，未找到 gtask 的 id
return SYNC_ACTION_ERROR;
}
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
////错误，未找到 gtask 的 id
// local modification only
return SYNC_ACTION_UPDATE_REMOTE;
} else {
@ -311,41 +325,41 @@ public class Task extends Node {
return SYNC_ACTION_ERROR;
}
public boolean isWorthSaving() {
public boolean isWorthSaving() { //判断是否修改并同步操作
return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
|| (getNotes() != null && getNotes().trim().length() > 0);
}
public void setCompleted(boolean completed) {
this.mCompleted = completed;
}
} //设定是否完成的成员变量
public void setNotes(String notes) {
this.mNotes = notes;
}
} //设定note成员变量
public void setPriorSibling(Task priorSibling) {
this.mPriorSibling = priorSibling;
}
} //设置优先兄弟 task 的优先级
public void setParent(TaskList parent) {
this.mParent = parent;
}
} //设置父类节点
public boolean getCompleted() {
return this.mCompleted;
}
} //判断是否完成
public String getNotes() {
return this.mNotes;
}
} //获取成员变量 mNotes 的信息
public Task getPriorSibling() {
return this.mPriorSibling;
}
} //获取优先兄弟列表
public TaskList getParent() {
return this.mParent;
}
} //获取父类节点列表
}

162
src/Xiaominotes/app/src/main/java/net/micode/notes/gtask/data/TaskList.java
Unescape View File

@ -13,7 +13,8 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//TaskList代码标注
//主要作用：同步任务列表，将Task组织成同步任务列表进行管理
package net.micode.notes.gtask.data;
import android.database.Cursor;
@ -30,27 +31,33 @@ import org.json.JSONObject;
import java.util.ArrayList;
public class TaskList extends Node {
private static final String TAG = TaskList.class.getSimpleName();
public class TaskList extends Node {//创建继承 Node的任务表类
private static final String TAG = TaskList.class.getSimpleName(); //tag标记
//调用getSimplename（）函数获取名字并赋值给TAG作为标记
private int mIndex; //当前TaskList的指针
private int mIndex;
private ArrayList<Task> mChildren; //类中主要的保存数据的单元，用来实现一个以Task为元素的ArrayList
private ArrayList<Task> mChildren;
public TaskList() {
super();
mChildren = new ArrayList<Task>();
public TaskList() { //构造函数进行初始化
super(); //调用父类构造方法
mChildren = new ArrayList<Task>(); //声明数组
mIndex = 1;
}
/* (non-Javadoc)
* @see net.micode.notes.gtask.data.Node#getCreateAction(int)
* 生成并返回一个包含了一定数据的JSONObject实体
*/
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
JSONObject js = new JSONObject(); //直接构建即直接实例化一个JSONObject对象
try {
// action_type
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
//操作的是列表，而不只是单个task了
// action_id
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
@ -58,11 +65,15 @@ public class TaskList extends Node {
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
// entity_delta
JSONObject entity = new JSONObject();
// 新建一个 JSONObject 对象，名为实体，将 name，creator id，entity type 三个信息存在一起
JSONObject entity = new JSONObject(); //创建一个实体类并进行初始化
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
//getName是父类的一个函数
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
//初始化id
entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
//将实体类型设置为“GROUP”
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) {
@ -74,8 +85,13 @@ public class TaskList extends Node {
return js;
}
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
/* (non-Javadoc)
* @see net.micode.notes.gtask.data.Node#getUpdateAction(int)
* 生成并返回一个包含了一定数据的JSONObject实体
*/
public JSONObject getUpdateAction(int actionId) { //接受更新action，返回jsonobject
JSONObject js = new JSONObject(); //创建一个对象并进行初始化
try {
// action_type
@ -104,22 +120,25 @@ public class TaskList extends Node {
}
public void setContentByRemoteJSON(JSONObject js) {
//通过云端 JSON 数据设置实例化对象 js 的内容
if (js != null) {
try {
// id
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
}
//判断js对象是否为空，如果为空即没有内容就不需要进行设置了
// last_modified
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
}
//调用JSONObject中的getLong函数，得到last_modified的号，并作为参数传给setLastModified函数（父类函数）进行设置
// name
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
}
} //对任务的name进行设置
} catch (JSONException e) {
Log.e(TAG, e.toString());
@ -129,27 +148,37 @@ public class TaskList extends Node {
}
}
public void setContentByLocalJSON(JSONObject js) {
public void setContentByLocalJSON(JSONObject js) { //通过本地 JSON 数据设置对象 js 内容
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
//若 js 创建失败或 js 中不存在 META_HEAD_NOTE信息
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
}
} //警告，没有可用资源
try {
JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
//NullPointerException这个异常出现在处理对象时对象不存在但又没有捕捉到进行处理的时候
if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
//对文件夹，设置文件名
String name = folder.getString(NoteColumns.SNIPPET);
//获取文件夹片段字符串作为文件夹名称
setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name);
//设置名称为MIUI系统文件夹前缀+文件夹名称
} else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
//判断是不是系统文件
if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
//如果是根文件夹，设置名称：MIUI系统文件夹前缀+默认文件夹名称
else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ GTaskStringUtils.FOLDER_CALL_NOTE);
//如果是通话文件夹，设置名称：MIUI系统文件夹前缀+通话便签文件夹名称
else
Log.e(TAG, "invalid system folder");
;//无效系统文件夹警告
} else {
Log.e(TAG, "error type");
//错误的文件夹类型
}
} catch (JSONException e) {
Log.e(TAG, e.toString());
@ -157,19 +186,21 @@ public class TaskList extends Node {
}
}
public JSONObject getLocalJSONFromContent() {
public JSONObject getLocalJSONFromContent() { //从content获取本地json
try {
JSONObject js = new JSONObject();
JSONObject folder = new JSONObject();
JSONObject js = new JSONObject(); //创建对象并初始化
JSONObject folder = new JSONObject(); //创建文件夹对象并初始化
String folderName = getName();
if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
folderName.length());
folder.put(NoteColumns.SNIPPET, folderName);
//如果获取的文件夹名称是以[MIUI_Notes]开头，则文件夹名称应删掉前缀
if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
|| folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
//这里与上一个函数setContentByRemoteJSON(JSONObject js)是一个逆过程，可以参看上一个函数是如何构造出foldername的
else
folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
@ -183,26 +214,28 @@ public class TaskList extends Node {
}
}
public int getSyncAction(Cursor c) {
public int getSyncAction(Cursor c) { //获取同步信息
try {
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { //若本地修改未记录
// there is no local update
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
//记录最后一次修改
// no update both side
return SYNC_ACTION_NONE;
} else {
// apply remote to local
return SYNC_ACTION_UPDATE_LOCAL;
}
} //匹配失败，返回更新本地数据的同步行为
} else {
// validate gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match");
return SYNC_ACTION_ERROR;
}
} //如果获取的ID不匹配，返回同步动作失败
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// local modification only
return SYNC_ACTION_UPDATE_REMOTE;
//如果是最近一次修改的 id，则返回云端更新的同步动作
} else {
// for folder conflicts, just apply local modification
return SYNC_ACTION_UPDATE_REMOTE;
@ -216,43 +249,63 @@ public class TaskList extends Node {
return SYNC_ACTION_ERROR;
}
// @return
//功能：获得TaskList的大小，即mChildren的大小
public int getChildTaskCount() {
return mChildren.size();
}
//获得TaskList的大小，即mChildren的大小，mChildren 是TaskList 的一个实例
//@param task
//@return 返回值为是否成功添加任务。
//功能：在当前任务表末尾添加新的任务。
public boolean addChildTask(Task task) {
boolean ret = false;
if (task != null && !mChildren.contains(task)) {
if (task != null && !mChildren.contains(task)) { //任务非空且任务表中不存在该任务
ret = mChildren.add(task);
if (ret) {
// need to set prior sibling and parent
task.setPriorSibling(mChildren.isEmpty() ? null : mChildren
.get(mChildren.size() - 1));
task.setParent(this);
//ArrayList的每一次修改变化都要紧跟相关Task中PriorSibling的修改
}
}
return ret;
}
/**
* @param task
* @param index
* @return
* 功能：在当前任务表的指定位置添加新的任务。
*/
public boolean addChildTask(Task task, int index) {
if (index < 0 || index > mChildren.size()) {
Log.e(TAG, "add child task: invalid index");
return false;
}
//在当前任务表的指定位置添加新的任务，index是指针
int pos = mChildren.indexOf(task);
if (task != null && pos == -1) {
mChildren.add(index, task);
//获取要添加的任务在列表中的位置，如果不在列表中则返回-1
// update the task list
Task preTask = null;
Task preTask = null; //更新任务表
Task afterTask = null;
if (index != 0)
preTask = mChildren.get(index - 1);
if (index != mChildren.size() - 1)
afterTask = mChildren.get(index + 1);
task.setPriorSibling(preTask);
task.setPriorSibling(preTask); //使得前后三个任务连在一起
if (afterTask != null)
afterTask.setPriorSibling(task);
}
@ -260,27 +313,40 @@ public class TaskList extends Node {
return true;
}
public boolean removeChildTask(Task task) {
/**
* @param task
* @return 返回删除是否成功
* 功能：删除TaskList中的一个Task
*/
public boolean removeChildTask(Task task) { //删除任务表中的子任务
boolean ret = false;
int index = mChildren.indexOf(task);
if (index != -1) {
ret = mChildren.remove(task);
int index = mChildren.indexOf(task); //获取该任务在任务表中的索引
if (index != -1) { //索引有效，任务在表中存在
ret = mChildren.remove(task); //移除任务
if (ret) {
// reset prior sibling and parent
task.setPriorSibling(null);
task.setParent(null);
task.setParent(null); //删除成功，task的上一个任务指针和父指针置空
// update the task list
if (index != mChildren.size()) {
mChildren.get(index).setPriorSibling(
index == 0 ? null : mChildren.get(index - 1));
}
} //删除成功后，要对任务列表进行更新
}
}
return ret;
}
/**
* @param task
* @param index
* @return
* 功能：将当前TaskList中含有的某个Task移到index位置
*/
public boolean moveChildTask(Task task, int index) {
if (index < 0 || index >= mChildren.size()) {
@ -298,6 +364,13 @@ public class TaskList extends Node {
return true;
return (removeChildTask(task) && addChildTask(task, index));
}
//利用已经实现好的功能完成当下功能
/**
* @param gid
* @return返回寻找结果
* 功能：按gid寻找Task
*/
public Task findChildTaskByGid(String gid) {
for (int i = 0; i < mChildren.size(); i++) {
@ -309,20 +382,35 @@ public class TaskList extends Node {
return null;
}
/**
* @param task
* @return
* 功能：返回指定Task的index
*/
public int getChildTaskIndex(Task task) {
return mChildren.indexOf(task);
}
/**
* @param index
* @return
* 功能：返回指定index的Task
*/
public Task getChildTaskByIndex(int index) {
if (index < 0 || index >= mChildren.size()) {
Log.e(TAG, "getTaskByIndex: invalid index");
Log.e(TAG, "getTaskByIndex: invalid index"); //如果指针不在范围内，无效索引
return null;
}
return mChildren.get(index);
}
/**
* @param gid
* @return
* 功能：返回指定gid的Task
*/
public Task getChilTaskByGid(String gid) {
for (Task task : mChildren) {
for (Task task : mChildren) { //ArrayList的遍历方法 //通过索引获取子任务
if (task.getGid().equals(gid))
return task;
}
@ -331,13 +419,13 @@ public class TaskList extends Node {
public ArrayList<Task> getChildTaskList() {
return this.mChildren;
}
} //获取子任务列表
public void setIndex(int index) {
this.mIndex = index;
}
} //设置任务索引
public int getIndex() {
return this.mIndex;
}
} //获取任务索引
}

Write Preview
Loading…
Cancel
Save