添加注释,添加错误捕获

dcy
董春阳 1 year ago
parent e147b7fca6
commit 9a3dfb769e

@ -17,263 +17,288 @@
package net.micode.notes.data;
import android.net.Uri;
// 定义一个名为Notes的公共类用于管理笔记相关的常量和接口
public class Notes {
// 内容提供者的权限名称,用于在应用内标识该内容提供者
public static final String AUTHORITY = "micode_notes";
// 日志标签,用于在日志输出中标识该类相关的日志信息
public static final String TAG = "Notes";
public static final int TYPE_NOTE = 0;
public static final int TYPE_FOLDER = 1;
public static final int TYPE_SYSTEM = 2;
// 表示笔记类型的常量
public static final int TYPE_NOTE = 0;
// 表示文件夹类型的常量
public static final int TYPE_FOLDER = 1;
// 表示系统类型的常量
public static final int TYPE_SYSTEM = 2;
/**
* Following IDs are system folders' identifiers
* {@link Notes#ID_ROOT_FOLDER } is default folder
* {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
* {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
* ID
* {@link Notes#ID_ROOT_FOLDER }
* {@link Notes#ID_TEMPARAY_FOLDER }
* {@link Notes#ID_CALL_RECORD_FOLDER}
*/
// 根文件夹的ID
public static final int ID_ROOT_FOLDER = 0;
// 临时文件夹的ID用于存放不属于任何文件夹的笔记
public static final int ID_TEMPARAY_FOLDER = -1;
// 通话记录文件夹的ID
public static final int ID_CALL_RECORD_FOLDER = -2;
// 回收站文件夹的ID
public static final int ID_TRASH_FOLER = -3;
// 用于在Intent中传递提醒日期的额外字段名称
public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
// 用于在Intent中传递背景颜色ID的额外字段名称
public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
// 用于在Intent中传递小部件ID的额外字段名称
public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
// 用于在Intent中传递小部件类型的额外字段名称
public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
// 用于在Intent中传递文件夹ID的额外字段名称
public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
// 用于在Intent中传递通话日期的额外字段名称
public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
public static final int TYPE_WIDGET_INVALIDE = -1;
public static final int TYPE_WIDGET_2X = 0;
public static final int TYPE_WIDGET_4X = 1;
// 无效的小部件类型
public static final int TYPE_WIDGET_INVALIDE = -1;
// 2x尺寸的小部件类型
public static final int TYPE_WIDGET_2X = 0;
// 4x尺寸的小部件类型
public static final int TYPE_WIDGET_4X = 1;
// 数据常量的内部类,用于存储不同类型数据的相关常量
public static class DataConstants {
// 文本笔记的内容类型
public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
// 通话笔记的内容类型
public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
}
/**
* Uri to query all notes and folders
* Uri
*/
public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
/**
* Uri to query data
* Uri
*/
public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
// 笔记列的接口,定义了与笔记相关的数据库列名
public interface NoteColumns {
/**
* The unique ID for a row
* <P> Type: INTEGER (long) </P>
* ID
* <P> : INTEGER (long) </P>
*/
public static final String ID = "_id";
/**
* The parent's id for note or folder
* <P> Type: INTEGER (long) </P>
* ID
* <P> : INTEGER (long) </P>
*/
public static final String PARENT_ID = "parent_id";
/**
* Created data for note or folder
* <P> Type: INTEGER (long) </P>
*
* <P> : INTEGER (long) </P>
*/
public static final String CREATED_DATE = "created_date";
/**
* Latest modified date
* <P> Type: INTEGER (long) </P>
*
* <P> : INTEGER (long) </P>
*/
public static final String MODIFIED_DATE = "modified_date";
/**
* Alert date
* <P> Type: INTEGER (long) </P>
*
* <P> : INTEGER (long) </P>
*/
public static final String ALERTED_DATE = "alert_date";
/**
* Folder's name or text content of note
* <P> Type: TEXT </P>
*
* <P> : TEXT </P>
*/
public static final String SNIPPET = "snippet";
/**
* Note's widget id
* <P> Type: INTEGER (long) </P>
* ID
* <P> : INTEGER (long) </P>
*/
public static final String WIDGET_ID = "widget_id";
/**
* Note's widget type
* <P> Type: INTEGER (long) </P>
*
* <P> : INTEGER (long) </P>
*/
public static final String WIDGET_TYPE = "widget_type";
/**
* Note's background color's id
* <P> Type: INTEGER (long) </P>
* ID
* <P> : INTEGER (long) </P>
*/
public static final String BG_COLOR_ID = "bg_color_id";
/**
* For text note, it doesn't has attachment, for multi-media
* note, it has at least one attachment
* <P> Type: INTEGER </P>
*
* <P> : INTEGER </P>
*/
public static final String HAS_ATTACHMENT = "has_attachment";
/**
* Folder's count of notes
* <P> Type: INTEGER (long) </P>
*
* <P> : INTEGER (long) </P>
*/
public static final String NOTES_COUNT = "notes_count";
/**
* The file type: folder or note
* <P> Type: INTEGER </P>
*
* <P> : INTEGER </P>
*/
public static final String TYPE = "type";
/**
* The last sync id
* <P> Type: INTEGER (long) </P>
* ID
* <P> : INTEGER (long) </P>
*/
public static final String SYNC_ID = "sync_id";
/**
* Sign to indicate local modified or not
* <P> Type: INTEGER </P>
*
* <P> : INTEGER </P>
*/
public static final String LOCAL_MODIFIED = "local_modified";
/**
* Original parent id before moving into temporary folder
* <P> Type : INTEGER </P>
* ID
* <P> : INTEGER </P>
*/
public static final String ORIGIN_PARENT_ID = "origin_parent_id";
/**
* The gtask id
* <P> Type : TEXT </P>
* gtaskID
* <P> : TEXT </P>
*/
public static final String GTASK_ID = "gtask_id";
/**
* The version code
* <P> Type : INTEGER (long) </P>
*
* <P> : INTEGER (long) </P>
*/
public static final String VERSION = "version";
}
// 数据列的接口,定义了与数据相关的数据库列名
public interface DataColumns {
/**
* The unique ID for a row
* <P> Type: INTEGER (long) </P>
* ID
* <P> : INTEGER (long) </P>
*/
public static final String ID = "_id";
/**
* The MIME type of the item represented by this row.
* <P> Type: Text </P>
* MIME
* <P> : Text </P>
*/
public static final String MIME_TYPE = "mime_type";
/**
* The reference id to note that this data belongs to
* <P> Type: INTEGER (long) </P>
* ID
* <P> : INTEGER (long) </P>
*/
public static final String NOTE_ID = "note_id";
/**
* Created data for note or folder
* <P> Type: INTEGER (long) </P>
*
* <P> : INTEGER (long) </P>
*/
public static final String CREATED_DATE = "created_date";
/**
* Latest modified date
* <P> Type: INTEGER (long) </P>
*
* <P> : INTEGER (long) </P>
*/
public static final String MODIFIED_DATE = "modified_date";
/**
* Data's content
* <P> Type: TEXT </P>
*
* <P> : TEXT </P>
*/
public static final String CONTENT = "content";
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* integer data type
* <P> Type: INTEGER </P>
* {@link #MIMETYPE}
* <P> : INTEGER </P>
*/
public static final String DATA1 = "data1";
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* integer data type
* <P> Type: INTEGER </P>
* {@link #MIMETYPE}
* <P> : INTEGER </P>
*/
public static final String DATA2 = "data2";
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* TEXT data type
* <P> Type: TEXT </P>
* {@link #MIMETYPE}
* <P> : TEXT </P>
*/
public static final String DATA3 = "data3";
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* TEXT data type
* <P> Type: TEXT </P>
* {@link #MIMETYPE}
* <P> : TEXT </P>
*/
public static final String DATA4 = "data4";
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* TEXT data type
* <P> Type: TEXT </P>
* {@link #MIMETYPE}
* <P> : TEXT </P>
*/
public static final String DATA5 = "data5";
}
// 文本笔记的静态内部类实现了DataColumns接口定义了文本笔记相关的常量
public static final class TextNote implements DataColumns {
/**
* Mode to indicate the text in check list mode or not
* <P> Type: Integer 1:check list mode 0: normal mode </P>
*
* <P> : Integer 1: 0: </P>
*/
public static final String MODE = DATA1;
// 复选框列表模式的模式值
public static final int MODE_CHECK_LIST = 1;
// 文本笔记的内容类型(目录类型)
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
// 文本笔记的内容类型(项目类型)
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
// 文本笔记的内容Uri
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
}
// 通话笔记的静态内部类实现了DataColumns接口定义了通话笔记相关的常量
public static final class CallNote implements DataColumns {
/**
* Call date for this record
* <P> Type: INTEGER (long) </P>
*
* <P> : INTEGER (long) </P>
*/
public static final String CALL_DATE = DATA1;
/**
* Phone number for this record
* <P> Type: TEXT </P>
*
* <P> : TEXT </P>
*/
public static final String PHONE_NUMBER = DATA3;
// 通话笔记的内容类型(目录类型)
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
// 通话笔记的内容类型(项目类型)
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
// 通话笔记的内容Uri
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
}
}

@ -38,11 +38,37 @@ import org.json.JSONObject;
import java.util.ArrayList;
public class SqlNote {//sqlnot用法修改
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.widget.RemoteViews;
import com.google.gson.JsonObject;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.widget.AppCompatDrawableManager;
import androidx.cursoradapter.widget.SimpleCursorAdapter;
// SqlNote类用于处理与笔记数据的SQL相关操作包括从数据库加载、保存、更新笔记信息等
public class SqlNote {
// 日志标签,用于标识该类相关的日志信息
private static final String TAG = SqlNote.class.getSimpleName();
// 无效的ID值
private static final int INVALID_ID = -99999;
// 用于查询笔记时的投影列,指定要从数据库中获取的列
public static final String[] PROJECTION_NOTE = new String[] {
NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
@ -52,76 +78,79 @@ public class SqlNote {//sqlnot用法修改
NoteColumns.VERSION
};
// 投影列中ID列的索引
public static final int ID_COLUMN = 0;
// 投影列中提醒日期列的索引
public static final int ALERTED_DATE_COLUMN = 1;
// 投影列中背景颜色ID列的索引
public static final int BG_COLOR_ID_COLUMN = 2;
// 投影列中创建日期列的索引
public static final int CREATED_DATE_COLUMN = 3;
// 投影列中是否有附件列的索引
public static final int HAS_ATTACHMENT_COLUMN = 4;
// 投影列中修改日期列的索引
public static final int MODIFIED_DATE_COLUMN = 5;
// 投影列中文件夹内笔记数量列的索引
public static final int NOTES_COUNT_COLUMN = 6;
// 投影列中父级ID列的索引
public static final int PARENT_ID_COLUMN = 7;
// 投影列中文本内容或文件夹名称列的索引
public static final int SNIPPET_COLUMN = 8;
// 投影列中类型列的索引
public static final int TYPE_COLUMN = 9;
// 投影列中小部件ID列的索引
public static final int WIDGET_ID_COLUMN = 10;
// 投影列中小部件类型列的索引
public static final int WIDGET_TYPE_COLUMN = 11;
// 投影列中同步ID列的索引
public static final int SYNC_ID_COLUMN = 12;
// 投影列中本地修改标志列的索引
public static final int LOCAL_MODIFIED_COLUMN = 13;
// 投影列中原始父级ID列的索引
public static final int ORIGIN_PARENT_ID_COLUMN = 14;
// 投影列中gtask ID列的索引
public static final int GTASK_ID_COLUMN = 15;
// 投影列中版本号列的索引
public static final int VERSION_COLUMN = 16;
// 应用上下文
private Context mContext;
// 内容解析器,用于与内容提供者进行交互
private ContentResolver mContentResolver;
// 标识该笔记是否为新创建的
private boolean mIsCreate;
// 笔记的ID
private long mId;
// 提醒日期
private long mAlertDate;
// 背景颜色ID
private int mBgColorId;
// 创建日期
private long mCreatedDate;
// 是否有附件的标志
private int mHasAttachment;
// 修改日期
private long mModifiedDate;
// 父级ID
private long mParentId;
// 文本内容或文件夹名称
private String mSnippet;
// 类型(笔记、文件夹或系统类型)
private int mType;
// 小部件ID
private int mWidgetId;
// 小部件类型
private int mWidgetType;
// 原始父级ID
private long mOriginParent;
// 版本号
private long mVersion;
// 用于存储笔记数据差异的ContentValues用于更新操作
private ContentValues mDiffNoteValues;
// 存储与该笔记相关的SqlData对象列表
private ArrayList<SqlData> mDataList;
// 构造函数用于创建一个新的SqlNote对象通常用于新笔记的创建
public SqlNote(Context context) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -143,6 +172,7 @@ public class SqlNote {//sqlnot用法修改
mDataList = new ArrayList<SqlData>();
}
// 构造函数通过Cursor对象初始化SqlNote对象通常用于从数据库加载现有笔记
public SqlNote(Context context, Cursor c) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -154,6 +184,7 @@ public class SqlNote {//sqlnot用法修改
mDiffNoteValues = new ContentValues();
}
// 构造函数通过笔记ID从数据库加载笔记并初始化SqlNote对象
public SqlNote(Context context, long id) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -163,28 +194,31 @@ public class SqlNote {//sqlnot用法修改
if (mType == Notes.TYPE_NOTE)
loadDataContent();
mDiffNoteValues = new ContentValues();
}
// 根据给定的ID从数据库加载笔记数据
private void loadFromCursor(long id) {
Cursor c = null;
try {
// 使用内容解析器查询笔记数据
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
new String[] {
String.valueOf(id)
String.valueOf(id)
}, null);
if (c != null) {
if (c!= null) {
c.moveToNext();
// 从Cursor中加载数据
loadFromCursor(c);
} else {
Log.w(TAG, "loadFromCursor: cursor = null");
}
} finally {
if (c != null)
if (c!= null)
c.close();
}
}
// 从Cursor中加载笔记数据到当前对象的属性中
private void loadFromCursor(Cursor c) {
mId = c.getLong(ID_COLUMN);
mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
@ -200,20 +234,23 @@ public class SqlNote {//sqlnot用法修改
mVersion = c.getLong(VERSION_COLUMN);
}
// 加载与该笔记相关的数据内容(例如文本笔记的具体内容等)
private void loadDataContent() {
Cursor c = null;
mDataList.clear();
try {
// 使用内容解析器查询与该笔记相关的数据
c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
"(note_id=?)", new String[] {
String.valueOf(mId)
String.valueOf(mId)
}, null);
if (c != null) {
if (c!= null) {
if (c.getCount() == 0) {
Log.w(TAG, "it seems that the note has not data");
return;
}
while (c.moveToNext()) {
// 创建SqlData对象并添加到列表中
SqlData data = new SqlData(mContext, c);
mDataList.add(data);
}
@ -221,112 +258,113 @@ public class SqlNote {//sqlnot用法修改
Log.w(TAG, "loadDataContent: cursor = null");
}
} finally {
if (c != null)
if (c!= null)
c.close();
}
}
// 根据JSONObject设置笔记的内容
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
// 对于文件夹,只能更新文本内容和类型
String snippet = note.has(NoteColumns.SNIPPET)? note
.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)
int type = note.has(NoteColumns.TYPE)? note.getInt(NoteColumns.TYPE)
: Notes.TYPE_NOTE;
if (mIsCreate || mType != type) {
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) {
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
long alertDate = note.has(NoteColumns.ALERTED_DATE)? note
.getLong(NoteColumns.ALERTED_DATE) : 0;
if (mIsCreate || mAlertDate != alertDate) {
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) {
if (mIsCreate || mBgColorId!= bgColorId) {
mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);
}
mBgColorId = bgColorId;
long createDate = note.has(NoteColumns.CREATED_DATE) ? note
long createDate = note.has(NoteColumns.CREATED_DATE)? note
.getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
if (mIsCreate || mCreatedDate != createDate) {
if (mIsCreate || mCreatedDate!= createDate) {
mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
}
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) {
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) {
if (mIsCreate || mModifiedDate!= modifiedDate) {
mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
}
mModifiedDate = modifiedDate;
long parentId = note.has(NoteColumns.PARENT_ID) ? note
long parentId = note.has(NoteColumns.PARENT_ID)? note
.getLong(NoteColumns.PARENT_ID) : 0;
if (mIsCreate || mParentId != parentId) {
if (mIsCreate || mParentId!= parentId) {
mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
}
mParentId = parentId;
String snippet = note.has(NoteColumns.SNIPPET) ? note
String snippet = note.has(NoteColumns.SNIPPET)? note
.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)
int type = note.has(NoteColumns.TYPE)? note.getInt(NoteColumns.TYPE)
: Notes.TYPE_NOTE;
if (mIsCreate || mType != type) {
if (mIsCreate || mType!= type) {
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) {
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) {
if (mIsCreate || mWidgetType!= widgetType) {
mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
}
mWidgetType = widgetType;
long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID)? note
.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
if (mIsCreate || mOriginParent != originParent) {
if (mIsCreate || mOriginParent!= originParent) {
mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
}
mOriginParent = originParent;
@ -359,6 +397,7 @@ public class SqlNote {//sqlnot用法修改
return true;
}
// 获取当前笔记的内容以JSONObject形式返回
public JSONObject getContent() {
try {
JSONObject js = new JSONObject();
@ -387,7 +426,7 @@ public class SqlNote {//sqlnot用法修改
JSONArray dataArray = new JSONArray();
for (SqlData sqlData : mDataList) {
JSONObject data = sqlData.getContent();
if (data != null) {
if (data!= null) {
dataArray.put(data);
}
}

@ -73,18 +73,29 @@ public class GTaskManager {
private HashMap<Long, String> mNidToGid;
// GTaskManager类用于管理与Google任务相关的同步操作
private GTaskManager() {
// 初始化同步状态为未同步
mSyncing = false;
// 初始化取消状态为未取消
mCancelled = false;
// 初始化用于存储Google任务列表的HashMap
mGTaskListHashMap = new HashMap<String, TaskList>();
// 初始化用于存储Google任务的HashMap
mGTaskHashMap = new HashMap<String, Node>();
// 初始化用于存储元数据的HashMap
mMetaHashMap = new HashMap<String, MetaData>();
// 初始化元数据列表为null
mMetaList = null;
// 初始化用于存储本地已删除任务ID的HashSet
mLocalDeleteIdMap = new HashSet<Long>();
// 初始化用于映射Google任务ID到本地笔记ID的HashMap
mGidToNid = new HashMap<String, Long>();
// 初始化用于映射本地笔记ID到Google任务ID的HashMap
mNidToGid = new HashMap<Long, String>();
}
// 获取GTaskManager单例实例的方法
public static synchronized GTaskManager getInstance() {
if (mInstance == null) {
mInstance = new GTaskManager();
@ -92,56 +103,76 @@ public class GTaskManager {
return mInstance;
}
// 设置Activity上下文的方法用于获取认证令牌
public synchronized void setActivityContext(Activity activity) {
// used for getting authtoken
// 存储Activity上下文用于后续获取认证令牌等操作
mActivity = activity;
}
// 执行同步操作的方法
public int sync(Context context, GTaskASyncTask asyncTask) {
// 如果当前正在同步,则返回同步中状态
if (mSyncing) {
Log.d(TAG, "Sync is in progress");
return STATE_SYNC_IN_PROGRESS;
}
// 设置应用上下文
mContext = context;
// 获取内容解析器
mContentResolver = mContext.getContentResolver();
// 设置同步状态为正在同步
mSyncing = true;
// 设置取消状态为未取消
mCancelled = false;
// 清空Google任务列表HashMap
mGTaskListHashMap.clear();
// 清空Google任务HashMap
mGTaskHashMap.clear();
// 清空元数据HashMap
mMetaHashMap.clear();
// 清空本地已删除任务ID的HashSet
mLocalDeleteIdMap.clear();
// 清空Google任务ID到本地笔记ID的映射HashMap
mGidToNid.clear();
// 清空本地笔记ID到Google任务ID的映射HashMap
mNidToGid.clear();
try {
// 获取GTaskClient实例
GTaskClient client = GTaskClient.getInstance();
// 重置更新数组
client.resetUpdateArray();
// login google task
// 登录Google任务
if (!mCancelled) {
if (!client.login(mActivity)) {
// 登录失败则抛出网络失败异常
throw new NetworkFailureException("login google task failed");
}
}
// get the task list from google
// 从Google获取任务列表并在异步任务中更新进度
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
initGTaskList();
// do content sync work
// 执行内容同步工作,并在异步任务中更新进度
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
syncContent();
} catch (NetworkFailureException e) {
// 捕获网络失败异常,记录错误日志并返回网络错误状态
Log.e(TAG, e.toString());
return STATE_NETWORK_ERROR;
} catch (ActionFailureException e) {
// 捕获操作失败异常,记录错误日志并返回内部错误状态
Log.e(TAG, e.toString());
return STATE_INTERNAL_ERROR;
} catch (Exception e) {
// 捕获其他异常,记录错误日志并返回内部错误状态
Log.e(TAG, e.toString());
e.printStackTrace();
return STATE_INTERNAL_ERROR;
} finally {
// 无论同步过程是否成功,最终都清空相关数据结构,并设置同步状态为未同步
mGTaskListHashMap.clear();
mGTaskHashMap.clear();
mMetaHashMap.clear();
@ -151,44 +182,62 @@ public class GTaskManager {
mSyncing = false;
}
return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
// 根据是否取消同步,返回相应的同步状态
return mCancelled? STATE_SYNC_CANCELLED : STATE_SUCCESS;
}
// 初始化Google任务列表的方法
private void initGTaskList() throws NetworkFailureException {
// 如果同步已取消,则直接返回
if (mCancelled)
return;
// 获取GTaskClient实例
GTaskClient client = GTaskClient.getInstance();
try {
// 从Google获取任务列表的JSON数组
JSONArray jsTaskLists = client.getTaskLists();
// init meta list first
// 首先初始化元数据列表
mMetaList = null;
for (int i = 0; i < jsTaskLists.length(); i++) {
// 获取当前任务列表的JSONObject
JSONObject object = jsTaskLists.getJSONObject(i);
// 获取任务列表的Google ID
String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
// 获取任务列表的名称
String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
if (name
.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
// 如果任务列表名称符合特定格式,说明是元数据相关的任务列表
if (name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
// 创建元数据任务列表对象并根据远程JSON数据设置其内容
mMetaList = new TaskList();
mMetaList.setContentByRemoteJSON(object);
// load meta data
// 加载元数据
JSONArray jsMetas = client.getTaskList(gid);
for (int j = 0; j < jsMetas.length(); j++) {
// 获取当前元数据的JSONObject
object = (JSONObject) jsMetas.getJSONObject(j);
// 创建元数据对象并根据远程JSON数据设置其内容
MetaData metaData = new MetaData();
metaData.setContentByRemoteJSON(object);
// 如果元数据值得保存
if (metaData.isWorthSaving()) {
// 将元数据添加到元数据任务列表中
mMetaList.addChildTask(metaData);
if (metaData.getGid() != null) {
// 如果元数据有相关的Google ID则添加到元数据HashMap中
if (metaData.getGid()!= null) {
mMetaHashMap.put(metaData.getRelatedGid(), metaData);
}
}
}
}
}
} catch (JSONException e) {
// 捕获JSON解析异常抛出网络失败异常
throw new NetworkFailureException("Error getting task lists from Google");
}
}
// create meta list if not existed
if (mMetaList == null) {
mMetaList = new TaskList();

Loading…
Cancel
Save