pqfx375oj
/
CodeReading-MiNote
1
0
Fork 0
Code Issues Pull Requests 2 Packages Projects Releases Wiki Activity

Compare commits

base: pqfx375oj:4f9de7a38485f33da0401b38faeffc078cabb57b
Branches Tags
pqfx375oj:main
pqfx375oj:doc
pqfx375oj:src
..
compare: pqfx375oj:f1e29fc2a4f7efc7f6f495a1898c8ff37752c842
Branches Tags
pqfx375oj:main
pqfx375oj:doc
pqfx375oj:src

3 Commits
4f9de7a384 ... f1e29fc2a4

Author SHA1 Message Date
张鹏展 f1e29fc2a4 添加了zpz修改统计
8 months ago
张鹏展 1dc7b252d8 Merge branch 'src' of https://bdgit.educoder.net/pqfx375oj/CodeReading-MiNote into src
8 months ago
张鹏展 073337a9e6 gtask后面两个文件夹exception和remote，tool中四个代码
8 months ago
7 changed files with 1282 additions and 515 deletions
Show Stats

39
Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
Unescape View File

@ -1,33 +1,72 @@
/* /*
* Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
* // 版权声明，指定代码的版权所有者和代码编写的时间范围
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* // 声明该代码是根据Apache License 2.0版本授权的
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* // 提示使用者，除非符合该许可证的要求，否则不能使用此文件
* You may obtain a copy of the License at * You may obtain a copy of the License at
* // 指出如何获取许可证副本
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* // 许可证的URL链接
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
* // 指出根据许可证分发的软件是“按现状”提供的，没有明示或暗示的任何保证或条件
*/ */
<<<<<<< HEAD
package net.micode.notes.gtask.exception; // 定义该类所在的包
=======
package net.micode.notes.gtask.exception; package net.micode.notes.gtask.exception;
// 指定该Java文件的包路径
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
/**
* ActionFailureException 是一个运行时异常，表示执行操作失败的情况。
* 这个异常可以通过不同的构造函数来创建，允许提供详细的错误信息和导致异常的原因。
*/
public class ActionFailureException extends RuntimeException { public class ActionFailureException extends RuntimeException {
<<<<<<< HEAD
private static final long serialVersionUID = 4425249765923293627L; // 序列化版本UID，用于序列化机制
=======
// 声明一个名为ActionFailureException的公共类，该类继承自RuntimeException
private static final long serialVersionUID = 4425249765923293627L; private static final long serialVersionUID = 4425249765923293627L;
// 声明一个常量serialVersionUID，用于序列化时保持版本的兼容性
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
// 默认构造函数
public ActionFailureException() { public ActionFailureException() {
<<<<<<< HEAD
super(); // 调用父类的构造函数
=======
super(); super();
// 默认构造函数，调用父类RuntimeException的无参构造函数
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
} }
// 带有错误信息的构造函数
public ActionFailureException(String paramString) { public ActionFailureException(String paramString) {
<<<<<<< HEAD
super(paramString); // 调用父类构造函数，传递错误信息
=======
super(paramString); super(paramString);
// 带有一个字符串参数的构造函数，调用父类RuntimeException的带字符串参数的构造函数
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
} }
// 带有错误信息和根本原因的构造函数
public ActionFailureException(String paramString, Throwable paramThrowable) { public ActionFailureException(String paramString, Throwable paramThrowable) {
<<<<<<< HEAD
super(paramString, paramThrowable); // 调用父类构造函数，传递错误信息和原因
=======
super(paramString, paramThrowable); super(paramString, paramThrowable);
// 带有一个字符串和一个Throwable参数的构造函数，调用父类RuntimeException的相应构造函数
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
} }
} }

41
Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
Unescape View File

@ -14,20 +14,55 @@
* limitations under the License. * limitations under the License.
*/ */
<<<<<<< HEAD
package net.micode.notes.gtask.exception; // 定义包路径
/**
* NetworkFailureException 是一个自定义异常类，
* 用于表示网络故障的相关异常情况。
*/
public class NetworkFailureException extends Exception {
// 序列版本UID，用于序列化
private static final long serialVersionUID = 2107610287180234136L;
// 默认构造函数
=======
// 该类所属的包名，表明这个类是位于net.micode.notes.gtask.exception包下，用于存放相关的异常类
package net.micode.notes.gtask.exception; package net.micode.notes.gtask.exception;
// NetworkFailureException类继承自Exception，用于表示网络相关的操作出现故障时抛出的异常情况
public class NetworkFailureException extends Exception { public class NetworkFailureException extends Exception {
// 序列化版本号，用于在对象序列化和反序列化过程中确保版本的兼容性，这里是一个固定的长整型数值
private static final long serialVersionUID = 2107610287180234136L; private static final long serialVersionUID = 2107610287180234136L;
// 无参构造函数，调用父类（Exception）的无参构造函数，用于创建一个默认的NetworkFailureException实例，不附带任何详细信息
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
public NetworkFailureException() { public NetworkFailureException() {
super(); super(); // 调用父类的构造函数
} }
<<<<<<< HEAD
// 带有消息的构造函数
=======
// 带有一个字符串参数的构造函数，该字符串参数通常用于传递异常相关的详细描述信息，
// 调用父类（Exception）的对应构造函数，将传入的字符串作为异常的详细消息
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
public NetworkFailureException(String paramString) { public NetworkFailureException(String paramString) {
super(paramString); super(paramString); // 调用父类的构造函数，传入异常消息
} }
<<<<<<< HEAD
// 带有消息和原因的构造函数
=======
// 带有一个字符串参数和一个Throwable参数的构造函数，字符串参数用于传递异常相关的详细描述信息，
// Throwable参数通常用于关联引起当前异常的其他异常（例如底层网络库抛出的原始异常等），
// 调用父类（Exception）的对应构造函数进行初始化，将两个参数传递给父类构造函数
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
public NetworkFailureException(String paramString, Throwable paramThrowable) { public NetworkFailureException(String paramString, Throwable paramThrowable) {
super(paramString, paramThrowable); super(paramString, paramThrowable); // 调用父类的构造函数，传入异常消息和原因
} }
<<<<<<< HEAD
}
=======
} }
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae

203
Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
Unescape View File

