Merge branch 'main' of https://bdgit.educoder.net/pqfx375oj/Code-Reading-MiNote

# Conflicts:
#	src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
#	src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
#	src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
#	src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
#	src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
#	src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java

src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java

@@ -1,40 +1,72 @@
 /*
  * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ * // 版权声明，指定代码的版权所有者和代码编写的时间范围
  *
  * 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 obtain a copy of the License at
+ * // 指出如何获取许可证副本
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
+ * // 许可证的URL链接
  *
  * 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.
+ * // 指出根据许可证分发的软件是“按现状”提供的，没有明示或暗示的任何保证或条件
  */
 
+<<<<<<< HEAD
 package net.micode.notes.gtask.exception; // 定义该类所在的包
+=======
+package net.micode.notes.gtask.exception;
+// 指定该Java文件的包路径
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
 
 /**
  * ActionFailureException 是一个运行时异常，表示执行操作失败的情况。
  * 这个异常可以通过不同的构造函数来创建，允许提供详细的错误信息和导致异常的原因。
  */
 public class ActionFailureException extends RuntimeException {
+<<<<<<< HEAD
     private static final long serialVersionUID = 4425249765923293627L; // 序列化版本UID，用于序列化机制
+=======
+    // 声明一个名为ActionFailureException的公共类，该类继承自RuntimeException
+    private static final long serialVersionUID = 4425249765923293627L;
+    // 声明一个常量serialVersionUID，用于序列化时保持版本的兼容性
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
 
     // 默认构造函数
     public ActionFailureException() {
+<<<<<<< HEAD
         super(); // 调用父类的构造函数
+=======
+        super();
+        // 默认构造函数，调用父类RuntimeException的无参构造函数
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     }
 
     // 带有错误信息的构造函数
     public ActionFailureException(String paramString) {
+<<<<<<< HEAD
         super(paramString); // 调用父类构造函数，传递错误信息
+=======
+        super(paramString);
+        // 带有一个字符串参数的构造函数，调用父类RuntimeException的带字符串参数的构造函数
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     }
 
     // 带有错误信息和根本原因的构造函数
     public ActionFailureException(String paramString, Throwable paramThrowable) {
+<<<<<<< HEAD
         super(paramString, paramThrowable); // 调用父类构造函数，传递错误信息和原因
+=======
+        super(paramString, paramThrowable);
+        // 带有一个字符串和一个Throwable参数的构造函数，调用父类RuntimeException的相应构造函数
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     }
 }

src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java

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

src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java

@@ -1,17 +1,15 @@
 /*
  * 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
  *
- * 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; // 定义包名
@@ -23,6 +21,7 @@ import android.content.Context; // 导入上下文类
 import android.content.Intent; // 导入意图类
 import android.os.AsyncTask; // 导入异步任务类
 
+<<<<<<< HEAD
 import net.micode.notes.R; // 导入资源文件
 import net.micode.notes.ui.NotesListActivity; // 导入笔记列表活动
 import net.micode.notes.ui.NotesPreferenceActivity; // 导入笔记偏好设置活动
@@ -33,16 +32,38 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
     private static int GTASK_SYNC_NOTIFICATION_ID = 5234235; // 定义用于同步通知的ID
 
     // 定义完成监听器接口
+=======
+// 异步任务类，用于执行GTask同步操作
+public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
+
+    // 定义GTASK同步通知的ID
+    private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
+
+    // 定义完成监听接口
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public interface OnCompleteListener {
         void onComplete(); // 监听完成事件
     }
 
+<<<<<<< HEAD
     private Context mContext; // 上下文
     private NotificationManager mNotifiManager; // 通知管理器
     private GTaskManager mTaskManager; // 任务管理器
     private OnCompleteListener mOnCompleteListener; // 完成监听器
 
     // 构造函数，初始化上下文和监听器
+=======
+    // 上下文对象
+    private Context mContext;
+    // 通知管理器
+    private NotificationManager mNotifiManager;
+    // 任务管理器
+    private GTaskManager mTaskManager;
+    // 完成监听器
+    private OnCompleteListener mOnCompleteListener;
+
+    // 构造函数，初始化上下文、通知管理器、任务管理器和完成监听器
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public GTaskASyncTask(Context context, OnCompleteListener listener) {
         mContext = context; // 设置上下文
         mOnCompleteListener = listener; // 设置完成监听器
@@ -51,15 +72,26 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
         mTaskManager = GTaskManager.getInstance(); // 获取任务管理器实例
     }
 
+<<<<<<< HEAD
     // 取消同步
+=======
+    // 取消同步的方法
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public void cancelSync() {
         mTaskManager.cancelSync(); // 调用任务管理器的取消同步方法
     }
 
+<<<<<<< HEAD
     // 发布进度
     public void publishProgess(String message) {
         publishProgress(new String[] {
             message // 发布进度消息
+=======
+    // 发布进度消息的方法
+    public void publishProgess(String message) {
+        publishProgress(new String[] {
+                message
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         });
     }
 
@@ -68,6 +100,7 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
         // 创建通知对象
         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; // 定义待处理意图
@@ -76,6 +109,15 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
             pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
                     NotesPreferenceActivity.class), 0); // 启动偏好设置活动
 
+=======
+        notification.defaults = Notification.DEFAULT_LIGHTS;
+        notification.flags = Notification.FLAG_AUTO_CANCEL;
+        // 根据tickerId创建不同的PendingIntent
+        PendingIntent pendingIntent;
+        if (tickerId != R.string.ticker_success) {
+            pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+                    NotesPreferenceActivity.class), 0);
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         } else {
             pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
                     NotesListActivity.class), 0); // 启动笔记列表活动
@@ -83,9 +125,15 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
         // 设置通知的最新事件信息
         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);
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     }
 
+    // 后台执行同步操作的方法
     @Override
     protected Integer doInBackground(Void... unused) {
         // 发布登录进度
@@ -94,6 +142,7 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
         return mTaskManager.sync(mContext, this); // 调用同步方法并返回状态
     }
 
+    // 更新进度的方法
     @Override
     protected void onProgressUpdate(String... progress) {
         showNotification(R.string.ticker_syncing, progress[0]); // 显示同步进度通知
@@ -103,9 +152,14 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
         }
     }
 
+    // 执行完毕后的方法
     @Override
     protected void onPostExecute(Integer result) {
+<<<<<<< HEAD
         // 根据同步结果显示相应的通知
+=======
+        // 根据结果展示不同的通知
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         if (result == GTaskManager.STATE_SUCCESS) {
             showNotification(R.string.ticker_success, mContext.getString(
                     R.string.success_sync_account, mTaskManager.getSyncAccount()));
@@ -118,7 +172,11 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
             showNotification(R.string.ticker_cancel, mContext
                     .getString(R.string.error_sync_cancelled)); // 显示取消同步通知
         }
+<<<<<<< HEAD
         // 如果存在完成监听器，则在新线程中调用其onComplete方法
+=======
+        // 如果存在完成监听器，则通知监听器任务完成
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         if (mOnCompleteListener != null) {
             new Thread(new Runnable() {
                 public void run() {

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

@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 /*
  * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
  *
@@ -15,6 +16,8 @@
  */
 
 // 定义包名
+=======
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
 package net.micode.notes.gtask.remote;
 
 // 导入相关类和接口
@@ -55,6 +58,7 @@ import org.json.JSONArray; // 引入JSON数组类
 import org.json.JSONException; // 引入JSON异常类
 import org.json.JSONObject; // 引入JSON对象类
 
+<<<<<<< HEAD
 // 引入JDK类
 import java.io.BufferedReader; // 引入缓冲读取器类
 import java.io.IOException; // 引入IO异常类
@@ -67,18 +71,30 @@ import java.util.zip.Inflater; // 引入解压缩类
 import java.util.zip.InflaterInputStream; // 引入解压缩输入流类
 
 // GTaskClient类负责处理与Google任务(GTask)的通信
