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

更新 #4

Merged
p7iam4w8v merged 12 commits from dev into main 2 years ago
Conversation 0 Commits 12 Files Changed 10
10 changed files with 652 additions and 497 deletions
Show Stats Download Patch File Download Diff File

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

@ -38,7 +38,6 @@ public class MetaData extends Task {
}
/*
* 功能描述：判断当前数据是否为空，若为空则返回真即值得保存
* Made By CuiCan
*/
@Override
public boolean isWorthSaving() {
@ -67,7 +66,6 @@ public class MetaData extends Task {
}
/*
* 功能描述：使用本地json数据对象设置元数据内容，一般不会用到，若用到，则抛出异常
* Made By CuiCan
*/
@Override
public void setContentByLocalJSON(JSONObject js) {
@ -79,26 +77,22 @@ public class MetaData extends Task {
}
/*
* 功能描述：从元数据内容中获取本地json对象，一般不会用到，若用到，则抛出异常
* Made By CuiCan
*/
@Override
public JSONObject getLocalJSONFromContent() {
throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
/*
* 传递非法参数异常
* Made By Cui Can
*/
}
/*
* 功能描述：获取同步动作状态，一般不会用到，若用到，则抛出异常
* Made By CuiCan
*/
@Override
public int getSyncAction(Cursor c) {
throw new IllegalAccessError("MetaData:getSyncAction should not be called");
/*
* 传递非法参数异常
* Made By Cui Can
*/
}

73
src/gtask/data/SqlData.java
Unescape View File

@ -6,18 +6,11 @@
*/
package net.micode.notes.gtask.data;
/*
* 功能描述：
* 实现过程：
* 参数注解：
* Made By CuiCan
*/
public class SqlData {
/*
* 功能描述：得到类的简写名称存入字符串TAG中
* 实现过程：调用getSimpleName ()函数
* Made By CuiCan
*/
private static final String TAG = SqlData.class.getSimpleName();
@ -67,8 +60,6 @@ public class SqlData {
* 功能描述：构造函数，用于初始化数据
* 参数注解：mContentResolver用于获取ContentProvider提供的数据
* 参数注解： mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同）
* 参数注解：
* Made By CuiCan
*/
public SqlData(Context context) {
mContentResolver = context.getContentResolver();
@ -86,8 +77,6 @@ public class SqlData {
* 功能描述：构造函数，初始化数据
* 参数注解：mContentResolver用于获取ContentProvider提供的数据
* 参数注解： mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同）
* 参数注解：
* Made By CuiCan
*/
public SqlData(Context context, Cursor c) {
mContentResolver = context.getContentResolver();
@ -99,7 +88,6 @@ public class SqlData {
/*
* 功能描述：从光标处加载数据
* 从当前的光标处将五列的数据加载到该类的对象
* Made By CuiCan
*/
private void loadFromCursor(Cursor c) {
mDataId = c.getLong(DATA_ID_COLUMN);
@ -110,50 +98,54 @@ public class SqlData {
}
/*
* 功能描述：设置用于共享的数据，并提供异常抛出与处理机制
* 参数注解：
* Made By CuiCan
*/
/**
* 设置用于共享的数据，并提供异常抛出与处理机制
*
* @param js 传入的 JSONObject 对象
* @throws JSONException JSON 解析异常
*/
public void setContent(JSONObject js) throws JSONException {
//如果传入的JSONObject对象中有DataColumns.ID这一项，则设置，否则设为INVALID_ID
// 如果传入的 JSONObject 对象中有 DataColumns.ID 这一项，则设置，否则设为 INVALID_ID
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
if (mIsCreate || mDataId != dataId) {
mDiffDataValues.put(DataColumns.ID, dataId);
}
mDataId = dataId;
// 获取数据 MIME 类型，默认为 DataConstants.NOTE
String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
: DataConstants.NOTE;
if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
}
mDataMimeType = dataMimeType;
// 获取数据内容，默认为空字符串
String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
if (mIsCreate || !mDataContent.equals(dataContent)) {
mDiffDataValues.put(DataColumns.CONTENT, dataContent);
}
mDataContent = dataContent;
// 获取数据附加内容 1，默认为 0
long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
if (mIsCreate || mDataContentData1 != dataContentData1) {
mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
}
mDataContentData1 = dataContentData1;
// 获取数据附加内容 3，默认为空字符串
String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
}
mDataContentData3 = dataContentData3;
}
/*
* 功能描述：获取共享的数据内容，并提供异常抛出与处理机制
* 参数注解：
* Made By CuiCan
*/
public JSONObject getContent() throws JSONException {
if (mIsCreate) {
@ -170,37 +162,45 @@ public class SqlData {
return js;
}
/*
* 功能描述：commit函数用于把当前造作所做的修改保存到数据库
* 参数注解：
* Made By CuiCan
*/
/**
* 提交数据变更到数据库
*
* @param noteId 笔记 ID，用于关联数据
* @param validateVersion 是否验证版本信息
* @param version 笔记版本号
*/
public void commit(long noteId, boolean validateVersion, long version) {
// 如果是新创建的数据
if (mIsCreate) {
// 如果数据 ID 无效且差异数据集合包含数据 ID，则移除数据 ID
if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
mDiffDataValues.remove(DataColumns.ID);
}
// 设置笔记 ID，将差异数据插入到数据表
mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
try {
// 从 URI 中获取插入的数据 ID
mDataId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed");
}
} else {
// 如果有数据更新
if (mDiffDataValues.size() > 0) {
int result = 0;
if (!validateVersion) {
// 如果不需要验证版本，直接更新数据表
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
} else {
// 需要验证版本，构造 SQL 语句进行更新
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
" ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+ " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
+ " WHERE " + NoteColumns.VERSION + "=?)", new String[]{
String.valueOf(noteId), String.valueOf(version)
});
}
@ -209,16 +209,15 @@ public class SqlData {
}
}
}
// 清空差异数据集合和创建标志
mDiffDataValues.clear();
mIsCreate = false;
}
/*
* 功能描述：获取当前id
* 实现过程：
* 参数注解：
* Made By CuiCan
*/
public long getId() {
return mDataId;

507
src/gtask/data/SqlNote.java
Unescape View File

@ -5,18 +5,11 @@
*/
package net.micode.notes.gtask.data;
/*
* 功能描述：
* 实现过程：
* 参数注解：
* Made By CuiCan
*/
public class SqlNote {
/*
* 功能描述：得到类的简写名称存入字符串TAG中
* 实现过程：调用getSimpleName ()函数
* Made By CuiCan
*/
private static final String TAG = SqlNote.class.getSimpleName();
@ -106,8 +99,6 @@ public class SqlNote {
/*
* 功能描述：构造函数
* 参数注解： mIsCreate用于标示构造方式
* 参数注解：
* Made By CuiCan
*/
//构造函数只有context，对所有的变量进行初始化
public SqlNote(Context context) {
@ -135,8 +126,6 @@ public class SqlNote {
/*
* 功能描述：构造函数
* 参数注解： mIsCreate用于标示构造方式
* 参数注解：
* Made By CuiCan
*/
//构造函数有context和一个数据库的cursor，多数变量通过cursor指向的一条记录直接进行初始化
public SqlNote(Context context, Cursor c) {
@ -155,8 +144,6 @@ public class SqlNote {
/*
* 功能描述：构造函数
* 参数注解： mIsCreate用于标示构造方式
* 参数注解：
* Made By CuiCan
*/
public SqlNote(Context context, long id) {
mContext = context;
@ -172,7 +159,6 @@ public class SqlNote {
/*
* 功能描述：通过id从光标处加载数据
* Made By CuiCan
*/
private void loadFromCursor(long id) {
Cursor c = null;
@ -196,7 +182,6 @@ public class SqlNote {
/*
* 功能描述：通过游标从光标处加载数据
* Made By CuiCan
*/
private void loadFromCursor(Cursor c) {
//直接从一条记录中的获得以下变量的初始值
@ -216,188 +201,216 @@ public class SqlNote {
/*
* 功能描述：通过content机制获取共享数据并加载到数据库当前游标处
* 参数注解：
* Made By CuiCan
*/
private void loadDataContent() {
Cursor c = null;
mDataList.clear();
Cursor c = null; // 初始化一个游标对象 c
mDataList.clear(); // 清空 mDataList，这可能是一个用于存储从内容提供者检索到的数据的列表
try {
c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
"(note_id=?)", new String[] {
String.valueOf(mId)
}, null);
// 使用内容解析器（mContentResolver）查询 Notes.CONTENT_DATA_URI，根据指定的 note_id 检索数据
c = mContentResolver.query(
Notes.CONTENT_DATA_URI, // 数据的 URI
SqlData.PROJECTION_DATA, // 要检索的列投影
"(note_id=?)", // 选择条件，基于 note_id
new String[] { String.valueOf(mId) }, // 选择条件中的参数，替换 note_id 的占位符
null
);
if (c != null) {
if (c.getCount() == 0) {
Log.w(TAG, "it seems that the note has not data");
Log.w(TAG, "似乎该笔记没有数据"); // 如果游标中没有数据，记录一个警告日志
return;
}
// 遍历游标中的数据，创建 SqlData 对象并添加到 mDataList 中
while (c.moveToNext()) {
SqlData data = new SqlData(mContext, c);
mDataList.add(data);
}
} else {
Log.w(TAG, "loadDataContent: cursor = null");
Log.w(TAG, "loadDataContent: cursor = null"); // 如果游标为空，记录一个警告日志
}
} finally {
if (c != null)
c.close();
c.close(); // 在最终块中确保关闭游标，释放资源
}
}
/*
* 功能描述：设置通过content机制用于共享的数据信息
* 参数注解：
* Made By CuiCan
*/
public boolean setContent(JSONObject js) {
try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
Log.w(TAG, "cannot set system folder");
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
// for folder we can only update the snnipet and type
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : "";
if (mIsCreate || !mSnippet.equals(snippet)) {
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
}
mSnippet = snippet;
int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
: Notes.TYPE_NOTE;
if (mIsCreate || mType != type) {
mDiffNoteValues.put(NoteColumns.TYPE, type);
}
mType = type;
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
if (mIsCreate || mId != id) {
mDiffNoteValues.put(NoteColumns.ID, id);
}
mId = id;
long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note
.getLong(NoteColumns.ALERTED_DATE) : 0;
if (mIsCreate || mAlertDate != alertDate) {
mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);
}
mAlertDate = alertDate;
int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note
.getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
if (mIsCreate || mBgColorId != bgColorId) {
mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);
}
mBgColorId = bgColorId;
long createDate = note.has(NoteColumns.CREATED_DATE) ? note
.getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
if (mIsCreate || mCreatedDate != createDate) {
mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
}
mCreatedDate = createDate;
int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note
.getInt(NoteColumns.HAS_ATTACHMENT) : 0;
if (mIsCreate || mHasAttachment != hasAttachment) {
mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);
}
mHasAttachment = hasAttachment;
long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note
.getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();
if (mIsCreate || mModifiedDate != modifiedDate) {
mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
}
mModifiedDate = modifiedDate;
long parentId = note.has(NoteColumns.PARENT_ID) ? note
.getLong(NoteColumns.PARENT_ID) : 0;
if (mIsCreate || mParentId != parentId) {
mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
}
mParentId = parentId;
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : "";
if (mIsCreate || !mSnippet.equals(snippet)) {
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
}
mSnippet = snippet;
int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
: Notes.TYPE_NOTE;
if (mIsCreate || mType != type) {
mDiffNoteValues.put(NoteColumns.TYPE, type);
}
mType = type;
int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)
: AppWidgetManager.INVALID_APPWIDGET_ID;
if (mIsCreate || mWidgetId != widgetId) {
mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
}
mWidgetId = widgetId;
int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
.getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
if (mIsCreate || mWidgetType != widgetType) {
mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
}
mWidgetType = widgetType;
long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
if (mIsCreate || mOriginParent != originParent) {
mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
}
mOriginParent = originParent;
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
SqlData sqlData = null;
if (data.has(DataColumns.ID)) {
long dataId = data.getLong(DataColumns.ID);
for (SqlData temp : mDataList) {
if (dataId == temp.getId()) {
sqlData = temp;
}
}
}
if (sqlData == null) {
sqlData = new SqlData(mContext);
mDataList.add(sqlData);
}
sqlData.setContent(data);
}
}
} catch (JSONException e) {
Log.e(TAG, e.toString());
e.printStackTrace();
return false;
}
return true;
}
public boolean setContent(JSONObject js) {
try {
// 从传入的 JSON 对象中获取笔记对象
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
// 检查笔记的类型，如果是系统文件夹则记录一个警告日志
if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
Log.w(TAG, "无法设置系统文件夹");
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
// 对于文件夹，只能更新摘要和类型
// 获取摘要，如果没有则设置为空字符串
String snippet = note.has(NoteColumns.SNIPPET) ? note.getString(NoteColumns.SNIPPET) : "";
// 如果是创建操作或者摘要发生变化，则将摘要加入 mDiffNoteValues 中
if (mIsCreate || !mSnippet.equals(snippet)) {
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
}
mSnippet = snippet;
// 获取类型，如果没有则默认为 Notes.TYPE_NOTE
int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE;
// 如果是创建操作或者类型发生变化，则将类型加入 mDiffNoteValues 中
if (mIsCreate || mType != type) {
mDiffNoteValues.put(NoteColumns.TYPE, type);
}
mType = type;
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
// 处理笔记类型为 Note 的情况
// 从 JSON 中获取数据数组
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
// 获取笔记 ID，如果没有则设置为 INVALID_ID
long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
// 如果是创建操作或者 ID 发生变化，则将 ID 加入 mDiffNoteValues 中
if (mIsCreate || mId != id) {
mDiffNoteValues.put(NoteColumns.ID, id);
}
mId = id;
// 获取提醒日期，如果没有则设置为 0
long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note.getLong(NoteColumns.ALERTED_DATE) : 0;
// 如果是创建操作或者提醒日期发生变化，则将提醒日期加入 mDiffNoteValues 中
if (mIsCreate || mAlertDate != alertDate) {
mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);
}
mAlertDate = alertDate;
// 获取背景颜色 ID，如果没有则设置为默认值
int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note.getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
// 如果是创建操作或者背景颜色 ID 发生变化，则将背景颜色 ID 加入 mDiffNoteValues 中
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();
// 如果是创建操作或者创建日期发生变化，则将创建日期加入 mDiffNoteValues 中
if (mIsCreate || mCreatedDate != createDate) {
mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
}
mCreatedDate = createDate;
// 获取是否有附件，如果没有则设置为 0
int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note.getInt(NoteColumns.HAS_ATTACHMENT) : 0;
// 如果是创建操作或者是否有附件发生变化，则将是否有附件加入 mDiffNoteValues 中
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();
// 如果是创建操作或者修改日期发生变化，则将修改日期加入 mDiffNoteValues 中
if (mIsCreate || mModifiedDate != modifiedDate) {
mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
}
mModifiedDate = modifiedDate;
// 获取父级 ID，如果没有则设置为 0
long parentId = note.has(NoteColumns.PARENT_ID) ? note.getLong(NoteColumns.PARENT_ID) : 0;
// 如果是创建操作或者父级 ID 发生变化，则将父级 ID 加入 mDiffNoteValues 中
if (mIsCreate || mParentId != parentId) {
mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
}
mParentId = parentId;
// 获取摘要，如果没有则设置为空字符串
String snippet = note.has(NoteColumns.SNIPPET) ? note.getString(NoteColumns.SNIPPET) : "";
// 如果是创建操作或者摘要发生变化，则将摘要加入 mDiffNoteValues 中
if (mIsCreate || !mSnippet.equals(snippet)) {
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
}
mSnippet = snippet;
// 获取类型，如果没有则默认为 Notes.TYPE_NOTE
int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE;
// 如果是创建操作或者类型发生变化，则将类型加入 mDiffNoteValues 中
if (mIsCreate || mType != type) {
mDiffNoteValues.put(NoteColumns.TYPE, type);
}
mType = type;
// 获取小部件 ID，如果没有则设置为 AppWidgetManager.INVALID_APPWIDGET_ID
int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID) : AppWidgetManager.INVALID_APPWIDGET_ID;
// 如果是创建操作或者小部件 ID 发生变化，则将小部件 ID 加入 mDiffNoteValues 中
if (mIsCreate || mWidgetId != widgetId) {
mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
}
mWidgetId = widgetId;
// 获取小部件类型，如果没有则设置为 Notes.TYPE_WIDGET_INVALIDE
int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note.getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
// 如果是创建操作或者小部件类型发生变化，则将小部件类型加入 mDiffNoteValues 中
if (mIsCreate || mWidgetType != widgetType) {
mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
}
mWidgetType = widgetType;
// 获取原始父级 ID，如果没有则设置为 0
long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
// 如果是创建操作或者原始父级 ID 发生变化，则将原始父级 ID 加入 mDiffNoteValues 中
if (mIsCreate || mOriginParent != originParent) {
mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
}
mOriginParent = originParent;
}
} catch (JSONException e) {
// 如果发生异常，记录错误日志并返回 false
Log.e(TAG, e.toString());
e.printStackTrace();
return false;
}
return true; // 如果没有发生异常，返回 true 表示设置成功
}
/*
* 功能描述：获取content机制提供的数据并加载到note中
* 参数注解：
* Made By CuiCan
*/
public JSONObject getContent() {
try {
JSONObject js = new JSONObject();
// 如果是创建操作而没有在数据库中创建记录，记录一个错误日志并返回 null
if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet");
Log.e(TAG, "似乎我们还没有在数据库中创建这个记录");
return null;
}
JSONObject note = new JSONObject();
if (mType == Notes.TYPE_NOTE) {//类型为note时
// 根据笔记的类型填充 note 对象的属性
if (mType == Notes.TYPE_NOTE) { // 类型为 Note 时
note.put(NoteColumns.ID, mId);
note.put(NoteColumns.ALERTED_DATE, mAlertDate);
note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
@ -411,7 +424,7 @@ public class SqlNote {
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) {
JSONObject data = sqlData.getContent();
@ -420,13 +433,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);
}
return js;
} catch (JSONException e) {
Log.e(TAG, e.toString());
@ -434,11 +447,10 @@ public class SqlNote {
}
return null;
}
/*
* 功能描述：给当前id设置父id
* 参数注解：
* Made By CuiCan
*/
public void setParentId(long id) {
mParentId = id;
@ -447,8 +459,6 @@ public class SqlNote {
/*
* 功能描述：给当前id设置Gtaskid
* 参数注解：
* Made By CuiCan
*/
public void setGtaskId(String gid) {
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
@ -456,8 +466,6 @@ public class SqlNote {
/*
* 功能描述：给当前id设置同步id
* 参数注解：
* Made By CuiCan
*/
public void setSyncId(long syncId) {
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
@ -465,8 +473,6 @@ public class SqlNote {
/*
* 功能描述：初始化本地修改，即撤销所有当前修改
* 参数注解：
* Made By CuiCan
*/
public void resetLocalModified() {
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
@ -474,8 +480,6 @@ public class SqlNote {
/*
* 功能描述：获得当前id
* 参数注解：
* Made By CuiCan
*/
public long getId() {
return mId;
@ -483,8 +487,6 @@ public class SqlNote {
/*
* 功能描述：获得当前id的父id
* 参数注解：
* Made By CuiCan
*/
public long getParentId() {
return mParentId;
@ -492,8 +494,6 @@ public class SqlNote {
/*
* 功能描述：获取小片段即用于显示的部分便签内容
* 参数注解：
* Made By CuiCan
*/
public String getSnippet() {
return mSnippet;
@ -501,8 +501,6 @@ public class SqlNote {
/*
* 功能描述：判断是否为便签类型
* 参数注解：
* Made By CuiCan
*/
public boolean isNoteType() {
return mType == Notes.TYPE_NOTE;
@ -510,69 +508,78 @@ public class SqlNote {
/*
* 功能描述：commit函数用于把当前造作所做的修改保存到数据库
* 参数注解：
* Made By CuiCan
*/
public void commit(boolean validateVersion) {
if (mIsCreate) {
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
mDiffNoteValues.remove(NoteColumns.ID);
}
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
try {
mId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed");
}
if (mId == 0) {
throw new IllegalStateException("Create thread id failed");
}
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {//直接使用sqldata中的实现
sqlData.commit(mId, false, -1);
}
}
} else {
if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
Log.e(TAG, "No such note");
throw new IllegalStateException("Try to update note with invalid id");
}
if (mDiffNoteValues.size() > 0) {
mVersion ++;
int result = 0;
if (!validateVersion) {//构造字符串
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?)", new String[] {
String.valueOf(mId)
});
} else {
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
new String[] {
String.valueOf(mId), String.valueOf(mVersion)
});
}
if (result == 0) {
Log.w(TAG, "there is no update. maybe user updates note when syncing");
}
}
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, validateVersion, mVersion);
}
}
}
// refresh local info
loadFromCursor(mId);
if (mType == Notes.TYPE_NOTE)
loadDataContent();
mDiffNoteValues.clear();
mIsCreate = false;
}
}
public void commit(boolean validateVersion) {
if (mIsCreate) {
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
mDiffNoteValues.remove(NoteColumns.ID);
}
// 将差异的笔记值插入数据库
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
try {
// 获取插入记录的ID并更新到当前对象的mId属性
mId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
Log.e(TAG, "获取笔记ID出错：" + e.toString());
throw new ActionFailureException("创建笔记失败");
}
if (mId == 0) {
throw new IllegalStateException("创建笔记ID失败");
}
// 如果笔记类型为 Notes.TYPE_NOTE，提交关联的 SqlData 列表
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, false, -1);
}
}
} else {
// 更新已存在的笔记
if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
Log.e(TAG, "没有这样的笔记");
throw new IllegalStateException("尝试使用无效ID更新笔记");
}
if (mDiffNoteValues.size() > 0) {
mVersion++;
// 构造更新条件和参数
int result = 0;
if (!validateVersion) {
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?)", new String[] {
String.valueOf(mId)
});
} else {
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
new String[] {
String.valueOf(mId), String.valueOf(mVersion)
});
}
if (result == 0) {
Log.w(TAG, "没有更新。可能是用户在同步时更新了笔记");
}
}
// 如果笔记类型为 Notes.TYPE_NOTE，提交关联的 SqlData 列表
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, validateVersion, mVersion);
}
}
}
// 刷新本地信息
loadFromCursor(mId);
if (mType == Notes.TYPE_NOTE)
loadDataContent();
// 清空差异值、重置创建标志
mDiffNoteValues.clear();
mIsCreate = false;
}

225
src/gtask/data/Task.java
Unescape View File

@ -24,170 +24,220 @@ public class Task extends Node {
mMetaInfo = null;
}
/**
* 生成创建任务操作的 JSON 对象
*
* @param actionId 操作的唯一标识符
* @return 包含创建任务操作信息的 JSON 对象
* @throws ActionFailureException 如果生成 JSON 对象时发生异常，则抛出 ActionFailureException 异常
*/
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
try {
// action_type
// 设置操作类型为创建任务
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
// action_id
// 设置操作的唯一标识符
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// 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,
GTaskStringUtils.GTASK_JSON_TYPE_TASK);
// 如果任务有附加注释，则设置注释信息
if (getNotes() != null) {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
}
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
// parent_id
if (mParent!= null) {
js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
// 设置父任务的唯一标识符
if (mParent != null) {
js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
}
// dest_parent_type
// 设置目标父任务的类型为 GROUP
js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
// list_id
if (mParent!= null) {
js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
// 设置任务所属列表的唯一标识符
if (mParent != null) {
js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
}
// prior_sibling_id
// 设置相邻任务的唯一标识符，用于确定任务在兄弟任务中的位置
if (mPriorSibling != null) {
js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
}
} catch (JSONException e) {
// 如果生成 JSON 对象时发生异常，则记录错误日志并抛出 ActionFailureException 异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("fail to generate task-create jsonobject");
throw new ActionFailureException("生成任务创建 JSON 对象失败");
}
return js;
}
/**
* 生成更新任务操作的 JSON 对象
*
* @param actionId 操作的唯一标识符
* @return 包含更新任务操作信息的 JSON 对象
* @throws ActionFailureException 如果生成 JSON 对象时发生异常，则抛出 ActionFailureException 异常
*/
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
try {
// action_type
// 设置操作类型为更新任务
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
// action_id
// 设置操作的唯一标识符
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// id
// 设置任务的唯一标识符
js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
// entity_delta
// 设置实体的变化信息
JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
// 如果任务有附加注释，则设置注释信息
if (getNotes() != null) {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
}
// 设置任务是否被删除
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) {
// 如果生成 JSON 对象时发生异常，则记录错误日志并抛出 ActionFailureException 异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("fail to generate task-update jsonobject");
throw new ActionFailureException("生成任务更新 JSON 对象失败");
}
return js;
}
/**
* 根据远程 JSON 对象设置任务内容
*
* @param js 包含任务内容信息的远程 JSON 对象
* @throws ActionFailureException 如果解析 JSON 对象时发生异常，则抛出 ActionFailureException 异常
*/
public void setContentByRemoteJSON(JSONObject js) {
if (js != null) {
try {
// id
// 设置任务的唯一标识符
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
}
// last_modified
// 设置任务的最后修改时间
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
}
// name
// 设置任务的名称
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
}
// notes
// 设置任务的注释
if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
}
// deleted
// 设置任务是否被删除
if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
}
// completed
// 设置任务是否已完成
if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
}
} catch (JSONException e) {
// 如果解析 JSON 对象时发生异常，则记录错误日志并抛出 ActionFailureException 异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("fail to get task content from jsonobject");
throw new ActionFailureException("从 JSON 对象获取任务内容失败");
}
}
}
public void setContentByLocalJSON(JSONObject js) { // metadata ʵʩ
/**
* 根据本地 JSON 对象设置任务内容
*
* @param js 包含任务内容信息的本地 JSON 对象
*/
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: 没有可用的信息");
}
try {
// 获取任务的元数据
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
// 检查任务类型是否为 Notes.TYPE_NOTE
if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
Log.e(TAG, "invalid type");
Log.e(TAG, "无效的类型");
return;
}
// 遍历数据数组，查找包含 MIME_TYPE 为 DataConstants.NOTE 的数据项
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));
break;
}
}
} catch (JSONException e) {
// 如果解析 JSON 对象时发生异常，则记录错误日志
Log.e(TAG, e.toString());
e.printStackTrace();
}
}
/**
* 从任务内容生成本地 JSON 对象
*
* @return 包含任务元数据的本地 JSON 对象
*/
public JSONObject getLocalJSONFromContent() {
String name = getName();
try {
// 如果任务的元数据为空，表示是从 web 创建的新任务
if (mMetaInfo == null) {
// new task created from web
// 新任务为空，记录警告日志并返回 null
if (name == null) {
Log.w(TAG, "the note seems to be an empty one");
Log.w(TAG, "任务似乎是一个空任务");
return null;
}
// 构建 JSON 对象包含任务元数据和数据数组
JSONObject js = new JSONObject();
JSONObject note = new JSONObject();
JSONArray dataArray = new JSONArray();
@ -199,10 +249,10 @@ public class Task extends Node {
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
return js;
} else {
// synced task
// 如果是已同步的任务，更新数据数组中 MIME_TYPE 为 DataConstants.NOTE 的数据项的内容
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);
if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
@ -210,80 +260,105 @@ public class Task extends Node {
break;
}
}
// 更新任务类型为 Notes.TYPE_NOTE，并返回元数据 JSON 对象
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
return mMetaInfo;
}
} catch (JSONException e) {
// 如果生成 JSON 对象时发生异常，则记录错误日志并返回 null
Log.e(TAG, e.toString());
e.printStackTrace();
return null;
}
}
/**
* 根据 MetaData 对象设置元数据信息
*
* @param metaData 包含元数据信息的 MetaData 对象
*/
public void setMetaInfo(MetaData metaData) {
// 检查 MetaData 对象是否有效，且是否包含注释信息
if (metaData != null && metaData.getNotes() != null) {
try {
// 将注释信息转换为 JSON 对象并赋值给 mMetaInfo
mMetaInfo = new JSONObject(metaData.getNotes());
} catch (JSONException e) {
// 如果转换为 JSON 对象时发生异常，则记录警告日志并将 mMetaInfo 置为 null
Log.w(TAG, e.toString());
mMetaInfo = null;
}
}
}
/**
* 获取同步操作类型
*
* @param c 包含本地数据库信息的 Cursor 对象
* @return 同步操作类型，可能的值有 SYNC_ACTION_NONE、SYNC_ACTION_UPDATE_REMOTE、
* SYNC_ACTION_UPDATE_LOCAL、SYNC_ACTION_UPDATE_CONFLICT 和 SYNC_ACTION_ERROR
*/
public int getSyncAction(Cursor c) {
try {
JSONObject noteInfo = null;
// 检查元数据是否存在且包含注释信息
if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
}
// 如果注释信息不存在，记录警告日志并返回 SYNC_ACTION_UPDATE_REMOTE
if (noteInfo == null) {
Log.w(TAG, "it seems that note meta has been deleted");
Log.w(TAG, "似乎已删除注释元数据");
return SYNC_ACTION_UPDATE_REMOTE;
}
// 如果注释信息中不包含 NoteColumns.ID，记录警告日志并返回 SYNC_ACTION_UPDATE_LOCAL
if (!noteInfo.has(NoteColumns.ID)) {
Log.w(TAG, "remote note id seems to be deleted");
Log.w(TAG, "远程注释 ID 似乎已删除");
return SYNC_ACTION_UPDATE_LOCAL;
}
// validate the note id now
// 验证注释 ID 是否与本地数据库中的 ID 匹配
if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
Log.w(TAG, "note id doesn't match");
Log.w(TAG, "注释 ID 不匹配");
return SYNC_ACTION_UPDATE_LOCAL;
}
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
// 验证 gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match");
Log.e(TAG, "gtask ID 不匹配");
return SYNC_ACTION_ERROR;
}
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// local modification only
// 仅本地修改
return SYNC_ACTION_UPDATE_REMOTE;
} else {
return SYNC_ACTION_UPDATE_CONFLICT;
}
}
} catch (Exception e) {
// 如果发生异常，记录错误日志并返回 SYNC_ACTION_ERROR
Log.e(TAG, e.toString());
e.printStackTrace();
}
return SYNC_ACTION_ERROR;
}
public boolean isWorthSaving() {
return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)