@ -1,151 +1,188 @@
/* /*
* Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * 根据Apache License, Version 2.0（以下简称“许可证”）授权；
* you may not use this file except in compliance with the License. * 除非遵守许可证，否则不得使用此文件。
* You may obtain a copy of the License at * 你可以在以下网址获得许可证的副本：
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * 除非适用法律要求或书面同意，否则按“原样”提供软件
* distributed under the License is distributed on an "AS IS" BASIS, * 在许可证下分发，不附带任何明示或暗示的保证或条件。
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * 请参阅许可证，了解有关权限和限制的具体语言。
* See the License for the specific language governing permissions and
* limitations under the License.
*/ */
package net.micode.notes.gtask.remote; package net.micode.notes.gtask.remote; // 定义包名
import android.app.Notification; import android.app.Notification; // 导入通知相关类
import android.app.NotificationManager; import android.app.NotificationManager; // 导入通知管理类
import android.app.PendingIntent; import android.app.PendingIntent; // 导入待处理意图类
import android.content.Context; import android.content.Context; // 导入上下文类
import android.content.Intent; import android.content.Intent; // 导入意图类
import android.os.AsyncTask; import android.os.AsyncTask; // 导入异步任务类
import net.micode.notes.R; <<<<<<< HEAD
import net.micode.notes.ui.NotesListActivity; import net.micode.notes.R; // 导入资源文件
import net.micode.notes.ui.NotesPreferenceActivity; import net.micode.notes.ui.NotesListActivity; // 导入笔记列表活动
import net.micode.notes.ui.NotesPreferenceActivity; // 导入笔记偏好设置活动
/** // 定义GTaskASyncTask类，继承自AsyncTask
* GTaskASyncTask 是一个用于在后台执行 Google Task 同步操作的异步任务类。 public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
* 它继承自 Android 的 AsyncTask 类，处理同步过程中的通知显示和结果处理。
*/ private static int GTASK_SYNC_NOTIFICATION_ID = 5234235; // 定义用于同步通知的ID
// 定义完成监听器接口
=======
// 异步任务类，用于执行GTask同步操作
public class GTaskASyncTask extends AsyncTask<Void, String, Integer> { public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
// 定义 Google Task 同步的通知 ID // 定义GTASK同步通知的ID
private static int GTASK_SYNC_NOTIFICATION_ID = 5234235; private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
/** // 定义完成监听接口
* 定义接口 OnCompleteListener，用于在同步完成后执行特定的操作 >>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
*/
public interface OnCompleteListener { public interface OnCompleteListener {
void onComplete(); void onComplete(); // 监听完成事件
} }
// 上下文环境 <<<<<<< HEAD
private Context mContext; private Context mContext; // 上下文
private NotificationManager mNotifiManager; // 通知管理器
private GTaskManager mTaskManager; // 任务管理器
private OnCompleteListener mOnCompleteListener; // 完成监听器
// 构造函数，初始化上下文和监听器
=======
// 上下文对象
private Context mContext;
// 通知管理器 // 通知管理器
private NotificationManager mNotifiManager; private NotificationManager mNotifiManager;
// 任务管理器
// Google Task 管理器
private GTaskManager mTaskManager; private GTaskManager mTaskManager;
// 完成监听器
// 同步完成后的监听器
private OnCompleteListener mOnCompleteListener; private OnCompleteListener mOnCompleteListener;
/** // 构造函数，初始化上下文、通知管理器、任务管理器和完成监听器
* 构造函数，初始化上下文环境、监听器、通知管理器和 Google Task 管理器 >>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
* @param context 应用程序的上下文环境
* @param listener 同步完成后的监听器
*/
public GTaskASyncTask(Context context, OnCompleteListener listener) { public GTaskASyncTask(Context context, OnCompleteListener listener) {
mContext = context; mContext = context; // 设置上下文
mOnCompleteListener = listener; mOnCompleteListener = listener; // 设置完成监听器
mNotifiManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE); mNotifiManager = (NotificationManager) mContext
mTaskManager = GTaskManager.getInstance(); .getSystemService(Context.NOTIFICATION_SERVICE); // 获取通知服务
mTaskManager = GTaskManager.getInstance(); // 获取任务管理器实例
} }
/** <<<<<<< HEAD
* 取消同步操作 // 取消同步
*/ =======
// 取消同步的方法
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
public void cancelSync() { public void cancelSync() {
mTaskManager.cancelSync(); mTaskManager.cancelSync(); // 调用任务管理器的取消同步方法
} }
/** <<<<<<< HEAD
* 发布进度信息，显示在通知栏中 // 发布进度
* @param message 进度信息 public void publishProgess(String message) {
*/ publishProgress(new String[] {
message // 发布进度消息
=======
// 发布进度消息的方法
public void publishProgess(String message) { public void publishProgess(String message) {
publishProgress(new String[]{message}); publishProgress(new String[] {
message
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
});
} }
/** // 显示通知的方法
* 显示通知的方法
* @param tickerId 通知的标题资源 ID
* @param content 通知的内容
*/
private void showNotification(int tickerId, String content) { private void showNotification(int tickerId, String content) {
Notification notification = new Notification(R.drawable.notification, mContext.getString(tickerId), System.currentTimeMillis()); // 创建通知对象
Notification notification = new Notification(R.drawable.notification, mContext
.getString(tickerId), System.currentTimeMillis());
<<<<<<< HEAD
notification.defaults = Notification.DEFAULT_LIGHTS; // 设置默认灯光效果
notification.flags = Notification.FLAG_AUTO_CANCEL; // 设置自动取消标志
PendingIntent pendingIntent; // 定义待处理意图
// 根据tickerId判断要跳转的活动
if (tickerId != R.string.ticker_success) {
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
NotesPreferenceActivity.class), 0); // 启动偏好设置活动
=======
notification.defaults = Notification.DEFAULT_LIGHTS; notification.defaults = Notification.DEFAULT_LIGHTS;
notification.flags = Notification.FLAG_AUTO_CANCEL; notification.flags = Notification.FLAG_AUTO_CANCEL;
// 根据tickerId创建不同的PendingIntent
PendingIntent pendingIntent; PendingIntent pendingIntent;
if (tickerId != R.string.ticker_success) { if (tickerId != R.string.ticker_success) {
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, NotesPreferenceActivity.class), 0); pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
NotesPreferenceActivity.class), 0);
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
} else { } else {
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, NotesListActivity.class), 0); pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
NotesListActivity.class), 0); // 启动笔记列表活动
} }
notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content, pendingIntent); // 设置通知的最新事件信息
notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
pendingIntent);
<<<<<<< HEAD
mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification); // 发送通知
=======
// 发送通知
mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification); mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
} }
/** // 后台执行同步操作的方法
* 在后台线程中执行同步任务
* @param unused 无用参数
* @return 同步任务的结果状态码
*/
@Override @Override
protected Integer doInBackground(Void... unused) { protected Integer doInBackground(Void... unused) {
publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity.getSyncAccountName(mContext))); // 发布登录进度
return mTaskManager.sync(mContext, this); publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
.getSyncAccountName(mContext)));
return mTaskManager.sync(mContext, this); // 调用同步方法并返回状态
} }
/** // 更新进度的方法
* 当同步过程中有进度更新时调用此方法，在通知栏中显示进度信息
* @param progress 更新的进度信息
*/
@Override @Override
protected void onProgressUpdate(String... progress) { protected void onProgressUpdate(String... progress) {
showNotification(R.string.ticker_syncing, progress[0]); showNotification(R.string.ticker_syncing, progress[0]); // 显示同步进度通知
// 如果上下文是GTaskSyncService，则广播进度消息
if (mContext instanceof GTaskSyncService) { if (mContext instanceof GTaskSyncService) {
((GTaskSyncService) mContext).sendBroadcast(progress[0]); ((GTaskSyncService) mContext).sendBroadcast(progress[0]);
} }
} }
/** // 执行完毕后的方法
* 同步任务完成后调用此方法，根据结果状态码进行不同的处理
* @param result 同步任务的结果状态码
*/
@Override @Override
protected void onPostExecute(Integer result) { protected void onPostExecute(Integer result) {
<<<<<<< HEAD
// 根据同步结果显示相应的通知
=======
// 根据结果展示不同的通知
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
if (result == GTaskManager.STATE_SUCCESS) { if (result == GTaskManager.STATE_SUCCESS) {
showNotification(R.string.ticker_success, mContext.getString(R.string.success_sync_account, mTaskManager.getSyncAccount())); showNotification(R.string.ticker_success, mContext.getString(
NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis()); R.string.success_sync_account, mTaskManager.getSyncAccount()));
NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis()); // 记录最后同步时间
} else if (result == GTaskManager.STATE_NETWORK_ERROR) { } else if (result == GTaskManager.STATE_NETWORK_ERROR) {
showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network)); showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network)); // 显示网络错误通知
} else if (result == GTaskManager.STATE_INTERNAL_ERROR) { } else if (result == GTaskManager.STATE_INTERNAL_ERROR) {
showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal)); showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal)); // 显示内部错误通知
} else if (result == GTaskManager.STATE_SYNC_CANCELLED) { } else if (result == GTaskManager.STATE_SYNC_CANCELLED) {
showNotification(R.string.ticker_cancel, mContext.getString(R.string.error_sync_cancelled)); showNotification(R.string.ticker_cancel, mContext
.getString(R.string.error_sync_cancelled)); // 显示取消同步通知
} }
<<<<<<< HEAD
// 如果存在完成监听器，则在新线程中调用其onComplete方法
=======
// 如果存在完成监听器，则通知监听器任务完成
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
if (mOnCompleteListener != null) { if (mOnCompleteListener != null) {
new Thread(new Runnable() { new Thread(new Runnable() {
public void run() { public void run() {
mOnCompleteListener.onComplete(); mOnCompleteListener.onComplete(); // 调用完成监听器的onComplete方法
} }
}).start(); }).start();
} }
} }
} }

916
Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
View File

File diff suppressed because it is too large Load Diff

378
Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
Unescape View File