+=======
+// GTaskClient类用于与Google Tasks进行交互，实现诸如登录、任务和任务列表的创建、更新、移动、删除以及获取相关数据等功能
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
 public class GTaskClient {
     // 日志标签
     private static final String TAG = GTaskClient.class.getSimpleName();
 
+<<<<<<< HEAD
     // Google任务相关的URL
     private static final String GTASK_URL = "https://mail.google.com/tasks/";
     private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
+=======
+    // Google Tasks的基础URL
+    private static final String GTASK_URL = "https://mail.google.com/tasks/";
+    // 用于获取Google Tasks数据的URL
+    private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
+    // 用于向Google Tasks发送POST请求的URL
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
 
     // 单例实例
     private static GTaskClient mInstance = null;
 
+<<<<<<< HEAD
     // HTTP客户端
     private DefaultHttpClient mHttpClient;
 
@@ -97,6 +113,28 @@ public class GTaskClient {
     private JSONArray mUpdateArray;
 
     // 私有构造函数，初始化类的成员变量
+=======
+    // 用于发送HTTP请求的HttpClient对象
+    private DefaultHttpClient mHttpClient;
+    // 获取数据的具体URL
+    private String mGetUrl;
+    // 发送POST请求的具体URL
+    private String mPostUrl;
+    // 客户端版本号
+    private long mClientVersion;
+    // 标记是否已登录
+    private boolean mLoggedin;
+    // 上次登录的时间戳
+    private long mLastLoginTime;
+    // 用于标识操作的ID，每次操作自增
+    private int mActionId;
+    // 当前使用的账户
+    private Account mAccount;
+    // 用于暂存更新操作相关数据的JSON数组
+    private JSONArray mUpdateArray;
+
+    // 私有构造函数，初始化相关成员变量
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     private GTaskClient() {
         mHttpClient = null;
         mGetUrl = GTASK_GET_URL;
@@ -109,7 +147,11 @@ public class GTaskClient {
         mUpdateArray = null;
     }
 
+<<<<<<< HEAD
     // 获取单例实例
+=======
+    // 获取GTaskClient的单例实例
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public static synchronized GTaskClient getInstance() {
         if (mInstance == null) {
             mInstance = new GTaskClient();
@@ -117,17 +159,31 @@ public class GTaskClient {
         return mInstance;
     }
 
+<<<<<<< HEAD
     // 登录方法
     public boolean login(Activity activity) {
         // 假设cookie在5分钟后过期
+=======
+    // 执行登录操作
+    public boolean login(Activity activity) {
+        // 假设Cookie在5分钟后过期，若距离上次登录时间超过5分钟，则需要重新登录
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         final long interval = 1000 * 60 * 5;
         if (mLastLoginTime + interval < System.currentTimeMillis()) {
             mLoggedin = false;  // 如果超时，设置未登录
         }
 
+<<<<<<< HEAD
         // 如果账户切换，需要重新登录
         if (mLoggedin && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity.getSyncAccountName(activity))) {
             mLoggedin = false; // 账户切换，重新登录
+=======
+        // 如果已登录，但当前账户与设置中的同步账户不一致，也需要重新登录
+        if (mLoggedin
+                && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
+                        .getSyncAccountName(activity))) {
+            mLoggedin = false;
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         }
 
         // 若已经登录，无需再次登录
@@ -136,15 +192,27 @@ public class GTaskClient {
             return true;
         }
 
+<<<<<<< HEAD
         mLastLoginTime = System.currentTimeMillis(); // 更新最后登录时间
         String authToken = loginGoogleAccount(activity, false); // 获取Google账户的认证令牌
+=======
+        mLastLoginTime = System.currentTimeMillis();
+        // 登录Google账户获取授权令牌
+        String authToken = loginGoogleAccount(activity, false);
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         if (authToken == null) {
             Log.e(TAG, "login google account failed");
             return false; // 登录失败
         }
 
+<<<<<<< HEAD
         // 如果为自定义域，则尝试进行登录
         if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase().endsWith("googlemail.com"))) {
+=======
+        // 如果账户不是以gmail.com或googlemail.com结尾（可能是自定义域名），则使用自定义域名相关的URL进行登录
+        if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()
+                .endsWith("googlemail.com"))) {
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             StringBuilder url = new StringBuilder(GTASK_URL).append("a/");
             int index = mAccount.name.indexOf('@') + 1;
             String suffix = mAccount.name.substring(index);
@@ -157,7 +225,11 @@ public class GTaskClient {
             }
         }
 
+<<<<<<< HEAD
         // 尝试以 Google 官方 URL 登录
+=======
+        // 如果使用自定义域名登录失败，则尝试使用Google官方URL登录
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         if (!mLoggedin) {
             mGetUrl = GTASK_GET_URL; // 恢复默认的GET请求URL
             mPostUrl = GTASK_POST_URL; // 恢复默认的POST请求URL
@@ -170,11 +242,21 @@ public class GTaskClient {
         return true;
     }
 
+<<<<<<< HEAD
     // 获取Google账户认证令牌的方法
     private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
         String authToken;
         AccountManager accountManager = AccountManager.get(activity); // 获取账户管理器
         Account[] accounts = accountManager.getAccountsByType("com.google"); // 获取Google账户
+=======
+    // 登录Google账户获取授权令牌
+    private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
+        String authToken;
+        // 获取账户管理器
+        AccountManager accountManager = AccountManager.get(activity);
+        // 获取所有Google类型的账户
+        Account[] accounts = accountManager.getAccountsByType("com.google");
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
 
         // 如果没有可用的Google账户，日志记录并返回null
         if (accounts.length == 0) {
@@ -182,7 +264,12 @@ public class GTaskClient {
             return null;
         }
 
+<<<<<<< HEAD
         String accountName = NotesPreferenceActivity.getSyncAccountName(activity); // 获取同步的账户名
+=======
+        // 获取设置中的同步账户名称
+        String accountName = NotesPreferenceActivity.getSyncAccountName(activity);
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         Account account = null;
 
         // 找到设置中与账户名匹配的账户
@@ -199,14 +286,21 @@ public class GTaskClient {
             return null; // 找不到匹配账户，返回null
         }
 
+<<<<<<< HEAD
         // 获取认证令牌
         AccountManagerFuture<Bundle> accountManagerFuture = accountManager.getAuthToken(account, "goanna_mobile", null, activity, null, null);
+=======
+        // 获取授权令牌
+        AccountManagerFuture<Bundle> accountManagerFuture = accountManager.getAuthToken(account,
+                "goanna_mobile", null, activity, null, null);
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         try {
             Bundle authTokenBundle = accountManagerFuture.getResult(); // 获取结果
             authToken = authTokenBundle.getString(AccountManager.KEY_AUTHTOKEN); // 读取令牌
 
             // 如果需要无效化令牌，则重新获取
             if (invalidateToken) {
+                // 如果需要使令牌失效，则先失效再重新获取
                 accountManager.invalidateAuthToken("com.google", authToken);
                 loginGoogleAccount(activity, false); // 递归调用获取新令牌
             }
@@ -218,10 +312,17 @@ public class GTaskClient {
         return authToken; // 返回令牌
     }
 
+<<<<<<< HEAD
     // 尝试登录到GTask
     private boolean tryToLoginGtask(Activity activity, String authToken) {
         if (!loginGtask(authToken)) {
             // 如果认证令牌过期，则无效化并尝试重新登录
+=======
+    // 尝试登录Google Tasks
+    private boolean tryToLoginGtask(Activity activity, String authToken) {
+        if (!loginGtask(authToken)) {
+            // 如果登录失败，可能是授权令牌过期，先使令牌失效再重新尝试登录Google账户获取新令牌，然后再次登录Google Tasks
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             authToken = loginGoogleAccount(activity, true);
             if (authToken == null) {
                 Log.e(TAG, "login google account failed");
@@ -236,6 +337,7 @@ public class GTaskClient {
         return true; // 登录成功
     }
 
+<<<<<<< HEAD
     // 使用认证令牌登录到GTask
     private boolean loginGtask(String authToken) {
         int timeoutConnection = 10000; // 连接超时设置
@@ -249,12 +351,32 @@ public class GTaskClient {
         HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false); // 设置HTTP协议参数
 
         // 登录GTask
+=======
+    // 实际执行登录Google Tasks的操作，获取相关信息（如客户端版本号等）
+    private boolean loginGtask(String authToken) {
+        int timeoutConnection = 10000;
+        int timeoutSocket = 15000;
+        // 设置HTTP请求的参数，包括连接超时和读取超时时间
+        HttpParams httpParameters = new BasicHttpParams();
+        HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
+        HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);
+        mHttpClient = new DefaultHttpClient(httpParameters);
+        BasicCookieStore localBasicCookieStore = new BasicCookieStore();
+        mHttpClient.setCookieStore(localBasicCookieStore);
+        HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false);
+
+        // 登录Google Tasks，发送带有授权令牌的GET请求
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         try {
             String loginUrl = mGetUrl + "?auth=" + authToken; // 创建登录URL
             HttpGet httpGet = new HttpGet(loginUrl); // 创建GET请求
             HttpResponse response = mHttpClient.execute(httpGet); // 执行请求
 
+<<<<<<< HEAD
             // 获取Cookie
+=======
+            // 获取登录后的Cookie信息，检查是否包含认证相关的Cookie（名称包含"GTL"）
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             List<Cookie> cookies = mHttpClient.getCookieStore().getCookies();
             boolean hasAuthCookie = false; // 验证是否存在认证Cookie
             for (Cookie cookie : cookies) {
@@ -266,7 +388,11 @@ public class GTaskClient {
                 Log.w(TAG, "it seems that there is no auth cookie"); // 没有认证Cookie的警告
             }
 
+<<<<<<< HEAD
             // 从响应中获取客户端版本
+=======
+            // 从响应中获取客户端版本号等信息，通过解析返回的JavaScript代码中的相关数据
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             String resString = getResponseContent(response.getEntity());
             String jsBegin = "_setup(";
             String jsEnd = ")}</script>";
@@ -283,6 +409,10 @@ public class GTaskClient {
             e.printStackTrace();
             return false; // 处理JSON异常，返回登录失败
         } catch (Exception e) {
+<<<<<<< HEAD
+=======
+            // 捕获其他所有异常，若发生异常则登录失败
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             Log.e(TAG, "httpget gtask_url failed");
             return false; // 处理其他异常，返回登录失败
         }
@@ -290,12 +420,20 @@ public class GTaskClient {
         return true; // 登录成功
     }
 
+<<<<<<< HEAD
     // 获取下一个动作ID
+=======
+    // 获取下一个操作的ID
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     private int getActionId() {
         return mActionId++; // 返回当前ID并递增
     }
 
+<<<<<<< HEAD
     // 创建HTTP POST请求
+=======
+    // 创建用于发送POST请求的HttpPost对象，并设置相关请求头
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     private HttpPost createHttpPost() {
         HttpPost httpPost = new HttpPost(mPostUrl); // 创建POST请求
         httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8"); // 设置请求头
@@ -303,7 +441,11 @@ public class GTaskClient {
         return httpPost; // 返回POST请求
     }
 
+<<<<<<< HEAD
     // 获取HTTP响应内容
+=======
+    // 从HTTP实体中获取响应内容，根据内容编码（如gzip、deflate等）进行相应的解压处理
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     private String getResponseContent(HttpEntity entity) throws IOException {
         String contentEncoding = null; // 声明内容编码
         if (entity.getContentEncoding() != null) {
@@ -338,7 +480,11 @@ public class GTaskClient {
         }
     }
 
+<<<<<<< HEAD
     // 发送POST请求
+=======
+    // 发送POST请求，将JSON数据发送到Google Tasks服务器，并处理响应返回的JSON数据
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
         if (!mLoggedin) {
             Log.e(TAG, "please login first"); // 如果未登录，记录错误
@@ -352,7 +498,11 @@ public class GTaskClient {
             UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8"); // 创建实体
             httpPost.setEntity(entity); // 设置POST实体
 
+<<<<<<< HEAD
             // 执行POST请求并获取响应
+=======
+            // 执行POST请求并获取响应，然后解析响应内容为JSONObject返回
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             HttpResponse response = mHttpClient.execute(httpPost);
             String jsString = getResponseContent(response.getEntity()); // 获取响应内容
             return new JSONObject(jsString); // 返回响应的JSON对象
@@ -376,21 +526,36 @@ public class GTaskClient {
         }
     }
 
+<<<<<<< HEAD
     // 创建任务
+=======
+    // 创建一个任务并发送到Google Tasks服务器
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public void createTask(Task task) throws NetworkFailureException {
         commitUpdate(); // 提交更新
         try {
             JSONObject jsPost = new JSONObject(); // 创建JSON对象
             JSONArray actionList = new JSONArray(); // 创建动作列表
 
+<<<<<<< HEAD
             // 添加创建动作到动作列表
+=======
+            // 将任务的创建操作添加到操作列表中
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             actionList.put(task.getCreateAction(getActionId()));
             jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // 添加动作列表到JSON对象
 
+<<<<<<< HEAD
             // 添加客户端版本到JSON对象
             jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
 
             // 执行POST请求
+=======
+            // 设置客户端版本号
+            jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+            // 发送POST请求并处理响应，获取新创建任务的ID并设置到任务对象中
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             JSONObject jsResponse = postRequest(jsPost);
             JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_RESULTS).get(0); // 获取返回结果
             task.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID)); // 设置任务的ID
@@ -402,21 +567,36 @@ public class GTaskClient {
         }
     }
 
+<<<<<<< HEAD
     // 创建任务列表
+=======
+    // 创建一个任务列表并发送到Google Tasks服务器
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public void createTaskList(TaskList tasklist) throws NetworkFailureException {
         commitUpdate(); // 提交更新
         try {
             JSONObject jsPost = new JSONObject(); // 创建JSON对象
             JSONArray actionList = new JSONArray(); // 创建动作列表
 
+<<<<<<< HEAD
             // 添加创建动作到动作列表
+=======
+            // 将任务列表的创建操作添加到操作列表中
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             actionList.put(tasklist.getCreateAction(getActionId()));
             jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // 添加动作列表到JSON对象
 
+<<<<<<< HEAD
             // 添加客户端版本到JSON对象
             jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
 
             // 执行POST请求
+=======
+            // 设置客户端版本号
+            jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+            // 发送POST请求并处理响应，获取新创建任务列表的ID并设置到任务列表对象中
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             JSONObject jsResponse = postRequest(jsPost);
             JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_RESULTS).get(0); // 获取返回结果
             tasklist.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID)); // 设置任务列表的ID
@@ -428,16 +608,27 @@ public class GTaskClient {
         }
     }
 
+<<<<<<< HEAD
     // 提交更新
+=======
+    // 提交更新操作，将暂存的更新操作数组发送到服务器
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public void commitUpdate() throws NetworkFailureException {
         // 如果存在更新数组
         if (mUpdateArray != null) {
             try {
                 JSONObject jsPost = new JSONObject(); // 创建JSON对象
 
+<<<<<<< HEAD
                 // 添加动作列表到JSON对象
                 jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, mUpdateArray);
                 // 添加客户端版本到JSON对象
+=======
+                // 设置操作列表
+                jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, mUpdateArray);
+
+                // 设置客户端版本号
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
                 jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
 
                 postRequest(jsPost); // 执行POST请求
@@ -450,15 +641,25 @@ public class GTaskClient {
         }
     }
 
+<<<<<<< HEAD
     // 添加更新节点
     public void addUpdateNode(Node node) throws NetworkFailureException {
         if (node != null) {
             // 更新项目过多可能会导致错误，最多设为10个项目
+=======
+    // 添加一个节点的更新操作到暂存的更新操作数组中，限制最多10个更新项
+    // 将节点的更新操作添加到更新数组中，如果更新数组中的元素超过10个，则先提交更新
+    public void addUpdateNode(Node node) throws NetworkFailureException {
+        if (node != null) {
+            // 过多的更新项可能会导致错误，所以设置最大更新项数量为10个
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             if (mUpdateArray != null && mUpdateArray.length() > 10) {
                 commitUpdate(); // 提交更新
             }
 
+            // 如果更新数组为空，则创建一个新的JSONArray对象用于存放更新操作
             if (mUpdateArray == null)
+<<<<<<< HEAD
                 mUpdateArray = new JSONArray(); // 初始化更新数组
             mUpdateArray.put(node.getUpdateAction(getActionId())); // 将更新的节点添加到数组
         }
@@ -467,11 +668,24 @@ public class GTaskClient {
     // 移动任务
     public void moveTask(Task task, TaskList preParent, TaskList curParent) throws NetworkFailureException {
         commitUpdate(); // 提交更新
+=======
+                mUpdateArray = new JSONArray();
+            // 将节点的更新操作（通过节点获取，操作ID使用当前的操作ID）添加到更新数组中
+            mUpdateArray.put(node.getUpdateAction(getActionId()));
+        }
+    }
+
+    // 移动任务，将任务从一个任务列表移动到另一个任务列表（可能是同一个列表内移动位置）
+    public void moveTask(Task task, TaskList preParent, TaskList curParent)
+            throws NetworkFailureException {
+        commitUpdate();
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         try {
             JSONObject jsPost = new JSONObject(); // 创建JSON对象
             JSONArray actionList = new JSONArray(); // 创建动作列表
             JSONObject action = new JSONObject(); // 创建动作对象
 
+<<<<<<< HEAD
             // 构建移动动作
             action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_MOVE);
             action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId());
@@ -495,21 +709,64 @@ public class GTaskClient {
             jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
 
             postRequest(jsPost); // 执行POST请求
+=======
+            // 操作列表相关设置
+            // 设置操作类型为移动任务（对应预定义的移动操作类型常量）
+            action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_MOVE);
+            // 设置操作的唯一ID，通过获取下一个可用的操作ID来赋值
+            action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId());
+            // 设置要移动的任务的全局唯一ID
+            action.put(GTaskStringUtils.GTASK_JSON_ID, task.getGid());
+            // 如果移动前后的父任务列表相同（即在同一个任务列表内移动），并且任务不是该列表中的第一个任务，
+            // 则设置其前一个兄弟任务的ID，用于确定移动后的顺序
+            if (preParent == curParent && task.getPriorSibling() != null) {
+                action.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, task.getPriorSibling());
+            }
+            // 设置任务原来所在的任务列表的全局唯一ID（源列表）
+            action.put(GTaskStringUtils.GTASK_JSON_SOURCE_LIST, preParent.getGid());
+            // 设置任务要移动到的目标任务列表的父级任务列表的全局唯一ID（目标父列表）
+            action.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT, curParent.getGid());
+            // 如果移动是在不同的任务列表之间进行，则设置目标任务列表的全局唯一ID（目标列表）
+            if (preParent != curParent) {
+                action.put(GTaskStringUtils.GTASK_JSON_DEST_LIST, curParent.getGid());
+            }
+            // 将这个移动操作添加到操作列表中
+            actionList.put(action);
+            // 将操作列表添加到要发送的JSON数据对象中，对应预定义的操作列表的JSON键
+            jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
+
+            // 设置客户端版本号，对应预定义的客户端版本号的JSON键
+            jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+            // 发送POST请求，将包含移动任务操作信息的JSON数据发送到服务器进行处理
+            postRequest(jsPost);
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
 
         } catch (JSONException e) {
             Log.e(TAG, e.toString());
             e.printStackTrace();
+<<<<<<< HEAD
             throw new ActionFailureException("move task: handing jsonobject failed"); // 抛出JSON处理异常
         }
     }
 
     // 删除节点
+=======
+            // 如果JSON处理出现异常，抛出操作失败异常，并说明是移动任务时处理JSON对象失败
+            throw new ActionFailureException("move task: handing jsonobject failed");
+        }
+    }
+
+    // 删除节点（比如任务、任务列表等），通过设置节点的删除标记为true，并将其更新操作发送到服务器来实现删除
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public void deleteNode(Node node) throws NetworkFailureException {
         commitUpdate(); // 提交更新
         try {
             JSONObject jsPost = new JSONObject(); // 创建JSON对象
             JSONArray actionList = new JSONArray(); // 创建动作列表
 
+<<<<<<< HEAD
             // 标记节点为已删除并添加到动作列表
             node.setDeleted(true);
             actionList.put(node.getUpdateAction(getActionId())); // 获取节点更新动作并添加到列表
@@ -528,6 +785,32 @@ public class GTaskClient {
     }
 
     // 获取任务列表
+=======
+            // 操作列表相关设置
+            // 将节点标记为已删除
+            node.setDeleted(true);
+            // 将节点的更新操作（此时因为已标记为删除，对应的就是删除操作）添加到操作列表中
+            actionList.put(node.getUpdateAction(getActionId()));
+            // 将操作列表添加到要发送的JSON数据对象中，对应预定义的操作列表的JSON键
+            jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
+
+            // 设置客户端版本号，对应预定义的客户端版本号的JSON键
+            jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+            // 发送POST请求，将包含删除节点操作信息的JSON数据发送到服务器进行处理
+            postRequest(jsPost);
+            // 发送成功后，将更新数组置空，因为相关更新操作已提交完成
+            mUpdateArray = null;
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            // 如果JSON处理出现异常，抛出操作失败异常，并说明是删除节点时处理JSON对象失败
+            throw new ActionFailureException("delete node: handing jsonobject failed");
+        }
+    }
+
+    // 获取所有的任务列表信息，前提是已经登录成功，否则会抛出异常提示需要先登录
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public JSONArray getTaskLists() throws NetworkFailureException {
         if (!mLoggedin) {
             Log.e(TAG, "please login first"); // 如果未登录，记录错误
@@ -535,11 +818,22 @@ public class GTaskClient {
         }
 
         try {
+<<<<<<< HEAD
             HttpGet httpGet = new HttpGet(mGetUrl); // 创建GET请求
             HttpResponse response = mHttpClient.execute(httpGet); // 执行请求
 
             // 获取任务列表
             String resString = getResponseContent(response.getEntity()); // 获取响应内容
+=======
+            // 创建一个HTTP GET请求对象，用于获取任务列表数据，请求的URL是之前设置好的获取数据的URL
+            HttpGet httpGet = new HttpGet(mGetUrl);
+            HttpResponse response = null;
+            // 执行HTTP GET请求，获取服务器的响应
+            response = mHttpClient.execute(httpGet);
+
+            // 从响应的实体中获取内容，并进行处理，提取出包含任务列表信息的JSON数据部分
+            String resString = getResponseContent(response.getEntity());
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             String jsBegin = "_setup(";
             String jsEnd = ")}</script>";
             int begin = resString.indexOf(jsBegin);
@@ -549,6 +843,7 @@ public class GTaskClient {
             if (begin != -1 && end != -1 && begin < end) {
                 jsString = resString.substring(begin + jsBegin.length(), end);
             }
+<<<<<<< HEAD
             JSONObject js = new JSONObject(jsString); // 创建JSON对象
             return js.getJSONObject("t").getJSONArray(GTaskStringUtils.GTASK_JSON_LISTS); // 返回任务列表
         } catch (ClientProtocolException e) {
@@ -567,6 +862,30 @@ public class GTaskClient {
     }
 
     // 获取指定任务列表
+=======
+            JSONObject js = new JSONObject(jsString);
+            // 从解析后的JSON对象中获取任务列表数组并返回，对应预定义的任务列表的JSON键
+            return js.getJSONObject("t").getJSONArray(GTaskStringUtils.GTASK_JSON_LISTS);
+        } catch (ClientProtocolException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            // 如果HTTP协议相关操作出现异常，抛出网络失败异常，并说明是获取任务列表时HTTP GET请求失败
+            throw new NetworkFailureException("gettasklists: httpget failed");
+        } catch (IOException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            // 如果输入输出操作出现异常，抛出网络失败异常，并说明是获取任务列表时HTTP GET请求失败
+            throw new NetworkFailureException("gettasklists: httpget failed");
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            // 如果JSON处理出现异常，抛出操作失败异常，并说明是获取任务列表时处理JSON对象失败
+            throw new ActionFailureException("get task lists: handing jasonobject failed");
+        }
+    }
+
+    // 根据给定的任务列表全局唯一ID，获取该任务列表中的任务信息，需要先提交之前暂存的更新操作
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public JSONArray getTaskList(String listGid) throws NetworkFailureException {
         commitUpdate(); // 提交更新
         try {
@@ -574,6 +893,7 @@ public class GTaskClient {
             JSONArray actionList = new JSONArray(); // 创建动作列表
             JSONObject action = new JSONObject(); // 创建动作对象
 
+<<<<<<< HEAD
             // 构建获取所有任务的动作
             action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_GETALL);
             action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId());
@@ -595,12 +915,52 @@ public class GTaskClient {
     }
 
     // 获取同步账户
+=======
+            // 操作列表相关设置
+            // 设置操作类型为获取所有任务（对应预定义的获取所有任务操作类型常量）
+            action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_GETALL);
+            // 设置操作的唯一ID，通过获取下一个可用的操作ID来赋值
+            action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId());
+            // 设置要获取任务的任务列表的全局唯一ID
+            action.put(GTaskStringUtils.GTASK_JSON_LIST_ID, listGid);
+            // 设置是否获取已删除的任务，这里设置为false，表示不获取已删除任务
+            action.put(GTaskStringUtils.GTASK_JSON_GET_DELETED, false);
+            // 将这个获取任务操作添加到操作列表中
+            actionList.put(action);
+            // 将操作列表添加到要发送的JSON数据对象中，对应预定义的操作列表的JSON键
+            jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
+
+            // 设置客户端版本号，对应预定义的客户端版本号的JSON键
+            jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+            // 发送POST请求，将包含获取任务列表中任务操作信息的JSON数据发送到服务器进行处理
+            JSONObject jsResponse = postRequest(jsPost);
+            // 从服务器响应的JSON数据中获取任务数组并返回，对应预定义的任务的JSON键
+            return jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_TASKS);
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            // 如果JSON处理出现异常，抛出操作失败异常，并说明是获取任务列表时处理JSON对象失败
+            throw new ActionFailureException("get task list: handing jsonobject failed");
+        }
+    }
+
+    // 获取当前用于同步的账户信息
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public Account getSyncAccount() {
         return mAccount; // 返回账户信息
     }
 
+<<<<<<< HEAD
     // 重置更新数组
     public void resetUpdateArray() {
         mUpdateArray = null; // 清空更新数组
     }
 }
+=======
+    // 重置更新数组，即将其置为空，一般用于清除之前暂存的更新操作相关数据
+public void resetUpdateArray() {
+    mUpdateArray = null;
+}
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae

src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java

@@ -28,6 +28,7 @@ import android.util.Log; // 记录日志的工具类
 // 导入项目中的相关类
 import net.micode.notes.R;
 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; // 任务元数据类
@@ -47,3 +48,898 @@ 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.NoteColumns;
+import net.micode.notes.gtask.data.MetaData;
+import net.micode.notes.gtask.data.Node;
+import net.micode.notes.gtask.data.SqlNote;
+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;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+
+// GTaskManager类用于管理与Google Tasks的同步操作，包括初始化任务列表、同步内容、处理各种同步类型的操作等功能
+public class GTaskManager {
+    private static final String TAG = GTaskManager.class.getSimpleName();
+
+    // 同步成功状态码
+    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;
+
+    private static GTaskManager mInstance = null;
+
+    // 关联的Activity，用于获取授权令牌等操作
+    private Activity mActivity;
+    // 应用上下文
+    private Context mContext;
+    // 用于操作内容提供器，进行数据查询、更新等操作
+    private ContentResolver mContentResolver;
+    // 标记是否正在同步
+    private boolean mSyncing;
+    // 标记同步是否被取消
+    private boolean mCancelled;
+    // 存储Google Tasks任务列表的哈希表，以任务列表的全局唯一ID（GID）为键，任务列表对象为值
+    private HashMap<String, TaskList> mGTaskListHashMap;
+    // 存储Google Tasks节点（任务、任务列表等）的哈希表，以节点的全局唯一ID（GID）为键，节点对象为值
+    private HashMap<String, Node> mGTaskHashMap;
+    // 存储元数据的哈希表，以相关的全局唯一ID为键，元数据对象为值
+    private HashMap<String, MetaData> mMetaHashMap;
+    // 元数据对应的任务列表
+    private TaskList mMetaList;
+    // 存储本地已删除记录的ID集合，用于后续清理本地数据
+    private HashSet<Long> mLocalDeleteIdMap;
+    // 存储从Google Tasks的全局唯一ID（GID）到本地记录ID（NID）的映射关系
+    private HashMap<String, Long> mGidToNid;
+    // 存储从本地记录ID（NID）到Google Tasks的全局唯一ID（GID）的映射关系
+    private HashMap<Long, String> mNidToGid;
+
+    // 私有构造函数，初始化相关成员变量
+    private GTaskManager() {
+        mSyncing = false;
+        mCancelled = false;
+        mGTaskListHashMap = new HashMap<String, TaskList>();
+        mGTaskHashMap = new HashMap<String, Node>();
+        mMetaHashMap = new HashMap<String, MetaData>();
+        mMetaList = null;
+        mLocalDeleteIdMap = new HashSet<Long>();
+        mGidToNid = new HashMap<String, Long>();
+        mNidToGid = new HashMap<Long, String>();
+    }
+
+    // 获取GTaskManager的单例实例
+    public static synchronized GTaskManager getInstance() {
+        if (mInstance == null) {
+            mInstance = new GTaskManager();
+        }
+        return mInstance;
+    }
+
+    // 设置关联的Activity上下文，主要用于获取授权令牌等相关操作
+    public synchronized void setActivityContext(Activity activity) {
+        // used for getting authtoken
+        mActivity = activity;
+    }
+
+    // 执行同步操作，与Google Tasks进行数据同步
+    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;
+        // 清除之前同步相关的数据缓存，如任务列表、节点、元数据等的哈希表以及ID映射关系等
+        mGTaskListHashMap.clear();
+        mGTaskHashMap.clear();
+        mMetaHashMap.clear();
+        mLocalDeleteIdMap.clear();
+        mGidToNid.clear();
+        mNidToGid.clear();
+
+        try {
+            GTaskClient client = GTaskClient.getInstance();
+            client.resetUpdateArray();
+
+            // 登录Google Tasks，如果取消同步则不再进行登录操作，如果登录失败则抛出网络异常
+            if (!mCancelled) {
+                if (!client.login(mActivity)) {
+                    throw new NetworkFailureException("login google task failed");
+                }
+            }
+
+            // 发布同步进度信息，初始化任务列表阶段
+            asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
+            initGTaskList();
+
+            // 发布同步进度信息，进行内容同步阶段
+            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();
+            mLocalDeleteIdMap.clear();
+            mGidToNid.clear();
+            mNidToGid.clear();
+            mSyncing = false;
+        }
+
+        return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
+    }
+
+    // 初始化Google Tasks任务列表相关信息，包括获取任务列表、元数据列表以及加载任务等操作
+    private void initGTaskList() throws NetworkFailureException {
+        if (mCancelled)
+            return;
+        GTaskClient client = GTaskClient.getInstance();
+        try {
+            // 从Google Tasks获取任务列表信息，返回JSON数组形式的数据
+            JSONArray jsTaskLists = client.getTaskLists();
+
+            // 先初始化元数据列表，查找名为特定前缀加上"meta"的任务列表作为元数据列表
+            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);
+
+                    // 加载元数据，获取元数据列表对应的任务列表中的具体元数据信息
+                    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()) {
+                            mMetaList.addChildTask(metaData);
+                            if (metaData.getGid() != null) {
+                                mMetaHashMap.put(metaData.getRelatedGid(), metaData);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 如果元数据列表不存在，则创建一个新的元数据列表，并发送到Google Tasks服务器创建对应的任务列表
+            if (mMetaList == null) {
+                mMetaList = new TaskList();
+                mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+                        + GTaskStringUtils.FOLDER_META);
+                GTaskClient.getInstance().createTaskList(mMetaList);
+            }
+
+            // 初始化普通任务列表，遍历获取到的任务列表信息，创建任务列表对象并加载对应的任务信息
+            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);
+
+                    // 加载任务，获取当前任务列表对应的任务信息
+                    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);
+                        }
+                    }
+                }
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("initGTaskList: handing JSONObject failed");
+        }
+    }
+
+    // 进行内容同步操作，处理本地与Google Tasks之间的数据同步，包括本地删除、文件夹同步、数据库中已有记录的同步等情况
+    private void syncContent() throws NetworkFailureException {
+        int syncType;
+        Cursor c = null;
+        String gid;
+        Node node;
+
+        mLocalDeleteIdMap.clear();
+
+        if (mCancelled) {
+            return;
+        }
+
+        // 处理本地已删除的笔记（记录），查询本地回收站文件夹中的记录，对比Google Tasks中的对应节点进行相应的同步操作
+        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);
+            if (c != null) {
+                while (c.moveToNext()) {
+                    gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                    node = mGTaskHashMap.get(gid);
+                    if (node != null) {
+                        mGTaskHashMap.remove(gid);
+                        doContentSync(Node.SYNC_ACTION_DEL_REMOTE, node, c);
+                    }
+
+                    mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
+                }
+            } else {
+                Log.w(TAG, "failed to query trash folder");
+            }
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // 同步文件夹相关信息
+        syncFolder();
+
+        // 处理数据库中已存在的笔记（记录），根据其在Google Tasks中的对应情况确定同步类型，然后进行相应的同步操作
+        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");
+            if (c != null) {
+                while (c.moveToNext()) {
+                    gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                    node = mGTaskHashMap.get(gid);
+                    if (node != null) {
+                        mGTaskHashMap.remove(gid);
+                        mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));
+                        mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);
+                        syncType = node.getSyncAction(c);
+                    } else {
+                        if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
+                            // 本地新增情况
+                            syncType = Node.SYNC_ACTION_ADD_REMOTE;
+                        } else {
+                            // 远程已删除情况
+                            syncType = Node.SYNC_ACTION_DEL_LOCAL;
+                        }
+                    }
+                    doContentSync(syncType, node, c);
+                }
+            } else {
+                Log.w(TAG, "failed to query existing note in database");
+            }
+
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // 处理剩余的在Google Tasks中存在但本地未处理的节点，进行相应的同步操作（一般是添加到本地）
+        Iterator<Map.Entry<String, Node>> iter = mGTaskHashMap.entrySet().iterator();
+        while (iter.hasNext()) {
+            Map.Entry<String, Node> entry = iter.next();
+            node = entry.getValue();
+            doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
+        }
+
+        // mCancelled可能被其他线程设置，所以需要逐个检查，清除本地已删除记录的相关数据（如果同步未取消）
+        if (!mCancelled) {
+            if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) {
+                throw new ActionFailureException("failed to batch-delete local deleted notes");
+            }
+        }
+
+        // 刷新本地同步ID（如果同步未取消），提交更新并进行相关操作来更新本地记录的同步ID
+        if (!mCancelled) {
+            GTaskClient.getInstance().commitUpdate();
+            refreshLocalSyncId();
+        }
+
+    }
+
+    // 同步文件夹相关信息，包括根文件夹、通话记录文件夹、本地已存在的文件夹以及远程新增的文件夹等情况的处理
+    private void syncFolder() throws NetworkFailureException {
+        Cursor c = null;
+        String gid;
+        Node node;
+        int syncType;
+
+        if (mCancelled) {
+            return;
+        }
+
+        // 处理根文件夹的同步情况，根据其在Google Tasks中的对应情况进行相应的同步操作（添加、更新等）
+        try {
+            c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
+                    Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null);
+            if (c != null) {
+                c.moveToNext();
+                gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                node = mGTaskHashMap.get(gid);
+                if (node != null) {
+                    mGTaskHashMap.remove(gid);
+                    mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER);
+                    mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid);
+                    // 对于系统文件夹，仅在必要时更新远程名称
+                    if (!node.getName().equals(
+                            GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT))
+                        doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
+                } else {
+                    doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
+                }
+            } else {
+                Log.w(TAG, "failed to query root folder");
+            }
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // for call-note文件夹相关的同步操作处理
+        // 查询通话记录文件夹在本地数据库中的信息，根据其在Google Tasks中的对应情况进行相应的同步操作（添加、更新等）
+        // 如果查询到该文件夹信息存在（即游标c不为空且能移动到下一条记录），则进一步处理
+        try {
+            // 通过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.moveToNext()) {
+                    // 获取该文件夹在Google Tasks中对应的全局唯一ID（GID）
+                    gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                    // 根据GID从存储Google Tasks节点的哈希表中获取对应的节点对象
+                    node = mGTaskHashMap.get(gid);
+                    if (node != null) {
+                        // 如果节点存在，从哈希表中移除该节点（表示已处理）
+                        mGTaskHashMap.remove(gid);
+                        // 在本地ID到Google Tasks的GID映射表中记录该文件夹的映射关系，键为GID，值为通话记录文件夹的本地ID
+                        mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER);
+                        // 在Google Tasks的GID到本地ID映射表中记录映射关系，键为本地ID，值为GID
+                        mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid);
+                        // 对于系统文件夹，仅在其名称与预期的通话记录文件夹名称不一致时（即可能有更新情况），进行远程更新操作
+                        if (!node.getName().equals(
+                                GTaskStringUtils.MIUI_FOLDER_PREFFIX
+                                        + GTaskStringUtils.FOLDER_CALL_NOTE))
+                            doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
+                    } else {
+                        // 如果节点不存在，则执行添加远程节点的操作（意味着本地有该文件夹记录，但在Google Tasks中还未创建对应节点）
+                        doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
+                    }
+                }
+            } else {
+                // 如果查询失败，打印警告日志
+                Log.w(TAG, "failed to query call note folder");
+            }
+        } finally {
+            // 无论查询是否成功，最终都要关闭游标，释放资源，并将游标置空
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // 处理本地已存在的文件夹的同步情况
+        // 查询本地除回收站外的文件夹记录信息，根据其在Google Tasks中的对应情况进行相应的同步操作
+        try {
+            // 通过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) {
+                while (c.moveToNext()) {
+                    // 获取文件夹在Google Tasks中对应的全局唯一ID（GID）
+                    gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                    // 根据GID从存储Google Tasks节点的哈希表中获取对应的节点对象
+                    node = mGTaskHashMap.get(gid);
+                    if (node != null) {
+                        // 如果节点存在，从哈希表中移除该节点（表示已处理）
+                        mGTaskHashMap.remove(gid);
+                        // 在本地ID到Google Tasks的GID映射表中记录该文件夹的映射关系，键为GID，值为文件夹的本地ID
+                        mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));
+                        // 在Google Tasks的GID到本地ID映射表中记录映射关系，键为本地ID，值为GID
+                        mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);
+                        // 获取该节点对应的同步操作类型（根据节点和游标信息判断是添加、更新、删除等哪种类型）
+                        syncType = node.getSyncAction(c);
+                    } else {
+                        // 如果节点不存在，根据其GID是否为空字符串判断是本地新增还是远程删除情况，进而确定同步类型
+                        if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
+                            // 本地新增情况，同步类型设置为添加远程节点
+                            syncType = Node.SYNC_ACTION_ADD_REMOTE;
+                        } else {
+                            // 远程删除情况，同步类型设置为删除本地节点
+                            syncType = Node.SYNC_ACTION_DEL_LOCAL;
+                        }
+                    }
+                    // 根据确定的同步类型执行相应的内容同步操作
+                    doContentSync(syncType, node, c);
+                }
+            } else {
+                // 如果查询失败，打印警告日志
+                Log.w(TAG, "failed to query existing folder");
+            }
+        } finally {
+            // 无论查询是否成功，最终都要关闭游标，释放资源，并将游标置空
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // 处理远程新增文件夹的同步情况
+        // 遍历存储Google Tasks任务列表的哈希表，对于在Google
+        // Tasks中存在但本地未处理（还在mGTaskHashMap中）的文件夹，进行添加本地节点的同步操作
+        Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
+        while (iter.hasNext()) {
+            Map.Entry<String, TaskList> entry = iter.next();
+            gid = entry.getKey();
+            node = entry.getValue();
+            if (mGTaskHashMap.containsKey(gid)) {
+                mGTaskHashMap.remove(gid);
+                doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
+            }
+        }
+
+        // 如果同步未被取消，提交Google Tasks客户端的更新操作（将之前暂存的更新操作发送到服务器执行）
+        if (!mCancelled)
+            GTaskClient.getInstance().commitUpdate();
+    }
+
+    // 根据给定的同步类型执行具体的内容同步操作
+    private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        MetaData meta;
+        switch (syncType) {
+            // 同步类型为添加本地节点，调用相应方法进行本地节点添加操作
+            case Node.SYNC_ACTION_ADD_LOCAL:
+                addLocalNode(node);
+                break;
+            // 同步类型为添加远程节点，调用相应方法进行远程节点添加操作，并传入节点和游标信息
+            case Node.SYNC_ACTION_ADD_REMOTE:
+                addRemoteNode(node, c);
+                break;
+            // 同步类型为删除本地节点，先从元数据哈希表中获取对应的元数据，若存在则调用Google Tasks客户端删除该元数据节点，
+            // 同时将本地记录的ID添加到本地已删除记录集合中
+            case Node.SYNC_ACTION_DEL_LOCAL:
+                meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN));
+                if (meta != null) {
+                    GTaskClient.getInstance().deleteNode(meta);
+                }
+                mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
+                break;
+            // 同步类型为删除远程节点，先从元数据哈希表中获取对应节点的元数据，若存在则调用Google Tasks客户端删除该元数据节点，
+            // 然后再删除该节点本身
+            case Node.SYNC_ACTION_DEL_REMOTE:
+                meta = mMetaHashMap.get(node.getGid());
+                if (meta != null) {
+                    GTaskClient.getInstance().deleteNode(meta);
+                }
+                GTaskClient.getInstance().deleteNode(node);
+                break;
+            // 同步类型为更新本地节点，调用相应方法进行本地节点更新操作，并传入节点和游标信息
+            case Node.SYNC_ACTION_UPDATE_LOCAL:
+                updateLocalNode(node, c);
+                break;
+            // 同步类型为更新远程节点，调用相应方法进行远程节点更新操作，并传入节点和游标信息
+            case Node.SYNC_ACTION_UPDATE_REMOTE:
+                updateRemoteNode(node, c);
+                break;
+            // 同步类型为更新冲突，目前简单采用本地更新的方式（可能后续可以考虑合并修改等更好的处理方式），调用远程节点更新方法
+            case Node.SYNC_ACTION_UPDATE_CONFLICT:
+                // merging both modifications maybe a good idea
+                // right now just use local update simply
+                updateRemoteNode(node, c);
+                break;
+            // 同步类型为无操作，直接跳过不做任何处理
+            case Node.SYNC_ACTION_NONE:
+                break;
+            // 同步类型为错误或其他未知类型，抛出操作失败异常，表示遇到了未知的同步操作类型
+            case Node.SYNC_ACTION_ERROR:
+            default:
+                throw new ActionFailureException("unkown sync action type");
+        }
+    }
+
+    // 添加本地节点的操作方法
+    private void addLocalNode(Node node) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        SqlNote sqlNote;
+        // 如果节点是任务列表类型（TaskList）
+        if (node instanceof TaskList) {
+            // 如果节点名称是默认根文件夹的名称，创建一个对应根文件夹的SqlNote对象，传入上下文和根文件夹的本地ID
+            if (node.getName().equals(
+                    GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) {
+                sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER);
+            } else if (node.getName().equals(
+                    GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) {
+                // 如果节点名称是通话记录文件夹的名称，创建一个对应通话记录文件夹的SqlNote对象，传入上下文和通话记录文件夹的本地ID
+                sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER);
+            } else {
+                // 其他普通任务列表情况，创建一个新的SqlNote对象，传入上下文
+                sqlNote = new SqlNote(mContext);
+                // 设置SqlNote的内容为节点的本地JSON格式内容（从节点获取）
+                sqlNote.setContent(node.getLocalJSONFromContent());
+                // 设置父ID为根文件夹的本地ID
+                sqlNote.setParentId(Notes.ID_ROOT_FOLDER);
+            }
+        } else {
+            // 如果节点是普通任务（Task）类型，创建一个新的SqlNote对象，传入上下文
+            sqlNote = new SqlNote(mContext);
+            JSONObject js = node.getLocalJSONFromContent();
+            try {
+                // 如果节点的本地JSON数据中包含特定的笔记头部信息（META_HEAD_NOTE）
+                if (js.has(GTaskStringUtils.META_HEAD_NOTE)) {
+                    JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+                    if (note.has(NoteColumns.ID)) {
+                        long id = note.getLong(NoteColumns.ID);
+                        // 检查该笔记ID在本地笔记数据库中是否已存在，如果存在则移除该ID（可能需要重新生成新的ID）
+                        if (DataUtils.existInNoteDatabase(mContentResolver, id)) {
+                            // the id is not available, have to create a new one
+                            note.remove(NoteColumns.ID);
+                        }
+                    }
+                }
+
+                // 如果节点的本地JSON数据中包含特定的数据头部信息（META_HEAD_DATA）
+                if (js.has(GTaskStringUtils.META_HEAD_DATA)) {
+                    JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+                    for (int i = 0; i < dataArray.length(); i++) {
+                        JSONObject data = dataArray.getJSONObject(i);
+                        if (data.has(DataColumns.ID)) {
+                            long dataId = data.getLong(DataColumns.ID);
+                            // 检查该数据ID在本地数据数据库中是否已存在，如果存在则移除该ID（可能需要重新生成新的ID）
+                            if (DataUtils.existInDataDatabase(mContentResolver, dataId)) {
+                                // the data id is not available, have to create
+                                // a new one
+                                data.remove(DataColumns.ID);
+                            }
+                        }
+                    }
+
+                }
+            } catch (JSONException e) {
+                Log.w(TAG, e.toString());
+                e.printStackTrace();
+            }
+            // 设置SqlNote的内容为处理后的JSON数据
+            sqlNote.setContent(js);
+
+            // 获取任务节点的父节点在本地ID到Google Tasks的GID映射表中的对应父ID，如果不存在则抛出异常表示找不到本地父ID
+            Long parentId = mGidToNid.get(((Task) node).getParent().getGid());
+            if (parentId == null) {
+                Log.e(TAG, "cannot find task's parent id locally");
+                throw new ActionFailureException("cannot add local node");
+            }
+            // 设置SqlNote的父ID为获取到的父节点的本地ID
+            sqlNote.setParentId(parentId.longValue());
+        }
+
+        // 设置SqlNote的Google Tasks全局唯一ID（GID）为节点的GID
+        sqlNote.setGtaskId(node.getGid());
+        // 将SqlNote对象提交保存到本地数据库（传入参数false可能表示不触发某些额外的相关操作）
+        sqlNote.commit(false);
+
+        // 在本地ID到Google Tasks的GID映射表中记录该节点的映射关系，键为节点的GID，值为SqlNote的本地ID
+        mGidToNid.put(node.getGid(), sqlNote.getId());
+        // 在Google Tasks的GID到本地ID映射表中记录映射关系，键为SqlNote的本地ID，值为节点的GID
+        mNidToGid.put(sqlNote.getId(), node.getGid());
+
+        // 更新远程元数据，传入节点的GID和对应的SqlNote对象
+        updateRemoteMeta(node.getGid(), sqlNote);
+    }
+
+    // 更新本地节点的操作方法
+    private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        SqlNote sqlNote;
+        // 根据传入的上下文和游标信息创建一个新的SqlNote对象，用于更新本地节点信息
+        sqlNote = new SqlNote(mContext, c);
+        // 设置SqlNote的内容为节点的本地JSON格式内容（从节点获取）
+        sqlNote.setContent(node.getLocalJSONFromContent());
+
+        Long parentId = (node instanceof Task) ? mGidToNid.get(((Task) node).getParent().getGid())
+                : new Long(Notes.ID_ROOT_FOLDER);
+        if (parentId == null) {
+            Log.e(TAG, "cannot find task's parent id locally");
+            throw new ActionFailureException("cannot update local node");
+        }
+        // 设置SqlNote的父ID为获取到的父节点的本地ID
+        sqlNote.setParentId(parentId.longValue());
+        // 将更新后的SqlNote对象提交保存到本地数据库（传入参数true可能表示触发某些额外的相关操作）
+        sqlNote.commit(true);
+
+        // 更新远程元数据，传入节点的GID和对应的SqlNote对象
+        updateRemoteMeta(node.getGid(), sqlNote);
+    }
+
+    // 添加远程节点的操作方法
+    private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        SqlNote sqlNote = new SqlNote(mContext, c);
+        Node n;
+
+        // 如果SqlNote对应的是笔记类型（即普通任务）
+        if (sqlNote.isNoteType()) {
+            Task task = new Task();
+            // 设置任务的内容为从本地SqlNote获取的JSON格式内容
+            task.setContentByLocalJSON(sqlNote.getContent());
+
+            String parentGid = mNidToGid.get(sqlNote.getParentId());
+            if (parentGid == null) {
+                Log.e(TAG, "cannot find task's parent tasklist");
+                throw new ActionFailureException("cannot add remote task");
+            }
+            // 将任务添加到对应的父任务列表中（通过本地ID到Google Tasks的GID映射表找到父任务列表）
+            mGTaskListHashMap.get(parentGid).addChildTask(task);
+
+            // 通过Google Tasks客户端创建该任务（发送到服务器创建对应的任务节点）
+            GTaskClient.getInstance().createTask(task);
+            n = (Node) task;
+
+            // 更新远程元数据，传入任务的GID和对应的SqlNote对象
+            updateRemoteMeta(task.getGid(), sqlNote);
+        } else {
+            TaskList tasklist = null;
+
+            // 构建文件夹名称，先添加特定的前缀，然后根据SqlNote的本地ID判断是否是根文件夹或通话记录文件夹，添加相应的后缀名称，
+            // 否则添加SqlNote的摘要信息作为后缀
+            String folderName = GTaskStringUtils.MIUI_FOLDER_PREFFIX;
+            if (sqlNote.getId() == Notes.ID_ROOT_FOLDER)
+                folderName += GTaskStringUtils.FOLDER_DEFAULT;
+            else if (sqlNote.getId() == Notes.ID_CALL_RECORD_FOLDER)
+                folderName += GTaskStringUtils.FOLDER_CALL_NOTE;
+            else
+                folderName += sqlNote.getSnippet();
+
+            // 遍历存储Google Tasks任务列表的哈希表（mGTaskListHashMap）的迭代器
+            Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
+            while (iter.hasNext()) {
+                // 获取哈希表中的每一个键值对，键是任务列表的全局唯一ID（GID），值是对应的任务列表对象（TaskList）
+                Map.Entry<String, TaskList> entry = iter.next();
+                String gid = entry.getKey();
+                TaskList list = entry.getValue();
+
+                // 判断当前任务列表的名称是否与之前构建的文件夹名称（folderName）相等
+                if (list.getName().equals(folderName)) {
+                    // 如果相等，说明找到了对应的任务列表，将其赋值给tasklist变量
+                    tasklist = list;
+                    // 如果在存储Google Tasks节点的哈希表（mGTaskHashMap）中包含该任务列表的GID，说明已经处理过，将其移除
+                    if (mGTaskHashMap.containsKey(gid)) {
+                        mGTaskHashMap.remove(gid);
+                    }
+                    // 找到匹配的任务列表后就可以结束循环了
+                    break;
+                }
+            }
+
+            // 如果经过上述查找没有找到匹配的任务列表（tasklist仍为null），则创建一个新的任务列表对象
+            if (tasklist == null) {
+                tasklist = new TaskList();
+                // 设置新任务列表的内容为从本地SqlNote获取的JSON格式内容
+                tasklist.setContentByLocalJSON(sqlNote.getContent());
+                // 通过Google Tasks客户端创建该任务列表（发送到服务器创建对应的任务列表节点）
+                GTaskClient.getInstance().createTaskList(tasklist);
+                // 将新创建的任务列表添加到存储Google Tasks任务列表的哈希表中，键为任务列表的GID，值为任务列表对象
+                mGTaskListHashMap.put(tasklist.getGid(), tasklist);
+            }
+            // 将创建或找到的任务列表对象转换为Node类型并赋值给n（因为Node是更通用的节点类型，TaskList是一种特殊的Node）
+            n = (Node) tasklist;
+        }
+
+        // 更新本地笔记相关信息
+        // 设置本地SqlNote的Google Tasks全局唯一ID（GID）为n的GID，即与远程任务列表或任务对应的GID保持一致
+        sqlNote.setGtaskId(n.getGid());
+        // 将SqlNote对象提交保存到本地数据库（传入参数false可能表示不触发某些额外的相关操作，此处用于保存基本的关联信息等）
+        sqlNote.commit(false);
+        // 重置本地修改标志（可能表示将本地记录标记为已与远程同步，不再是本地修改状态）
+        sqlNote.resetLocalModified();
+        // 再次提交保存SqlNote对象到本地数据库（传入参数true可能表示触发一些更新相关的额外操作，确保修改标志等信息更新成功）
+        sqlNote.commit(true);
+
+        // gid-id映射更新
+        // 在本地ID到Google Tasks的GID映射表（mGidToNid）中记录该节点（n）的映射关系，键为节点的GID，值为SqlNote的本地ID
+        mGidToNid.put(n.getGid(), sqlNote.getId());
+        // 在Google Tasks的GID到本地ID映射表（mNidToGid）中记录映射关系，键为SqlNote的本地ID，值为节点的GID
+        mNidToGid.put(sqlNote.getId(), n.getGid());
+    }
+
+    // 更新远程节点的操作方法
+    private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        // 根据传入的上下文和游标信息创建一个新的SqlNote对象，用于后续操作
+        SqlNote sqlNote = new SqlNote(mContext, c);
+
+        // 远程更新操作
+        // 设置远程节点（node）的内容为从本地SqlNote获取的JSON格式内容，即将本地修改同步到远程节点
+        node.setContentByLocalJSON(sqlNote.getContent());
+        // 通过Google Tasks客户端将更新后的节点添加到更新队列中（后续会批量提交更新到服务器）
+        GTaskClient.getInstance().addUpdateNode(node);
+
+        // 更新远程元数据，传入节点的GID和对应的SqlNote对象
+        updateRemoteMeta(node.getGid(), sqlNote);
+
+        // 如果SqlNote对应的是笔记类型（即普通任务），则可能需要处理任务移动相关操作
+        if (sqlNote.isNoteType()) {
+            Task task = (Task) node;
+            // 获取任务当前的父任务列表
+            TaskList preParentList = task.getParent();
+
+            // 通过本地ID到Google Tasks的GID映射表，根据本地记录的父ID获取当前任务在远程对应的父任务列表的GID
+            String curParentGid = mNidToGid.get(sqlNote.getParentId());
+            if (curParentGid == null) {
+                Log.e(TAG, "cannot find task's parent tasklist");
+                throw new ActionFailureException("cannot update remote task");
+            }
+            // 根据获取到的GID从存储Google Tasks任务列表的哈希表中获取当前任务在远程对应的父任务列表对象
+            TaskList curParentList = mGTaskListHashMap.get(curParentGid);
+
+            // 如果当前任务的前后父任务列表不一致，说明任务需要在远程进行移动操作
+            if (preParentList != curParentList) {
+                // 先从原父任务列表中移除该任务
+                preParentList.removeChildTask(task);
+                // 将任务添加到新的父任务列表中
+                curParentList.addChildTask(task);
+                // 通过Google Tasks客户端执行任务移动操作，告知服务器任务在远程的位置变更
+                GTaskClient.getInstance().moveTask(task, preParentList, curParentList);
+            }
+        }
+
+        // 清除本地修改标志，标记本地记录已同步到远程，不再处于本地修改状态
+        sqlNote.resetLocalModified();
+        // 将更新后的SqlNote对象提交保存到本地数据库（传入参数true可能表示触发一些更新相关的额外操作，确保修改标志等信息更新成功）
+        sqlNote.commit(true);
+    }
+
+    // 更新远程元数据的操作方法
+    private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
+        if (sqlNote != null && sqlNote.isNoteType()) {
+            // 从存储元数据的哈希表（mMetaHashMap）中根据GID获取对应的元数据对象（MetaData）
+            MetaData metaData = mMetaHashMap.get(gid);
+            if (metaData != null) {
+                // 如果元数据对象存在，设置其元数据内容，传入GID和从本地SqlNote获取的JSON格式内容
+                metaData.setMeta(gid, sqlNote.getContent());
+                // 通过Google Tasks客户端将更新后的元数据添加到更新队列中（后续会批量提交更新到服务器）
+                GTaskClient.getInstance().addUpdateNode(metaData);
+            } else {
+                // 如果元数据对象不存在，则创建一个新的元数据对象
+                metaData = new MetaData();
+                // 设置新元数据对象的元数据内容，传入GID和从本地SqlNote获取的JSON格式内容
+                metaData.setMeta(gid, sqlNote.getContent());
+                // 将新创建的元数据对象添加到元数据列表（mMetaList）中作为子任务（从逻辑上关联起来）
+                mMetaList.addChildTask(metaData);
+                // 将新创建的元数据对象添加到存储元数据的哈希表中，键为GID，值为元数据对象
+                mMetaHashMap.put(gid, metaData);
+                // 通过Google Tasks客户端创建该元数据任务（发送到服务器创建对应的元数据节点）
+                GTaskClient.getInstance().createTask(metaData);
+            }
+        }
+    }
+
+    // 刷新本地同步ID的操作方法
+    private void refreshLocalSyncId() throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        // 为了获取最新的Google Tasks列表信息，先清空之前存储相关信息的哈希表
+        mGTaskHashMap.clear();
+        mGTaskListHashMap.clear();
+        mMetaHashMap.clear();
+        // 重新初始化Google Tasks列表信息（重新获取任务列表、元数据等相关内容）
+        initGTaskList();
+
+        Cursor c = null;
+        try {
+            // 通过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) {
+                while (c.moveToNext()) {
+                    // 获取笔记在Google Tasks中对应的全局唯一ID（GID）
+                    String gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                    // 根据GID从存储Google Tasks节点的哈希表中获取对应的节点对象
+                    Node node = mGTaskHashMap.get(gid);
+                    if (node != null) {
+                        // 如果节点存在，从哈希表中移除该节点（表示已处理）
+                        mGTaskHashMap.remove(gid);
+                        // 创建一个ContentValues对象用于存放要更新的数据，此处将同步ID设置为节点的最后修改时间
+                        ContentValues values = new ContentValues();
+                        values.put(NoteColumns.SYNC_ID, node.getLastModified());
+                        // 通过ContentResolver更新本地数据库中对应笔记的记录，设置同步ID字段的值
+                        mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
+                                c.getLong(SqlNote.ID_COLUMN)), values, null, null);
+                    } else {
+                        Log.e(TAG, "something is missed");
+                        throw new ActionFailureException(
+                                "some local items don't have gid after sync");
+                    }
+                }
+            } else {
+                Log.w(TAG, "failed to query local note to refresh sync id");
+            }
+        } finally {
+            // 无论查询是否成功，最终都要关闭游标，释放资源，并将游标置空
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+    }
+
+    // 获取同步账户名称的方法，通过Google Tasks客户端获取同步账户对象，并返回其名称
+    public String getSyncAccount() {
+        return GTaskClient.getInstance().getSyncAccount().name;
+    }
+
+    // 取消同步的方法，将表示同步是否取消的标志（mCancelled）设置为true，其他相关操作可以根据该标志来判断是否停止执行
+    public void cancelSync() {
+        mCancelled = true;
+    }
+}
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae

src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java

@@ -23,6 +23,7 @@ import android.content.Intent;
 import android.os.Bundle;
 import android.os.IBinder;
 
+<<<<<<< HEAD
 /**
  * GTaskSyncService 是一个用于处理 Google 任务同步的服务类。
  * 该类扩展自 Android 的 Service 类，负责执行同步操作。
@@ -60,25 +61,78 @@ public class GTaskSyncService extends Service {
      */
     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) {
+            // 创建一个新的GTaskASyncTask对象，传入当前服务上下文（this）以及一个完成监听器（OnCompleteListener）
             mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
+                // 当同步任务完成时会调用的回调方法
                 public void onComplete() {
+<<<<<<< HEAD
                     // 同步任务完成后，重置任务状态并发送广播
+=======
+                    // 将正在执行的同步任务对象置为null，表示同步已结束
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
                     mSyncTask = null;
+                    // 发送一个空消息的广播（可能用于通知其他组件同步已完成等状态变化）
                     sendBroadcast("");
+                    // 停止当前服务（因为同步任务已完成，服务的主要工作完成，可以停止自身运行）
                     stopSelf();
                 }
             });
+<<<<<<< HEAD
             // 发送初始广播，表示同步开始
             sendBroadcast("");
             // 执行异步任务
+=======
+            // 发送一个空消息的广播（可能在创建任务后就先通知其他组件同步即将开始等情况）
+            sendBroadcast("");
+            // 执行同步任务，开始真正的同步操作流程
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             mSyncTask.execute();
         }
     }
 