176
src/gtask/data/TaskList.java
Unescape View File

@ -13,186 +13,250 @@ public class TaskList extends Node {
mIndex = 1;
}
/* (non-Javadoc)
* @see net.micode.notes.gtask.data.Node#getCreateAction(int)
* 生成并返回一个包含了一定数据的JSONObject实体
/**
* 获取创建任务列表操作的 JSON 对象
*
* @param actionId 操作的唯一标识符
* @return 包含创建任务列表操作信息的 JSON 对象
* @throws ActionFailureException 如果生成 JSON 对象过程中发生异常
*/
public JSONObject getCreateAction(int actionId) {
public JSONObject getCreateAction(int actionId) throws ActionFailureException {
// 创建空的 JSON 对象
JSONObject js = new JSONObject();
try {
// action_type
// 设置操作类型为创建任务列表
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
// action_id
// 设置操作的唯一标识符
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// index
// 设置任务列表的索引
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
// entity_delta
JSONObject entity = new JSONObject();//entity实体
// 创建实体信息的 JSON 对象
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,
GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
// 将实体信息添加到操作中
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) {
// 如果生成 JSON 对象过程中发生异常，记录错误日志并抛出 ActionFailureException 异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("fail to generate tasklist-create jsonobject");
throw new ActionFailureException("生成任务列表创建操作的 JSON 对象失败");
}
return js;
}
/* (non-Javadoc)
* @see net.micode.notes.gtask.data.Node#getUpdateAction(int)
* 生成并返回一个包含了一定数据的JSONObject实体
/**
* 获取更新任务列表操作的 JSON 对象
*
* @param actionId 操作的唯一标识符
* @return 包含更新任务列表操作信息的 JSON 对象
* @throws ActionFailureException 如果生成 JSON 对象过程中发生异常
*/
public JSONObject getUpdateAction(int actionId) {
public JSONObject getUpdateAction(int actionId) throws ActionFailureException {
// 创建空的 JSON 对象
JSONObject js = new JSONObject();
try {
// action_type
// 设置操作类型为更新任务列表
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
// action_id
// 设置操作的唯一标识符
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// id
// 设置任务列表的唯一标识符
js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
// entity_delta
// 创建实体信息的 JSON 对象
JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
// 将实体信息添加到操作中
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) {
// 如果生成 JSON 对象过程中发生异常，记录错误日志并抛出 ActionFailureException 异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("fail to generate tasklist-update jsonobject");
throw new ActionFailureException("生成任务列表更新操作的 JSON 对象失败");
}
return js;
}
public void setContentByRemoteJSON(JSONObject js) {
/**
* 通过远程 JSON 对象设置任务列表内容
*
* @param js 包含任务列表信息的 JSON 对象
* @throws ActionFailureException 如果在设置任务列表内容过程中发生异常
*/
public void setContentByRemoteJSON(JSONObject js) throws ActionFailureException {
if (js != null) {
try {
// id
// 设置任务列表的唯一标识符
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
}
// last_modified
// 设置任务列表的最后修改时间
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
}
// name
// 设置任务列表的名称
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
}
} catch (JSONException e) {
// 如果在设置任务列表内容过程中发生异常，记录错误日志并抛出 ActionFailureException 异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("fail to get tasklist content from jsonobject");
throw new ActionFailureException("从 JSON 对象获取任务列表内容失败");
}
}
}
/**
* 通过本地 JSON 对象设置任务列表内容
*
* @param js 包含任务列表信息的本地 JSON 对象
*/
public void setContentByLocalJSON(JSONObject js) {
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
// 如果 JSON 对象为空或不包含任务列表信息，记录警告日志
Log.w(TAG, "setContentByLocalJSON: 没有可用的信息");
}
try {
// 获取任务列表的元数据信息
JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
// 如果是文件夹类型的任务列表
String name = folder.getString(NoteColumns.SNIPPET);
// 设置任务列表名称为 MIUI 文件夹前缀加上文件夹的片段信息
setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name);
} 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);
else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ GTaskStringUtils.FOLDER_CALL_NOTE);
// 通话记录文件夹
setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE);
else
Log.e(TAG, "invalid system folder");
// 无效的系统文件夹
Log.e(TAG, "无效的系统文件夹");
} else {
Log.e(TAG, "error type");
// 错误的类型
Log.e(TAG, "错误的类型");
}
} catch (JSONException e) {
// 如果在设置任务列表内容的过程中发生异常，记录错误日志
Log.e(TAG, e.toString());
e.printStackTrace();
}
}
/**
* 根据任务列表内容生成本地 JSON 对象
*
* @return 包含任务列表信息的本地 JSON 对象
*/
public JSONObject getLocalJSONFromContent() {
try {
// 创建 JSON 对象用于存储任务列表信息
JSONObject js = new JSONObject();
// 创建 JSON 对象用于存储任务列表元数据
JSONObject folder = new JSONObject();
// 获取任务列表名称
String folderName = getName();
// 如果名称以 MIUI 文件夹前缀开头，去掉前缀部分
if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
folderName.length());
// 设置任务列表元数据的片段信息和类型
folder.put(NoteColumns.SNIPPET, folderName);
if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
|| folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
// 如果是默认文件夹或通话记录文件夹，设置为系统文件夹类型
folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
else
// 否则设置为文件夹类型
folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
// 将任务列表元数据放入 JSON 对象
js.put(GTaskStringUtils.META_HEAD_NOTE, folder);
return js;
} catch (JSONException e) {
// 如果在生成本地 JSON 对象的过程中发生异常，记录错误日志
Log.e(TAG, e.toString());
e.printStackTrace();
return null;
}
}
/**
* 获取同步操作类型
*
* @param c 游标对象，包含本地数据库中的任务信息
* @return 同步操作类型，可能的取值有 SYNC_ACTION_NONE、SYNC_ACTION_UPDATE_LOCAL、
* SYNC_ACTION_UPDATE_REMOTE 和 SYNC_ACTION_ERROR
*/
public int getSyncAction(Cursor c) {
try {
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
// 验证 gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match");
return SYNC_ACTION_ERROR;
}
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// local modification only
// 仅有本地修改
return SYNC_ACTION_UPDATE_REMOTE;
} else {
// for folder conflicts, just apply local modification
// 对于文件夹冲突，仅应用本地修改
return SYNC_ACTION_UPDATE_REMOTE;
}
}
} catch (Exception e) {
// 如果在获取同步操作类型的过程中发生异常，记录错误日志
Log.e(TAG, e.toString());
e.printStackTrace();
}
return SYNC_ACTION_ERROR;
}
/**
* @return

2
src/gtask/exception/ActionFailureException.java
Unescape View File

@ -11,7 +11,6 @@ public class ActionFailureException extends RuntimeException {
/*
* serialVersionUID相当于java类的身份证。主要用于版本控制。
* serialVersionUID作用是序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。
* Made By Cuican
*/
public ActionFailureException() {
@ -22,7 +21,6 @@ public class ActionFailureException extends RuntimeException {
* 如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。
* 怎么去引用里面的父类对象呢？使用super来引用
* 也就是说，此处super()以及super (paramString)可认为是Exception ()和Exception (paramString)
* Made By Cuican
*/
public ActionFailureException(String paramString) {
super(paramString);

2
src/gtask/exception/NetworkFailureException.java
Unescape View File

@ -10,7 +10,6 @@ public class NetworkFailureException extends Exception {
/*
* serialVersionUID相当于java类的身份证。主要用于版本控制。
* serialVersionUID作用是序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。
* Made By Cuican
*/
public NetworkFailureException() {
@ -22,7 +21,6 @@ public class NetworkFailureException extends Exception {
* 如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。
* 怎么去引用里面的父类对象呢？使用super来引用
* 也就是说，此处super()以及super (paramString)可认为是Exception ()和Exception (paramString)
* Made By Cuican
*/
public NetworkFailureException(String paramString) {
super(paramString);

38
src/gtask/remote/GTaskASyncTask.java
Unescape View File

@ -25,31 +25,43 @@ import net.micode.notes.ui.NotesPreferenceActivity;
public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
/*
* 通知的ID，用于同步通知
*/
private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
/**
* 完成监听器接口，用于在任务完成时回调
*/
public interface OnCompleteListener {
void onComplete();
}
private Context mContext;
private NotificationManager mNotifiManager;
private GTaskManager mTaskManager;
private OnCompleteListener mOnCompleteListener;
private Context mContext; // 上下文对象
private NotificationManager mNotifiManager; // 通知管理器
private GTaskManager mTaskManager; // GTask管理器
private OnCompleteListener mOnCompleteListener; // 完成监听器
/**
* 构造函数，初始化异步任务
*
* @param context 上下文对象
* @param listener 完成监听器
*/
public GTaskASyncTask(Context context, OnCompleteListener listener) {
mContext = context;
mOnCompleteListener = listener;
mNotifiManager = (NotificationManager) mContext
.getSystemService(Context.NOTIFICATION_SERVICE);
mNotifiManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
mTaskManager = GTaskManager.getInstance();
}
/**
* 取消同步任务
*/
public void cancelSync() {
mTaskManager.cancelSync();
}
public void publishProgess(String message) { // 发布进度单位，系统将会调用onProgressUpdate()方法更新这些值
publishProgress(new String[] {

118
src/gtask/remote/GTaskManager.java
Unescape View File

@ -38,7 +38,6 @@ public class GTaskManager {
/**
* 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。
* 功能：类初始化函数
* @author TTS
* @return GtaskManger
*/
public static synchronized GTaskManager getInstance() { //可能运行在多线程环境下，使用语言级同步--synchronized
@ -50,7 +49,6 @@ public class GTaskManager {
/**
* 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。
* @author TTS
* @param activity
*/
public synchronized void setActivityContext(Activity activity) {
@ -61,7 +59,6 @@ public class GTaskManager {
/**
* 核心函数
* 功能：实现了本地同步操作和远端同步操作
* @author TTS
* @param context-----获取上下文
* @param asyncTask-------用于同步的异步操作类
* @return int
@ -126,7 +123,6 @@ public class GTaskManager {
/**
*功能：初始化GtaskList，获取Google上的JSONtasklist转为本地TaskList。
*获得的数据存储在mMetaList，mGTaskListHashMap，mGTaskHashMap
*@author TTS
*@exception NetworkFailureException
*@return void
*/
@ -320,22 +316,20 @@ public class GTaskManager {
}
/**
* 功能：
* @author TTS
* @throws NetworkFailureException
/*
* 同步文件夹的方法，抛出网络异常
*/
private void syncFolder() throws NetworkFailureException {
Cursor c = null;
String gid;
Node node;
int syncType;
if (mCancelled) {
return;
}
// for root folder
// 同步根目录
try {
c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null);
@ -347,7 +341,7 @@ public class GTaskManager {
mGTaskHashMap.remove(gid);
mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER);
mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid);
// for system folder, only update remote name if necessary
// 仅在必要时更新远程名称
if (!node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT))
doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
@ -363,12 +357,12 @@ public class GTaskManager {
c = null;
}
}
// for call-note folder
// 同步通话记录文件夹
try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)",
new String[] {
String.valueOf(Notes.ID_CALL_RECORD_FOLDER)
String.valueOf(Notes.ID_CALL_RECORD_FOLDER)
}, null);
if (c != null) {
if (c.moveToNext()) {
@ -378,8 +372,7 @@ public class GTaskManager {
mGTaskHashMap.remove(gid);
mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER);
mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid);
// for system folder, only update remote name if
// necessary
// 仅在必要时更新远程名称
if (!node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ GTaskStringUtils.FOLDER_CALL_NOTE))
@ -397,8 +390,8 @@ public class GTaskManager {
c = null;
}
}
// for local existing folders
// 同步本地已存在的文件夹
try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
"(type=? AND parent_id<>?)", new String[] {
@ -415,10 +408,10 @@ public class GTaskManager {
syncType = node.getSyncAction(c);
} else {
if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
// local add
// 本地添加
syncType = Node.SYNC_ACTION_ADD_REMOTE;
} else {
// remote delete
// 远程删除
syncType = Node.SYNC_ACTION_DEL_LOCAL;
}
}
@ -433,8 +426,8 @@ public class GTaskManager {
c = null;
}
}
// for remote add folders
// 同步远程添加的文件夹
Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<String, TaskList> entry = iter.next();
@ -445,33 +438,38 @@ public class GTaskManager {
doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
}
}
if (!mCancelled)
GTaskClient.getInstance().commitUpdate();
}
/**
* 功能：syncType分类，addLocalNode，addRemoteNode，deleteNode，updateLocalNode，updateRemoteNode
* @author TTS
* @param syncType
* @param node
* @param c
* @throws NetworkFailureException
*/
/*
* 执行内容同步操作
*/
private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
}
MetaData meta;
switch (syncType) {
case Node.SYNC_ACTION_ADD_LOCAL:
// 添加本地节点
addLocalNode(node);
break;
case Node.SYNC_ACTION_ADD_REMOTE:
// 添加远程节点
addRemoteNode(node, c);
break;
case Node.SYNC_ACTION_DEL_LOCAL:
// 获取本地删除节点的元数据，然后删除
meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN));
if (meta != null) {
GTaskClient.getInstance().deleteNode(meta);
@ -479,6 +477,7 @@ public class GTaskManager {
mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
break;
case Node.SYNC_ACTION_DEL_REMOTE:
// 获取远程删除节点的元数据，然后删除节点
meta = mMetaHashMap.get(node.getGid());
if (meta != null) {
GTaskClient.getInstance().deleteNode(meta);
@ -486,63 +485,77 @@ public class GTaskManager {
GTaskClient.getInstance().deleteNode(node);
break;
case Node.SYNC_ACTION_UPDATE_LOCAL:
// 更新本地节点
updateLocalNode(node, c);
break;
case Node.SYNC_ACTION_UPDATE_REMOTE:
// 更新远程节点
updateRemoteNode(node, c);
break;
case Node.SYNC_ACTION_UPDATE_CONFLICT:
// merging both modifications maybe a good idea
// right now just use local update simply
// 合并两者的修改，目前仅简单使用本地更新
updateRemoteNode(node, c);
break;
case Node.SYNC_ACTION_NONE:
// 无动作
break;
case Node.SYNC_ACTION_ERROR:
default:
throw new ActionFailureException("unkown sync action type");
// 未知的同步操作类型，抛出异常
throw new ActionFailureException("unknown sync action type");
}
}
/**
* 功能：本地增加Node
* @author TTS
* @param node
* @throws NetworkFailureException
/*
* 功能描述：添加本地节点
* 参数：node - 节点对象
* 返回：无
* 异常：NetworkFailureException - 网络异常
*/
private void addLocalNode(Node node) throws NetworkFailureException {
if (mCancelled) {
return;
}
SqlNote sqlNote;
// 如果节点为任务列表
if (node instanceof TaskList) {
if (node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) {
// 根据任务列表的名称判断是否为默认文件夹，创建对应的 SqlNote 对象
sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER);
} else if (node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) {
// 根据任务列表的名称判断是否为通话记录文件夹，创建对应的 SqlNote 对象
sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER);
} else {
// 其他情况创建普通任务列表对应的 SqlNote 对象
sqlNote = new SqlNote(mContext);
sqlNote.setContent(node.getLocalJSONFromContent());
sqlNote.setParentId(Notes.ID_ROOT_FOLDER);
}
} else {
// 如果节点为任务
sqlNote = new SqlNote(mContext);
JSONObject js = node.getLocalJSONFromContent();
try {
// 处理 META_HEAD_NOTE 中的 ID，确保本地数据库中不存在该 ID
if (js.has(GTaskStringUtils.META_HEAD_NOTE)) {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
if (note.has(NoteColumns.ID)) {
long id = note.getLong(NoteColumns.ID);
if (DataUtils.existInNoteDatabase(mContentResolver, id)) {
// the id is not available, have to create a new one
// 如果 ID 在本地数据库中存在，则移除该 ID，创建新的任务 ID
note.remove(NoteColumns.ID);
}
}
}
// 处理 META_HEAD_DATA 中的 ID，确保本地数据库中不存在该 ID
if (js.has(GTaskStringUtils.META_HEAD_DATA)) {
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
for (int i = 0; i < dataArray.length(); i++) {
@ -550,20 +563,21 @@ public class GTaskManager {
if (data.has(DataColumns.ID)) {
long dataId = data.getLong(DataColumns.ID);
if (DataUtils.existInDataDatabase(mContentResolver, dataId)) {
// the data id is not available, have to create
// a new one
// 如果 ID 在本地数据库中存在，则移除该 ID，创建新的数据 ID
data.remove(DataColumns.ID);
}
}
}
}
} catch (JSONException e) {
Log.w(TAG, e.toString());
e.printStackTrace();
}
// 设置 SqlNote 对象的内容为节点的本地 JSON 表示
sqlNote.setContent(js);
// 获取节点的父节点的本地 ID，用于设置 SqlNote 对象的父 ID
Long parentId = mGidToNid.get(((Task) node).getParent().getGid());
if (parentId == null) {
Log.e(TAG, "cannot find task's parent id locally");
@ -571,22 +585,22 @@ public class GTaskManager {
}
sqlNote.setParentId(parentId.longValue());
}
// create the local node
// 设置 SqlNote 对象的 GTask ID，并提交到本地数据库
sqlNote.setGtaskId(node.getGid());
sqlNote.commit(false);
// update gid-nid mapping
// 更新 GTask ID 到本地 ID 的映射关系
mGidToNid.put(node.getGid(), sqlNote.getId());
mNidToGid.put(sqlNote.getId(), node.getGid());
// update meta
// 更新远程 Meta 信息
updateRemoteMeta(node.getGid(), sqlNote);
}
/**
* 功能：update本地node
* @author TTS
* @param node
* ----同步操作的基础数据类型
* @param c
@ -619,7 +633,6 @@ public class GTaskManager {
/**
* 功能：远程增加Node
* 需要updateRemoteMeta
* @author TTS
* @param node
* ----同步操作的基础数据类型
* @param c
@ -703,7 +716,6 @@ public class GTaskManager {
/**
* 功能：更新远端的Node，包含meta更新(updateRemoteMeta)
* @author TTS
* @param node
* ----同步操作的基础数据类型
* @param c
@ -755,7 +767,6 @@ public class GTaskManager {
/**
* 功能：升级远程meta。 meta---元数据----计算机文件系统管理数据---管理数据的数据。
* @author TTS
* @param gid
* ---GoogleID为String类型
* @param sqlNote
@ -780,7 +791,6 @@ public class GTaskManager {
/**
* 功能：刷新本地，给sync的ID对应上最后更改过的对象
* @author TTS
* @return void
* @throws NetworkFailureException
*/
@ -830,7 +840,6 @@ public class GTaskManager {
/**
* 功能：获取同步账号,mAccount.name
* @author TTS
* @return String
*/
public String getSyncAccount() {
@ -839,7 +848,6 @@ public class GTaskManager {
/**
* 功能：取消同步，置mCancelled为true
* @author TTS
*/
public void cancelSync() {
mCancelled = true;

2
src/gtask/remote/GTaskSyncService.java
Unescape View File

@ -91,7 +91,7 @@ public class GTaskSyncService extends Service {
}
}
public IBinder onBind(Intent intent) { //不知道干吗用的
public IBinder onBind(Intent intent) {
return null;
}

Write Preview
Loading…
Cancel
Save