@ -1,31 +1,54 @@
/* /*
* Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) * 版权所有 (c) 2010-2011, MiCode 开源社区 (www.micode.net)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * 根据 Apache 许可证，第 2.0 版（“许可证”）许可；
* you may not use this file except in compliance with the License. * 除非遵循许可证，否则不得使用此文件。
* You may obtain a copy of the License at * 可以在以下网址获取许可证副本：
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * 除非适用于相关法律或书面协议，否则根据许可证分发的软件
* distributed under the License is distributed on an "AS IS" BASIS, * 是以“原样”基础提供，不提供任何形式的保证或条件，无论是明示的还是暗示的。
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * 请参阅许可证以了解特定语言管理权限和
* See the License for the specific language governing permissions and * 许可证下的限制。
* limitations under the License.
*/ */
// 定义包
package net.micode.notes.gtask.remote; package net.micode.notes.gtask.remote;
import android.app.Activity; // 导入需要的类
import android.content.ContentResolver; import android.app.Activity; // 用于活动管理的类
import android.content.ContentUris; import android.content.ContentResolver; // 用于内容提供者的类
import android.content.ContentValues; import android.content.ContentUris; // 处理内容 URI 的工具类
import android.content.Context; import android.content.ContentValues; // 包含 ContentProvider 插入或更新所需值的类
import android.database.Cursor; import android.content.Context; // 应用上下文类
import android.util.Log; import android.database.Cursor; // 数据库查询结果的类
import android.util.Log; // 记录日志的工具类
// 导入项目中的相关类
import net.micode.notes.R; import net.micode.notes.R;
import net.micode.notes.data.Notes; import net.micode.notes.data.Notes;
<<<<<<< HEAD
import net.micode.notes.data.Notes.DataColumns; // 数据列常量
import net.micode.notes.data.Notes.NoteColumns; // 笔记列常量
import net.micode.notes.gtask.data.MetaData; // 任务元数据类
import net.micode.notes.gtask.data.Node; // 节点类
import net.micode.notes.gtask.data.SqlNote; // SQL 笔记类
import net.micode.notes.gtask.data.Task; // 任务类
import net.micode.notes.gtask.data.TaskList; // 任务列表类
import net.micode.notes.gtask.exception.ActionFailureException; // 操作失败异常
import net.micode.notes.gtask.exception.NetworkFailureException; // 网络失败异常
import net.micode.notes.tool.DataUtils; // 数据工具类
import net.micode.notes.tool.GTaskStringUtils; // GTask 字符串工具类
import org.json.JSONArray; // JSON 数组类
import org.json.JSONException; // JSON 异常类
import org.json.JSONObject; // JSON 对象类
import java.util.HashMap; // 哈希表实现
import java.util.HashSet; // 哈希集合实现
import java.util.Iterator; // 迭代器类
=======
import net.micode.notes.data.Notes.DataColumns; import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.NoteColumns; import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.gtask.data.MetaData; import net.micode.notes.gtask.data.MetaData;
@ -47,47 +70,49 @@ import java.util.HashSet;
import java.util.Iterator; import java.util.Iterator;
import java.util.Map; import java.util.Map;
// 这是一个管理Google任务同步的类 // GTaskManager类用于管理与Google Tasks的同步操作，包括初始化任务列表、同步内容、处理各种同步类型的操作等功能
public class GTaskManager { public class GTaskManager {
private static final String TAG = GTaskManager.class.getSimpleName(); private static final String TAG = GTaskManager.class.getSimpleName();
// 同步成功状态码
public static final int STATE_SUCCESS = 0; public static final int STATE_SUCCESS = 0;
// 网络错误状态码
public static final int STATE_NETWORK_ERROR = 1; public static final int STATE_NETWORK_ERROR = 1;
// 内部错误状态码
public static final int STATE_INTERNAL_ERROR = 2; public static final int STATE_INTERNAL_ERROR = 2;
// 同步正在进行状态码
public static final int STATE_SYNC_IN_PROGRESS = 3; public static final int STATE_SYNC_IN_PROGRESS = 3;
// 同步被取消状态码
public static final int STATE_SYNC_CANCELLED = 4; public static final int STATE_SYNC_CANCELLED = 4;
private static GTaskManager mInstance = null; private static GTaskManager mInstance = null;
// 关联的Activity，用于获取授权令牌等操作
private Activity mActivity; private Activity mActivity;
// 应用上下文
private Context mContext; private Context mContext;
// 用于操作内容提供器，进行数据查询、更新等操作
private ContentResolver mContentResolver; private ContentResolver mContentResolver;
// 标记是否正在同步
private boolean mSyncing; private boolean mSyncing;
// 标记同步是否被取消
private boolean mCancelled; private boolean mCancelled;
// 存储Google Tasks任务列表的哈希表，以任务列表的全局唯一ID（GID）为键，任务列表对象为值
private HashMap<String, TaskList> mGTaskListHashMap; private HashMap<String, TaskList> mGTaskListHashMap;
// 存储Google Tasks节点（任务、任务列表等）的哈希表，以节点的全局唯一ID（GID）为键，节点对象为值
private HashMap<String, Node> mGTaskHashMap; private HashMap<String, Node> mGTaskHashMap;
// 存储元数据的哈希表，以相关的全局唯一ID为键，元数据对象为值
private HashMap<String, MetaData> mMetaHashMap; private HashMap<String, MetaData> mMetaHashMap;
// 元数据对应的任务列表
private TaskList mMetaList; private TaskList mMetaList;
// 存储本地已删除记录的ID集合，用于后续清理本地数据
private HashSet<Long> mLocalDeleteIdMap; private HashSet<Long> mLocalDeleteIdMap;
// 存储从Google Tasks的全局唯一ID（GID）到本地记录ID（NID）的映射关系
private HashMap<String, Long> mGidToNid; private HashMap<String, Long> mGidToNid;
// 存储从本地记录ID（NID）到Google Tasks的全局唯一ID（GID）的映射关系
private HashMap<Long, String> mNidToGid; private HashMap<Long, String> mNidToGid;
// 私有构造函数，防止外部实例化 // 私有构造函数，初始化相关成员变量
private GTaskManager() { private GTaskManager() {
mSyncing = false; mSyncing = false;
mCancelled = false; mCancelled = false;
@ -108,12 +133,13 @@ public class GTaskManager {
return mInstance; return mInstance;
} }
// 设置活动上下文，用于获取认证令牌 // 设置关联的Activity上下文，主要用于获取授权令牌等相关操作
public synchronized void setActivityContext(Activity activity) { public synchronized void setActivityContext(Activity activity) {
// used for getting authtoken
mActivity = activity; mActivity = activity;
} }
// 同步Google任务与本地数据库 // 执行同步操作，与Google Tasks进行数据同步
public int sync(Context context, GTaskASyncTask asyncTask) { public int sync(Context context, GTaskASyncTask asyncTask) {
if (mSyncing) { if (mSyncing) {
Log.d(TAG, "Sync is in progress"); Log.d(TAG, "Sync is in progress");
@ -123,6 +149,7 @@ public class GTaskManager {
mContentResolver = mContext.getContentResolver(); mContentResolver = mContext.getContentResolver();
mSyncing = true; mSyncing = true;
mCancelled = false; mCancelled = false;
// 清除之前同步相关的数据缓存，如任务列表、节点、元数据等的哈希表以及ID映射关系等
mGTaskListHashMap.clear(); mGTaskListHashMap.clear();
mGTaskHashMap.clear(); mGTaskHashMap.clear();
mMetaHashMap.clear(); mMetaHashMap.clear();
@ -134,18 +161,18 @@ public class GTaskManager {
GTaskClient client = GTaskClient.getInstance(); GTaskClient client = GTaskClient.getInstance();
client.resetUpdateArray(); client.resetUpdateArray();
// 登录Google任务 // 登录Google Tasks，如果取消同步则不再进行登录操作，如果登录失败则抛出网络异常
if (!mCancelled) { if (!mCancelled) {
if (!client.login(mActivity)) { if (!client.login(mActivity)) {
throw new NetworkFailureException("login google task failed"); throw new NetworkFailureException("login google task failed");
} }
} }
// 从Google获取任务列表 // 发布同步进度信息，初始化任务列表阶段
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list)); asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
initGTaskList(); initGTaskList();
// 同步内容 // 发布同步进度信息，进行内容同步阶段
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing)); asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
syncContent(); syncContent();
} catch (NetworkFailureException e) { } catch (NetworkFailureException e) {
@ -159,6 +186,7 @@ public class GTaskManager {
e.printStackTrace(); e.printStackTrace();
return STATE_INTERNAL_ERROR; return STATE_INTERNAL_ERROR;
} finally { } finally {
// 无论同步是否成功，最终都清除同步相关的数据缓存
mGTaskListHashMap.clear(); mGTaskListHashMap.clear();
mGTaskHashMap.clear(); mGTaskHashMap.clear();
mMetaHashMap.clear(); mMetaHashMap.clear();
@ -171,26 +199,28 @@ public class GTaskManager {
return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS; return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
} }
// 初始化Google任务列表 // 初始化Google Tasks任务列表相关信息，包括获取任务列表、元数据列表以及加载任务等操作
private void initGTaskList() throws NetworkFailureException { private void initGTaskList() throws NetworkFailureException {
if (mCancelled) if (mCancelled)
return; return;
GTaskClient client = GTaskClient.getInstance(); GTaskClient client = GTaskClient.getInstance();
try { try {
// 从Google Tasks获取任务列表信息，返回JSON数组形式的数据
JSONArray jsTaskLists = client.getTaskLists(); JSONArray jsTaskLists = client.getTaskLists();
// 初始化元数据列表 // 先初始化元数据列表，查找名为特定前缀加上"meta"的任务列表作为元数据列表
mMetaList = null; mMetaList = null;
for (int i = 0; i < jsTaskLists.length(); i++) { for (int i = 0; i < jsTaskLists.length(); i++) {
JSONObject object = jsTaskLists.getJSONObject(i); JSONObject object = jsTaskLists.getJSONObject(i);
String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); 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)) {
mMetaList = new TaskList(); mMetaList = new TaskList();
mMetaList.setContentByRemoteJSON(object); mMetaList.setContentByRemoteJSON(object);
// 加载元数据 // 加载元数据，获取元数据列表对应的任务列表中的具体元数据信息
JSONArray jsMetas = client.getTaskList(gid); JSONArray jsMetas = client.getTaskList(gid);
for (int j = 0; j < jsMetas.length(); j++) { for (int j = 0; j < jsMetas.length(); j++) {
object = (JSONObject) jsMetas.getJSONObject(j); object = (JSONObject) jsMetas.getJSONObject(j);
@ -206,26 +236,29 @@ public class GTaskManager {
} }
} }
// 如果元数据列表不存在则创建 // 如果元数据列表不存在，则创建一个新的元数据列表，并发送到Google Tasks服务器创建对应的任务列表
if (mMetaList == null) { if (mMetaList == null) {
mMetaList = new TaskList(); mMetaList = new TaskList();
mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META); mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ GTaskStringUtils.FOLDER_META);
GTaskClient.getInstance().createTaskList(mMetaList); GTaskClient.getInstance().createTaskList(mMetaList);
} }
// 初始化任务列表 // 初始化普通任务列表，遍历获取到的任务列表信息，创建任务列表对象并加载对应的任务信息
for (int i = 0; i < jsTaskLists.length(); i++) { for (int i = 0; i < jsTaskLists.length(); i++) {
JSONObject object = jsTaskLists.getJSONObject(i); JSONObject object = jsTaskLists.getJSONObject(i);
String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX) && !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) { if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)
&& !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ GTaskStringUtils.FOLDER_META)) {
TaskList tasklist = new TaskList(); TaskList tasklist = new TaskList();
tasklist.setContentByRemoteJSON(object); tasklist.setContentByRemoteJSON(object);
mGTaskListHashMap.put(gid, tasklist); mGTaskListHashMap.put(gid, tasklist);
mGTaskHashMap.put(gid, tasklist); mGTaskHashMap.put(gid, tasklist);
// 加载任务 // 加载任务，获取当前任务列表对应的任务信息
JSONArray jsTasks = client.getTaskList(gid); JSONArray jsTasks = client.getTaskList(gid);
for (int j = 0; j < jsTasks.length(); j++) { for (int j = 0; j < jsTasks.length(); j++) {
object = (JSONObject) jsTasks.getJSONObject(j); object = (JSONObject) jsTasks.getJSONObject(j);
@ -247,7 +280,7 @@ public class GTaskManager {
} }
} }
// 同步内容到Google任务或本地数据库 // 进行内容同步操作，处理本地与Google Tasks之间的数据同步，包括本地删除、文件夹同步、数据库中已有记录的同步等情况
private void syncContent() throws NetworkFailureException { private void syncContent() throws NetworkFailureException {
int syncType; int syncType;
Cursor c = null; Cursor c = null;
@ -260,9 +293,12 @@ public class GTaskManager {
return; return;
} }
// 同步本地删除的笔记 // 处理本地已删除的笔记（记录），查询本地回收站文件夹中的记录，对比Google Tasks中的对应节点进行相应的同步操作
try { 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) }, null); 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)
}, null);
if (c != null) { if (c != null) {
while (c.moveToNext()) { while (c.moveToNext()) {
gid = c.getString(SqlNote.GTASK_ID_COLUMN); gid = c.getString(SqlNote.GTASK_ID_COLUMN);
@ -284,12 +320,15 @@ public class GTaskManager {
} }
} }
// 同步文件夹 // 同步文件夹相关信息
syncFolder(); syncFolder();
// 同步本地存在的笔记 // 处理数据库中已存在的笔记（记录），根据其在Google Tasks中的对应情况确定同步类型，然后进行相应的同步操作
try { try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(type=? AND parent_id<>?)", new String[] { String.valueOf(Notes.TYPE_NOTE), String.valueOf(Notes.ID_TRASH_FOLER) }, NoteColumns.TYPE + " DESC"); c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
"(type=? AND parent_id<>?)", new String[] {
String.valueOf(Notes.TYPE_NOTE), String.valueOf(Notes.ID_TRASH_FOLER)
}, NoteColumns.TYPE + " DESC");
if (c != null) { if (c != null) {
while (c.moveToNext()) { while (c.moveToNext()) {
gid = c.getString(SqlNote.GTASK_ID_COLUMN); gid = c.getString(SqlNote.GTASK_ID_COLUMN);
@ -301,10 +340,10 @@ public class GTaskManager {
syncType = node.getSyncAction(c); syncType = node.getSyncAction(c);
} else { } else {
if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) { if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
// 本地新增 // 本地新增情况
syncType = Node.SYNC_ACTION_ADD_REMOTE; syncType = Node.SYNC_ACTION_ADD_REMOTE;
} else { } else {
// 远程删除 // 远程已删除情况
syncType = Node.SYNC_ACTION_DEL_LOCAL; syncType = Node.SYNC_ACTION_DEL_LOCAL;
} }
} }
@ -321,7 +360,7 @@ public class GTaskManager {
} }
} }
// 同步剩余的Google任务 // 处理剩余的在Google Tasks中存在但本地未处理的节点，进行相应的同步操作（一般是添加到本地）
Iterator<Map.Entry<String, Node>> iter = mGTaskHashMap.entrySet().iterator(); Iterator<Map.Entry<String, Node>> iter = mGTaskHashMap.entrySet().iterator();
while (iter.hasNext()) { while (iter.hasNext()) {
Map.Entry<String, Node> entry = iter.next(); Map.Entry<String, Node> entry = iter.next();
@ -329,14 +368,14 @@ public class GTaskManager {
doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null); doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
} }
// 清除本地删除的条目 // mCancelled可能被其他线程设置，所以需要逐个检查，清除本地已删除记录的相关数据（如果同步未取消）
if (!mCancelled) { if (!mCancelled) {
if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) { if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) {
throw new ActionFailureException("failed to batch-delete local deleted notes"); throw new ActionFailureException("failed to batch-delete local deleted notes");
} }
} }
// 刷新本地同步ID // 刷新本地同步ID（如果同步未取消），提交更新并进行相关操作来更新本地记录的同步ID
if (!mCancelled) { if (!mCancelled) {
GTaskClient.getInstance().commitUpdate(); GTaskClient.getInstance().commitUpdate();
refreshLocalSyncId(); refreshLocalSyncId();
@ -344,7 +383,7 @@ public class GTaskManager {
} }
// 同步文件夹到Google任务或本地数据库 // 同步文件夹相关信息，包括根文件夹、通话记录文件夹、本地已存在的文件夹以及远程新增的文件夹等情况的处理
private void syncFolder() throws NetworkFailureException { private void syncFolder() throws NetworkFailureException {
Cursor c = null; Cursor c = null;
String gid; String gid;
@ -355,9 +394,10 @@ public class GTaskManager {
return; return;
} }
// 同步根文件夹 // 处理根文件夹的同步情况，根据其在Google Tasks中的对应情况进行相应的同步操作（添加、更新等）
try { try {
c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null); c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null);
if (c != null) { if (c != null) {
c.moveToNext(); c.moveToNext();
gid = c.getString(SqlNote.GTASK_ID_COLUMN); gid = c.getString(SqlNote.GTASK_ID_COLUMN);
@ -366,8 +406,9 @@ public class GTaskManager {
mGTaskHashMap.remove(gid); mGTaskHashMap.remove(gid);
mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER); mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER);
mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid); mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid);
// 更新远程名称（如果需要） // 对于系统文件夹，仅在必要时更新远程名称
if (!node.getName().equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) if (!node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT))
doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c); doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
} else { } else {
doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c); doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
@ -382,68 +423,101 @@ public class GTaskManager {
} }
} }
// 同步通话记录文件夹 // for call-note文件夹相关的同步操作处理
// 查询通话记录文件夹在本地数据库中的信息，根据其在Google Tasks中的对应情况进行相应的同步操作（添加、更新等）
// 如果查询到该文件夹信息存在（即游标c不为空且能移动到下一条记录），则进一步处理
try { try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)", new String[] { String.valueOf(Notes.ID_CALL_RECORD_FOLDER) }, null); // 通过ContentResolver查询本地数据库中通话记录文件夹的记录信息，指定查询条件为_id等于通话记录文件夹的特定ID
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)",
new String[] {
String.valueOf(Notes.ID_CALL_RECORD_FOLDER)
}, null);
if (c != null) { if (c != null) {
if (c.moveToNext()) { if (c.moveToNext()) {
// 获取该文件夹在Google Tasks中对应的全局唯一ID（GID）
gid = c.getString(SqlNote.GTASK_ID_COLUMN); gid = c.getString(SqlNote.GTASK_ID_COLUMN);
// 根据GID从存储Google Tasks节点的哈希表中获取对应的节点对象
node = mGTaskHashMap.get(gid); node = mGTaskHashMap.get(gid);
if (node != null) { if (node != null) {
// 如果节点存在，从哈希表中移除该节点（表示已处理）
mGTaskHashMap.remove(gid); mGTaskHashMap.remove(gid);
// 在本地ID到Google Tasks的GID映射表中记录该文件夹的映射关系，键为GID，值为通话记录文件夹的本地ID
mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER); mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER);
// 在Google Tasks的GID到本地ID映射表中记录映射关系，键为本地ID，值为GID
mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid); mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid);
// 更新远程名称（如果需要） // 对于系统文件夹，仅在其名称与预期的通话记录文件夹名称不一致时（即可能有更新情况），进行远程更新操作
if (!node.getName().equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) if (!node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ GTaskStringUtils.FOLDER_CALL_NOTE))
doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c); doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
} else { } else {
// 如果节点不存在，则执行添加远程节点的操作（意味着本地有该文件夹记录，但在Google Tasks中还未创建对应节点）
doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c); doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
} }
} }
} else { } else {
// 如果查询失败，打印警告日志
Log.w(TAG, "failed to query call note folder"); Log.w(TAG, "failed to query call note folder");
} }
} finally { } finally {
// 无论查询是否成功，最终都要关闭游标，释放资源，并将游标置空
if (c != null) { if (c != null) {
c.close(); c.close();
c = null; c = null;
} }
} }
// 同步本地存在的文件夹 // 处理本地已存在的文件夹的同步情况
// 查询本地除回收站外的文件夹记录信息，根据其在Google Tasks中的对应情况进行相应的同步操作
try { try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(type=? AND parent_id<>?)", new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER) }, NoteColumns.TYPE + " DESC"); // 通过ContentResolver查询本地数据库中符合条件的文件夹记录信息，条件为类型是文件夹且父ID不等于回收站文件夹的ID
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
"(type=? AND parent_id<>?)", new String[] {
String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)
}, NoteColumns.TYPE + " DESC");
if (c != null) { if (c != null) {
while (c.moveToNext()) { while (c.moveToNext()) {
// 获取文件夹在Google Tasks中对应的全局唯一ID（GID）
gid = c.getString(SqlNote.GTASK_ID_COLUMN); gid = c.getString(SqlNote.GTASK_ID_COLUMN);
// 根据GID从存储Google Tasks节点的哈希表中获取对应的节点对象
node = mGTaskHashMap.get(gid); node = mGTaskHashMap.get(gid);
if (node != null) { if (node != null) {
// 如果节点存在，从哈希表中移除该节点（表示已处理）
mGTaskHashMap.remove(gid); mGTaskHashMap.remove(gid);
// 在本地ID到Google Tasks的GID映射表中记录该文件夹的映射关系，键为GID，值为文件夹的本地ID
mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN)); mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));
// 在Google Tasks的GID到本地ID映射表中记录映射关系，键为本地ID，值为GID
mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid); mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);
// 获取该节点对应的同步操作类型（根据节点和游标信息判断是添加、更新、删除等哪种类型）
syncType = node.getSyncAction(c); syncType = node.getSyncAction(c);
} else { } else {
// 如果节点不存在，根据其GID是否为空字符串判断是本地新增还是远程删除情况，进而确定同步类型
if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) { if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
// 本地新增 // 本地新增情况，同步类型设置为添加远程节点
syncType = Node.SYNC_ACTION_ADD_REMOTE; syncType = Node.SYNC_ACTION_ADD_REMOTE;
} else { } else {
// 远程删除 // 远程删除情况，同步类型设置为删除本地节点
syncType = Node.SYNC_ACTION_DEL_LOCAL; syncType = Node.SYNC_ACTION_DEL_LOCAL;
} }
} }
// 根据确定的同步类型执行相应的内容同步操作
doContentSync(syncType, node, c); doContentSync(syncType, node, c);
} }
} else { } else {
// 如果查询失败，打印警告日志
Log.w(TAG, "failed to query existing folder"); Log.w(TAG, "failed to query existing folder");
} }
} finally { } finally {
// 无论查询是否成功，最终都要关闭游标，释放资源，并将游标置空
if (c != null) { if (c != null) {
c.close(); c.close();
c = null; c = null;
} }
} }
// 同步远程新增的文件夹 // 处理远程新增文件夹的同步情况
// 遍历存储Google Tasks任务列表的哈希表，对于在Google
// Tasks中存在但本地未处理（还在mGTaskHashMap中）的文件夹，进行添加本地节点的同步操作
Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator(); Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
while (iter.hasNext()) { while (iter.hasNext()) {
Map.Entry<String, TaskList> entry = iter.next(); Map.Entry<String, TaskList> entry = iter.next();
@ -455,11 +529,12 @@ public class GTaskManager {
} }
} }
// 如果同步未被取消，提交Google Tasks客户端的更新操作（将之前暂存的更新操作发送到服务器执行）
if (!mCancelled) if (!mCancelled)
GTaskClient.getInstance().commitUpdate(); GTaskClient.getInstance().commitUpdate();
} }
// 执行内容同步操作 // 根据给定的同步类型执行具体的内容同步操作
private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException { private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) { if (mCancelled) {
return; return;
@ -467,12 +542,16 @@ public class GTaskManager {
MetaData meta; MetaData meta;
switch (syncType) { switch (syncType) {
// 同步类型为添加本地节点，调用相应方法进行本地节点添加操作
case Node.SYNC_ACTION_ADD_LOCAL: case Node.SYNC_ACTION_ADD_LOCAL:
addLocalNode(node); addLocalNode(node);
break; break;
// 同步类型为添加远程节点，调用相应方法进行远程节点添加操作，并传入节点和游标信息
case Node.SYNC_ACTION_ADD_REMOTE: case Node.SYNC_ACTION_ADD_REMOTE:
addRemoteNode(node, c); addRemoteNode(node, c);
break; break;
// 同步类型为删除本地节点，先从元数据哈希表中获取对应的元数据，若存在则调用Google Tasks客户端删除该元数据节点，
// 同时将本地记录的ID添加到本地已删除记录集合中
case Node.SYNC_ACTION_DEL_LOCAL: case Node.SYNC_ACTION_DEL_LOCAL:
meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN)); meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN));
if (meta != null) { if (meta != null) {
@ -480,6 +559,8 @@ public class GTaskManager {
} }
mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
break; break;
// 同步类型为删除远程节点，先从元数据哈希表中获取对应节点的元数据，若存在则调用Google Tasks客户端删除该元数据节点，
// 然后再删除该节点本身
case Node.SYNC_ACTION_DEL_REMOTE: case Node.SYNC_ACTION_DEL_REMOTE:
meta = mMetaHashMap.get(node.getGid()); meta = mMetaHashMap.get(node.getGid());
if (meta != null) { if (meta != null) {
@ -487,65 +568,84 @@ public class GTaskManager {
} }
GTaskClient.getInstance().deleteNode(node); GTaskClient.getInstance().deleteNode(node);
break; break;
// 同步类型为更新本地节点，调用相应方法进行本地节点更新操作，并传入节点和游标信息
case Node.SYNC_ACTION_UPDATE_LOCAL: case Node.SYNC_ACTION_UPDATE_LOCAL:
updateLocalNode(node, c); updateLocalNode(node, c);
break; break;
// 同步类型为更新远程节点，调用相应方法进行远程节点更新操作，并传入节点和游标信息
case Node.SYNC_ACTION_UPDATE_REMOTE: case Node.SYNC_ACTION_UPDATE_REMOTE:
updateRemoteNode(node, c); updateRemoteNode(node, c);
break; break;
// 同步类型为更新冲突，目前简单采用本地更新的方式（可能后续可以考虑合并修改等更好的处理方式），调用远程节点更新方法
case Node.SYNC_ACTION_UPDATE_CONFLICT: case Node.SYNC_ACTION_UPDATE_CONFLICT:
// 合并修改可能是更好的做法 // merging both modifications maybe a good idea
// 目前我们简单地使用本地更新 // right now just use local update simply
updateRemoteNode(node, c); updateRemoteNode(node, c);
break; break;
// 同步类型为无操作，直接跳过不做任何处理
case Node.SYNC_ACTION_NONE: case Node.SYNC_ACTION_NONE:
break; break;
// 同步类型为错误或其他未知类型，抛出操作失败异常，表示遇到了未知的同步操作类型
case Node.SYNC_ACTION_ERROR: case Node.SYNC_ACTION_ERROR:
default: default:
throw new ActionFailureException("unkown sync action type"); throw new ActionFailureException("unkown sync action type");
} }
} }
// 在本地添加Google任务节点 // 添加本地节点的操作方法
private void addLocalNode(Node node) throws NetworkFailureException { private void addLocalNode(Node node) throws NetworkFailureException {
if (mCancelled) { if (mCancelled) {
return; return;
} }
SqlNote sqlNote; SqlNote sqlNote;
// 如果节点是任务列表类型（TaskList）
if (node instanceof TaskList) { if (node instanceof TaskList) {
if (node.getName().equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) { // 如果节点名称是默认根文件夹的名称，创建一个对应根文件夹的SqlNote对象，传入上下文和根文件夹的本地ID
if (node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) {
sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER); sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER);
} else if (node.getName().equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) { } else if (node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) {
// 如果节点名称是通话记录文件夹的名称，创建一个对应通话记录文件夹的SqlNote对象，传入上下文和通话记录文件夹的本地ID
sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER); sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER);
} else { } else {
// 其他普通任务列表情况，创建一个新的SqlNote对象，传入上下文
sqlNote = new SqlNote(mContext); sqlNote = new SqlNote(mContext);
// 设置SqlNote的内容为节点的本地JSON格式内容（从节点获取）
sqlNote.setContent(node.getLocalJSONFromContent()); sqlNote.setContent(node.getLocalJSONFromContent());
// 设置父ID为根文件夹的本地ID
sqlNote.setParentId(Notes.ID_ROOT_FOLDER); sqlNote.setParentId(Notes.ID_ROOT_FOLDER);
} }
} else { } else {
// 如果节点是普通任务（Task）类型，创建一个新的SqlNote对象，传入上下文
sqlNote = new SqlNote(mContext); sqlNote = new SqlNote(mContext);
JSONObject js = node.getLocalJSONFromContent(); JSONObject js = node.getLocalJSONFromContent();
try { try {
// 如果节点的本地JSON数据中包含特定的笔记头部信息（META_HEAD_NOTE）
if (js.has(GTaskStringUtils.META_HEAD_NOTE)) { if (js.has(GTaskStringUtils.META_HEAD_NOTE)) {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
if (note.has(NoteColumns.ID)) { if (note.has(NoteColumns.ID)) {
long id = note.getLong(NoteColumns.ID); long id = note.getLong(NoteColumns.ID);
// 检查该笔记ID在本地笔记数据库中是否已存在，如果存在则移除该ID（可能需要重新生成新的ID）
if (DataUtils.existInNoteDatabase(mContentResolver, id)) { if (DataUtils.existInNoteDatabase(mContentResolver, id)) {
// ID不可用，必须创建一个新的 // the id is not available, have to create a new one
note.remove(NoteColumns.ID); note.remove(NoteColumns.ID);
} }
} }
} }
// 如果节点的本地JSON数据中包含特定的数据头部信息（META_HEAD_DATA）
if (js.has(GTaskStringUtils.META_HEAD_DATA)) { if (js.has(GTaskStringUtils.META_HEAD_DATA)) {
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
for (int i = 0; i < dataArray.length(); i++) { for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i); JSONObject data = dataArray.getJSONObject(i);
if (data.has(DataColumns.ID)) { if (data.has(DataColumns.ID)) {
long dataId = data.getLong(DataColumns.ID); long dataId = data.getLong(DataColumns.ID);
// 检查该数据ID在本地数据数据库中是否已存在，如果存在则移除该ID（可能需要重新生成新的ID）
if (DataUtils.existInDataDatabase(mContentResolver, dataId)) { if (DataUtils.existInDataDatabase(mContentResolver, dataId)) {
// Data ID不可用，必须创建一个新的 // the data id is not available, have to create
// a new one
data.remove(DataColumns.ID); data.remove(DataColumns.ID);
} }
} }
@ -556,52 +656,61 @@ public class GTaskManager {
Log.w(TAG, e.toString()); Log.w(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
} }
// 设置SqlNote的内容为处理后的JSON数据
sqlNote.setContent(js); sqlNote.setContent(js);
// 获取任务节点的父节点在本地ID到Google Tasks的GID映射表中的对应父ID，如果不存在则抛出异常表示找不到本地父ID
Long parentId = mGidToNid.get(((Task) node).getParent().getGid()); Long parentId = mGidToNid.get(((Task) node).getParent().getGid());
if (parentId == null) { if (parentId == null) {
Log.e(TAG, "cannot find task's parent id locally"); Log.e(TAG, "cannot find task's parent id locally");
throw new ActionFailureException("cannot add local node"); throw new ActionFailureException("cannot add local node");
} }
// 设置SqlNote的父ID为获取到的父节点的本地ID
sqlNote.setParentId(parentId.longValue()); sqlNote.setParentId(parentId.longValue());
} }
// 创建本地节点 // 设置SqlNote的Google Tasks全局唯一ID（GID）为节点的GID
sqlNote.setGtaskId(node.getGid()); sqlNote.setGtaskId(node.getGid());
// 将SqlNote对象提交保存到本地数据库（传入参数false可能表示不触发某些额外的相关操作）
sqlNote.commit(false); sqlNote.commit(false);
// 更新GID-NID映射 // 在本地ID到Google Tasks的GID映射表中记录该节点的映射关系，键为节点的GID，值为SqlNote的本地ID
mGidToNid.put(node.getGid(), sqlNote.getId()); mGidToNid.put(node.getGid(), sqlNote.getId());
// 在Google Tasks的GID到本地ID映射表中记录映射关系，键为SqlNote的本地ID，值为节点的GID
mNidToGid.put(sqlNote.getId(), node.getGid()); mNidToGid.put(sqlNote.getId(), node.getGid());
// 更新元数据 // 更新远程元数据，传入节点的GID和对应的SqlNote对象
updateRemoteMeta(node.getGid(), sqlNote); updateRemoteMeta(node.getGid(), sqlNote);
} }
// 更新本地Google任务节点 // 更新本地节点的操作方法
private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException { private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) { if (mCancelled) {
return; return;
} }
SqlNote sqlNote; SqlNote sqlNote;
// 更新本地笔记 // 根据传入的上下文和游标信息创建一个新的SqlNote对象，用于更新本地节点信息
sqlNote = new SqlNote(mContext, c); sqlNote = new SqlNote(mContext, c);
// 设置SqlNote的内容为节点的本地JSON格式内容（从节点获取）
sqlNote.setContent(node.getLocalJSONFromContent()); sqlNote.setContent(node.getLocalJSONFromContent());
Long parentId = (node instanceof Task) ? mGidToNid.get(((Task) node).getParent().getGid()) : new Long(Notes.ID_ROOT_FOLDER); Long parentId = (node instanceof Task) ? mGidToNid.get(((Task) node).getParent().getGid())
: new Long(Notes.ID_ROOT_FOLDER);
if (parentId == null) { if (parentId == null) {
Log.e(TAG, "cannot find task's parent id locally"); Log.e(TAG, "cannot find task's parent id locally");
throw new ActionFailureException("cannot update local node"); throw new ActionFailureException("cannot update local node");
} }
// 设置SqlNote的父ID为获取到的父节点的本地ID
sqlNote.setParentId(parentId.longValue()); sqlNote.setParentId(parentId.longValue());
// 将更新后的SqlNote对象提交保存到本地数据库（传入参数true可能表示触发某些额外的相关操作）
sqlNote.commit(true); sqlNote.commit(true);
// 更新元数据信息 // 更新远程元数据，传入节点的GID和对应的SqlNote对象
updateRemoteMeta(node.getGid(), sqlNote); updateRemoteMeta(node.getGid(), sqlNote);
} }
// 在Google任务中添加新的节点 // 添加远程节点的操作方法
private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException { private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) { if (mCancelled) {
return; return;
@ -610,9 +719,10 @@ public class GTaskManager {
SqlNote sqlNote = new SqlNote(mContext, c); SqlNote sqlNote = new SqlNote(mContext, c);
Node n; Node n;
// 远程更新 // 如果SqlNote对应的是笔记类型（即普通任务）
if (sqlNote.isNoteType()) { if (sqlNote.isNoteType()) {
Task task = new Task(); Task task = new Task();
// 设置任务的内容为从本地SqlNote获取的JSON格式内容
task.setContentByLocalJSON(sqlNote.getContent()); task.setContentByLocalJSON(sqlNote.getContent());
String parentGid = mNidToGid.get(sqlNote.getParentId()); String parentGid = mNidToGid.get(sqlNote.getParentId());
@ -620,17 +730,20 @@ public class GTaskManager {
Log.e(TAG, "cannot find task's parent tasklist"); Log.e(TAG, "cannot find task's parent tasklist");
throw new ActionFailureException("cannot add remote task"); throw new ActionFailureException("cannot add remote task");
} }
// 将任务添加到对应的父任务列表中（通过本地ID到Google Tasks的GID映射表找到父任务列表）
mGTaskListHashMap.get(parentGid).addChildTask(task); mGTaskListHashMap.get(parentGid).addChildTask(task);
// 通过Google Tasks客户端创建该任务（发送到服务器创建对应的任务节点）
GTaskClient.getInstance().createTask(task); GTaskClient.getInstance().createTask(task);
n = (Node) task; n = (Node) task;
// 添加元数据 // 更新远程元数据，传入任务的GID和对应的SqlNote对象
updateRemoteMeta(task.getGid(), sqlNote); updateRemoteMeta(task.getGid(), sqlNote);
} else { } else {
TaskList tasklist = null; TaskList tasklist = null;
// 如果文件夹已经存在则跳过 // 构建文件夹名称，先添加特定的前缀，然后根据SqlNote的本地ID判断是否是根文件夹或通话记录文件夹，添加相应的后缀名称，
// 否则添加SqlNote的摘要信息作为后缀
String folderName = GTaskStringUtils.MIUI_FOLDER_PREFFIX; String folderName = GTaskStringUtils.MIUI_FOLDER_PREFFIX;
if (sqlNote.getId() == Notes.ID_ROOT_FOLDER) if (sqlNote.getId() == Notes.ID_ROOT_FOLDER)
folderName += GTaskStringUtils.FOLDER_DEFAULT; folderName += GTaskStringUtils.FOLDER_DEFAULT;
@ -639,131 +752,179 @@ public class GTaskManager {
else else
folderName += sqlNote.getSnippet(); folderName += sqlNote.getSnippet();
// 遍历存储Google Tasks任务列表的哈希表（mGTaskListHashMap）的迭代器
Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator(); Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
while (iter.hasNext()) { while (iter.hasNext()) {
// 获取哈希表中的每一个键值对，键是任务列表的全局唯一ID（GID），值是对应的任务列表对象（TaskList）
Map.Entry<String, TaskList> entry = iter.next(); Map.Entry<String, TaskList> entry = iter.next();
String gid = entry.getKey(); String gid = entry.getKey();
TaskList list = entry.getValue(); TaskList list = entry.getValue();
// 判断当前任务列表的名称是否与之前构建的文件夹名称（folderName）相等
if (list.getName().equals(folderName)) { if (list.getName().equals(folderName)) {
// 如果相等，说明找到了对应的任务列表，将其赋值给tasklist变量
tasklist = list; tasklist = list;
// 如果在存储Google Tasks节点的哈希表（mGTaskHashMap）中包含该任务列表的GID，说明已经处理过，将其移除
if (mGTaskHashMap.containsKey(gid)) { if (mGTaskHashMap.containsKey(gid)) {
mGTaskHashMap.remove(gid); mGTaskHashMap.remove(gid);
} }
// 找到匹配的任务列表后就可以结束循环了
break; break;
} }
} }
// 如果没有匹配项则可以添加 // 如果经过上述查找没有找到匹配的任务列表（tasklist仍为null），则创建一个新的任务列表对象
if (tasklist == null) { if (tasklist == null) {
tasklist = new TaskList(); tasklist = new TaskList();
// 设置新任务列表的内容为从本地SqlNote获取的JSON格式内容
tasklist.setContentByLocalJSON(sqlNote.getContent()); tasklist.setContentByLocalJSON(sqlNote.getContent());
// 通过Google Tasks客户端创建该任务列表（发送到服务器创建对应的任务列表节点）
GTaskClient.getInstance().createTaskList(tasklist); GTaskClient.getInstance().createTaskList(tasklist);
// 将新创建的任务列表添加到存储Google Tasks任务列表的哈希表中，键为任务列表的GID，值为任务列表对象
mGTaskListHashMap.put(tasklist.getGid(), tasklist); mGTaskListHashMap.put(tasklist.getGid(), tasklist);
} }
// 将创建或找到的任务列表对象转换为Node类型并赋值给n（因为Node是更通用的节点类型，TaskList是一种特殊的Node）
n = (Node) tasklist; n = (Node) tasklist;
} }
// 更新本地笔记 // 更新本地笔记相关信息
// 设置本地SqlNote的Google Tasks全局唯一ID（GID）为n的GID，即与远程任务列表或任务对应的GID保持一致
sqlNote.setGtaskId(n.getGid()); sqlNote.setGtaskId(n.getGid());
// 将SqlNote对象提交保存到本地数据库（传入参数false可能表示不触发某些额外的相关操作，此处用于保存基本的关联信息等）
sqlNote.commit(false); sqlNote.commit(false);
// 重置本地修改标志（可能表示将本地记录标记为已与远程同步，不再是本地修改状态）
sqlNote.resetLocalModified(); sqlNote.resetLocalModified();
// 再次提交保存SqlNote对象到本地数据库（传入参数true可能表示触发一些更新相关的额外操作，确保修改标志等信息更新成功）
sqlNote.commit(true); sqlNote.commit(true);
// GID-ID映射 // gid-id映射更新
// 在本地ID到Google Tasks的GID映射表（mGidToNid）中记录该节点（n）的映射关系，键为节点的GID，值为SqlNote的本地ID
mGidToNid.put(n.getGid(), sqlNote.getId()); mGidToNid.put(n.getGid(), sqlNote.getId());
// 在Google Tasks的GID到本地ID映射表（mNidToGid）中记录映射关系，键为SqlNote的本地ID，值为节点的GID
mNidToGid.put(sqlNote.getId(), n.getGid()); mNidToGid.put(sqlNote.getId(), n.getGid());
} }
// 在Google任务中更新节点 // 更新远程节点的操作方法
private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException { private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) { if (mCancelled) {
return; return;
} }
// 根据传入的上下文和游标信息创建一个新的SqlNote对象，用于后续操作
SqlNote sqlNote = new SqlNote(mContext, c); SqlNote sqlNote = new SqlNote(mContext, c);
// 远程更新 // 远程更新操作
// 设置远程节点（node）的内容为从本地SqlNote获取的JSON格式内容，即将本地修改同步到远程节点
node.setContentByLocalJSON(sqlNote.getContent()); node.setContentByLocalJSON(sqlNote.getContent());
// 通过Google Tasks客户端将更新后的节点添加到更新队列中（后续会批量提交更新到服务器）
GTaskClient.getInstance().addUpdateNode(node); GTaskClient.getInstance().addUpdateNode(node);
// 更新元数据 // 更新远程元数据，传入节点的GID和对应的SqlNote对象
updateRemoteMeta(node.getGid(), sqlNote); updateRemoteMeta(node.getGid(), sqlNote);
// 如果需要移动任务 // 如果SqlNote对应的是笔记类型（即普通任务），则可能需要处理任务移动相关操作
if (sqlNote.isNoteType()) { if (sqlNote.isNoteType()) {
Task task = (Task) node; Task task = (Task) node;
// 获取任务当前的父任务列表
TaskList preParentList = task.getParent(); TaskList preParentList = task.getParent();
// 通过本地ID到Google Tasks的GID映射表，根据本地记录的父ID获取当前任务在远程对应的父任务列表的GID
String curParentGid = mNidToGid.get(sqlNote.getParentId()); String curParentGid = mNidToGid.get(sqlNote.getParentId());
if (curParentGid == null) { if (curParentGid == null) {
Log.e(TAG, "cannot find task's parent tasklist"); Log.e(TAG, "cannot find task's parent tasklist");
throw new ActionFailureException("cannot update remote task"); throw new ActionFailureException("cannot update remote task");
} }
// 根据获取到的GID从存储Google Tasks任务列表的哈希表中获取当前任务在远程对应的父任务列表对象
TaskList curParentList = mGTaskListHashMap.get(curParentGid); TaskList curParentList = mGTaskListHashMap.get(curParentGid);
// 如果当前任务的前后父任务列表不一致，说明任务需要在远程进行移动操作
if (preParentList != curParentList) { if (preParentList != curParentList) {
// 先从原父任务列表中移除该任务
preParentList.removeChildTask(task); preParentList.removeChildTask(task);
// 将任务添加到新的父任务列表中
curParentList.addChildTask(task); curParentList.addChildTask(task);
// 通过Google Tasks客户端执行任务移动操作，告知服务器任务在远程的位置变更
GTaskClient.getInstance().moveTask(task, preParentList, curParentList); GTaskClient.getInstance().moveTask(task, preParentList, curParentList);
} }
} }
// 清除本地修改标志 // 清除本地修改标志，标记本地记录已同步到远程，不再处于本地修改状态
sqlNote.resetLocalModified(); sqlNote.resetLocalModified();
// 将更新后的SqlNote对象提交保存到本地数据库（传入参数true可能表示触发一些更新相关的额外操作，确保修改标志等信息更新成功）
sqlNote.commit(true); sqlNote.commit(true);
} }
// 更新Google任务中的元数据 // 更新远程元数据的操作方法
private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException { private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
if (sqlNote != null && sqlNote.isNoteType()) { if (sqlNote != null && sqlNote.isNoteType()) {
// 从存储元数据的哈希表（mMetaHashMap）中根据GID获取对应的元数据对象（MetaData）
MetaData metaData = mMetaHashMap.get(gid); MetaData metaData = mMetaHashMap.get(gid);
if (metaData != null) { if (metaData != null) {
// 如果元数据对象存在，设置其元数据内容，传入GID和从本地SqlNote获取的JSON格式内容
metaData.setMeta(gid, sqlNote.getContent()); metaData.setMeta(gid, sqlNote.getContent());
// 通过Google Tasks客户端将更新后的元数据添加到更新队列中（后续会批量提交更新到服务器）
GTaskClient.getInstance().addUpdateNode(metaData); GTaskClient.getInstance().addUpdateNode(metaData);
} else { } else {
// 如果元数据对象不存在，则创建一个新的元数据对象
metaData = new MetaData(); metaData = new MetaData();
// 设置新元数据对象的元数据内容，传入GID和从本地SqlNote获取的JSON格式内容
metaData.setMeta(gid, sqlNote.getContent()); metaData.setMeta(gid, sqlNote.getContent());
// 将新创建的元数据对象添加到元数据列表（mMetaList）中作为子任务（从逻辑上关联起来）
mMetaList.addChildTask(metaData); mMetaList.addChildTask(metaData);
// 将新创建的元数据对象添加到存储元数据的哈希表中，键为GID，值为元数据对象
mMetaHashMap.put(gid, metaData); mMetaHashMap.put(gid, metaData);
// 通过Google Tasks客户端创建该元数据任务（发送到服务器创建对应的元数据节点）
GTaskClient.getInstance().createTask(metaData); GTaskClient.getInstance().createTask(metaData);
} }
} }
} }
// 刷新本地同步ID // 刷新本地同步ID的操作方法
private void refreshLocalSyncId() throws NetworkFailureException { private void refreshLocalSyncId() throws NetworkFailureException {
if (mCancelled) { if (mCancelled) {
return; return;
} }
// 获取最新的Google任务列表 // 为了获取最新的Google Tasks列表信息，先清空之前存储相关信息的哈希表
mGTaskHashMap.clear(); mGTaskHashMap.clear();
mGTaskListHashMap.clear(); mGTaskListHashMap.clear();
mMetaHashMap.clear(); mMetaHashMap.clear();
// 重新初始化Google Tasks列表信息（重新获取任务列表、元数据等相关内容）
initGTaskList(); initGTaskList();
Cursor c = null; Cursor c = null;
try { 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"); // 通过ContentResolver查询本地数据库中除系统类型且不在回收站的笔记记录信息，按照类型降序排列
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) { if (c != null) {
while (c.moveToNext()) { while (c.moveToNext()) {
// 获取笔记在Google Tasks中对应的全局唯一ID（GID）
String gid = c.getString(SqlNote.GTASK_ID_COLUMN); String gid = c.getString(SqlNote.GTASK_ID_COLUMN);
// 根据GID从存储Google Tasks节点的哈希表中获取对应的节点对象
Node node = mGTaskHashMap.get(gid); Node node = mGTaskHashMap.get(gid);
if (node != null) { if (node != null) {
// 如果节点存在，从哈希表中移除该节点（表示已处理）
mGTaskHashMap.remove(gid); mGTaskHashMap.remove(gid);
// 创建一个ContentValues对象用于存放要更新的数据，此处将同步ID设置为节点的最后修改时间
ContentValues values = new ContentValues(); ContentValues values = new ContentValues();
values.put(NoteColumns.SYNC_ID, node.getLastModified()); values.put(NoteColumns.SYNC_ID, node.getLastModified());
mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(SqlNote.ID_COLUMN)), values, null, null); // 通过ContentResolver更新本地数据库中对应笔记的记录，设置同步ID字段的值
mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
c.getLong(SqlNote.ID_COLUMN)), values, null, null);
} else { } else {
Log.e(TAG, "something is missed"); Log.e(TAG, "something is missed");
throw new ActionFailureException("some local items don't have gid after sync"); throw new ActionFailureException(
"some local items don't have gid after sync");
} }
} }
} else { } else {
Log.w(TAG, "failed to query local note to refresh sync id"); Log.w(TAG, "failed to query local note to refresh sync id");
} }
} finally { } finally {
// 无论查询是否成功，最终都要关闭游标，释放资源，并将游标置空
if (c != null) { if (c != null) {
c.close(); c.close();
c = null; c = null;
@ -771,13 +932,14 @@ public class GTaskManager {
} }
} }
// 获取同步账户 // 获取同步账户名称的方法，通过Google Tasks客户端获取同步账户对象，并返回其名称
public String getSyncAccount() { public String getSyncAccount() {
return GTaskClient.getInstance().getSyncAccount().name; return GTaskClient.getInstance().getSyncAccount().name;
} }
// 取消同步 // 取消同步的方法，将表示同步是否取消的标志（mCancelled）设置为true，其他相关操作可以根据该标志来判断是否停止执行
public void cancelSync() { public void cancelSync() {
mCancelled = true; mCancelled = true;
} }
} }
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae

