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

增加gtask中的注释

Browse Source
master
qw1ko 2 years ago
parent 2239c8b40b
commit 0317fe1c44
2 changed files with 151 additions and 131 deletions
Show Stats Download Patch File Download Diff File

8
Notes-master2/src/net/micode/notes/gtask/remote/GTaskClient.java
Unescape View File

@ -551,7 +551,7 @@ public class GTaskClient {
throw new ActionFailureException("delete node: handing jsonobject failed");
}
}
//返回一个 JSONArray 对象，表示当前用户在 Google Tasks 上的所有任务列表。如果用户未登录，则抛出一个 ActionFailureException 异常。如果获取任务列表时发生网络故障，则抛出一个 NetworkFailureException 异常。
public JSONArray getTaskLists() throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
@ -589,7 +589,7 @@ public class GTaskClient {
throw new ActionFailureException("get task lists: handing jasonobject failed");
}
}
//返回一个 JSONArray 对象，表示具有给定 ID 的任务列表中的所有任务。该方法将先执行一个 commitUpdate() 方法，该方法的实现未在代码中给出。如果获取任务列表时发生网络故障，则抛出一个 NetworkFailureException 异常。如果在处理 JSON 数据时发生错误，则抛出一个 ActionFailureException 异常。
public JSONArray getTaskList(String listGid) throws NetworkFailureException {
commitUpdate();
try {
@ -617,11 +617,11 @@ public class GTaskClient {
throw new ActionFailureException("get task list: handing jsonobject failed");
}
}
//返回一个 Account 对象，表示当前用户在应用中同步的 Google 帐户。
public Account getSyncAccount() {
return mAccount;
}
// 重置 mUpdateArray 变量，但在代码中未给出 mUpdateArray 的定义。
public void resetUpdateArray() {
mUpdateArray = null;
}

274
Notes-master2/src/net/micode/notes/gtask/remote/GTaskManager.java
Unescape View File

@ -50,41 +50,39 @@ import java.util.Map;
public class GTaskManager {
private static final String TAG = GTaskManager.class.getSimpleName();
//定义了一些实例变量，如 mActivity、mContext、mContentResolver 等，以及一些数据结构，如 mGTaskListHashMap、mGTaskHashMap、mMetaHashMap 等，用于存储同步任务的相关信息。
public static final int STATE_SUCCESS = 0;
public static final int STATE_NETWORK_ERROR = 1;
public static final int STATE_INTERNAL_ERROR = 2;
public static final int STATE_SYNC_IN_PROGRESS = 3;
public static final int STATE_SYNC_CANCELLED = 4;
//GTaskManager 采用单例模式，使用 getInstance() 方法获取实例。
private static GTaskManager mInstance = null;
private Activity mActivity;
private Activity mActivity; // 用于获取身份验证令牌
private Context mContext;
private ContentResolver mContentResolver;
private boolean mSyncing;
private boolean mCancelled;
private boolean mSyncing; // 表示是否正在进行同步
private boolean mCancelled; // 表示同步是否被取消
// 存储 Google Tasks 列表的哈希映射
private HashMap<String, TaskList> mGTaskListHashMap;
// 存储 Google Tasks 节点（任务）的哈希映射
private HashMap<String, Node> mGTaskHashMap;
// 存储 Google Tasks 的元数据的哈希映射
private HashMap<String, MetaData> mMetaHashMap;
private TaskList mMetaList; // 元数据对应的任务列表
private TaskList mMetaList;
// 存储本地已删除的任务ID
private HashSet<Long> mLocalDeleteIdMap;
// 存储 Google Tasks ID 到本地 ID 的哈希映射
private HashMap<String, Long> mGidToNid;
// 存储本地 ID 到 Google Tasks ID 的哈希映射
private HashMap<Long, String> mNidToGid;
private GTaskManager() {
@ -107,19 +105,22 @@ public class GTaskManager {
}
public synchronized void setActivityContext(Activity activity) {
// used for getting authtoken
mActivity = activity;
}
// 同步方法，接收一个上下文对象和 GTaskASyncTask 对象
public int sync(Context context, GTaskASyncTask asyncTask) {
if (mSyncing) {
if (mSyncing) { // 如果正在同步
Log.d(TAG, "Sync is in progress");
return STATE_SYNC_IN_PROGRESS;
return STATE_SYNC_IN_PROGRESS; // 返回同步进行中的状态
}
mContext = context;
mContentResolver = mContext.getContentResolver();
mSyncing = true;
mCancelled = false;
mSyncing = true; // 表示同步开始
mCancelled = false; // 同步未被取消
// 清空所有的哈希映射和集合
mGTaskListHashMap.clear();
mGTaskHashMap.clear();
mMetaHashMap.clear();
@ -128,34 +129,36 @@ public class GTaskManager {
mNidToGid.clear();
try {
// 获取Google任务客户端实例并重置更新数组
GTaskClient client = GTaskClient.getInstance();
client.resetUpdateArray();
// login google task
// 登录Google任务
if (!mCancelled) {
if (!client.login(mActivity)) {
throw new NetworkFailureException("login google task failed");
if (!client.login(mActivity)) { // 如果登录失败
throw new NetworkFailureException("login google task failed"); // 抛出网络故障异常
}
}
// get the task list from 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;
// 从Google获取任务列表
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list)); // 发布任务进度到UI线程
initGTaskList(); // 初始化Google任务列表
// 同步内容
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing)); // 发布任务进度到UI线程
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 {
// 清空任务列表HashMap、任务HashMap、元数据HashMap、本地删除ID映射、GID和NID映射，以及同步标记
mGTaskListHashMap.clear();
mGTaskHashMap.clear();
mMetaHashMap.clear();
@ -165,32 +168,33 @@ public class GTaskManager {
mSyncing = false;
}
// 根据取消标记返回状态码
return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
}
}
private void initGTaskList() throws NetworkFailureException {
if (mCancelled)
return;
GTaskClient client = GTaskClient.getInstance();
try {
JSONArray jsTaskLists = client.getTaskLists();
// init meta list first
mMetaList = null;
for (int i = 0; i < jsTaskLists.length(); i++) {
JSONObject object = jsTaskLists.getJSONObject(i);
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)) {
mMetaList = new TaskList();
mMetaList.setContentByRemoteJSON(object);
// load meta data
JSONArray jsMetas = client.getTaskList(gid);
for (int j = 0; j < jsMetas.length(); j++) {
object = (JSONObject) jsMetas.getJSONObject(j);
private void initGTaskList() throws NetworkFailureException {
if (mCancelled) // 如果取消标记为true，则直接返回
return;
GTaskClient client = GTaskClient.getInstance();
try {
JSONArray jsTaskLists = client.getTaskLists(); // 获取任务列表
// 首先初始化元数据列表
mMetaList = null;
for (int i = 0; i < jsTaskLists.length(); i++) {
JSONObject object = jsTaskLists.getJSONObject(i);
String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); // 获取任务列表的ID
String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); // 获取任务列表的名称
if (name
.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) { // 如果任务列表名称为元数据列表名称
mMetaList = new TaskList();
mMetaList.setContentByRemoteJSON(object); // 根据JSON数据填充元数据列表
// 加载元数据
JSONArray jsMetas = client.getTaskList(gid); // 获取元数据列表
for (int j = 0; j < jsMetas.length(); j++) {
object = (JSONObject) jsMetas.getJSONObject(j);
MetaData metaData = new MetaData();
metaData.setContentByRemoteJSON(object);
if (metaData.isWorthSaving()) {
@ -204,42 +208,43 @@ public class GTaskManager {
}
// create meta list if not existed
if (mMetaList == null) {
mMetaList = new TaskList();
mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ GTaskStringUtils.FOLDER_META);
GTaskClient.getInstance().createTaskList(mMetaList);
}
// create meta list if not existed
if (mMetaList == null) { // 如果元列表不存在
mMetaList = new TaskList(); // 新建元列表
mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ GTaskStringUtils.FOLDER_META); // 设置元列表名称
GTaskClient.getInstance().createTaskList(mMetaList); // 创建元列表
}
// init task list
for (int i = 0; i < jsTaskLists.length(); i++) {
JSONObject object = jsTaskLists.getJSONObject(i);
String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)
&& !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ GTaskStringUtils.FOLDER_META)) {
TaskList tasklist = new TaskList();
tasklist.setContentByRemoteJSON(object);
mGTaskListHashMap.put(gid, tasklist);
mGTaskHashMap.put(gid, tasklist);
// load tasks
JSONArray jsTasks = client.getTaskList(gid);
for (int j = 0; j < jsTasks.length(); j++) {
object = (JSONObject) jsTasks.getJSONObject(j);
gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
Task task = new Task();
task.setContentByRemoteJSON(object);
if (task.isWorthSaving()) {
task.setMetaInfo(mMetaHashMap.get(gid));
tasklist.addChildTask(task);
mGTaskHashMap.put(gid, task);
// init task list
for (int i = 0; i < jsTaskLists.length(); i++) { // 遍历任务列表
JSONObject object = jsTaskLists.getJSONObject(i); // 获取任务列表对象
String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); // 获取任务列表ID
String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); // 获取任务列表名称
if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX) // 如果任务列表以指定前缀开头
&& !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ GTaskStringUtils.FOLDER_META)) { // 并且不是元列表
TaskList tasklist = new TaskList(); // 新建任务列表
tasklist.setContentByRemoteJSON(object); // 从远程JSON设置任务列表内容
mGTaskListHashMap.put(gid, tasklist); // 将任务列表添加到哈希表中
mGTaskHashMap.put(gid, tasklist); // 将任务列表添加到哈希表中
// load tasks
JSONArray jsTasks = client.getTaskList(gid); // 获取任务列表的任务
for (int j = 0; j < jsTasks.length(); j++) { // 遍历任务
object = (JSONObject) jsTasks.getJSONObject(j); // 获取任务对象
gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); // 获取任务ID
Task task = new Task(); // 新建任务
task.setContentByRemoteJSON(object); // 从远程JSON设置任务内容
if (task.isWorthSaving()) { // 如果值得保存
task.setMetaInfo(mMetaHashMap.get(gid)); // 设置任务的元信息
tasklist.addChildTask(task); // 添加任务到任务列表中
mGTaskHashMap.put(gid, task); // 将任务添加到哈希表中
}
}
}
}
}
} catch (JSONException e) {
Log.e(TAG, e.toString());
e.printStackTrace();
@ -477,65 +482,65 @@ public class GTaskManager {
}
private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
if (mCancelled) { // 如果已经取消，则直接返回
return;
}
MetaData meta;
switch (syncType) {
case Node.SYNC_ACTION_ADD_LOCAL:
MetaData meta; // 定义一个MetaData类型的变量
switch (syncType) { // 根据syncType的值进行不同的操作
case Node.SYNC_ACTION_ADD_LOCAL: // 添加本地节点
addLocalNode(node);
break;
case Node.SYNC_ACTION_ADD_REMOTE:
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));
case Node.SYNC_ACTION_DEL_LOCAL: // 删除本地节点
meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN)); // 获取该节点的meta数据
if (meta != null) {
GTaskClient.getInstance().deleteNode(meta);
GTaskClient.getInstance().deleteNode(meta); // 删除该节点的meta数据
}
mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); // 添加该节点的ID到本地删除ID Map中
break;
case Node.SYNC_ACTION_DEL_REMOTE:
meta = mMetaHashMap.get(node.getGid());
case Node.SYNC_ACTION_DEL_REMOTE: // 删除远程节点
meta = mMetaHashMap.get(node.getGid()); // 获取该节点的meta数据
if (meta != null) {
GTaskClient.getInstance().deleteNode(meta);
GTaskClient.getInstance().deleteNode(meta); // 删除该节点的meta数据
}
GTaskClient.getInstance().deleteNode(node);
GTaskClient.getInstance().deleteNode(node); // 删除该节点
break;
case Node.SYNC_ACTION_UPDATE_LOCAL:
case Node.SYNC_ACTION_UPDATE_LOCAL: // 更新本地节点
updateLocalNode(node, c);
break;
case Node.SYNC_ACTION_UPDATE_REMOTE:
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
case Node.SYNC_ACTION_UPDATE_CONFLICT: // 更新冲突节点
// 将两个修改合并可能是个好主意
// 现在只是简单地使用本地更新
updateRemoteNode(node, c);
break;
case Node.SYNC_ACTION_NONE:
case Node.SYNC_ACTION_NONE: // 没有操作
break;
case Node.SYNC_ACTION_ERROR:
case Node.SYNC_ACTION_ERROR: // 操作错误
default:
throw new ActionFailureException("unkown sync action type");
throw new ActionFailureException("unkown sync action type"); // 抛出一个ActionFailureException异常
}
}
private void addLocalNode(Node node) throws NetworkFailureException {
if (mCancelled) {
private void addLocalNode(Node node) throws NetworkFailureException { // 添加本地节点
if (mCancelled) { // 如果已经取消，则直接返回
return;
}
SqlNote sqlNote;
if (node instanceof TaskList) {
if (node.getName().equals(
SqlNote sqlNote; // 定义一个SqlNote类型的变量
if (node instanceof TaskList) { // 如果该节点是任务列表
if (node.getName().equals( // 如果该节点的名称为MIUI_FOLDER_PREFFIX + FOLDER_DEFAULT
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) {
sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER);
} else if (node.getName().equals(
sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER); // 创建一个根文件夹SqlNote
} else if (node.getName().equals( // 如果该节点的名称为MIUI_FOLDER_PREFFIX + FOLDER_CALL_NOTE
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) {
sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER);
} else {
sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER); // 创建一个通话记录文件夹SqlNote
} else { // 否则创建一个普通文件夹
sqlNote = new SqlNote(mContext);
sqlNote.setContent(node.getLocalJSONFromContent());
sqlNote.setParentId(Notes.ID_ROOT_FOLDER);
@ -731,16 +736,24 @@ public class GTaskManager {
}
private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
// 如果 SqlNote 是笔记类型的
if (sqlNote != null && sqlNote.isNoteType()) {
// 获取 gid 对应的 MetaData
MetaData metaData = mMetaHashMap.get(gid);
if (metaData != null) {
// 更新 metaData 中 gid 对应的 meta 值
metaData.setMeta(gid, sqlNote.getContent());
// 将 metaData 加入到更新队列中
GTaskClient.getInstance().addUpdateNode(metaData);
} else {
// 创建一个新的 MetaData
metaData = new MetaData();
metaData.setMeta(gid, sqlNote.getContent());
// 将 metaData 加入到 MetaList 中，等待更新
mMetaList.addChildTask(metaData);
// 将 metaData 加入到 mMetaHashMap 中
mMetaHashMap.put(gid, metaData);
// 在 Google Tasks 中创建一个新任务
GTaskClient.getInstance().createTask(metaData);
}
}
@ -751,7 +764,7 @@ public class GTaskManager {
return;
}
// get the latest gtask list
// 获取最新的 Google 任务列表
mGTaskHashMap.clear();
mGTaskListHashMap.clear();
mMetaHashMap.clear();
@ -759,21 +772,26 @@ public class GTaskManager {
Cursor c = null;
try {
// 查询本地笔记表格，过滤掉系统笔记和垃圾桶笔记
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
"(type<>? AND parent_id<>?)", new String[] {
String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER)
}, NoteColumns.TYPE + " DESC");
if (c != null) {
while (c.moveToNext()) {
// 获取本地笔记的 gid
String gid = c.getString(SqlNote.GTASK_ID_COLUMN);
// 获取 gid 对应的 Google 任务节点
Node node = mGTaskHashMap.get(gid);
if (node != null) {
// 如果 Google 任务中存在该节点，则更新本地笔记的同步 ID
mGTaskHashMap.remove(gid);
ContentValues values = new ContentValues();
values.put(NoteColumns.SYNC_ID, node.getLastModified());
mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
c.getLong(SqlNote.ID_COLUMN)), values, null, null);
} else {
// 如果 Google 任务中不存在该节点，则说明有同步问题，抛出异常
Log.e(TAG, "something is missed");
throw new ActionFailureException(
"some local items don't have gid after sync");
@ -791,10 +809,12 @@ public class GTaskManager {
}
public String getSyncAccount() {
// 获取当前同步账户的名称
return GTaskClient.getInstance().getSyncAccount().name;
}
public void cancelSync() {
// 取消同步
mCancelled = true;
}
}

Write Preview
Loading…
Cancel
Save