+<<<<<<< HEAD
     /**
      * 取消当前同步任务的方法
      */
+=======
+    // 取消同步的私有方法，用于取消正在执行的同步任务（如果存在的话）
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     private void cancelSync() {
         // 如果有正在进行的同步任务，则取消该任务
         if (mSyncTask != null) {
@@ -86,35 +140,52 @@ public class GTaskSyncService extends Service {
         }
     }
 
+    // 服务创建时调用的方法，在这里将正在执行的同步任务对象初始化为null，确保服务启动时处于初始状态
     @Override
     public void onCreate() {
         // 服务创建时，初始化同步任务为空
         mSyncTask = null;
     }
 
+    // 当服务通过startService()方法启动时会调用此方法，用于处理传入的Intent并根据不同的操作意图执行相应操作
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
+<<<<<<< HEAD
         // 从 Intent 中获取数据
+=======
+        // 从传入的Intent中获取附加的Bundle数据（通常用于传递额外的参数信息）
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         Bundle bundle = intent.getExtras();
+        // 如果获取到的Bundle不为null且包含表示操作类型的键（ACTION_STRING_NAME）
         if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
+            // 根据操作类型的值进行不同的操作分支判断
             switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
+                // 如果操作类型是启动同步（ACTION_START_SYNC）
                 case ACTION_START_SYNC:
                     // 开始同步操作
                     startSync();
                     break;
+                // 如果操作类型是取消同步（ACTION_CANCEL_SYNC）
                 case ACTION_CANCEL_SYNC:
                     // 取消同步操作
                     cancelSync();
                     break;
+                // 其他未知或不处理的操作类型，直接跳过不做操作
                 default:
                     break;
             }
+<<<<<<< HEAD
             // 返回服务的启动模式
+=======
+            // 返回START_STICKY表示服务在被系统意外终止后会尝试重新创建并保持启动状态（常用于需要持续运行的服务场景）
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
             return START_STICKY;
         }
+        // 如果不符合上述条件或者操作类型无效等情况，调用父类的onStartCommand方法进行默认处理
         return super.onStartCommand(intent, flags, startId);
     }
 
+    // 当系统内存不足时会调用此方法，在这里用于取消正在执行的同步任务（如果存在的话），释放内存资源
     @Override
     public void onLowMemory() {
         // 当系统内存不足时，取消同步任务
@@ -123,15 +194,23 @@ public class GTaskSyncService extends Service {
         }
     }
 
+<<<<<<< HEAD
+=======
+    // 用于服务绑定操作的方法，这里返回null表示不支持绑定操作（如果需要支持绑定，需要返回一个有效的IBinder对象）
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     @Override
     public IBinder onBind(Intent intent) {
         // 返回 null 表示不提供绑定服务的功能
         return null;
     }
 
+<<<<<<< HEAD
     /**
      * 发送广播以更新同步状态和进度消息
      */
