mvpola2e5
/
gitProject
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

210340163 王宇航<代码注释>

Browse Source
yangfuyin_branch
gitProject 2 years ago
parent b4ed2ba7f3
commit 8ed1c0cb9b
9 changed files with 267 additions and 264 deletions
Show Stats Download Patch File Download Diff File

22
src/main/java/net/micode/notes/gtask/data/MetaData.java
Unescape View File

@ -25,14 +25,14 @@ import org.json.JSONException;
import org.json.JSONObject;
public class MetaData extends Task {
private final static String TAG = MetaData.class.getSimpleName();
public class MetaData extends Task //创建一个继承成Task类的类
private final static String TAG = MetaData.class.getSimpleName();//实现过程：调用getSimpleName ()函数,得到类的简写名称存入字符串TAG中
private String mRelatedGid = null;
public void setMeta(String gid, JSONObject metaInfo) {
public void setMeta(String gid, JSONObject metaInfo) {//获取相关联的Gid
try {
metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);//将这对键值放入metaInfo这个jsonobject对象中
} catch (JSONException e) {
Log.e(TAG, "failed to put related gid");
}
@ -42,19 +42,19 @@ public class MetaData extends Task {
public String getRelatedGid() {
return mRelatedGid;
}
}//判断当前数据是否为空，若为空则返回真即值得保存
@Override
public boolean isWorthSaving() {
return getNotes() != null;
}
}//调用父类Task中的setContentByRemoteJSON ()函数，使用远程json数据对象设置元数据内
@Override
public void setContentByRemoteJSON(JSONObject js) {
public void setContentByRemoteJSON(JSONObject js) {//调用父类Task中的setContentByRemoteJSON ()函数，使用远程json数据对象设置元数据内容
super.setContentByRemoteJSON(js);
if (getNotes() != null) {
try {
JSONObject metaInfo = new JSONObject(getNotes().trim());
JSONObject metaInfo = new JSONObject(getNotes().trim());//trim():去掉字符串首尾的空格
mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
} catch (JSONException e) {
Log.w(TAG, "failed to get related gid");
@ -64,18 +64,18 @@ public class MetaData extends Task {
}
@Override
public void setContentByLocalJSON(JSONObject js) {
public void setContentByLocalJSON(JSONObject js) {//使用本地json数据对象设置元数据内容，一般不会用到，若用到，则抛出异常
// this function should not be called
throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
}
@Override
public JSONObject getLocalJSONFromContent() {
public JSONObject getLocalJSONFromContent() {//从元数据内容中获取本地json对象，抛出异常
throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
}
@Override
public int getSyncAction(Cursor c) {
public int getSyncAction(Cursor c) {//获取同步动作状态
throw new IllegalAccessError("MetaData:getSyncAction should not be called");
}

20
src/main/java/net/micode/notes/gtask/data/Node.java
Unescape View File

@ -20,9 +20,9 @@ import android.database.Cursor;
import org.json.JSONObject;
public abstract class Node {
public abstract class Node {//同步操作的基础数据类型，定义了相关指示同步操作的常量
public static final int SYNC_ACTION_NONE = 0;
//定义了各种用于表征同步状态的常量，需要操作标识
public static final int SYNC_ACTION_ADD_REMOTE = 1;
public static final int SYNC_ACTION_ADD_LOCAL = 2;
@ -40,22 +40,22 @@ public abstract class Node {
public static final int SYNC_ACTION_ERROR = 8;
private String mGid;
private String mName;
//记录最后一次修改时间
private String mName;//bool类型，表明表征是否被删除
private long mLastModified;
private boolean mDeleted;
public Node() {
public Node() {//构造函数，进行初始化，界面没有，名字为空，最后一次修改时间为0（没有修改），表征是否删除。
mGid = null;
mName = "";
mLastModified = 0;
mDeleted = false;
}
//函数：定义为一个抽象的函数，在TaskList子类中得到了实现
public abstract JSONObject getCreateAction(int actionId);
//主要功能：声明JSONObject对象抽象类，获取初始行为，参数为GTASK_JSON_ACTION_ID
public abstract JSONObject getUpdateAction(int actionId);
public abstract void setContentByRemoteJSON(JSONObject js);
@ -69,11 +69,11 @@ public abstract class Node {
public void setGid(String gid) {
this.mGid = gid;
}
//行到底部，都是一些赋值和返回值函数，即对构造函数中的对象进行赋值或者获取对象的具体内容。
public void setName(String name) {
this.mName = name;
}
//设置删除标识
public void setLastModified(long lastModified) {
this.mLastModified = lastModified;
}
@ -97,5 +97,5 @@ public abstract class Node {
public boolean getDeleted() {
return this.mDeleted;
}
//获取删除标识
}

56
src/main/java/net/micode/notes/gtask/data/SqlData.java
Unescape View File

@ -35,18 +35,18 @@ import org.json.JSONException;
import org.json.JSONObject;
public class SqlData {
public class SqlData {//公开类， 数据库类
private static final String TAG = SqlData.class.getSimpleName();
//调用getSimpleName ()函数来得到类的简写名称存入字符串TAG中
private static final int INVALID_ID = -99999;
public static final String[] PROJECTION_DATA = new String[] {
public static final String[] PROJECTION_DATA = new String[] {//新建一个字符串数组，集合了 interface DataColumns 中所有SF常量
DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
DataColumns.DATA3
};
//代码块：与sqlNote中定义的常量是相类似的，是一些列的序号
public static final int DATA_ID_COLUMN = 0;
//数据列的这一行表示的项的mime类型
public static final int DATA_MIME_TYPE_COLUMN = 1;
public static final int DATA_CONTENT_COLUMN = 2;
@ -56,24 +56,24 @@ public class SqlData {
public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
private ContentResolver mContentResolver;
//定义以下8个内部变量
private boolean mIsCreate;
//判断是否直接用Content生成，是为true，否则为false
private long mDataId;
private String mDataMimeType;
//数据mime类型
private String mDataContent;
//数据内容
private long mDataContentData1;
private String mDataContentData3;
private ContentValues mDiffDataValues;
public SqlData(Context context) {
//contenvalues只能存储基本类型的数据，像string，int之类的
public SqlData(Context context) {//构造函数，初始化数据，参数类型为Context
mContentResolver = context.getContentResolver();
mIsCreate = true;
mIsCreate = true;//mIsCreate为TRUE是这种构造方式的标志
mDataId = INVALID_ID;
mDataMimeType = DataConstants.NOTE;
mDataContent = "";
@ -81,7 +81,7 @@ public class SqlData {
mDataContentData3 = "";
mDiffDataValues = new ContentValues();
}
//第二种SqlData的构造方式，通过cursor来获取数据
public SqlData(Context context, Cursor c) {
mContentResolver = context.getContentResolver();
mIsCreate = false;
@ -89,7 +89,7 @@ public class SqlData {
mDiffDataValues = new ContentValues();
}
private void loadFromCursor(Cursor c) {
private void loadFromCursor(Cursor c) {//构造函数，初始化数据，参数类型分别为 Context 和 Cursor
mDataId = c.getLong(DATA_ID_COLUMN);
mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
mDataContent = c.getString(DATA_CONTENT_COLUMN);
@ -97,14 +97,14 @@ public class SqlData {
mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
}
public void setContent(JSONObject js) throws JSONException {
public void setContent(JSONObject js) throws JSONException {//设置用于共享的数据，并提供异常抛出与处理机制，其中很多if 条件语句的判断，某些条件下某些特定的操作
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
if (mIsCreate || mDataId != dataId) {
mDiffDataValues.put(DataColumns.ID, dataId);
}
mDataId = dataId;
String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)//如果传入的JSONObject对象有DataColumns.MIME_TYPE一项，则设置dataMimeType为这个，否则设为SqlData.java
: DataConstants.NOTE;
if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
@ -116,12 +116,12 @@ public class SqlData {
mDiffDataValues.put(DataColumns.CONTENT, dataContent);
}
mDataContent = dataContent;
//以原有数据文本类型为基础，修改共享数据文本类型
long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
if (mIsCreate || mDataContentData1 != dataContentData1) {
mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
}
mDataContentData1 = dataContentData1;
mDataContentData1 = dataContentData1;//共享数据同步后，共享1类型数据等于该1类型数据
String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
@ -129,7 +129,7 @@ public class SqlData {
}
mDataContentData3 = dataContentData3;
}
//获取共享数据内容及提供异常抛出与处理机制
public JSONObject getContent() throws JSONException {
if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet");
@ -143,12 +143,12 @@ public class SqlData {
js.put(DataColumns.DATA3, mDataContentData3);
return js;
}
//将当前数据提交到数据库
public void commit(long noteId, boolean validateVersion, long version) {
//commit 函数用于把当前所做的修改保存到数据库
if (mIsCreate) {
if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
mDiffDataValues.remove(DataColumns.ID);
mDiffDataValues.remove(DataColumns.ID);//更新共享数据，键为NOTE_ID，值为noteId
}
mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
@ -162,28 +162,28 @@ public class SqlData {
} else {
if (mDiffDataValues.size() > 0) {
int result = 0;
if (!validateVersion) {
if (!validateVersion) {//如果版本还没确认，则结果记录下的只是data的ID，还有data内容
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
} else {
result = mContentResolver.update(ContentUris.withAppendedId(
result = mContentResolver.update(ContentUris.withAppendedId(//若版本号确认，则对对应id进行更新，
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
" ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+ " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
String.valueOf(noteId), String.valueOf(version)
});
});//更新不存在，可能是用户在同步时已更新
}
if (result == 0) {
Log.w(TAG, "there is no update. maybe user updates note when syncing");
}
}//如果更新不存在（或许用户在同步时已经完成更新），则报错c
}
}
mDiffDataValues.clear();
mDiffDataValues.clear();//回到初始化，清空，表示已经更新
mIsCreate = false;
}
public long getId() {
return mDataId;
}
}//获取当前id
}

164
src/main/java/net/micode/notes/gtask/data/SqlNote.java
Unescape View File

@ -38,12 +38,12 @@ import org.json.JSONObject;
import java.util.ArrayList;
public class SqlNote {
public class SqlNote {//调用getSimpleName ()函数得到类的简写名称存入字符串TAG中
private static final String TAG = SqlNote.class.getSimpleName();
//语句：调用getSimpleName()函数将类的简写名称存到字符串TAG中
private static final int INVALID_ID = -99999;
public static final String[] PROJECTION_NOTE = new String[] {
public static final String[] PROJECTION_NOTE = new String[] {//集合了interface NoteColumns中所有SF常量（17个）
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,
@ -51,7 +51,7 @@ public class SqlNote {
NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID,
NoteColumns.VERSION
};
//定义每列的属性：
public static final int ID_COLUMN = 0;
public static final int ALERTED_DATE_COLUMN = 1;
@ -86,7 +86,7 @@ public class SqlNote {
public static final int VERSION_COLUMN = 16;
private Context mContext;
private Context mContext;//以下定义了17个内部变量，其中12个可以由content获得，5个需要初始化为0或者new
private ContentResolver mContentResolver;
@ -121,59 +121,59 @@ public class SqlNote {
private ContentValues mDiffNoteValues;
private ArrayList<SqlData> mDataList;
public SqlNote(Context context) {
//SqlNote第一种构造方法，只通过上下文context构造
public SqlNote(Context context) {//构造函数参数只有context，对所有的变量进行初始化
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = true;
mId = INVALID_ID;
mIsCreate = true;//对象不存在，是要新建的
mId = INVALID_ID;//无效用户
mAlertDate = 0;
mBgColorId = ResourceParser.getDefaultBgId(context);
mCreatedDate = System.currentTimeMillis();
mBgColorId = ResourceParser.getDefaultBgId(context);//系统默认背景
mCreatedDate = System.currentTimeMillis();//调用系统函数获取创建时间
mHasAttachment = 0;
mModifiedDate = System.currentTimeMillis();
mParentId = 0;
mSnippet = "";
mType = Notes.TYPE_NOTE;
mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;//控件Id初始化
mWidgetType = Notes.TYPE_WIDGET_INVALIDE;//控件类型初始化
mOriginParent = 0;
mVersion = 0;
mDiffNoteValues = new ContentValues();
mDataList = new ArrayList<SqlData>();
mDiffNoteValues = new ContentValues();//新建一个NoteValues值，用来记录改变的values
mDataList = new ArrayList<SqlData>();// 新建一个data的列表
}
public SqlNote(Context context, Cursor c) {
public SqlNote(Context context, Cursor c) {//构造函数有context和一个数据库的cursor两个参数，多数变量通过cursor指向的一条记录直接进行初始化
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = false;
loadFromCursor(c);
mDataList = new ArrayList<SqlData>();
if (mType == Notes.TYPE_NOTE)
if (mType == Notes.TYPE_NOTE)//如果是note类型，则调用下面的 loadDataContent()函数，加载数据内容
loadDataContent();
mDiffNoteValues = new ContentValues();
}
public SqlNote(Context context, long id) {
public SqlNote(Context context, long id) {//构造函数，两个参数
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = false;
loadFromCursor(id);
loadFromCursor(id);//调用下面的 loadFromCursor函数，通过ID从光标处加载数据
mDataList = new ArrayList<SqlData>();
if (mType == Notes.TYPE_NOTE)
if (mType == Notes.TYPE_NOTE)//如果是数据是便签类型，则加载数据内容
loadDataContent();
mDiffNoteValues = new ContentValues();
}
private void loadFromCursor(long id) {
//通过id从cursor加载数据
private void loadFromCursor(long id) {//通过id从光标处加载数据
Cursor c = null;
try {
try {//通过try避免异常
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
new String[] {
String.valueOf(id)
}, null);
if (c != null) {
}, null);//如果获取成功，则cursor移动到下一条记录，并加载该记录
if (c != null) {//代码块：如果有内容就将移入文档，并再次等待光标的内容
c.moveToNext();
loadFromCursor(c);
} else {
@ -184,9 +184,9 @@ public class SqlNote {
c.close();
}
}
private void loadFromCursor(Cursor c) {
mId = c.getLong(ID_COLUMN);
//通过cursor从cursor处加载数据
private void loadFromCursor(Cursor c) {//通过游标从光标处加载数据
mId = c.getLong(ID_COLUMN);//直接从一条记录中的获得以下变量的初始值
mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
mBgColorId = c.getInt(BG_COLOR_ID_COLUMN);
mCreatedDate = c.getLong(CREATED_DATE_COLUMN);
@ -199,22 +199,22 @@ public class SqlNote {
mWidgetType = c.getInt(WIDGET_TYPE_COLUMN);
mVersion = c.getLong(VERSION_COLUMN);
}
private void loadDataContent() {
//取ID对应content内容，如果查询到该note的id确实有对应项，即cursor有对应，获取ID对应content内容
private void loadDataContent() {//通过content机制获取共享数据并加载到数据库当前游标处
Cursor c = null;
mDataList.clear();
try {
c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
try {//获取ID对应content内容
c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,//获得该ID对应的数据内容
"(note_id=?)", new String[] {
String.valueOf(mId)
}, null);
if (c != null) {
if (c != null) {//如果光标处无内容，提示note无数据warning
if (c.getCount() == 0) {
Log.w(TAG, "it seems that the note has not data");
return;
}
while (c.moveToNext()) {
SqlData data = new SqlData(mContext, c);
SqlData data = new SqlData(mContext, c);//将获取数据存入数据表
mDataList.add(data);
}
} else {
@ -225,23 +225,23 @@ public class SqlNote {
c.close();
}
}
public boolean setContent(JSONObject js) {
//设置content共享信息
public boolean setContent(JSONObject js) {//设置通过content机制用于共享的数据信息
try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {//不能设置系统文件
Log.w(TAG, "cannot set system folder");
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_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
String snippet = note.has(NoteColumns.SNIPPET) ? note//如果共享数据存在摘要，则将其赋给声明的 snippet变量，否则变量为空
.getString(NoteColumns.SNIPPET) : "";
if (mIsCreate || !mSnippet.equals(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;
: Notes.TYPE_NOTE;//以下操作都和上面对snippet的操作一样，一起根据共享的数据设置SqlNote内容的上述17项
if (mIsCreate || mType != type) {
mDiffNoteValues.put(NoteColumns.TYPE, type);
}
@ -252,21 +252,21 @@ public class SqlNote {
if (mIsCreate || mId != id) {
mDiffNoteValues.put(NoteColumns.ID, id);
}
mId = id;
mId = id;//将该ID覆盖原ID
long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note
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
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;
mBgColorId = bgColorId;/将该背景颜色覆盖原背景颜色
long createDate = note.has(NoteColumns.CREATED_DATE) ? note
.getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
@ -275,66 +275,66 @@ public class SqlNote {
}
mCreatedDate = createDate;
int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note
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
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;
mModifiedDate = modifiedDate;//将该父节点ID覆盖原父节点ID
long parentId = note.has(NoteColumns.PARENT_ID) ? note
.getLong(NoteColumns.PARENT_ID) : 0;
if (mIsCreate || mParentId != parentId) {
if (mIsCreate || mParentId != parentId) {//如果只是通过上下文对note进行数据库操作，或者该文本片段与原文本片段不相同，
mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
}
mParentId = parentId;
String snippet = note.has(NoteColumns.SNIPPET) ? note
String snippet = note.has(NoteColumns.SNIPPET) ? note//如果只是通过上下文对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)
int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)//对类型操作
: Notes.TYPE_NOTE;
if (mIsCreate || mType != type) {
if (mIsCreate || mType != type) {//如果只是通过上下文对note进行数据库操作，或者该文件类型与原文件类型不相同
mDiffNoteValues.put(NoteColumns.TYPE, type);
}
mType = type;
int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)
int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)//对控件操作
: AppWidgetManager.INVALID_APPWIDGET_ID;
if (mIsCreate || mWidgetId != widgetId) {
if (mIsCreate || mWidgetId != widgetId) {//如果只是通过上下文对note进行数据库操作，或者该小部件ID与原小部件ID不相同
mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
}
mWidgetId = widgetId;
int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
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;
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);
}
mOriginParent = originParent;
mOriginParent = originParent;//将该原始父文件夹ID覆盖原原始父文件夹ID
for (int i = 0; i < dataArray.length(); i++) {
for (int i = 0; i < dataArray.length(); i++) {//遍历 dataArray，查找 id 为 dataId 的数据
JSONObject data = dataArray.getJSONObject(i);
SqlData sqlData = null;
if (data.has(DataColumns.ID)) {
if (data.has(DataColumns.ID)) {//该数据ID对应的数据如果存在，将对应的数据存在数据库中
long dataId = data.getLong(DataColumns.ID);
for (SqlData temp : mDataList) {
if (dataId == temp.getId()) {
@ -348,10 +348,10 @@ public class SqlNote {
mDataList.add(sqlData);
}
sqlData.setContent(data);
sqlData.setContent(data);//最后为数据库数据进行设置
}
}
} catch (JSONException e) {
} catch (JSONException e) {//出现JSONException时，日志显示错误，同时打印堆栈轨迹
Log.e(TAG, e.toString());
e.printStackTrace();
return false;
@ -359,7 +359,7 @@ public class SqlNote {
return true;
}
public JSONObject getContent() {
public JSONObject getContent() {//获取content机制提供的数据并加载到note中
try {
JSONObject js = new JSONObject();
@ -368,7 +368,7 @@ public class SqlNote {
return null;
}
JSONObject note = new JSONObject();
JSONObject note = new JSONObject();//新建变量note用于传输共享数据
if (mType == Notes.TYPE_NOTE) {
note.put(NoteColumns.ID, mId);
note.put(NoteColumns.ALERTED_DATE, mAlertDate);
@ -385,14 +385,14 @@ public class SqlNote {
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
JSONArray dataArray = new JSONArray();
for (SqlData sqlData : mDataList) {
for (SqlData sqlData : mDataList) {//将note中的data全部存入JSONArray中
JSONObject data = sqlData.getContent();
if (data != null) {
dataArray.put(data);
}
}
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) {//folder类型或system类型
note.put(NoteColumns.ID, mId);
note.put(NoteColumns.TYPE, mType);
note.put(NoteColumns.SNIPPET, mSnippet);
@ -400,14 +400,14 @@ public class SqlNote {
}
return js;
} catch (JSONException e) {
} catch (JSONException e) {//捕获json类型异常，显示错误，打印堆栈痕迹
Log.e(TAG, e.toString());
e.printStackTrace();
}
return null;
}
public void setParentId(long id) {
public void setParentId(long id) {//给当前id设置父id
mParentId = id;
mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
}
@ -415,38 +415,38 @@ public class SqlNote {
public void setGtaskId(String gid) {
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
}
//给当前id设置Gtaskid
public void setSyncId(long syncId) {
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
}
//给当前id设置同步id
public void resetLocalModified() {
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
}
//初始化本地修改，即撤销所有当前修改
public long getId() {
return mId;
}
//获取当前 id
public long getParentId() {
return mParentId;
}
//获得当前id的父id
public String getSnippet() {
return mSnippet;
}
//获取小片段即用于显示的部分便签内容
public boolean isNoteType() {
return mType == Notes.TYPE_NOTE;
}
public void commit(boolean validateVersion) {
//判断是否为便签类型
public void commit(boolean validateVersion) {//commit函数用于把当前造作所做的修改保存到数据库
if (mIsCreate) {
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
mDiffNoteValues.remove(NoteColumns.ID);
}
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);//内容解析器中插入该便签的uri
try {
mId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
@ -463,9 +463,9 @@ public class SqlNote {
}
}
} else {
if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {//对无效id操作
Log.e(TAG, "No such note");
throw new IllegalStateException("Try to update note with invalid id");
throw new IllegalStateException("Try to update note with invalid id");//尝试以无效 id 更新 note
}
if (mDiffNoteValues.size() > 0) {
mVersion ++;
@ -482,12 +482,12 @@ public class SqlNote {
String.valueOf(mId), String.valueOf(mVersion)
});
}
if (result == 0) {
if (result == 0) {//如果内容解析器没有更新，那么报错：没有更新，或许用户在同步时进行更新
Log.w(TAG, "there is no update. maybe user updates note when syncing");
}
}
if (mType == Notes.TYPE_NOTE) {
if (mType == Notes.TYPE_NOTE) {//note 类型
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, validateVersion, mVersion);
}
@ -495,11 +495,11 @@ public class SqlNote {
}
// refresh local info
loadFromCursor(mId);
loadFromCursor(mId);//通过 cursor 从当前 id 处加载数据
if (mType == Notes.TYPE_NOTE)
loadDataContent();
mDiffNoteValues.clear();
mIsCreate = false;
mIsCreate = false;//改变数据库构造模式
}
}

84
src/main/java/net/micode/notes/gtask/data/Task.java
Unescape View File

@ -32,9 +32,9 @@ 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();
//调用 getSimpleName ()函数来得到类的简写名称并存入字符串TAG中
private boolean mCompleted;
private String mNotes;
@ -45,16 +45,16 @@ public class Task extends Node {
private TaskList mParent;
public Task() {
public Task() {//Task类的构造函数，对对象进行初始化
super();
mCompleted = false;
mCompleted = false;//接下来是对类的变量进行初始化
mNotes = null;
mPriorSibling = null;
mParent = null;
mMetaInfo = null;
}
public JSONObject getCreateAction(int actionId) {
public JSONObject getCreateAction(int actionId) {//对操作号即actionId 进行一些操作的公用函数
JSONObject js = new JSONObject();
try {
@ -69,12 +69,12 @@ public class Task extends Node {
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
// entity_delta
JSONObject entity = new JSONObject();
JSONObject entity = new JSONObject();//创建实体数据并将name，创建者id，实体类型存入数据
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_TASK);
if (getNotes() != null) {
if (getNotes() != null) {//如果存在 notes ，则将其也放入 entity 中
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
}
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
@ -94,7 +94,7 @@ public class Task extends Node {
js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
}
} catch (JSONException e) {
} catch (JSONException e) {//抛出异常处理机制
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("fail to generate task-create jsonobject");
@ -103,10 +103,10 @@ public class Task extends Node {
return js;
}
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
public JSONObject getUpdateAction(int actionId) {//接收更新action
JSONObject js = new JSONObject();//声明并初始化
try {
try {//同样是使用try和catch进行异常处理操作
// action_type
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
@ -126,7 +126,7 @@ public class Task extends Node {
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) {
} catch (JSONException e) {//获取异常类型和异常详细消息
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("fail to generate task-update jsonobject");
@ -175,22 +175,22 @@ public class Task extends Node {
}
}
public void setContentByLocalJSON(JSONObject js) {
public void setContentByLocalJSON(JSONObject js) {//通过本地的json设置内容
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
|| !js.has(GTaskStringUtils.META_HEAD_DATA)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");//那么反馈给用户出错信息
}
try {
try {//否则进行try和catch的异常处理操作
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++) {
for (int i = 0; i < dataArray.length(); i++) {//遍历数据数组
JSONObject data = dataArray.getJSONObject(i);
if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
setName(data.getString(DataColumns.CONTENT));
@ -204,7 +204,7 @@ public class Task extends Node {
}
}
public JSONObject getLocalJSONFromContent() {
public JSONObject getLocalJSONFromContent() {//从content获取本地json
String name = getName();
try {
if (mMetaInfo == null) {
@ -214,7 +214,7 @@ public class Task extends Node {
return null;
}
JSONObject js = new JSONObject();
JSONObject js = new JSONObject();//初始化四个指针
JSONObject note = new JSONObject();
JSONArray dataArray = new JSONArray();
JSONObject data = new JSONObject();
@ -224,12 +224,12 @@ public class Task extends Node {
note.put(NoteColumns.TYPE, Notes.TYPE_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);
for (int i = 0; i < dataArray.length(); i++) {
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)) {
data.put(DataColumns.CONTENT, getName());
@ -247,8 +247,8 @@ public class Task extends Node {
}
}
public void setMetaInfo(MetaData metaData) {
if (metaData != null && metaData.getNotes() != null) {
public void setMetaInfo(MetaData metaData) {//设置元数据信息
if (metaData != null && metaData.getNotes() != null) {//如果元数据存在且能够获取到文本信息
try {
mMetaInfo = new JSONObject(metaData.getNotes());
} catch (JSONException e) {
@ -258,32 +258,32 @@ public class Task extends Node {
}
}
public int getSyncAction(Cursor c) {
public int getSyncAction(Cursor c) {//设置同步action
try {
JSONObject noteInfo = null;
if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {//代码块：元数据信息不为空并且元数据信息还含有“META_HEAD_NOTE”，说明便签存在
noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
}
if (noteInfo == null) {
if (noteInfo == null) {//云端便签 id 已被删除，不存在，返回更新本地数据的同步行为
Log.w(TAG, "it seems that note meta has been deleted");
return SYNC_ACTION_UPDATE_REMOTE;
}
if (!noteInfo.has(NoteColumns.ID)) {
if (!noteInfo.has(NoteColumns.ID)) {//匹配note的id
Log.w(TAG, "remote note id seems to be deleted");
return SYNC_ACTION_UPDATE_LOCAL;
}
// validate the note id now
if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {//代码块：信息不匹配
Log.w(TAG, "note id doesn't match");
return SYNC_ACTION_UPDATE_LOCAL;
}
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()) {
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {//最近一次修改的 id 匹配成功，返回无的同步行为
// no update both side
return SYNC_ACTION_NONE;
} else {
@ -292,11 +292,11 @@ public class Task extends Node {
}
} else {
// validate gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {//判断gtask的id与获取的id是否匹配
Log.e(TAG, "gtask id doesn't match");
return SYNC_ACTION_ERROR;
}
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {//本地id与云端id一致，即更新云端
// local modification only
return SYNC_ACTION_UPDATE_REMOTE;
} else {
@ -311,7 +311,7 @@ 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);
}
@ -319,33 +319,33 @@ public class Task extends Node {
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;
}
//获取 task 是否修改完毕的记录
public String getNotes() {
return this.mNotes;
}
//获取成员变量 mNotes 的信息
public Task getPriorSibling() {
return this.mPriorSibling;
}
//获取优先兄弟 task
public TaskList getParent() {
return this.mParent;
}
//获取父节点列表
}

85
src/main/java/net/micode/notes/gtask/data/TaskList.java
Unescape View File

@ -30,20 +30,20 @@ import org.json.JSONObject;
import java.util.ArrayList;
public class TaskList extends Node {
public class TaskList extends Node {//创建继承 Node的任务表类
private static final String TAG = TaskList.class.getSimpleName();
//调用getSimplename（）函数获取名字并赋值给TAG作为标记
private int mIndex;
//当前Tasklist的指针
private ArrayList<Task> mChildren;
public TaskList() {
//类中主要的保存数据的单元，用来实现一个以Task为元素的ArrayList
public TaskList() {//TaskList 的构造函数
super();
mChildren = new ArrayList<Task>();
mIndex = 1;
}
public JSONObject getCreateAction(int actionId) {
public JSONObject getCreateAction(int actionId) {//生成并返回一个包含了一定数据的JSONObject实体
JSONObject js = new JSONObject();
try {
@ -74,10 +74,11 @@ public class TaskList extends Node {
return js;
}
public JSONObject getUpdateAction(int actionId) {
public JSONObject getUpdateAction(int actionId) {//参考net.micode.notes.gtask.data.Node#getUpdateAction(int)
生成并返回一个包含了一定数据的JSONObject实体
JSONObject js = new JSONObject();
try {
try {//初始化 js 中的数据
// action_type
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
@ -94,34 +95,34 @@ public class TaskList extends Node {
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) {
} catch (JSONException e) {//代码块：处理异常信息
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("fail to generate tasklist-update jsonobject");
throw new ActionFailureException("fail to generate tasklist-update jsonobject");//生成更新任务列表的 JSONObject 失败，抛出异常
}
return js;
}
public void setContentByRemoteJSON(JSONObject js) {
if (js != null) {
public void setContentByRemoteJSON(JSONObject js) {//通过云端 JSON 数据设置实例化对象 js 的内容
if (js != null) {//判断js对象是否为空，如果为空即没有内容就不需要进行设置了
try {
// id
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {//若 js 中存在 GTASK_JSON_NAME 信息
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
}
// last_modified
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {//若 js 中存在 GTASK_JSON_NAME 信息
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
}
// name
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {//语句块：对任务的name进行设置
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
}
} catch (JSONException e) {
} catch (JSONException e) {//代码块：处理异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("fail to get tasklist content from jsonobject");
@ -129,14 +130,14 @@ 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)) {
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);
@ -157,17 +158,17 @@ public class TaskList extends Node {
}
}
public JSONObject getLocalJSONFromContent() {
public JSONObject getLocalJSONFromContent() {//通过 Content 机制获取本地 JSON 数据
try {
JSONObject js = new JSONObject();
JSONObject folder = new JSONObject();
String folderName = getName();
if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))//代码块：如果获取的文件夹名称是以[MIUI_Notes]开头，则文件夹名称应删掉前缀
folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
folderName.length());
folder.put(NoteColumns.SNIPPET, folderName);
if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)//代码块：这里与上一个函数setContentByRemoteJSON(JSONObject js)是一个逆过程，可以参看上一个函数是如何构造出foldername的
|| folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
else
@ -183,7 +184,7 @@ public class TaskList extends Node {
}
}
public int getSyncAction(Cursor c) {
public int getSyncAction(Cursor c) {//通过 cursor 获取同步信息
try {
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
// there is no local update
@ -208,7 +209,7 @@ public class TaskList extends Node {
return SYNC_ACTION_UPDATE_REMOTE;
}
}
} catch (Exception e) {
} catch (Exception e) {//获取异常类型和异常详细消息
Log.e(TAG, e.toString());
e.printStackTrace();
}
@ -218,9 +219,9 @@ public class TaskList extends Node {
public int getChildTaskCount() {
return mChildren.size();
}
}//获得TaskList的大小，即mChildren的大小，mChildren 是TaskList 的一个实例
public boolean addChildTask(Task task) {
public boolean addChildTask(Task task) {//在当前任务表末尾添加新的任务。
boolean ret = false;
if (task != null && !mChildren.contains(task)) {
ret = mChildren.add(task);
@ -234,13 +235,13 @@ public class TaskList extends Node {
return ret;
}
public boolean addChildTask(Task task, int index) {
if (index < 0 || index > mChildren.size()) {
public boolean addChildTask(Task task, int index) {//在当前任务表中的索引位置添加新的子任务
if (index < 0 || index > mChildren.size()) {//任务非空且任务表中不存在该任务
Log.e(TAG, "add child task: invalid index");
return false;
}
int pos = mChildren.indexOf(task);
int pos = mChildren.indexOf(task);//获取要添加的任务在任务表中的位置
if (task != null && pos == -1) {
mChildren.add(index, task);
@ -252,7 +253,7 @@ public class TaskList extends Node {
if (index != mChildren.size() - 1)
afterTask = mChildren.get(index + 1);
task.setPriorSibling(preTask);
task.setPriorSibling(preTask);//使得三个任务前后连在一块
if (afterTask != null)
afterTask.setPriorSibling(task);
}
@ -260,19 +261,19 @@ public class TaskList extends Node {
return true;
}
public boolean removeChildTask(Task task) {
public boolean removeChildTask(Task task) {//删除TaskList中的一个Task
boolean ret = false;
int index = mChildren.indexOf(task);
if (index != -1) {
ret = mChildren.remove(task);
if (ret) {
if (ret) {//如果删除成功，就要将该任务的优先兄弟任务和父任务设置为空
// reset prior sibling and parent
task.setPriorSibling(null);
task.setParent(null);
// update the task list
if (index != mChildren.size()) {
if (index != mChildren.size()) {//代码块：删除成功后，要对任务列表进行更新
mChildren.get(index).setPriorSibling(
index == 0 ? null : mChildren.get(index - 1));
}
@ -281,14 +282,14 @@ public class TaskList extends Node {
return ret;
}
public boolean moveChildTask(Task task, int index) {
public boolean moveChildTask(Task task, int index) {//将当前TaskList中含有的某个Task移到index位置
if (index < 0 || index >= mChildren.size()) {
if (index < 0 || index >= mChildren.size()) {//代码块：首先判断移动的位置是不是合法的
Log.e(TAG, "move child task: invalid index");
return false;
}
int pos = mChildren.indexOf(task);
int pos = mChildren.indexOf(task);//task不在列表中
if (pos == -1) {
Log.e(TAG, "move child task: the task should in the list");
return false;
@ -299,7 +300,7 @@ public class TaskList extends Node {
return (removeChildTask(task) && addChildTask(task, index));
}
public Task findChildTaskByGid(String gid) {
public Task findChildTaskByGid(String gid) {//按gid寻找Task
for (int i = 0; i < mChildren.size(); i++) {
Task t = mChildren.get(i);
if (t.getGid().equals(gid)) {
@ -311,16 +312,16 @@ public class TaskList extends Node {
public int getChildTaskIndex(Task task) {
return mChildren.indexOf(task);
}
}//返回指定Task的index
public Task getChildTaskByIndex(int index) {
public Task getChildTaskByIndex(int index) {//返回指定index的Task
if (index < 0 || index >= mChildren.size()) {
Log.e(TAG, "getTaskByIndex: invalid index");
return null;
}
return mChildren.get(index);
}
//返回指定gid的任务task
public Task getChilTaskByGid(String gid) {
for (Task task : mChildren) {
if (task.getGid().equals(gid))
@ -331,13 +332,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;
}
}
}//获取任务索引

11
src/main/java/net/micode/notes/gtask/exception/ActionFailureException.java
Unescape View File

@ -14,20 +14,21 @@
* limitations under the License.
*/
package net.micode.notes.gtask.exception;
package net.micode.notes.gtask.exception;//小米便签行为异常处理
public class ActionFailureException extends RuntimeException {
private static final long serialVersionUID = 4425249765923293627L;
//serialVersionUID相当于java类的身份证。
//有版本控制的功能。
public ActionFailureException() {
super();
}
//如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。
public ActionFailureException(String paramString) {
super(paramString);
}
//由于本类是extends的Exception类，所以super调用的是Exception的类，本语句相当于Exception（paramString）
public ActionFailureException(String paramString, Throwable paramThrowable) {
super(paramString, paramThrowable);
}
}
}//具有相同形参paramString和paramThrowable的构造方法来调用父类

11
src/main/java/net/micode/notes/gtask/exception/NetworkFailureException.java
Unescape View File

@ -14,20 +14,21 @@
* limitations under the License.
*/
package net.micode.notes.gtask.exception;
package net.micode.notes.gtask.exception;//小米便签网络异常处理
public class NetworkFailureException extends Exception {
private static final long serialVersionUID = 2107610287180234136L;
//serialVersionUID相当于java类的身份证。主要用于版本控制。
public NetworkFailureException() {
super();
}
public NetworkFailureException(String paramString) {
//不带参数的构造函数，super指向父类
public NetworkFailureException(String paramString)//调用父类具有相同形参paramString的构造方法，相当于Exception(paramString) {
super(paramString);
}
public NetworkFailureException(String paramString, Throwable paramThrowable) {
super(paramString, paramThrowable);
}
}
}//带有两个参数的函数。
调用父类具有相同形参paramString和paramThrowable的构造方法

78
src/main/java/net/micode/notes/model/Note.java
Unescape View File

@ -35,24 +35,24 @@ import java.util.ArrayList;
public class Note {
private ContentValues mNoteDiffValues;
private ContentValues mNoteDiffValues;//ContentValues是用于给其他应用调用小米便签的内容的共享数据
private NoteData mNoteData;
private static final String TAG = "Note";
/**
* Create a new note id for adding a new note to databases
*/
public static synchronized long getNewNoteId(Context context, long folderId) {
// Create a new note in the database
// Create a new note in the database//获取新建便签的编号
ContentValues values = new ContentValues();
long createdTime = System.currentTimeMillis();
long createdTime = System.currentTimeMillis();//读取当前系统时间
values.put(NoteColumns.CREATED_DATE, createdTime);
values.put(NoteColumns.MODIFIED_DATE, createdTime);
values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
values.put(NoteColumns.LOCAL_MODIFIED, 1);
values.put(NoteColumns.PARENT_ID, folderId);
Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
long noteId = 0;
//外部应用对ContentProvider中的数据进行添加、删除、修改和查询操作
long noteId = 0;//实现外部应用对数据的插入删除等操作
try {
noteId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
@ -65,12 +65,12 @@ public class Note {
return noteId;
}
public Note() {
public Note() {//定义两个变量用来存储便签的数据，一个是存储便签属性、一个是存储便签内容
mNoteDiffValues = new ContentValues();
mNoteData = new NoteData();
}
public void setNoteValue(String key, String value) {
public void setNoteValue(String key, String value) {//设置数据库表格的标签属性数据
mNoteDiffValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
@ -79,33 +79,33 @@ public class Note {
public void setTextData(String key, String value) {
mNoteData.setTextData(key, value);
}
//设置数据库表格的标签文本内容的数据
public void setTextDataId(long id) {
mNoteData.setTextDataId(id);
}
//设置文本数据的ID
public long getTextDataId() {
return mNoteData.mTextDataId;
}
//获取文本数据的id
public void setCallDataId(long id) {
mNoteData.setCallDataId(id);
}
//设置电话号码数据的ID
public void setCallData(String key, String value) {
mNoteData.setCallData(key, value);
}
public boolean isLocalModified() {
//得到电话号码数据的ID
public boolean isLocalModified() {//判断是否是本地修改
return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
}
public boolean syncNote(Context context, long noteId) {
public boolean syncNote(Context context, long noteId) {//判断便签是否同步
if (noteId <= 0) {
throw new IllegalArgumentException("Wrong note id:" + noteId);
}
if (!isLocalModified()) {
if (!isLocalModified()) {//如果本地没有发现修改，直接返回1，指示已经同步到数据库中
return true;
}
@ -114,15 +114,15 @@ public class Note {
* {@link NoteColumns#MODIFIED_DATE}. For data safety, though update note fails, we also update the
* note data info
*/
if (context.getContentResolver().update(
if (context.getContentResolver().update(//发现更新错误时，及时反馈错误信息
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
null) == 0) {
Log.e(TAG, "Update note error, should not happen");
// Do not return, fall through
}
mNoteDiffValues.clear();
mNoteDiffValues.clear();//初始化便签特征值
if (mNoteData.isLocalModified()
if (mNoteData.isLocalModified()//判断未同步
&& (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
return false;
}
@ -130,7 +130,7 @@ public class Note {
return true;
}
private class NoteData {
private class NoteData {//定义一个基本的便签内容的数据类，主要包含文本数据和电话号码数据
private long mTextDataId;
private ContentValues mTextDataValues;
@ -141,14 +141,14 @@ public class Note {
private static final String TAG = "NoteData";
public NoteData() {
public NoteData() {//NoteData的构造函数，初始化四个变量
mTextDataValues = new ContentValues();
mCallDataValues = new ContentValues();
mTextDataId = 0;
mCallDataId = 0;
}
boolean isLocalModified() {
boolean isLocalModified() {//下面是上述几个函数的具体实现
return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
}
@ -159,26 +159,26 @@ public class Note {
mTextDataId = id;
}
void setCallDataId(long id) {
void setCallDataId(long id) {//判断ID是否合法
if (id <= 0) {
throw new IllegalArgumentException("Call data id should larger than 0");
}
mCallDataId = id;
}
void setCallData(String key, String value) {
void setCallData(String key, String value) {//设置电话号码数据内容，并且保存修改时间
mCallDataValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
void setTextData(String key, String value) {
void setTextData(String key, String value) {//设置文本数据
mTextDataValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
Uri pushIntoContentResolver(Context context, long noteId) {
Uri pushIntoContentResolver(Context context, long noteId) {//下面函数的作用是将新的数据通过Uri的操作存储到数据库
/**
* Check for safety
*/
@ -186,24 +186,24 @@ public class Note {
throw new IllegalArgumentException("Wrong note id:" + noteId);
}
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();//数据库操作链表
ContentProviderOperation.Builder builder = null;
if(mTextDataValues.size() > 0) {
if(mTextDataValues.size() > 0) {//把文本数据存入DataColumns
mTextDataValues.put(DataColumns.NOTE_ID, noteId);
if (mTextDataId == 0) {
if (mTextDataId == 0) {//uri插入文本数据
mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
mTextDataValues);
try {
setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));
setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));//尝试重新给它设置id
} catch (NumberFormatException e) {
Log.e(TAG, "Insert new text data fail with noteId" + noteId);
Log.e(TAG, "Insert new text data fail with noteId" + noteId);//插入数据失败
mTextDataValues.clear();
return null;
}
} else {
builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(//更新builder对象，追加uri数据和文本ID
Notes.CONTENT_DATA_URI, mTextDataId));
builder.withValues(mTextDataValues);
operationList.add(builder.build());
@ -211,20 +211,20 @@ public class Note {
mTextDataValues.clear();
}
if(mCallDataValues.size() > 0) {
if(mCallDataValues.size() > 0) {//对于电话号码的数据也是和文本数据一样的同步处理
mCallDataValues.put(DataColumns.NOTE_ID, noteId);
if (mCallDataId == 0) {
if (mCallDataId == 0) {//将电话号码的id设定为uri提供的id
mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
mCallDataValues);
try {
try {/异常处理
setCallDataId(Long.valueOf(uri.getPathSegments().get(1)));
} catch (NumberFormatException e) {
Log.e(TAG, "Insert new call data fail with noteId" + noteId);
mCallDataValues.clear();
return null;
}
} else {
} else {// 当电话号码不为新建时，更新电话号码ID
builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mCallDataId));
builder.withValues(mCallDataValues);
@ -232,18 +232,18 @@ public class Note {
}
mCallDataValues.clear();
}
if (operationList.size() > 0) {
//把电话号码数据存入DataColumns
if (operationList.size() > 0) {//存储过程中如果遇到异常，通过如下进行处理
try {
ContentProviderResult[] results = context.getContentResolver().applyBatch(
Notes.AUTHORITY, operationList);
return (results == null || results.length == 0 || results[0] == null) ? null
: ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId);
} catch (RemoteException e) {
} catch (RemoteException e) {//捕捉操作异常并写回日志
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
return null;
} catch (OperationApplicationException e) {
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));//异常日志
return null;
}
}

Write Preview
Loading…
Cancel
Save