218
Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java
Unescape View File

@ -13,136 +13,268 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package net.micode.notes.gtask.remote; package net.micode.notes.gtask.remote;
import android.app.Activity; import android.app.Activity;
import android.app.Service; import android.app.Service;
import android.content.Context; import android.content.Context;
import android.content.Intent; import android.content.Intent;
import android.os.Bundle; import android.os.Bundle;
import android.os.IBinder; import android.os.IBinder;
// GTaskSyncService 是一个用于同步任务的服务类 <<<<<<< HEAD
/**
* GTaskSyncService 是一个用于处理 Google 任务同步的服务类。
* 该类扩展自 Android 的 Service 类，负责执行同步操作。
*/
public class GTaskSyncService extends Service { public class GTaskSyncService extends Service {
// 定义同步操作的 action 类型名称 // 主要用于标识同步动作的字符串名称
public final static String ACTION_STRING_NAME = "sync_action_type"; public final static String ACTION_STRING_NAME = "sync_action_type";
// 定义开始同步的 action 类型 // 开始同步的操作类型常量
public final static int ACTION_START_SYNC = 0; public final static int ACTION_START_SYNC = 0;
// 定义取消同步的 action 类型 // 取消同步的操作类型常量
public final static int ACTION_CANCEL_SYNC = 1; public final static int ACTION_CANCEL_SYNC = 1;
// 定义无效的 action 类型 // 无效的操作类型常量
public final static int ACTION_INVALID = 2; public final static int ACTION_INVALID = 2;
// 定义同步服务广播名称 // 广播名称，用于通知同步服务的状态
public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service"; public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
// 定义同步服务广播中是否正在同步的键名 // 广播参数，用于标识当前是否正在同步
public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing"; public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
// 定义同步服务广播中进度信息的键名 // 广播参数，用于传递同步进度消息
public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg"; public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
// 静态变量，用于存储同步任务实例 // 静态变量，表示当前的异步任务
private static GTaskASyncTask mSyncTask = null; private static GTaskASyncTask mSyncTask = null;
// 静态变量，用于存储同步进度信息 // 存储当前同步的进度信息
private static String mSyncProgress = ""; private static String mSyncProgress = "";
// 启动同步任务的方法 /**
* 启动同步任务的方法
*/
private void startSync() { private void startSync() {
// 如果没有正在进行的同步任务，则创建并启动新的任务
=======
// GTaskSyncService类继承自Service，用于管理与Google Tasks的同步相关操作，包括启动同步、取消同步以及广播同步状态等功能
public class GTaskSyncService extends Service {
// 用于在Intent中传递同步操作类型的字符串常量，作为键来标识具体的操作类型信息
public final static String ACTION_STRING_NAME = "sync_action_type";
// 表示启动同步操作的整数值常量，用于在根据操作类型进行判断时识别启动同步的意图
public final static int ACTION_START_SYNC = 0;
// 表示取消同步操作的整数值常量，用于在根据操作类型进行判断时识别取消同步的意图
public final static int ACTION_CANCEL_SYNC = 1;
// 表示无效操作类型的整数值常量，当获取到的操作类型不匹配已知的有效类型时使用该值来标识
public final static int ACTION_INVALID = 2;
// 用于广播同步服务相关状态信息的Intent的动作名称，其他组件可以通过注册监听该动作来接收同步服务的广播消息
public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
// 在广播Intent中用于传递是否正在同步状态的键名，对应的值为布尔类型，表示同步操作是否正在进行
public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
// 在广播Intent中用于传递同步进度消息的键名，对应的值为字符串类型，可用于展示同步操作的进度相关文本信息
public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
// 静态变量，用于存储正在执行的同步任务对象（GTaskASyncTask类型），方便在不同方法中对同步任务进行控制和判断状态
private static GTaskASyncTask mSyncTask = null;
// 静态变量，用于存储同步进度相关的消息字符串，可通过广播传递给其他关注同步进度的组件
private static String mSyncProgress = "";
// 启动同步的私有方法，用于创建并执行同步任务
private void startSync() {
// 如果当前没有正在执行的同步任务（mSyncTask为null）
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
if (mSyncTask == null) { if (mSyncTask == null) {
// 创建一个新的GTaskASyncTask对象，传入当前服务上下文（this）以及一个完成监听器（OnCompleteListener）
mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() { mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
// 当同步任务完成时会调用的回调方法
public void onComplete() { public void onComplete() {
<<<<<<< HEAD
// 同步任务完成后，重置任务状态并发送广播
=======
// 将正在执行的同步任务对象置为null，表示同步已结束
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
mSyncTask = null; mSyncTask = null;
// 发送一个空消息的广播（可能用于通知其他组件同步已完成等状态变化）
sendBroadcast(""); sendBroadcast("");
// 停止当前服务（因为同步任务已完成，服务的主要工作完成，可以停止自身运行）
stopSelf(); stopSelf();
} }
}); });
<<<<<<< HEAD
// 发送初始广播，表示同步开始
sendBroadcast(""); sendBroadcast("");
// 执行异步任务
=======
// 发送一个空消息的广播（可能在创建任务后就先通知其他组件同步即将开始等情况）
sendBroadcast("");
// 执行同步任务，开始真正的同步操作流程
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
mSyncTask.execute(); mSyncTask.execute();
} }
} }
// 取消同步任务的方法 <<<<<<< HEAD
/**
* 取消当前同步任务的方法
*/
=======
// 取消同步的私有方法，用于取消正在执行的同步任务（如果存在的话）
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
private void cancelSync() { private void cancelSync() {
// 如果有正在进行的同步任务，则取消该任务
if (mSyncTask != null) { if (mSyncTask != null) {
mSyncTask.cancelSync(); mSyncTask.cancelSync();
} }
} }
// 服务创建时的回调方法 // 服务创建时调用的方法，在这里将正在执行的同步任务对象初始化为null，确保服务启动时处于初始状态
@Override @Override
public void onCreate() { public void onCreate() {
// 服务创建时，初始化同步任务为空
mSyncTask = null; mSyncTask = null;
} }
// 服务启动命令的回调方法 // 当服务通过startService()方法启动时会调用此方法，用于处理传入的Intent并根据不同的操作意图执行相应操作
@Override @Override
public int onStartCommand(Intent intent, int flags, int startId) { public int onStartCommand(Intent intent, int flags, int startId) {
<<<<<<< HEAD
// 从 Intent 中获取数据
=======
// 从传入的Intent中获取附加的Bundle数据（通常用于传递额外的参数信息）
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
Bundle bundle = intent.getExtras(); Bundle bundle = intent.getExtras();
// 如果获取到的Bundle不为null且包含表示操作类型的键（ACTION_STRING_NAME）
if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) { if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
// 根据操作类型的值进行不同的操作分支判断
switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) { switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
// 如果操作类型是启动同步（ACTION_START_SYNC）
case ACTION_START_SYNC: case ACTION_START_SYNC:
// 开始同步操作
startSync(); startSync();
break; break;
// 如果操作类型是取消同步（ACTION_CANCEL_SYNC）
case ACTION_CANCEL_SYNC: case ACTION_CANCEL_SYNC:
// 取消同步操作
cancelSync(); cancelSync();
break; break;
// 其他未知或不处理的操作类型，直接跳过不做操作
default: default:
break; break;
} }
<<<<<<< HEAD
// 返回服务的启动模式
=======
// 返回START_STICKY表示服务在被系统意外终止后会尝试重新创建并保持启动状态（常用于需要持续运行的服务场景）
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
return START_STICKY; return START_STICKY;
} }
// 如果不符合上述条件或者操作类型无效等情况，调用父类的onStartCommand方法进行默认处理
return super.onStartCommand(intent, flags, startId); return super.onStartCommand(intent, flags, startId);
} }
// 服务内存不足时的回调方法 // 当系统内存不足时会调用此方法，在这里用于取消正在执行的同步任务（如果存在的话），释放内存资源
@Override @Override
public void onLowMemory() { public void onLowMemory() {
// 当系统内存不足时，取消同步任务
if (mSyncTask != null) { if (mSyncTask != null) {
mSyncTask.cancelSync(); mSyncTask.cancelSync();
} }
} }
// 返回服务的 IBinder 对象 <<<<<<< HEAD
=======
// 用于服务绑定操作的方法，这里返回null表示不支持绑定操作（如果需要支持绑定，需要返回一个有效的IBinder对象）
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
@Override
public IBinder onBind(Intent intent) { public IBinder onBind(Intent intent) {
// 返回 null 表示不提供绑定服务的功能
return null; return null;
} }
// 发送同步进度广播的方法 <<<<<<< HEAD
/**
* 发送广播以更新同步状态和进度消息
*/
=======
// 发送广播的公共方法，用于向其他组件广播同步服务的相关状态信息，包括同步进度消息、是否正在同步等
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
public void sendBroadcast(String msg) { public void sendBroadcast(String msg) {
mSyncProgress = msg; mSyncProgress = msg;
// 创建 Intent 用于发送广播
Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME); Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
// 设置当前是否正在同步的标志
intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null); intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null);
// 设置进度消息
intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg); intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg);
// 发送广播
sendBroadcast(intent); sendBroadcast(intent);
} }
// 静态方法，用于启动同步服务 <<<<<<< HEAD
/**
* 启动同步操作的静态方法
*/
public static void startSync(Activity activity) {
// 设置活动上下文
=======
// 静态公共方法，用于在外部（比如Activity中）启动同步服务进行同步操作，需要传入对应的Activity作为上下文来启动服务
public static void startSync(Activity activity) { public static void startSync(Activity activity) {
// 设置GTaskManager的Activity上下文（可能用于获取相关授权等操作，与同步操作相关联）
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
GTaskManager.getInstance().setActivityContext(activity); GTaskManager.getInstance().setActivityContext(activity);
Intent intent = new Intent(activity, GTaskSyncService.class); Intent intent = new Intent(activity, GTaskSyncService.class);
// 添加启动同步的指令
intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC); intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC);
// 启动服务
activity.startService(intent); activity.startService(intent);
} }
// 静态方法，用于取消同步服务 <<<<<<< HEAD
/**
* 取消同步操作的静态方法
*/
=======
// 静态公共方法，用于在外部（比如其他组件中）取消正在进行的同步操作，需要传入上下文（Context）来启动服务发送取消同步的意图
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
public static void cancelSync(Context context) { public static void cancelSync(Context context) {
Intent intent = new Intent(context, GTaskSyncService.class); Intent intent = new Intent(context, GTaskSyncService.class);
// 添加取消同步的指令
intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC); intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC);
// 启动服务
context.startService(intent); context.startService(intent);
} }
// 检查是否正在同步的方法 <<<<<<< HEAD
/**
* 判断当前是否正在同步的静态方法
*/
=======
// 静态公共方法，用于判断当前是否正在进行同步操作，通过检查正在执行的同步任务对象是否为null来返回相应的布尔值结果
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
public static boolean isSyncing() { public static boolean isSyncing() {
return mSyncTask != null; return mSyncTask != null;
} }
// 获取同步进度信息的方法 <<<<<<< HEAD
/**
* 获取当前同步进度的字符串信息
*/
=======
// 静态公共方法，用于获取当前的同步进度相关的字符串消息，返回存储同步进度消息的静态变量的值
>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
public static String getProgressString() { public static String getProgressString() {
return mSyncProgress; return mSyncProgress;
} }

2
代码注释统计.txt
Unescape View File

@ -3,6 +3,8 @@ ui中14段代码
程星桦： 程星桦：
张鹏展： 张鹏展：
gtask中exception和remote中共6段代码
tool中4段代码
文渤乔： 文渤乔：
data中4段代码 data中4段代码

Write Preview
Loading…
Cancel
Save