+=======
+    // 发送广播的公共方法，用于向其他组件广播同步服务的相关状态信息，包括同步进度消息、是否正在同步等
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public void sendBroadcast(String msg) {
         mSyncProgress = msg;
         // 创建 Intent 用于发送广播
@@ -144,11 +223,17 @@ public class GTaskSyncService extends Service {
         sendBroadcast(intent);
     }
 
+<<<<<<< HEAD
     /**
      * 启动同步操作的静态方法
      */
     public static void startSync(Activity activity) {
         // 设置活动上下文
+=======
+    // 静态公共方法，用于在外部（比如Activity中）启动同步服务进行同步操作，需要传入对应的Activity作为上下文来启动服务
+    public static void startSync(Activity activity) {
+        // 设置GTaskManager的Activity上下文（可能用于获取相关授权等操作，与同步操作相关联）
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
         GTaskManager.getInstance().setActivityContext(activity);
         Intent intent = new Intent(activity, GTaskSyncService.class);
         // 添加启动同步的指令
@@ -157,9 +242,13 @@ public class GTaskSyncService extends Service {
         activity.startService(intent);
     }
 
+<<<<<<< HEAD
     /**
      * 取消同步操作的静态方法
      */
+=======
+    // 静态公共方法，用于在外部（比如其他组件中）取消正在进行的同步操作，需要传入上下文（Context）来启动服务发送取消同步的意图
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public static void cancelSync(Context context) {
         Intent intent = new Intent(context, GTaskSyncService.class);
         // 添加取消同步的指令
@@ -168,16 +257,24 @@ public class GTaskSyncService extends Service {
         context.startService(intent);
     }
 
+<<<<<<< HEAD
     /**
      * 判断当前是否正在同步的静态方法
      */
+=======
+    // 静态公共方法，用于判断当前是否正在进行同步操作，通过检查正在执行的同步任务对象是否为null来返回相应的布尔值结果
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public static boolean isSyncing() {
         return mSyncTask != null;
     }
 
+<<<<<<< HEAD
     /**
      * 获取当前同步进度的字符串信息
      */
+=======
+    // 静态公共方法，用于获取当前的同步进度相关的字符串消息，返回存储同步进度消息的静态变量的值
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
     public static String getProgressString() {
         return mSyncProgress;
     }

src/Notes-master/src/net/micode/notes/model/Note.java

@@ -33,7 +33,7 @@ import net.micode.notes.data.Notes.TextNote;
 
 import java.util.ArrayList;
 
-
+// 代表一个笔记，包含笔记的基本信息和笔记数据
 public class Note {
     private ContentValues mNoteDiffValues;
     private NoteData mNoteData;
@@ -70,36 +70,44 @@ public class Note {
         mNoteData = new NoteData();
     }
 
+    // 设置笔记的基本信息
     public void setNoteValue(String key, String value) {
         mNoteDiffValues.put(key, value);
         mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
         mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
     }
 
+    // 设置文本笔记的数据
     public void setTextData(String key, String value) {
         mNoteData.setTextData(key, value);
     }
 
+    // 设置文本笔记的数据ID
     public void setTextDataId(long id) {
         mNoteData.setTextDataId(id);
     }
 
+    // 获取文本笔记的数据ID
     public long getTextDataId() {
         return mNoteData.mTextDataId;
     }
 
+    // 设置通话笔记的数据ID
     public void setCallDataId(long id) {
         mNoteData.setCallDataId(id);
     }
 
+    // 设置通话笔记的数据
     public void setCallData(String key, String value) {
         mNoteData.setCallData(key, value);
     }
 
+    // 判断笔记是否被本地修改过
     public boolean isLocalModified() {
         return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
     }
 
+    // 同步笔记到数据库
     public boolean syncNote(Context context, long noteId) {
         if (noteId <= 0) {
             throw new IllegalArgumentException("Wrong note id:" + noteId);
@@ -130,6 +138,7 @@ public class Note {
         return true;
     }
 
+    // 笔记数据类，包含文本数据和通话数据
     private class NoteData {
         private long mTextDataId;
 
@@ -148,10 +157,12 @@ public class Note {
             mCallDataId = 0;
         }
 
+        // 判断笔记数据是否被本地修改过
         boolean isLocalModified() {
             return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
         }
 
+        // 设置文本数据ID
         void setTextDataId(long id) {
             if(id <= 0) {
                 throw new IllegalArgumentException("Text data id should larger than 0");
@@ -159,6 +170,7 @@ public class Note {
             mTextDataId = id;
         }
 
+        // 设置通话数据ID
         void setCallDataId(long id) {
             if (id <= 0) {
                 throw new IllegalArgumentException("Call data id should larger than 0");
@@ -166,18 +178,21 @@ public class Note {
             mCallDataId = id;
         }
 
+        // 设置通话数据
         void setCallData(String key, String value) {
             mCallDataValues.put(key, value);
             mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
             mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
         }
 
+        // 设置文本数据
         void setTextData(String key, String value) {
             mTextDataValues.put(key, value);
             mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
             mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
         }
 
+        // 将笔记数据推送到内容解析器
         Uri pushIntoContentResolver(Context context, long noteId) {
             /**
              * Check for safety

src/Notes-master/src/net/micode/notes/model/WorkingNote.java

@@ -31,7 +31,7 @@ import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.Notes.TextNote;
 import net.micode.notes.tool.ResourceParser.NoteBgResources;
  
-
+// 表示正在编辑的笔记类
 public class WorkingNote {
     // Note for the working note
     private Note mNote;
@@ -62,6 +62,7 @@ public class WorkingNote {
  
     private NoteSettingChangedListener mNoteSettingStatusListener;
  
+    // 数据库查询笔记数据的列
     public static final String[] DATA_PROJECTION = new String[] {
             DataColumns.ID,
             DataColumns.CONTENT,
@@ -72,6 +73,7 @@ public class WorkingNote {
             DataColumns.DATA4,
     };
  
+    // 数据库查询笔记信息的列
     public static final String[] NOTE_PROJECTION = new String[] {
             NoteColumns.PARENT_ID,
             NoteColumns.ALERTED_DATE,
@@ -101,7 +103,7 @@ public class WorkingNote {
  
     private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
  
-    // New note construct
+    // 新笔记构造方法
     private WorkingNote(Context context, long folderId) {
         mContext = context;
         mAlertDate = 0;
@@ -114,7 +116,7 @@ public class WorkingNote {
         mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
     }
  
-    // Existing note construct
+    // 已有笔记构造方法
     private WorkingNote(Context context, long noteId, long folderId) {
         mContext = context;
         mNoteId = noteId;
@@ -124,6 +126,7 @@ public class WorkingNote {
         loadNote();
     }
  
+    // 从数据库加载笔记信息
     private void loadNote() {
         Cursor cursor = mContext.getContentResolver().query(
                 ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
@@ -146,6 +149,7 @@ public class WorkingNote {
         loadNoteData();
     }
  
+    // 从数据库加载笔记数据
     private void loadNoteData() {
         Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
                 DataColumns.NOTE_ID + "=?", new String[] {
@@ -174,6 +178,7 @@ public class WorkingNote {
         }
     }
  
+    // 创建一个空笔记
     public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
             int widgetType, int defaultBgColorId) {
         WorkingNote note = new WorkingNote(context, folderId);
@@ -183,10 +188,12 @@ public class WorkingNote {
         return note;
     }
  
+    // 从数据库加载笔记
     public static WorkingNote load(Context context, long id) {
         return new WorkingNote(context, id, 0);
     }
  
+    // 保存笔记到数据库
     public synchronized boolean saveNote() {
         if (isWorthSaving()) {
             if (!existInDatabase()) {
@@ -212,10 +219,12 @@ public class WorkingNote {
         }
     }
  
+    // 判断笔记是否存在于数据库中
     public boolean existInDatabase() {
         return mNoteId > 0;
     }
  
+    // 判断笔记是否值得保存
     private boolean isWorthSaving() {
         if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
                 || (existInDatabase() && !mNote.isLocalModified())) {
@@ -225,10 +234,12 @@ public class WorkingNote {
         }
     }
  
+    // 设置笔记信息改变监听器
     public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
         mNoteSettingStatusListener = l;
     }
  
+    // 设置闹钟提醒日期
     public void setAlertDate(long date, boolean set) {
         if (date != mAlertDate) {
             mAlertDate = date;
@@ -239,6 +250,7 @@ public class WorkingNote {
         }
     }
  
+    // 标记笔记是否已删除
     public void markDeleted(boolean mark) {
         mIsDeleted = mark;
         if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
@@ -247,6 +259,7 @@ public class WorkingNote {
         }
     }
  
+    // 设置笔记背景颜色ID
     public void setBgColorId(int id) {
         if (id != mBgColorId) {
             mBgColorId = id;
@@ -257,6 +270,7 @@ public class WorkingNote {
         }
     }
  
+    // 设置笔记的检查列表模式
     public void setCheckListMode(int mode) {
         if (mMode != mode) {
             if (mNoteSettingStatusListener != null) {
@@ -267,6 +281,7 @@ public class WorkingNote {
         }
     }
  
+    // 设置笔记的窗口小部件类型
     public void setWidgetType(int type) {
         if (type != mWidgetType) {
             mWidgetType = type;
@@ -274,6 +289,7 @@ public class WorkingNote {
         }
     }
  
+    // 设置笔记的窗口小部件ID
     public void setWidgetId(int id) {
         if (id != mWidgetId) {
             mWidgetId = id;
@@ -281,6 +297,7 @@ public class WorkingNote {
         }
     }
  
+    // 设置工作文本内容
     public void setWorkingText(String text) {
         if (!TextUtils.equals(mContent, text)) {
             mContent = text;
@@ -288,60 +305,74 @@ public class WorkingNote {
         }
     }
  
+    // 将笔记转换为通话笔记
     public void convertToCallNote(String phoneNumber, long callDate) {
         mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
         mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
         mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
     }
  
+    // 检查笔记是否有闹钟提醒
     public boolean hasClockAlert() {
         return (mAlertDate > 0 ? true : false);
     }
  
+    // 获取笔记内容
     public String getContent() {
         return mContent;
     }
  
+    // 获取闹钟提醒日期
     public long getAlertDate() {
         return mAlertDate;
     }
  
+    // 获取笔记修改日期
     public long getModifiedDate() {
         return mModifiedDate;
     }
  
+    // 获取笔记背景颜色资源ID
     public int getBgColorResId() {
         return NoteBgResources.getNoteBgResource(mBgColorId);
     }
  
+    // 获取笔记背景颜色ID
     public int getBgColorId() {
         return mBgColorId;
     }
  
+    // 获取笔记标题背景颜色资源ID
     public int getTitleBgResId() {
         return NoteBgResources.getNoteTitleBgResource(mBgColorId);
     }
  
+    // 获取检查列表模式
     public int getCheckListMode() {
         return mMode;
     }
  
+    // 获取笔记ID
     public long getNoteId() {
         return mNoteId;
     }
  
+    // 获取笔记所在的文件夹ID
     public long getFolderId() {
         return mFolderId;
     }
  
+    // 获取窗口小部件ID
     public int getWidgetId() {
         return mWidgetId;
     }
  
+    // 获取窗口小部件类型
     public int getWidgetType() {
         return mWidgetType;
     }
  
+    // 笔记信息改变监听器接口
     public interface NoteSettingChangedListener {
         /**
          * Called when the background color of current note has just changed

src/Notes-master/src/net/micode/notes/tool/BackupUtils.java

@@ -35,12 +35,13 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.PrintStream;
  
-
+// 备份工具类，用于将笔记数据导出为文本文件
 public class BackupUtils {
     private static final String TAG = "BackupUtils";
-    // Singleton stuff
+    // 单例实例
     private static BackupUtils sInstance;
  
+    // 获取BackupUtils的单例实例
     public static synchronized BackupUtils getInstance(Context context) {
         if (sInstance == null) {
             sInstance = new BackupUtils(context);
@@ -49,42 +50,47 @@ public class BackupUtils {
     }
  
     /**
-     * Following states are signs to represents backup or restore
+     * 以下状态码表示备份或恢复的状态
-     * status
      */
-    // Currently, the sdcard is not mounted
+    // SD卡未挂载
     public static final int STATE_SD_CARD_UNMOUONTED           = 0;
-    // The backup file not exist
+    // 备份文件不存在
     public static final int STATE_BACKUP_FILE_NOT_EXIST        = 1;
-    // The data is not well formated, may be changed by other programs
+    // 数据损坏或格式不正确
     public static final int STATE_DATA_DESTROIED               = 2;
-    // Some run-time exception which causes restore or backup fails
+    // 系统错误导致备份或恢复失败
     public static final int STATE_SYSTEM_ERROR                 = 3;
-    // Backup or restore success
+    // 备份或恢复成功
     public static final int STATE_SUCCESS                      = 4;
  
     private TextExport mTextExport;
  
+    // 构造函数，初始化TextExport实例
     private BackupUtils(Context context) {
         mTextExport = new TextExport(context);
     }
  
+    // 检查外部存储是否可用
     private static boolean externalStorageAvailable() {
         return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
     }
  
+    // 导出笔记数据为文本文件
     public int exportToText() {
         return mTextExport.exportToText();
     }
  
+    // 获取导出的文本文件名
     public String getExportedTextFileName() {
         return mTextExport.mFileName;
     }
  
+    // 获取导出的文本文件目录
     public String getExportedTextFileDir() {
         return mTextExport.mFileDirectory;
     }
  
+    // 文本导出类，用于将笔记数据导出为文本格式
     private static class TextExport {
         private static final String[] NOTE_PROJECTION = {
                 NoteColumns.ID,
@@ -125,6 +131,7 @@ public class BackupUtils {
         private String mFileName;
         private String mFileDirectory;
  
+        // 构造函数，初始化导出格式和上下文
         public TextExport(Context context) {
             TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
             mContext = context;
@@ -132,15 +139,14 @@ public class BackupUtils {
             mFileDirectory = "";
         }
  
+        // 根据ID获取导出格式字符串
         private String getFormat(int id) {
             return TEXT_FORMAT[id];
         }
  
-        /**
+        // 导出指定文件夹下的笔记到文本文件
-         * Export the folder identified by folder id to text
-         */
         private void exportFolderToText(String folderId, PrintStream ps) {
-            // Query notes belong to this folder
+            // 查询属于该文件夹的笔记
             Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                     NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] {
                         folderId
@@ -149,11 +155,11 @@ public class BackupUtils {
             if (notesCursor != null) {
                 if (notesCursor.moveToFirst()) {
                     do {
-                        // Print note's last modified date
+                        // 打印笔记的最后修改日期
                         ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
                                 mContext.getString(R.string.format_datetime_mdhm),
                                 notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
-                        // Query data belong to this note
+                        // 查询属于该笔记的数据
                         String noteId = notesCursor.getString(NOTE_COLUMN_ID);
                         exportNoteToText(noteId, ps);
                     } while (notesCursor.moveToNext());
@@ -162,9 +168,7 @@ public class BackupUtils {
             }
         }
  
-        /**
+        // 导出指定笔记到文本输出流
-         * Export note identified by id to a print stream
-         */
         private void exportNoteToText(String noteId, PrintStream ps) {
             Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
                     DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
@@ -176,7 +180,7 @@ public class BackupUtils {
                     do {
                         String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
                         if (DataConstants.CALL_NOTE.equals(mimeType)) {
-                            // Print phone number
+                            // 打印电话号码
                             String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER);
                             long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE);
                             String location = dataCursor.getString(DATA_COLUMN_CONTENT);
@@ -185,11 +189,11 @@ public class BackupUtils {
                                 ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
                                         phoneNumber));
                             }
-                            // Print call date
+                            // 打印通话日期
                             ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
                                     .format(mContext.getString(R.string.format_datetime_mdhm),
                                             callDate)));
-                            // Print call attachment location
+                            // 打印通话附件位置
                             if (!TextUtils.isEmpty(location)) {
                                 ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
                                         location));
@@ -205,7 +209,7 @@ public class BackupUtils {
                 }
                 dataCursor.close();
             }
-            // print a line separator between note
+            // 打印笔记之间的分隔符
             try {
                 ps.write(new byte[] {
                         Character.LINE_SEPARATOR, Character.LETTER_NUMBER
@@ -215,9 +219,7 @@ public class BackupUtils {
             }
         }
  
-        /**
+        // 将笔记数据导出为用户可读的文本文件
-         * Note will be exported as text which is user readable
-         */
         public int exportToText() {
             if (!externalStorageAvailable()) {
                 Log.d(TAG, "Media was not mounted");
@@ -229,7 +231,7 @@ public class BackupUtils {
                 Log.e(TAG, "get print stream error");
                 return STATE_SYSTEM_ERROR;
             }
-            // First export folder and its notes
+            // 首先导出文件夹及其笔记
             Cursor folderCursor = mContext.getContentResolver().query(
                     Notes.CONTENT_NOTE_URI,
                     NOTE_PROJECTION,
@@ -240,7 +242,7 @@ public class BackupUtils {
             if (folderCursor != null) {
                 if (folderCursor.moveToFirst()) {
                     do {
-                        // Print folder's name
+                        // 打印文件夹名称
                         String folderName = "";
                         if(folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {
                             folderName = mContext.getString(R.string.call_record_folder_name);
@@ -257,7 +259,7 @@ public class BackupUtils {
                 folderCursor.close();
             }
  
-            // Export notes in root's folder
+            // 导出根文件夹下的笔记
             Cursor noteCursor = mContext.getContentResolver().query(
                     Notes.CONTENT_NOTE_URI,
                     NOTE_PROJECTION,
@@ -270,7 +272,7 @@ public class BackupUtils {
                         ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
                                 mContext.getString(R.string.format_datetime_mdhm),
                                 noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
-                        // Query data belong to this note
+                        // 查询属于该笔记的数据
                         String noteId = noteCursor.getString(NOTE_COLUMN_ID);
                         exportNoteToText(noteId, ps);
                     } while (noteCursor.moveToNext());
@@ -282,9 +284,7 @@ public class BackupUtils {
             return STATE_SUCCESS;
         }
  
-        /**
+        // 获取指向导出文本文件的PrintStream
-         * Get a print stream pointed to the file {@generateExportedTextFile}
-         */
         private PrintStream getExportToTextPrintStream() {
             File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
                     R.string.file_name_txt_format);
@@ -309,9 +309,7 @@ public class BackupUtils {
         }
     }
  
-    /**
+    // 生成用于存储导入数据的文本文件
-     * Generate the text file to store imported data
-     */
     private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
         StringBuilder sb = new StringBuilder();
         sb.append(Environment.getExternalStorageDirectory());
@@ -340,5 +338,3 @@ public class BackupUtils {
         return null;
     }
 }
-
-

src/Notes-master/src/net/micode/notes/tool/DataUtils.java

@@ -34,9 +34,11 @@ import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
 import java.util.ArrayList;
 import java.util.HashSet;
 
-
+// 数据工具类，提供批量删除笔记、移动笔记到文件夹等操作
 public class DataUtils {
     public static final String TAG = "DataUtils";
+
+    // 批量删除笔记
     public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
         if (ids == null) {
             Log.d(TAG, "the ids is null");
@@ -72,6 +74,7 @@ public class DataUtils {
         return false;
     }
 
+    // 将笔记移动到指定文件夹
     public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
         ContentValues values = new ContentValues();
         values.put(NoteColumns.PARENT_ID, desFolderId);
@@ -80,6 +83,7 @@ public class DataUtils {
         resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
     }
 
+    // 批量将笔记移动到指定文件夹
     public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
             long folderId) {
         if (ids == null) {
@@ -112,7 +116,7 @@ public class DataUtils {
     }
 
     /**
-     * Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}}
+     * 获取用户文件夹（非系统文件夹）的数量
      */
     public static int getUserFolderCount(ContentResolver resolver) {
         Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI,
@@ -136,6 +140,7 @@ public class DataUtils {
         return count;
     }
 
+    // 检查指定类型的笔记是否可见
     public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                 null,
@@ -153,6 +158,7 @@ public class DataUtils {
         return exist;
     }
 
+    // 检查笔记是否存在于数据库中
     public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                 null, null, null, null);
@@ -167,6 +173,7 @@ public class DataUtils {
         return exist;
     }
 
+    // 检查数据是否存在于数据库中
     public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
                 null, null, null, null);
@@ -181,6 +188,7 @@ public class DataUtils {
         return exist;
     }
 
+    // 检查指定名称的用户文件夹是否存在
     public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
         Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
                 NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
@@ -197,6 +205,7 @@ public class DataUtils {
         return exist;
     }
 
+    // 获取指定文件夹下的笔记小部件信息
     public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
         Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
                 new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
@@ -224,6 +233,7 @@ public class DataUtils {
         return set;
     }
 
+    // 根据笔记ID获取通话号码
     public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
         Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                 new String [] { CallNote.PHONE_NUMBER },
@@ -243,6 +253,7 @@ public class DataUtils {
         return "";
     }
 
+    // 根据通话号码和通话日期获取笔记ID
     public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
         Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                 new String [] { CallNote.NOTE_ID },
@@ -264,6 +275,7 @@ public class DataUtils {
         return 0;
     }
 
+    // 根据笔记ID获取笔记摘要
     public static String getSnippetById(ContentResolver resolver, long noteId) {
         Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
                 new String [] { NoteColumns.SNIPPET },
@@ -282,6 +294,7 @@ public class DataUtils {
         throw new IllegalArgumentException("Note is not found with id: " + noteId);
     }
 
+    // 格式化笔记摘要
     public static String getFormattedSnippet(String snippet) {
         if (snippet != null) {
             snippet = snippet.trim();

src/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java

@@ -16,6 +16,7 @@
  
 package net.micode.notes.tool;
  
+// 此类用于定义和存储GTask相关的JSON字段名常量
 public class GTaskStringUtils {
  
     public final static String GTASK_JSON_ACTION_ID = "action_id";

src/Notes-master/src/net/micode/notes/tool/ResourceParser.java

@@ -24,21 +24,26 @@ import net.micode.notes.ui.NotesPreferenceActivity;
  
 public class ResourceParser {
  
+    // 定义笔记背景颜色的常量
     public static final int YELLOW           = 0;
     public static final int BLUE             = 1;
     public static final int WHITE            = 2;
     public static final int GREEN            = 3;
     public static final int RED              = 4;
  
+    // 默认笔记背景颜色
     public static final int BG_DEFAULT_COLOR = YELLOW;
  
+    // 定义笔记文本大小的常量
     public static final int TEXT_SMALL       = 0;
     public static final int TEXT_MEDIUM      = 1;
     public static final int TEXT_LARGE       = 2;
     public static final int TEXT_SUPER       = 3;
  
+    // 默认笔记背景文本大小
     public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
  
+    // 用于获取编辑笔记时的背景资源
     public static class NoteBgResources {
         private final static int [] BG_EDIT_RESOURCES = new int [] {
             R.drawable.edit_yellow,
@@ -56,15 +61,18 @@ public class ResourceParser {
             R.drawable.edit_title_red
         };
  
+        // 根据ID获取编辑笔记的背景资源
         public static int getNoteBgResource(int id) {
             return BG_EDIT_RESOURCES[id];
         }
  
+        // 根据ID获取编辑笔记标题的背景资源
         public static int getNoteTitleBgResource(int id) {
             return BG_EDIT_TITLE_RESOURCES[id];
         }
     }
  
+    // 获取默认笔记背景颜色ID
     public static int getDefaultBgId(Context context) {
         if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
                 NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
@@ -74,6 +82,7 @@ public class ResourceParser {
         }
     }
  
+    // 用于获取笔记列表项的背景资源
     public static class NoteItemBgResources {
         private final static int [] BG_FIRST_RESOURCES = new int [] {
             R.drawable.list_yellow_up,
@@ -88,7 +97,7 @@ public class ResourceParser {
             R.drawable.list_blue_middle,
             R.drawable.list_white_middle,
             R.drawable.list_green_middle,
-            R.drawable.list_red_middle
+            R.drawable.list_red_middle,
         };
  
         private final static int [] BG_LAST_RESOURCES = new int [] {
@@ -107,27 +116,33 @@ public class ResourceParser {
             R.drawable.list_red_single
         };
  
+        // 根据ID获取笔记列表第一项的背景资源
         public static int getNoteBgFirstRes(int id) {
             return BG_FIRST_RESOURCES[id];
         }
  
+        // 根据ID获取笔记列表最后一项的背景资源
         public static int getNoteBgLastRes(int id) {
             return BG_LAST_RESOURCES[id];
         }
  
+        // 根据ID获取单个笔记项的背景资源
         public static int getNoteBgSingleRes(int id) {
             return BG_SINGLE_RESOURCES[id];
         }
  
+        // 根据ID获取笔记列表中间项的背景资源
         public static int getNoteBgNormalRes(int id) {
             return BG_NORMAL_RESOURCES[id];
         }
  
+        // 获取文件夹背景资源
         public static int getFolderBgRes() {
             return R.drawable.list_folder;
         }
     }
  
+    // 用于获取小部件的背景资源
     public static class WidgetBgResources {
         private final static int [] BG_2X_RESOURCES = new int [] {
             R.drawable.widget_2x_yellow,
@@ -137,6 +152,7 @@ public class ResourceParser {
             R.drawable.widget_2x_red,
         };
  
+        // 根据ID获取2x小部件的背景资源
         public static int getWidget2xBgResource(int id) {
             return BG_2X_RESOURCES[id];
         }
@@ -149,11 +165,13 @@ public class ResourceParser {
             R.drawable.widget_4x_red
         };
  
+        // 根据ID获取4x小部件的背景资源
         public static int getWidget4xBgResource(int id) {
             return BG_4X_RESOURCES[id];
         }
     }
  
+    // 用于获取文本外观资源
     public static class TextAppearanceResources {
         private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
             R.style.TextAppearanceNormal,
@@ -162,6 +180,7 @@ public class ResourceParser {
             R.style.TextAppearanceSuper
         };
  
+        // 根据ID获取文本外观资源
         public static int getTexAppearanceResource(int id) {
             /**
              * HACKME: Fix bug of store the resource id in shared preference.
@@ -174,6 +193,7 @@ public class ResourceParser {
             return TEXTAPPEARANCE_RESOURCES[id];
         }
  
+        // 获取文本外观资源的数量
         public static int getResourcesSize() {
             return TEXTAPPEARANCE_RESOURCES.length;
         }

src/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java

@@ -39,21 +39,29 @@ import net.micode.notes.tool.DataUtils;
 
 import java.io.IOException;
 
-
+/**
+ * 闹钟提醒活动类，继承自Activity，实现了OnClickListener和OnDismissListener接口。
+ * 该活动用于在闹钟响起时显示提醒对话框，并播放默认的闹钟声音。
+ */
 public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
-    private long mNoteId;
+    private long mNoteId; // 保存笔记的ID
-    private String mSnippet;
+    private String mSnippet; // 保存笔记的摘要
-    private static final int SNIPPET_PREW_MAX_LEN = 60;
+    private static final int SNIPPET_PREW_MAX_LEN = 60; // 笔记摘要的最大长度
-    MediaPlayer mPlayer;
+    MediaPlayer mPlayer; // 用于播放闹钟声音的MediaPlayer实例
-
+
+    /**
+     * 创建活动时调用的方法。
+     * @param savedInstanceState 保存的实例状态数据包
+     */
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        requestWindowFeature(Window.FEATURE_NO_TITLE); // 请求无标题窗口
 
-        final Window win = getWindow();
+        final Window win = getWindow(); // 获取当前窗口
-        win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
+        win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED); // 设置窗口在锁屏时显示
 
+        // 如果屏幕未点亮，则添加更多标志以保持屏幕点亮并允许在锁屏时操作
         if (!isScreenOn()) {
             win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
                     | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
@@ -61,98 +69,123 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
                     | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
         }
 
-        Intent intent = getIntent();
+        Intent intent = getIntent(); // 获取启动该活动的Intent
 
         try {
-            mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
+            mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1)); // 从Intent中提取笔记ID
-            mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
+            mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId); // 根据笔记ID获取摘要
+            // 如果摘要长度超过最大限制，则截取前SNIPPET_PREW_MAX_LEN个字符并添加省略号
             mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0,
                     SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
                     : mSnippet;
         } catch (IllegalArgumentException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 打印异常信息
-            return;
+            return; // 如果发生异常，则结束该方法
         }
 
-        mPlayer = new MediaPlayer();
+        mPlayer = new MediaPlayer(); // 创建MediaPlayer实例
+        // 检查数据库中是否存在指定ID的笔记
         if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
-            showActionDialog();
+            showActionDialog(); // 显示操作对话框
-            playAlarmSound();
+            playAlarmSound(); // 播放闹钟声音
         } else {
-            finish();
+            finish(); // 如果笔记不存在，则结束该活动
         }
     }
 
+    /**
+     * 检查屏幕是否点亮。
+     * @return 如果屏幕点亮则返回true，否则返回false
+     */
     private boolean isScreenOn() {
-        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
+        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); // 获取电源管理服务
-        return pm.isScreenOn();
+        return pm.isScreenOn(); // 返回屏幕是否点亮的状态
     }
 
+    /**
+     * 播放闹钟声音的方法。
+     */
     private void playAlarmSound() {
+        // 获取实际的默认闹钟铃声URI
         Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
 
+        // 获取当前设置的静音模式影响的音频流类型
         int silentModeStreams = Settings.System.getInt(getContentResolver(),
                 Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
 
+        // 如果静音模式影响了闹钟音频流，则设置MediaPlayer的音频流类型为silentModeStreams
+        // 否则，设置为AudioManager.STREAM_ALARM
         if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {
             mPlayer.setAudioStreamType(silentModeStreams);
         } else {
             mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);
         }
         try {
-            mPlayer.setDataSource(this, url);
+            mPlayer.setDataSource(this, url); // 设置MediaPlayer的数据源为闹钟铃声URI
-            mPlayer.prepare();
+            mPlayer.prepare(); // 准备MediaPlayer
-            mPlayer.setLooping(true);
+            mPlayer.setLooping(true); // 设置MediaPlayer循环播放
-            mPlayer.start();
+            mPlayer.start(); // 开始播放闹钟声音
         } catch (IllegalArgumentException e) {
-            // TODO Auto-generated catch block
+            e.printStackTrace(); // 打印异常信息
-            e.printStackTrace();
         } catch (SecurityException e) {
-            // TODO Auto-generated catch block
+            e.printStackTrace(); // 打印异常信息
-            e.printStackTrace();
         } catch (IllegalStateException e) {
-            // TODO Auto-generated catch block
+            e.printStackTrace(); // 打印异常信息
-            e.printStackTrace();
         } catch (IOException e) {
-            // TODO Auto-generated catch block
+            e.printStackTrace(); // 打印异常信息
-            e.printStackTrace();
         }
     }
 
+    /**
+     * 显示操作对话框的方法。
+     */
     private void showActionDialog() {
-        AlertDialog.Builder dialog = new AlertDialog.Builder(this);
+        AlertDialog.Builder dialog = new AlertDialog.Builder(this); // 创建AlertDialog.Builder实例
-        dialog.setTitle(R.string.app_name);
+        dialog.setTitle(R.string.app_name); // 设置对话框标题为应用名称
-        dialog.setMessage(mSnippet);
+        dialog.setMessage(mSnippet); // 设置对话框消息为笔记摘要
-        dialog.setPositiveButton(R.string.notealert_ok, this);
+        dialog.setPositiveButton(R.string.notealert_ok, this); // 设置确定按钮及其监听器
+        // 如果屏幕已点亮，则添加进入按钮及其监听器
         if (isScreenOn()) {
             dialog.setNegativeButton(R.string.notealert_enter, this);
         }
-        dialog.show().setOnDismissListener(this);
+        dialog.show().setOnDismissListener(this); // 显示对话框并设置对话框消失监听器
     }
 
+    /**
+     * 实现OnClickListener接口的方法，处理对话框按钮点击事件。
+     * @param dialog 触发点击事件的对话框
+     * @param which 点击的按钮的ID
+     */
     public void onClick(DialogInterface dialog, int which) {
         switch (which) {
             case DialogInterface.BUTTON_NEGATIVE:
-                Intent intent = new Intent(this, NoteEditActivity.class);
+                Intent intent = new Intent(this, NoteEditActivity.class); // 创建Intent准备跳转到笔记编辑活动
-                intent.setAction(Intent.ACTION_VIEW);
+                intent.setAction(Intent.ACTION_VIEW); // 设置Intent动作类型为ACTION_VIEW
-                intent.putExtra(Intent.EXTRA_UID, mNoteId);
+                intent.putExtra(Intent.EXTRA_UID, mNoteId); // 添加笔记ID作为附加信息
-                startActivity(intent);
+                startActivity(intent); // 启动笔记编辑活动
                 break;
             default:
                 break;
         }
     }
 
+    /**
+     * 实现OnDismissListener接口的方法，处理对话框消失事件。
+     * @param dialog 消失的对话框
+     */
     public void onDismiss(DialogInterface dialog) {
-        stopAlarmSound();
+        stopAlarmSound(); // 停止播放闹钟声音
-        finish();
+        finish(); // 结束该活动
     }
 
+    /**
+     * 停止并释放MediaPlayer的方法。
+     */
     private void stopAlarmSound() {
         if (mPlayer != null) {
-            mPlayer.stop();
+            mPlayer.stop(); // 停止MediaPlayer播放
-            mPlayer.release();
+            mPlayer.release(); // 释放MediaPlayer资源
-            mPlayer = null;
+            mPlayer = null; // 将mPlayer置为null
         }
     }
 }

src/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java

@@ -27,17 +27,20 @@ import android.database.Cursor;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
  
-
+// 该广播接收器用于初始化闹钟，查询即将提醒的笔记并设置闹钟
 public class AlarmInitReceiver extends BroadcastReceiver {
  
+    // 查询笔记数据库时使用的列投影
     private static final String [] PROJECTION = new String [] {
         NoteColumns.ID,
         NoteColumns.ALERTED_DATE
     };
  
+    // 列索引常量，用于从查询结果中提取数据
     private static final int COLUMN_ID                = 0;
     private static final int COLUMN_ALERTED_DATE      = 1;
  
+    // 接收广播时执行的方法，查询数据库并设置闹钟
     @Override
     public void onReceive(Context context, Intent intent) {
         long currentDate = System.currentTimeMillis();

src/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java

@@ -20,11 +20,16 @@ import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
  
+// 一个继承自BroadcastReceiver的类，用于接收闹钟触发的广播
 public class AlarmReceiver extends BroadcastReceiver {
+    // 当接收到广播时，该方法会被调用
     @Override
     public void onReceive(Context context, Intent intent) {
+        // 设置Intent的目标Activity为AlarmAlertActivity
         intent.setClass(context, AlarmAlertActivity.class);
+        // 添加标志以允许启动新的Activity
         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        // 启动AlarmAlertActivity
         context.startActivity(intent);
     }
 }

src/Notes-master/src/net/micode/notes/ui/DateTimePicker.java

@@ -21,6 +21,263 @@ import java.util.Calendar;
  
 import net.micode.notes.R;
  
+import android.content.Context;
+import android.text.format.DateFormat;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.NumberPicker;
+ 
+// DateTimePicker类继承自FrameLayout，用于显示日期和时间选择控件
+public class DateTimePicker extends FrameLayout {
+ 
+    // 默认控件是否可用
+    private static final boolean DEFAULT_ENABLE_STATE = true;
+ 
+    // 半天中的小时数、全天中的小时数、一周中的天数等常量
+    private static final int HOURS_IN_HALF_DAY = 12;
+    private static final int HOURS_IN_ALL_DAY = 24;
+    private static final int DAYS_IN_ALL_WEEK = 7;
+    private static final int DATE_SPINNER_MIN_VAL = 0;
+    private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
+    private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
+    private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
+    private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
+    private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
+    private static final int MINUT_SPINNER_MIN_VAL = 0;
+    private static final int MINUT_SPINNER_MAX_VAL = 59;
+    private static final int AMPM_SPINNER_MIN_VAL = 0;
+    private static final int AMPM_SPINNER_MAX_VAL = 1;
+ 
+    // 日期、小时、分钟、AM/PM选择器控件
+    private final NumberPicker mDateSpinner;
+    private final NumberPicker mHourSpinner;
+    private final NumberPicker mMinuteSpinner;
+    private final NumberPicker mAmPmSpinner;
+    // 当前日期时间
+    private Calendar mDate;
+ 
+    // 日期显示值数组
+    private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
+ 
+    // 当前是否为AM
+    private boolean mIsAm;
+ 
+    // 是否为24小时制视图
+    private boolean mIs24HourView;
+ 
+    // 控件是否可用
+    private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
+ 
+    // 初始化标志
+    private boolean mInitialising;
+ 
+    // 日期时间改变监听器
+    private OnDateTimeChangedListener mOnDateTimeChangedListener;
+ 
+    // 日期选择器值改变监听器
+    private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);
+            updateDateControl();
+            onDateTimeChanged();
+        }
+    };
+ 
+    // 小时选择器值改变监听器
+    private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            boolean isDateChanged = false;
+            Calendar cal = Calendar.getInstance();
+            if (!mIs24HourView) {
+                if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, 1);
+                    isDateChanged = true;
+                } else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, -1);
+                    isDateChanged = true;
+                }
+                if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
+                        oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
+                    mIsAm = !mIsAm;
+                    updateAmPmControl();
+                }
+            } else {
+                if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, 1);
+                    isDateChanged = true;
+                } else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, -1);
+                    isDateChanged = true;
+                }
+            }
+            int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
+            mDate.set(Calendar.HOUR_OF_DAY, newHour);
+            onDateTimeChanged();
+            if (isDateChanged) {
+                setCurrentYear(cal.get(Calendar.YEAR));
+                setCurrentMonth(cal.get(Calendar.MONTH));
+                setCurrentDay(cal.get(Calendar.DAY_OF_MONTH));
+            }
+        }
+    };
+ 
+    // 分钟选择器值改变监听器
+    private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            int minValue = mMinuteSpinner.getMinValue();
+            int maxValue = mMinuteSpinner.getMaxValue();
+            int offset = 0;
+            if (oldVal == maxValue && newVal == minValue) {
+                offset += 1;
+            } else if (oldVal == minValue && newVal == maxValue) {
+                offset -= 1;
+            }
+            if (offset != 0) {
+                mDate.add(Calendar.HOUR_OF_DAY, offset);
+                mHourSpinner.setValue(getCurrentHour());
+                updateDateControl();
+                int newHour = getCurrentHourOfDay();
+                if (newHour >= HOURS_IN_HALF_DAY) {
+                    mIsAm = false;
+                    updateAmPmControl();
+                } else {
+                    mIsAm = true;
+                    updateAmPmControl();
+                }
+            }
+            mDate.set(Calendar.MINUTE, newVal);
+            onDateTimeChanged();
+        }
+    };
+ 
+    // AM/PM选择器值改变监听器
+    private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            mIsAm = !mIsAm;
+            if (mIsAm) {
+                mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
+            } else {
+                mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
+            }
+            updateAmPmControl();
+            onDateTimeChanged();
+        }
+    };
+ 
+    // 日期时间改变监听器接口
+    public interface OnDateTimeChangedListener {
+        void onDateTimeChanged(DateTimePicker view, int year, int month,
+                int dayOfMonth, int hourOfDay, int minute);
+    }
+ 
+    // 构造函数，默认使用当前时间
+    public DateTimePicker(Context context) {
+        this(context, System.currentTimeMillis());
+    }
+ 
+    // 构造函数，使用指定时间
+    public DateTimePicker(Context context, long date) {
+        this(context, date, DateFormat.is24HourFormat(context));
+    }
+ 
+    // 构造函数，使用指定时间和是否为24小时制
+    public DateTimePicker(Context context, long date, boolean is24HourView) {
+        super(context);
+        mDate = Calendar.getInstance();
+        mInitialising = true;
+        mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
+        inflate(context, R.layout.datetime_picker, this);
+ 
+        mDateSpinner = (NumberPicker) findViewById(R.id.date);
+        mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
+        mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
+        mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);
+ 
+        mHourSpinner = (NumberPicker) findViewById(R.id.hour);
+        mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
+        mMinuteSpinner =  (NumberPicker) findViewById(R.id.minute);
+        mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
+        mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
+        mMinuteSpinner.setOnLongPressUpdateInterval(100);
+        mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
+ 
+        String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
+        mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
+        mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
+        mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);
+        mAmPmSpinner.setDisplayedValues(stringsForAmPm);
+        mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
+ 
+        // 更新控件到初始状态
+        updateDateControl();
+        updateHourControl();
+        updateAmPmControl();
+ 
+        set24HourView(is24HourView);
+ 
+        // 设置到当前时间
+        setCurrentDate(date);
+ 
+        setEnabled(isEnabled());
+ 
+        // 设置内容描述
+        mInitialising = false;
+    }
+ 
+    // 设置控件是否可用
+    @Override
+    public void setEnabled(boolean enabled) {
+        if (mIsEnabled == enabled) {
+            return;
+        }
+        super.setEnabled(enabled);
+        mDateSpinner.setEnabled(enabled);
+        mMinuteSpinner.setEnabled(enabled);
+        mHourSpinner.setEnabled(enabled);
+        mAmPmSpinner.setEnabled(enabled);
+        mIsEnabled = enabled;
+    }
+ 
+    // 获取控件是否可用
+    @Override
+    public boolean isEnabled() {
+        return mIsEnabled;
+    }
+ 
+   
+
+```
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * 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
+ *
+ * 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.ui;
+
+import java.text.DateFormatSymbols;
+import java.util.Calendar;
+
+import net.micode.notes.R;
+
 
 import android.content.Context;
 import android.text.format.DateFormat;
@@ -28,6 +285,9 @@ import android.view.View;
 import android.widget.FrameLayout;
 import android.widget.NumberPicker;
 
+/**
+ * DateTimePicker 类用于显示和选择日期和时间。
+ */
 public class DateTimePicker extends FrameLayout {
 
     private static final boolean DEFAULT_ENABLE_STATE = true;
@@ -158,19 +418,31 @@ public class DateTimePicker extends FrameLayout {
         }
     };
 
+    /**
+     * OnDateTimeChangedListener 接口用于监听日期和时间的变化。
+     */
     public interface OnDateTimeChangedListener {
         void onDateTimeChanged(DateTimePicker view, int year, int month,
                 int dayOfMonth, int hourOfDay, int minute);
     }
 
+    /**
+     * 构造函数，使用当前时间初始化 DateTimePicker。
+     */
     public DateTimePicker(Context context) {
         this(context, System.currentTimeMillis());
     }
 
+    /**
+     * 构造函数，使用指定时间初始化 DateTimePicker。
+     */
     public DateTimePicker(Context context, long date) {
         this(context, date, DateFormat.is24HourFormat(context));
     }
 
+    /**
+     * 构造函数，使用指定时间和24小时制设置初始化 DateTimePicker。
+     */
     public DateTimePicker(Context context, long date, boolean is24HourView) {
         super(context);
         mDate = Calendar.getInstance();
@@ -198,22 +470,25 @@ public class DateTimePicker extends FrameLayout {
         mAmPmSpinner.setDisplayedValues(stringsForAmPm);
         mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
 
-        // update controls to initial state
+        // 更新控件到初始状态
         updateDateControl();
         updateHourControl();
         updateAmPmControl();
 
         set24HourView(is24HourView);
 
-        // set to current time
+        // 设置为当前时间
         setCurrentDate(date);
 
         setEnabled(isEnabled());
 
-        // set the content descriptions
+        // 设置内容描述
         mInitialising = false;
     }
 
+    /**
+     * 设置控件是否启用。
+     */
     @Override
     public void setEnabled(boolean enabled) {
         if (mIsEnabled == enabled) {
@@ -227,24 +502,23 @@ public class DateTimePicker extends FrameLayout {
         mIsEnabled = enabled;
     }
 
+    /**
+     * 获取控件是否启用。
+     */
     @Override
     public boolean isEnabled() {
         return mIsEnabled;
     }
 
     /**
-     * Get the current date in millis
+     * 获取当前日期的毫秒数。
-     *
-     * @return the current date in millis
      */
     public long getCurrentDateInTimeMillis() {
         return mDate.getTimeInMillis();
     }
 
     /**
-     * Set the current date
+     * 设置当前日期。
-     *
-     * @param date The current date in millis
      */
     public void setCurrentDate(long date) {
         Calendar cal = Calendar.getInstance();
@@ -254,13 +528,7 @@ public class DateTimePicker extends FrameLayout {
     }
 
     /**
-     * Set the current date
+     * 设置当前日期。
-     *
-     * @param year The current year
-     * @param month The current month
-     * @param dayOfMonth The current dayOfMonth
-     * @param hourOfDay The current hourOfDay
-     * @param minute The current minute
      */
     public void setCurrentDate(int year, int month,
             int dayOfMonth, int hourOfDay, int minute) {
@@ -272,18 +540,14 @@ public class DateTimePicker extends FrameLayout {
     }
 
     /**
-     * Get current year
+     * 获取当前年份。
-     *
-     * @return The current year
      */
     public int getCurrentYear() {
         return mDate.get(Calendar.YEAR);
     }
 
     /**
-     * Set current year
+     * 设置当前年份。
-     *
-     * @param year The current year
      */
     public void setCurrentYear(int year) {
         if (!mInitialising && year == getCurrentYear()) {
@@ -295,18 +559,14 @@ public class DateTimePicker extends FrameLayout {
     }
 
     /**
-     * Get current month in the year
+     * 获取当前月份。
-     *
-     * @return The current month in the year
      */
     public int getCurrentMonth() {
         return mDate.get(Calendar.MONTH);
     }
 
     /**
-     * Set current month in the year
+     * 设置当前月份。
-     *
-     * @param month The month in the year
      */
     public void setCurrentMonth(int month) {
         if (!mInitialising && month == getCurrentMonth()) {
@@ -318,18 +578,14 @@ public class DateTimePicker extends FrameLayout {
     }
 
     /**
-     * Get current day of the month
+     * 获取当前日期。
-     *
-     * @return The day of the month
      */
     public int getCurrentDay() {
         return mDate.get(Calendar.DAY_OF_MONTH);
     }
 
     /**
-     * Set current day of the month
+     * 设置当前日期。
-     *
-     * @param dayOfMonth The day of the month
      */
     public void setCurrentDay(int dayOfMonth) {
         if (!mInitialising && dayOfMonth == getCurrentDay()) {
@@ -341,8 +597,7 @@ public class DateTimePicker extends FrameLayout {
     }
 
     /**
-     * Get current hour in 24 hour mode, in the range (0~23)
+     * 获取当前小时（24小时制）。
-     * @return The current hour in 24 hour mode
      */
     public int getCurrentHourOfDay() {
         return mDate.get(Calendar.HOUR_OF_DAY);
@@ -362,9 +617,7 @@ public class DateTimePicker extends FrameLayout {
     }
 
     /**
-     * Set current hour in 24 hour mode, in the range (0~23)
+     * 设置当前小时（24小时制）。
-     *
-     * @param hourOfDay
      */
     public void setCurrentHour(int hourOfDay) {
         if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
@@ -390,16 +643,14 @@ public class DateTimePicker extends FrameLayout {
     }
 
     /**
-     * Get currentMinute
+     * 获取当前分钟。
-     *
-     * @return The Current Minute
      */
     public int getCurrentMinute() {
         return mDate.get(Calendar.MINUTE);
     }
 
     /**
-     * Set current minute
+     * 设置当前分钟。
      */
     public void setCurrentMinute(int minute) {
         if (!mInitialising && minute == getCurrentMinute()) {
@@ -411,16 +662,14 @@ public class DateTimePicker extends FrameLayout {
     }
 
     /**
-     * @return true if this is in 24 hour view else false.
+     * 判断是否为24小时制。
      */
     public boolean is24HourView () {
         return mIs24HourView;
     }
 
     /**
-     * Set whether in 24 hour or AM/PM mode.
+     * 设置是否为24小时制。
-     *
-     * @param is24HourView True for 24 hour mode. False for AM/PM mode.
      */
     public void set24HourView(boolean is24HourView) {
         if (mIs24HourView == is24HourView) {
@@ -434,6 +683,9 @@ public class DateTimePicker extends FrameLayout {
         updateAmPmControl();
     }
 
+    /**
+     * 更新日期控件的显示。
+     */
     private void updateDateControl() {
         Calendar cal = Calendar.getInstance();
         cal.setTimeInMillis(mDate.getTimeInMillis());
@@ -448,6 +700,9 @@ public class DateTimePicker extends FrameLayout {
         mDateSpinner.invalidate();
     }
 
+    /**
+     * 更新AM/PM控件的显示。
+     */
     private void updateAmPmControl() {
         if (mIs24HourView) {
             mAmPmSpinner.setVisibility(View.GONE);
@@ -458,6 +713,9 @@ public class DateTimePicker extends FrameLayout {
         }
     }
 
+    /**
+     * 更新小时控件的显示。
+     */
     private void updateHourControl() {
         if (mIs24HourView) {
             mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
@@ -469,13 +727,15 @@ public class DateTimePicker extends FrameLayout {
     }
 
     /**
-     * Set the callback that indicates the 'Set' button has been pressed.
+     * 设置日期时间变化的监听器。
-     * @param callback the callback, if null will do nothing
      */
     public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {
         mOnDateTimeChangedListener = callback;
     }
 
+    /**
+     * 当日期或时间发生变化时调用此方法。
+     */
     private void onDateTimeChanged() {
         if (mOnDateTimeChangedListener != null) {
             mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),

src/Notes-master/src/net/micode/notes/ui/DateTimePickerDialog.java

@@ -29,17 +29,24 @@ import android.content.DialogInterface.OnClickListener;
 import android.text.format.DateFormat;
 import android.text.format.DateUtils;
  
+// 自定义的日期时间选择对话框，继承自AlertDialog并实现了OnClickListener接口
 public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
  
+    // 存储当前选择的日期时间
     private Calendar mDate = Calendar.getInstance();
+    // 是否使用24小时制
     private boolean mIs24HourView;
+    // 回调接口，当日期时间设置完成后调用
     private OnDateTimeSetListener mOnDateTimeSetListener;
+    // 日期时间选择器控件
     private DateTimePicker mDateTimePicker;
  
+    // 定义日期时间设置完成后的回调接口
     public interface OnDateTimeSetListener {
         void OnDateTimeSet(AlertDialog dialog, long date);
     }
  
+    // 构造函数，初始化对话框并设置初始日期时间
     public DateTimePickerDialog(Context context, long date) {
         super(context);
         mDateTimePicker = new DateTimePicker(context);
@@ -64,14 +71,17 @@ public class DateTimePickerDialog extends AlertDialog implements OnClickListener
         updateTitle(mDate.getTimeInMillis());
     }
  
+    // 设置是否使用24小时制显示时间
     public void set24HourView(boolean is24HourView) {
         mIs24HourView = is24HourView;
     }
  
+    // 设置日期时间选择完成后的回调监听器
     public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
         mOnDateTimeSetListener = callBack;
     }
  
+    // 更新对话框的标题以显示当前选择的日期时间
     private void updateTitle(long date) {
         int flag =
             DateUtils.FORMAT_SHOW_YEAR |
@@ -81,6 +91,7 @@ public class DateTimePickerDialog extends AlertDialog implements OnClickListener
         setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
     }
  
+    // 处理用户点击对话框按钮的事件，如果是确认按钮则调用回调监听器
     public void onClick(DialogInterface arg0, int arg1) {
         if (mOnDateTimeSetListener != null) {
             mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());

src/Notes-master/src/net/micode/notes/ui/DropdownMenu.java

@@ -27,11 +27,13 @@ import android.widget.PopupMenu.OnMenuItemClickListener;
  
 import net.micode.notes.R;
  
+// 下拉菜单类，用于在按钮点击时显示一个弹出菜单
 public class DropdownMenu {
-    private Button mButton;
+    private Button mButton; // 用于触发下拉菜单的按钮
-    private PopupMenu mPopupMenu;
+    private PopupMenu mPopupMenu; // 弹出菜单对象
-    private Menu mMenu;
+    private Menu mMenu; // 菜单对象
  
+    // 构造函数，初始化下拉菜单，设置按钮背景，并将菜单资源加载到弹出菜单中
     public DropdownMenu(Context context, Button button, int menuId) {
         mButton = button;
         mButton.setBackgroundResource(R.drawable.dropdown_icon);
@@ -45,16 +47,19 @@ public class DropdownMenu {
         });
     }
  
+    // 设置下拉菜单项点击监听器
     public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
         if (mPopupMenu != null) {
             mPopupMenu.setOnMenuItemClickListener(listener);
         }
     }
  
+    // 根据菜单项的ID查找菜单项
     public MenuItem findItem(int id) {
         return mMenu.findItem(id);
     }
  
+    // 设置按钮的标题
     public void setTitle(CharSequence title) {
         mButton.setText(title);
     }

src/Notes-master/src/net/micode/notes/ui/FoldersListAdapter.java

@@ -28,26 +28,31 @@ import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 
-
+// 自定义的 CursorAdapter 用于显示文件夹列表
 public class FoldersListAdapter extends CursorAdapter {
+    // 定义查询文件夹时需要的列
     public static final String [] PROJECTION = {
         NoteColumns.ID,
         NoteColumns.SNIPPET
     };
 
+    // 列索引常量
     public static final int ID_COLUMN   = 0;
     public static final int NAME_COLUMN = 1;
 
+    // 构造函数，初始化 FoldersListAdapter
     public FoldersListAdapter(Context context, Cursor c) {
         super(context, c);
         // TODO Auto-generated constructor stub
     }
 
+    // 创建一个新的视图项
     @Override
     public View newView(Context context, Cursor cursor, ViewGroup parent) {
         return new FolderListItem(context);
     }
 
+    // 绑定数据到视图项
     @Override
     public void bindView(View view, Context context, Cursor cursor) {
         if (view instanceof FolderListItem) {
@@ -57,21 +62,25 @@ public class FoldersListAdapter extends CursorAdapter {
         }
     }
 
+    // 根据位置获取文件夹名称
     public String getFolderName(Context context, int position) {
         Cursor cursor = (Cursor) getItem(position);
         return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
                 .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
     }
 
+    // 内部类，定义文件夹列表项的视图结构
     private class FolderListItem extends LinearLayout {
         private TextView mName;
 
+        // 构造函数，初始化 FolderListItem 视图
         public FolderListItem(Context context) {
             super(context);
             inflate(context, R.layout.folder_list_item, this);
             mName = (TextView) findViewById(R.id.tv_folder_name);
         }
 
+        // 绑定文件夹名称到视图
         public void bind(String name) {
             mName.setText(name);
         }

src/Notes-master/src/net/micode/notes/ui/NoteEditActivity.java

@@ -71,9 +71,10 @@ import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
  
-
+// 笔记编辑界面的Activity类
 public class NoteEditActivity extends Activity implements OnClickListener,
         NoteSettingChangedListener, OnTextViewChangeListener {
+    // 用于存储笔记头部视图的ViewHolder类
     private class HeadViewHolder {
         public TextView tvModified;
  
@@ -84,6 +85,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         public ImageView ibSetBgColor;
     }
  
+    // 背景色选择按钮和颜色ID的映射
     private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
     static {
         sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
@@ -93,6 +95,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
     }
  
+    // 背景色选择后的显示标记和颜色ID的映射
     private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
     static {
         sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
@@ -102,6 +105,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
     }
  
+    // 字体大小选择按钮和字体大小ID的映射
     private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
     static {
         sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
@@ -110,6 +114,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
     }
  
+    // 字体大小选择后的显示标记和字体大小ID的映射
     private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
     static {
         sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
@@ -149,6 +154,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
     private String mUserQuery;
     private Pattern mPattern;
  
+    // 初始化Activity视图
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
@@ -161,10 +167,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         initResources();
     }
  
-    /**
+    // 当Activity被系统杀死后，恢复其状态
-     * Current activity may be killed when the memory is low. Once it is killed, for another time
-     * user load this activity, we should restore the former state
-     */
     @Override
     protected void onRestoreInstanceState(Bundle savedInstanceState) {
         super.onRestoreInstanceState(savedInstanceState);
@@ -179,19 +182,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
  
+    // 初始化Activity状态，根据Intent决定加载笔记或创建新笔记
     private boolean initActivityState(Intent intent) {
-        /**
-         * If the user specified the {@link Intent#ACTION_VIEW} but not provided with id,
-         * then jump to the NotesListActivity
-         */
         mWorkingNote = null;
         if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
             long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
             mUserQuery = "";
  
-            /**
-             * Starting from the searched result
-             */
             if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
                 noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
                 mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);
@@ -215,7 +212,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
                     WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
                             | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
         } else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) {
-            // New note
             long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0);
             int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
                     AppWidgetManager.INVALID_APPWIDGET_ID);
@@ -224,7 +220,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
             int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID,
                     ResourceParser.getDefaultBgId(this));
  
-            // Parse call-record note
             String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
             long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0);
             if (callDate != 0 && phoneNumber != null) {
@@ -262,12 +257,14 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return true;
     }
  
+    // Activity恢复时初始化笔记显示
     @Override
     protected void onResume() {
         super.onResume();
         initNoteScreen();
     }
  
+    // 初始化笔记显示界面，包括背景颜色、字体大小、修改日期等
     private void initNoteScreen() {
         mNoteEditor.setTextAppearance(this, TextAppearanceResources
                 .getTexAppearanceResource(mFontSizeId));
@@ -288,13 +285,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
                         | DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME
                         | DateUtils.FORMAT_SHOW_YEAR));
  
-        /**
-         * TODO: Add the menu for setting alert. Currently disable it because the DateTimePicker
-         * is not ready
-         */
         showAlertHeader();
     }
  
+    // 显示或隐藏提醒头部信息
     private void showAlertHeader() {
         if (mWorkingNote.hasClockAlert()) {
             long time = System.currentTimeMillis();
@@ -312,20 +306,17 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         };
     }
  
+    // 处理新的Intent，可能需要重新加载笔记或创建新笔记
     @Override
     protected void onNewIntent(Intent intent) {
         super.onNewIntent(intent);
         initActivityState(intent);
     }
  
+    // 保存Activity状态，在系统需要恢复Activity时使用
     @Override
     protected void onSaveInstanceState(Bundle outState) {
         super.onSaveInstanceState(outState);
-        /**
-         * For new note without note id, we should firstly save it to
-         * generate a id. If the editing note is not worth saving, there
-         * is no id which is equivalent to create new note
-         */
         if (!mWorkingNote.existInDatabase()) {
             saveNote();
         }
@@ -333,6 +324,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
     }
  
+    // 处理触摸事件，用于隐藏颜色和字体大小选择面板
     @Override
     public boolean dispatchTouchEvent(MotionEvent ev) {
         if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
@@ -349,6 +341,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return super.dispatchTouchEvent(ev);
     }
  
+    // 判断触摸事件是否发生在指定视图内
     private boolean inRangeOfView(View view, MotionEvent ev) {
         int []location = new int[2];
         view.getLocationOnScreen(location);
@@ -363,6 +356,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return true;
     }
  
+    // 初始化视图资源
     private void initResources() {
         mHeadViewPanel = findViewById(R.id.note_title);
         mNoteHeaderHolder = new HeadViewHolder();
@@ -386,17 +380,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         };
         mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
         mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
-        /**
-         * HACKME: Fix bug of store the resource id in shared preference.
-         * The id may larger than the length of resources, in this case,
-         * return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
-         */
         if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {
             mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
         }
         mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
     }
  
+    // 暂停Activity时保存笔记并清理设置状态
     @Override
     protected void onPause() {
         super.onPause();
@@ -406,6 +396,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         clearSettingState();
     }
  
+    // 更新桌面小部件显示
     private void updateWidget() {
         Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
         if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
@@ -425,12 +416,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         setResult(RESULT_OK, intent);
     }
  
+    // 处理视图点击事件，包括颜色和字体大小选择
     public void onClick(View v) {
         int id = v.getId();
         if (id == R.id.btn_set_bg_color) {
             mNoteBgColorSelector.setVisibility(View.VISIBLE);
             findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
-                    -                    View.VISIBLE);
+                    View.VISIBLE);
         } else if (sBgSelectorBtnsMap.containsKey(id)) {
             findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
                     View.GONE);
@@ -452,6 +444,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
  
+    // 处理返回键事件，如果设置面板可见则隐藏，否则保存笔记后返回
     @Override
     public void onBackPressed() {
         if(clearSettingState()) {
@@ -462,6 +455,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         super.onBackPressed();
     }
  
+    // 清理设置面板状态
     private boolean clearSettingState() {
         if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
             mNoteBgColorSelector.setVisibility(View.GONE);
@@ -473,6 +467,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return false;
     }
  
+    // 处理笔记背景颜色变化事件
     public void onBackgroundColorChanged() {
         findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
                 View.VISIBLE);
@@ -480,6 +475,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
     }
  
+    // 准备选项菜单，根据笔记状态动态更新菜单项
     @Override
     public boolean onPrepareOptionsMenu(Menu menu) {
         if (isFinishing()) {
@@ -505,6 +501,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return true;
     }
  
+    // 处理选项菜单项点击事件
     @Override
     public boolean onOptionsItemSelected(MenuItem item) {
         switch (item.getItemId()) {
@@ -553,6 +550,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return true;
     }
  
+    // 设置提醒时间
     private void setReminder() {
         DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
         d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
@@ -563,10 +561,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         d.show();
     }
  
-    /**
+    // 分享笔记内容到支持ACTION_SEND的其他应用
-     * Share note to apps that support {@link Intent#ACTION_SEND} action
-     * and {@text/plain} type
-     */
     private void sendTo(Context context, String info) {
         Intent intent = new Intent(Intent.ACTION_SEND);
         intent.putExtra(Intent.EXTRA_TEXT, info);
@@ -574,11 +569,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         context.startActivity(intent);
     }
  
+    // 创建新笔记，跳转到新笔记编辑界面
     private void createNewNote() {
-        // Firstly, save current editing notes
         saveNote();
  
-        // For safety, start a new NoteEditActivity
         finish();
         Intent intent = new Intent(this, NoteEditActivity.class);
         intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
@@ -586,6 +580,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         startActivity(intent);
     }
  
+    // 删除当前笔记
     private void deleteCurrentNote() {
         if (mWorkingNote.existInDatabase()) {
             HashSet<Long> ids = new HashSet<Long>();
@@ -608,15 +603,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         mWorkingNote.markDeleted(true);
     }
  
+    // 判断是否处于同步模式
     private boolean isSyncMode() {
         return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
     }
  
+    // 处理时钟提醒变化事件，设置或取消提醒
     public void onClockAlertChanged(long date, boolean set) {
-        /**
-         * User could set clock to an unsaved note, so before setting the
-         * alert clock, we should save the note first
-         */
         if (!mWorkingNote.existInDatabase()) {
             saveNote();
         }
@@ -632,20 +625,17 @@ public class NoteEditActivity extends Activity implements OnClickListener,
                 alarmManager.set(AlarmManager.RTC_WAKEUP, date, pendingIntent);
             }
         } else {
-            /**
-             * There is the condition that user has input nothing (the note is
-             * not worthy saving), we have no note id, remind the user that he
-             * should input something
-             */
             Log.e(TAG, "Clock alert setting error");
             showToast(R.string.error_note_empty_for_clock);
         }
     }
  
+    // 处理小部件变化事件，更新小部件显示
     public void onWidgetChanged() {
         updateWidget();
     }
  
+    // 处理EditText删除事件，调整列表项索引
     public void onEditTextDelete(int index, String text) {
         int childCount = mEditTextList.getChildCount();
         if (childCount == 1) {
@@ -672,10 +662,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         edit.setSelection(length);
     }
  
+    // 处理EditText输入事件，添加新列表项
     public void onEditTextEnter(int index, String text) {
-        /**
-         * Should not happen, check for debug
-         */
         if(index > mEditTextList.getChildCount()) {
             Log.e(TAG, "Index out of mEditTextList boundrary, should not happen");
         }
@@ -691,6 +679,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
  
+    // 切换到列表模式，根据笔记内容生成列表项
     private void switchToListMode(String text) {
         mEditTextList.removeAllViews();
         String[] items = text.split("\n");
@@ -708,6 +697,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         mEditTextList.setVisibility(View.VISIBLE);
     }
  
+    // 获取高亮查询结果，用于显示搜索关键词
     private Spannable getHighlightQueryResult(String fullText, String userQuery) {
         SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
         if (!TextUtils.isEmpty(userQuery)) {
@@ -725,6 +715,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return spannable;
     }
  
+    // 生成一个新的列表项视图
     private View getListItem(String item, int index) {
         View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);
         final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
@@ -756,6 +747,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return view;
     }
  
+    // 处理EditText文本变化事件，显示或隐藏复选框
     public void onTextChange(int index, boolean hasText) {
         if (index >= mEditTextList.getChildCount()) {
             Log.e(TAG, "Wrong index, should not happen");
@@ -768,6 +760,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
  
+    // 处理笔记模式变化事件，从普通模式切换到列表模式或反之
     public void onCheckListModeChanged(int oldMode, int newMode) {
         if (newMode == TextNote.MODE_CHECK_LIST) {
             switchToListMode(mNoteEditor.getText().toString());
@@ -782,6 +775,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
  
+    // 获取正在编辑的文本内容，根据列表模式添加标签
     private boolean getWorkingText() {
         boolean hasChecked = false;
         if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
@@ -805,28 +799,18 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return hasChecked;
     }
  
+    // 保存笔记内容到数据库
     private boolean saveNote() {
         getWorkingText();
         boolean saved = mWorkingNote.saveNote();
         if (saved) {
-            /**
-             * There are two modes from List view to edit view, open one note,
-             * create/edit a node. Opening node requires to the original
-             * position in the list when back from edit view, while creating a
-             * new node requires to the top of the list. This code
-             * {@link #RESULT_OK} is used to identify the create/edit state
-             */
             setResult(RESULT_OK);
         }
         return saved;
     }
  
+    // 将笔记快捷方式添加到桌面
     private void sendToDesktop() {
-        /**
-         * Before send message to home, we should make sure that current
-         * editing note is exists in databases. So, for new note, firstly
-         * save it
-         */
         if (!mWorkingNote.existInDatabase()) {
             saveNote();
         }
@@ -846,16 +830,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
             showToast(R.string.info_note_enter_desktop);
             sendBroadcast(sender);
         } else {
-            /**
-             * There is the condition that user has input nothing (the note is
-             * not worthy saving), we have no note id, remind the user that he
-             * should input something
-             */
             Log.e(TAG, "Send to desktop error");
             showToast(R.string.error_note_empty_for_send_to_desktop);
         }
     }
  
+    // 生成桌面快捷方式的标题，截取笔记内容的一部分作为标题
     private String makeShortcutIconTitle(String content) {
         content = content.replace(TAG_CHECKED, "");
         content = content.replace(TAG_UNCHECKED, "");
@@ -863,10 +843,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
                 SHORTCUT_ICON_TITLE_MAX_LEN) : content;
     }
  
+    // 显示短Toast消息
     private void showToast(int resId) {
         showToast(resId, Toast.LENGTH_SHORT);
     }
  
+    // 显示指定持续时间的Toast消息
     private void showToast(int resId, int duration) {
         Toast.makeText(this, resId, duration).show();
     }

src/Notes-master/src/net/micode/notes/ui/NoteEditText.java

@@ -37,6 +37,7 @@ import net.micode.notes.R;
 import java.util.HashMap;
 import java.util.Map;
  
+// 自定义的EditText，用于笔记应用中，支持删除、添加文本事件监听
 public class NoteEditText extends EditText {
     private static final String TAG = "NoteEditText";
     private int mIndex;
@@ -82,10 +83,12 @@ public class NoteEditText extends EditText {
         mIndex = 0;
     }
  
+    // 设置当前文本框的索引
     public void setIndex(int index) {
         mIndex = index;
     }
  
+    // 设置文本变化监听器
     public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
         mOnTextViewChangeListener = listener;
     }
@@ -99,6 +102,7 @@ public class NoteEditText extends EditText {
         // TODO Auto-generated constructor stub
     }
  
+    // 处理触摸事件，更新光标位置
     @Override
     public boolean onTouchEvent(MotionEvent event) {
         switch (event.getAction()) {
@@ -121,6 +125,7 @@ public class NoteEditText extends EditText {
         return super.onTouchEvent(event);
     }
  
+    // 处理按键按下事件，记录删除操作前的光标位置
     @Override
     public boolean onKeyDown(int keyCode, KeyEvent event) {
         switch (keyCode) {
@@ -138,6 +143,7 @@ public class NoteEditText extends EditText {
         return super.onKeyDown(keyCode, event);
     }
  
+    // 处理按键弹起事件，根据按键类型执行相应操作
     @Override
     public boolean onKeyUp(int keyCode, KeyEvent event) {
         switch(keyCode) {
@@ -167,6 +173,7 @@ public class NoteEditText extends EditText {
         return super.onKeyUp(keyCode, event);
     }
  
+    // 当EditText焦点发生变化时调用，通知监听器文本是否有内容
     @Override
     protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
         if (mOnTextViewChangeListener != null) {
@@ -179,6 +186,7 @@ public class NoteEditText extends EditText {
         super.onFocusChanged(focused, direction, previouslyFocusedRect);
     }
  
+    // 创建上下文菜单，处理URL点击事件
     @Override
     protected void onCreateContextMenu(ContextMenu menu) {
         if (getText() instanceof Spanned) {

src/Notes-master/src/net/micode/notes/ui/NoteItemData.java

@@ -25,7 +25,7 @@ import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.tool.DataUtils;
  
-
+// 该类用于从数据库游标中提取笔记项数据，并处理与笔记位置相关的逻辑
 public class NoteItemData {
     static final String [] PROJECTION = new String [] {
         NoteColumns.ID,
@@ -42,6 +42,7 @@ public class NoteItemData {
         NoteColumns.WIDGET_TYPE,
     };
  
+    // 定义了游标中各个列的索引位置
     private static final int ID_COLUMN                    = 0;
     private static final int ALERTED_DATE_COLUMN          = 1;
     private static final int BG_COLOR_ID_COLUMN           = 2;
@@ -55,6 +56,7 @@ public class NoteItemData {
     private static final int WIDGET_ID_COLUMN             = 10;
     private static final int WIDGET_TYPE_COLUMN           = 11;
  
+    // 笔记项的各种属性
     private long mId;
     private long mAlertDate;
     private int mBgColorId;
@@ -70,12 +72,14 @@ public class NoteItemData {
     private String mName;
     private String mPhoneNumber;
  
+    // 笔记项在列表中的位置信息
     private boolean mIsLastItem;
     private boolean mIsFirstItem;
     private boolean mIsOnlyOneItem;
     private boolean mIsOneNoteFollowingFolder;
     private boolean mIsMultiNotesFollowingFolder;
  
+    // 构造函数，从游标中提取笔记项数据
     public NoteItemData(Context context, Cursor cursor) {
         mId = cursor.getLong(ID_COLUMN);
         mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
@@ -109,6 +113,7 @@ public class NoteItemData {
         checkPostion(cursor);
     }
  
+    // 检查笔记项在列表中的位置信息
     private void checkPostion(Cursor cursor) {
         mIsLastItem = cursor.isLast() ? true : false;
         mIsFirstItem = cursor.isFirst() ? true : false;
@@ -134,90 +139,112 @@ public class NoteItemData {
         }
     }
  
+    // 判断该笔记项是否是单个笔记跟在一个文件夹后
     public boolean isOneFollowingFolder() {
         return mIsOneNoteFollowingFolder;
     }
  
+    // 判断该笔记项是否是多个笔记跟在一个文件夹后
     public boolean isMultiFollowingFolder() {
         return mIsMultiNotesFollowingFolder;
     }
  
+    // 判断该笔记项是否是列表中的最后一个项
     public boolean isLast() {
         return mIsLastItem;
     }
  
+    // 获取与该笔记项关联的呼叫记录的联系人名称
     public String getCallName() {
         return mName;
     }
  
+    // 判断该笔记项是否是列表中的第一个项
     public boolean isFirst() {
         return mIsFirstItem;
     }
  
+    // 判断该笔记项是否是列表中唯一的项
     public boolean isSingle() {
         return mIsOnlyOneItem;
     }
  
+    // 获取笔记项的ID
     public long getId() {
         return mId;
     }
  
+    // 获取笔记项的提醒日期
     public long getAlertDate() {
         return mAlertDate;
     }
  
+    // 获取笔记项的创建日期
     public long getCreatedDate() {
         return mCreatedDate;
     }
  
+    // 判断该笔记项是否有附件
     public boolean hasAttachment() {
         return mHasAttachment;
     }
  
+    // 获取笔记项的修改日期
     public long getModifiedDate() {
         return mModifiedDate;
     }
  
+    // 获取笔记项的背景颜色ID
     public int getBgColorId() {
         return mBgColorId;
     }
  
+    // 获取笔记项的父ID
     public long getParentId() {
         return mParentId;
     }
  
+    // 获取笔记项包含的笔记数量
     public int getNotesCount() {
         return mNotesCount;
     }
  
+    // 获取笔记项所在的文件夹ID
     public long getFolderId () {
         return mParentId;
     }
  
+    // 获取笔记项的类型
     public int getType() {
         return mType;
     }
  
+    // 获取笔记项的小部件类型
     public int getWidgetType() {
         return mWidgetType;
     }
  
+    // 获取笔记项的小部件ID
     public int getWidgetId() {
         return mWidgetId;
     }
  
+    // 获取笔记项的摘要
     public String getSnippet() {
         return mSnippet;
     }
  
+    // 判断该笔记项是否有提醒
     public boolean hasAlert() {
         return (mAlertDate > 0);
     }
  
+    // 判断该笔记项是否是呼叫记录类型
     public boolean isCallRecord() {
         return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
     }
  
+    // 静态方法，从游标中获取笔记项的类型
     public static int getNoteType(Cursor cursor) {
         return cursor.getInt(TYPE_COLUMN);
     }

src/Notes-master/src/net/micode/notes/ui/NotesListAdapter.java

@@ -30,7 +30,7 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
  
-
+// 自定义的CursorAdapter，用于显示笔记列表
 public class NotesListAdapter extends CursorAdapter {
     private static final String TAG = "NotesListAdapter";
     private Context mContext;
@@ -38,11 +38,13 @@ public class NotesListAdapter extends CursorAdapter {
     private int mNotesCount;
     private boolean mChoiceMode;
  
+    // 用于存储小部件属性的内部类
     public static class AppWidgetAttribute {
         public int widgetId;
         public int widgetType;
     };
  
+    // 构造函数，初始化上下文和选择索引
     public NotesListAdapter(Context context) {
         super(context, null);
         mSelectedIndex = new HashMap<Integer, Boolean>();
@@ -50,11 +52,13 @@ public class NotesListAdapter extends CursorAdapter {
         mNotesCount = 0;
     }
  
+    // 创建新的视图项
     @Override
     public View newView(Context context, Cursor cursor, ViewGroup parent) {
         return new NotesListItem(context);
     }
  
+    // 绑定数据到视图项
     @Override
     public void bindView(View view, Context context, Cursor cursor) {
         if (view instanceof NotesListItem) {
@@ -64,20 +68,24 @@ public class NotesListAdapter extends CursorAdapter {
         }
     }
  
+    // 设置指定位置的项是否被选中，并通知数据集发生变化
     public void setCheckedItem(final int position, final boolean checked) {
         mSelectedIndex.put(position, checked);
         notifyDataSetChanged();
     }
  
+    // 检查当前是否处于多选模式
     public boolean isInChoiceMode() {
         return mChoiceMode;
     }
  
+    // 设置多选模式，清空选择索引
     public void setChoiceMode(boolean mode) {
         mSelectedIndex.clear();
         mChoiceMode = mode;
     }
  
+    // 全选或全不选所有笔记
     public void selectAll(boolean checked) {
         Cursor cursor = getCursor();
         for (int i = 0; i < getCount(); i++) {
@@ -89,6 +97,7 @@ public class NotesListAdapter extends CursorAdapter {
         }
     }
  
+    // 获取所有选中的笔记ID集合
     public HashSet<Long> getSelectedItemIds() {
         HashSet<Long> itemSet = new HashSet<Long>();
         for (Integer position : mSelectedIndex.keySet()) {
@@ -105,6 +114,7 @@ public class NotesListAdapter extends CursorAdapter {
         return itemSet;
     }
  
+    // 获取所有选中的小部件属性集合
     public HashSet<AppWidgetAttribute> getSelectedWidget() {
         HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
         for (Integer position : mSelectedIndex.keySet()) {
@@ -128,6 +138,7 @@ public class NotesListAdapter extends CursorAdapter {
         return itemSet;
     }
  
+    // 获取选中的笔记数量
     public int getSelectedCount() {
         Collection<Boolean> values = mSelectedIndex.values();
         if (null == values) {
@@ -143,11 +154,13 @@ public class NotesListAdapter extends CursorAdapter {
         return count;
     }
  
+    // 检查是否所有笔记都被选中
     public boolean isAllSelected() {
         int checkedCount = getSelectedCount();
         return (checkedCount != 0 && checkedCount == mNotesCount);
     }
  
+    // 检查指定位置的项是否被选中
     public boolean isSelectedItem(final int position) {
         if (null == mSelectedIndex.get(position)) {
             return false;
@@ -155,18 +168,21 @@ public class NotesListAdapter extends CursorAdapter {
         return mSelectedIndex.get(position);
     }
  
+    // 当数据内容发生变化时，更新笔记数量
     @Override
     protected void onContentChanged() {
         super.onContentChanged();
         calcNotesCount();
     }
  
+    // 更改Cursor时，更新笔记数量
     @Override
     public void changeCursor(Cursor cursor) {
         super.changeCursor(cursor);
         calcNotesCount();
     }
  
+    // 计算笔记数量
     private void calcNotesCount() {
         mNotesCount = 0;
         for (int i = 0; i < getCount(); i++) {

src/Notes-master/src/net/micode/notes/ui/NotesListItem.java

@@ -29,7 +29,7 @@ import net.micode.notes.data.Notes;
 import net.micode.notes.tool.DataUtils;
 import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
  
-
+// NotesListItem 类继承自 LinearLayout，用于表示笔记列表中的一个项
 public class NotesListItem extends LinearLayout {
     private ImageView mAlert;
     private TextView mTitle;
@@ -38,6 +38,7 @@ public class NotesListItem extends LinearLayout {
     private NoteItemData mItemData;
     private CheckBox mCheckBox;
  
+    // 构造函数，初始化 NotesListItem 的视图组件
     public NotesListItem(Context context) {
         super(context);
         inflate(context, R.layout.note_item, this);
@@ -48,6 +49,7 @@ public class NotesListItem extends LinearLayout {
         mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
     }
  
+    // 绑定数据到 NotesListItem 的视图组件，并设置选择模式和选中状态
     public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
         if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
             mCheckBox.setVisibility(View.VISIBLE);
@@ -99,6 +101,7 @@ public class NotesListItem extends LinearLayout {
         setBackground(data);
     }
  
+    // 根据数据设置 NotesListItem 的背景资源
     private void setBackground(NoteItemData data) {
         int id = data.getBgColorId();
         if (data.getType() == Notes.TYPE_NOTE) {
@@ -116,6 +119,7 @@ public class NotesListItem extends LinearLayout {
         }
     }
  
+    // 获取绑定到此 NotesListItem 的数据
     public NoteItemData getItemData() {
         return mItemData;
     }

src/Notes-master/src/net/micode/notes/ui/NotesPreferenceActivity.java

@@ -47,7 +47,7 @@ import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.gtask.remote.GTaskSyncService;
  
-
+// 设置界面活动类，继承自PreferenceActivity
 public class NotesPreferenceActivity extends PreferenceActivity {
     public static final String PREFERENCE_NAME = "notes_preferences";
  
@@ -69,11 +69,12 @@ public class NotesPreferenceActivity extends PreferenceActivity {
  
     private boolean mHasAddedAccount;
  
+    // 创建活动时初始化界面
     @Override
     protected void onCreate(Bundle icicle) {
         super.onCreate(icicle);
  
-        /* using the app icon for navigation */
+        /* 使用应用图标进行导航 */
         getActionBar().setDisplayHomeAsUpEnabled(true);
  
         addPreferencesFromResource(R.xml.preferences);
@@ -88,12 +89,12 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         getListView().addHeaderView(header, null, true);
     }
  
+    // 恢复活动时刷新界面
     @Override
     protected void onResume() {
         super.onResume();
  
-        // need to set sync account automatically if user has added a new
+        // 如果用户添加了新账户，自动设置同步账户
-        // account
         if (mHasAddedAccount) {
             Account[] accounts = getGoogleAccounts();
             if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
@@ -116,6 +117,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         refreshUI();
     }
  
+    // 销毁活动时注销广播接收器
     @Override
     protected void onDestroy() {
         if (mReceiver != null) {
@@ -124,6 +126,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         super.onDestroy();
     }
  
+    // 加载账户偏好设置
     private void loadAccountPreference() {
         mAccountCategory.removeAll();
  
@@ -135,11 +138,10 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             public boolean onPreferenceClick(Preference preference) {
                 if (!GTaskSyncService.isSyncing()) {
                     if (TextUtils.isEmpty(defaultAccount)) {
-                        // the first time to set account
+                        // 第一次设置账户
                         showSelectAccountAlertDialog();
                     } else {
-                        // if the account has already been set, we need to promp
+                        // 如果账户已经设置，提示用户切换账户的风险
-                        // user about the risk
                         showChangeAccountConfirmAlertDialog();
                     }
                 } else {
@@ -154,11 +156,12 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         mAccountCategory.addPreference(accountPref);
     }
  
+    // 加载同步按钮
     private void loadSyncButton() {
         Button syncButton = (Button) findViewById(R.id.preference_sync_button);
         TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
  
-        // set button state
+        // 设置按钮状态
         if (GTaskSyncService.isSyncing()) {
             syncButton.setText(getString(R.string.preferences_button_sync_cancel));
             syncButton.setOnClickListener(new View.OnClickListener() {
@@ -176,7 +179,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }
         syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
  
-        // set last sync time
+        // 设置上次同步时间
         if (GTaskSyncService.isSyncing()) {
             lastSyncTimeView.setText(GTaskSyncService.getProgressString());
             lastSyncTimeView.setVisibility(View.VISIBLE);
@@ -193,11 +196,13 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }
     }
  
+    // 刷新用户界面
     private void refreshUI() {
         loadAccountPreference();
         loadSyncButton();
     }
  
+    // 显示选择账户的对话框
     private void showSelectAccountAlertDialog() {
         AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
  
@@ -254,6 +259,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         });
     }
  
+    // 显示更改账户确认对话框
     private void showChangeAccountConfirmAlertDialog() {
         AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
  
@@ -283,11 +289,13 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         dialogBuilder.show();
     }
  
+    // 获取Google账户列表
     private Account[] getGoogleAccounts() {
         AccountManager accountManager = AccountManager.get(this);
         return accountManager.getAccountsByType("com.google");
     }
  
+    // 设置同步账户
     private void setSyncAccount(String account) {
         if (!getSyncAccountName(this).equals(account)) {
             SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
@@ -299,10 +307,10 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             }
             editor.commit();
  
-            // clean up last sync time
+            // 清除上次同步时间
             setLastSyncTime(this, 0);
  
-            // clean up local gtask related info
+            // 清除本地Gtask相关信息
             new Thread(new Runnable() {
                 public void run() {
                     ContentValues values = new ContentValues();
@@ -318,6 +326,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }
     }
  
+    // 移除同步账户
     private void removeSyncAccount() {
         SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
         SharedPreferences.Editor editor = settings.edit();
@@ -329,7 +338,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }
         editor.commit();
  
-        // clean up local gtask related info
+        // 清除本地Gtask相关信息
         new Thread(new Runnable() {
             public void run() {
                 ContentValues values = new ContentValues();
@@ -340,12 +349,14 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }).start();
     }
  
+    // 获取同步账户名称
     public static String getSyncAccountName(Context context) {
         SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                 Context.MODE_PRIVATE);
         return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
     }
  
+    // 设置上次同步时间
     public static void setLastSyncTime(Context context, long time) {
         SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                 Context.MODE_PRIVATE);
@@ -354,12 +365,14 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         editor.commit();
     }
  
+    // 获取上次同步时间
     public static long getLastSyncTime(Context context) {
         SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                 Context.MODE_PRIVATE);
         return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
     }
  
+    // 广播接收器，用于接收同步状态更新
     private class GTaskReceiver extends BroadcastReceiver {
  
         @Override
@@ -374,6 +387,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }
     }
  
+    // 选项菜单项点击事件处理
     public boolean onOptionsItemSelected(MenuItem item) {
         switch (item.getItemId()) {
             case android.R.id.home:

src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java

@@ -32,19 +32,24 @@ import net.micode.notes.tool.ResourceParser;
 import net.micode.notes.ui.NoteEditActivity;
 import net.micode.notes.ui.NotesListActivity;
  
+// 提供笔记小部件功能的抽象类，继承自AppWidgetProvider
 public abstract class NoteWidgetProvider extends AppWidgetProvider {
+    // 查询笔记时使用的投影列
     public static final String [] PROJECTION = new String [] {
         NoteColumns.ID,
         NoteColumns.BG_COLOR_ID,
         NoteColumns.SNIPPET
     };
  
+    // 投影列对应的索引
     public static final int COLUMN_ID           = 0;
     public static final int COLUMN_BG_COLOR_ID  = 1;
     public static final int COLUMN_SNIPPET      = 2;
  
+    // 日志标签
     private static final String TAG = "NoteWidgetProvider";
  
+    // 当小部件被删除时调用，更新数据库中的小部件ID为无效值
     @Override
     public void onDeleted(Context context, int[] appWidgetIds) {
         ContentValues values = new ContentValues();
@@ -57,6 +62,7 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
         }
     }
  
+    // 根据小部件ID获取笔记信息
     private Cursor getNoteWidgetInfo(Context context, int widgetId) {
         return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                 PROJECTION,
@@ -65,10 +71,12 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
                 null);
     }
  
+    // 更新小部件视图
     protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
         update(context, appWidgetManager, appWidgetIds, false);
     }
  
+    // 更新小部件视图，支持隐私模式
     private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
             boolean privacyMode) {
         for (int i = 0; i < appWidgetIds.length; i++) {
@@ -124,9 +132,12 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
         }
     }
  
+    // 获取背景资源ID的方法，由子类实现
     protected abstract int getBgResourceId(int bgId);
  
+    // 获取布局ID的方法，由子类实现
     protected abstract int getLayoutId();
  
+    // 获取小部件类型的ID，由子类实现
     protected abstract int getWidgetType();
 }

src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java

@@ -23,23 +23,27 @@ import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.tool.ResourceParser;
  
-
+// 2x2 小部件提供者类，继承自 NoteWidgetProvider
 public class NoteWidgetProvider_2x extends NoteWidgetProvider {
+    // 更新小部件时调用的方法
     @Override
     public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
         super.update(context, appWidgetManager, appWidgetIds);
     }
  
+    // 返回 2x2 小部件的布局 ID
     @Override
     protected int getLayoutId() {
         return R.layout.widget_2x;
     }
  
+    // 根据背景 ID 返回对应的 2x2 小部件背景资源 ID
     @Override
     protected int getBgResourceId(int bgId) {
         return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
     }
  
+    // 返回 2x2 小部件的类型 ID
     @Override
     protected int getWidgetType() {
         return Notes.TYPE_WIDGET_2X;

src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java

@@ -1,19 +1,3 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * 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
- *
- * 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.widget;
 
 import android.appwidget.AppWidgetManager;
@@ -23,22 +7,26 @@ import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.tool.ResourceParser;
 
-
+// 定义一个4x4小部件的提供者类，继承自NoteWidgetProvider
 public class NoteWidgetProvider_4x extends NoteWidgetProvider {
+    // 覆盖父类的onUpdate方法，用于更新小部件的视图
     @Override
     public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
         super.update(context, appWidgetManager, appWidgetIds);
     }
 
+    // 返回4x4小部件的布局资源ID
     protected int getLayoutId() {
         return R.layout.widget_4x;
     }
 
+    // 根据背景ID返回4x4小部件的背景资源ID
     @Override
     protected int getBgResourceId(int bgId) {
         return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
     }
 
+    // 返回小部件的类型，这里是4x4类型
     @Override
     protected int getWidgetType() {
         return Notes.TYPE_WIDGET_4X;