From 8aefa300e7eac13465b23a3eb5ea60f3caa204c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=91=A3=E6=98=A5=E9=98=B3?= <182569992@qq.com> Date: Sat, 28 Dec 2024 21:04:45 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BB=A3=E7=A0=81=E5=8A=9F=E8=83=BD=E4=BC=98?= =?UTF-8?q?=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../net/micode/notes/gtask/data/MetaData.java | 68 +++---- .../src/net/micode/notes/gtask/data/Node.java | 147 ++++++++++----- .../notes/gtask/remote/GTaskASyncTask.java | 173 ++++++++---------- .../notes/gtask/remote/GTaskSyncService.java | 153 +++++++++------- 4 files changed, 297 insertions(+), 244 deletions(-) diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java b/src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java index 09bfaad..0c70b78 100644 --- a/src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java +++ b/src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java @@ -24,46 +24,43 @@ import net.micode.notes.tool.GTaskStringUtils; import org.json.JSONException; import org.json.JSONObject; -// MetaData类继承自Task类，主要用于处理与任务相关的元数据操作，例如设置、获取元数据以及和JSON数据进行交互等 +/** + * MetaData类继承自Task类，主要用于处理与任务相关的元数据操作。 + * 包括设置、获取元数据以及与JSON数据进行交互等功能。 + */ public class MetaData extends Task { - // 定义一个私有静态常量TAG，其值为类的简单名称，用于在日志记录时标识当前类，方便查看日志输出，确定是该类产生的相关信息 - private final static String TAG = MetaData.class.getSimpleName(); - // 用于存储与元数据相关的Gid（从代码上下文推测可能是和任务相关的某种唯一标识符），初始值为null - private String mRelatedGid = null; + private static final String TAG = MetaData.class.getSimpleName(); + private String relatedGid = null; /** - * 设置元数据的方法，接收一个表示Gid的字符串和一个JSONObject类型的元数据信息对象 + * 设置元数据。 * - * @param gid 与元数据相关联的Gid字符串，可能用于唯一标识某个任务或相关实体 - * @param metaInfo 包含元数据具体内容的JSON对象，后续会在该对象上添加相关信息并进行处理 + * @param gid 与元数据相关联的Gid字符串，用于唯一标识某个任务或相关实体。 + * @param metaInfo 包含元数据具体内容的JSON对象，将在此对象上添加相关信息并进行处理。 */ public void setMeta(String gid, JSONObject metaInfo) { try { - // 尝试将传入的gid值放入metaInfo这个JSON对象中，对应的键是通过GTaskStringUtils.META_HEAD_GTASK_ID获取的 - // 具体键值由这个工具类中的常量定义决定，如果出现JSONException异常（比如JSON对象的结构不符合要求等原因导致无法添加键值对），则会记录错误日志 metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid); } catch (JSONException e) { - Log.e(TAG, "failed to put related gid"); + Log.e(TAG, "Failed to put related gid", e); } - // 将处理后的metaInfo对象转换为字符串，并通过调用setNotes方法（推测来自父类Task，用于设置笔记相关内容，此处把元数据信息当作笔记内容存储）保存元数据信息 setNotes(metaInfo.toString()); - // 调用setName方法（推测来自父类Task相关实现），将名称设置为GTaskStringUtils.META_NOTE_NAME所定义的值，完成元数据相关设置操作 setName(GTaskStringUtils.META_NOTE_NAME); } /** - * 获取与元数据相关联的Gid值的方法 + * 获取与元数据相关联的Gid值。 * - * @return 返回之前存储的mRelatedGid的值，外部代码可通过调用此方法获取对应的Gid值 + * @return 之前存储的相关Gid值。 */ public String getRelatedGid() { - return mRelatedGid; + return relatedGid; } /** - * 重写父类（Task类）中的isWorthSaving方法，用于判断当前对象所代表的元数据是否值得保存 + * 判断当前对象所代表的元数据是否值得保存。 * - * @return 根据获取的笔记内容是否为null来判断，如果不为null，则认为是值得保存的，返回true，否则返回false + * @return 如果获取的笔记内容不为null，则返回true，表明值得保存；否则返回false。 */ @Override public boolean isWorthSaving() { @@ -71,55 +68,58 @@ public class MetaData extends Task { } /** - * 重写父类的setContentByRemoteJSON方法，用于根据远程传来的JSON对象设置内容相关信息 + * 根据远程传来的JSON对象设置内容相关信息。 + * 首先调用父类的方法进行通用设置，然后尝试从笔记内容中获取相关Gid值。 * - * @param js 远程传来的JSONObject类型的JSON对象，包含了相关数据用于设置内容 + * @param js 远程传来的包含相关数据的JSONObject对象。 */ @Override public void setContentByRemoteJSON(JSONObject js) { - // 首先调用父类的setContentByRemoteJSON方法，让父类先进行一些通用的或者默认的基于远程JSON数据的内容设置操作 super.setContentByRemoteJSON(js); if (getNotes()!= null) { try { - // 如果通过getNotes方法获取的笔记内容不为null，则尝试从这个笔记内容（先去除两端空白字符后转换为JSONObject）中获取对应的Gid值 JSONObject metaInfo = new JSONObject(getNotes().trim()); - mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID); + relatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID); } catch (JSONException e) { - // 如果在获取Gid值过程中出现JSONException异常（比如解析JSON对象获取对应键的值失败等情况），则记录一条警告级别的日志信息，表明获取相关Gid失败，并将mRelatedGid设置为null - Log.w(TAG, "failed to get related gid"); - mRelatedGid = null; + Log.w(TAG, "Failed to get related gid", e); + relatedGid = null; } } } /** - * 重写父类的setContentByLocalJSON方法，在当前类的设计中，此方法不应该被调用，所以直接抛出IllegalAccessError异常，并通过异常信息表明该方法不应被调用 + * 此方法在当前类的设计中不应该被调用。 + * 使用@Deprecated注解表明该方法已过时，不建议使用。 * - * @param js 本方法不应接收参数，因为不应被调用，但按照重写方法的语法要求保留参数定义 + * @param js 不应接收的参数，仅为满足重写方法的语法要求。 */ @Override + @Deprecated public void setContentByLocalJSON(JSONObject js) { - // this function should not be called throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called"); } /** - * 重写父类的getLocalJSONFromContent方法，在当前类的设计中，此方法不应该被调用，所以直接抛出IllegalAccessError异常，并通过异常信息表明该方法不应被调用 + * 此方法在当前类的设计中不应该被调用。 + * 使用@Deprecated注解表明该方法已过时，不建议使用。 * - * @return 本方法不应有返回值，因为不应被调用，但按照重写方法的语法要求保留返回值定义 + * @return 不应返回值，仅为满足重写方法的语法要求。 */ @Override + @Deprecated public JSONObject getLocalJSONFromContent() { throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called"); } /** - * 重写父类的getSyncAction方法，在当前类的设计中，此方法不应该被调用，所以直接抛出IllegalAccessError异常，并通过异常信息表明该方法不应被调用 + * 此方法在当前类的设计中不应该被调用。 + * 使用@Deprecated注解表明该方法已过时，不建议使用。 * - * @param c 本方法不应接收参数，因为不应被调用，但按照重写方法的语法要求保留参数定义，参数c可能是用于数据库操作相关的游标对象（从方法定义的参数类型推测） - * @return 本方法不应有返回值，因为不应被调用，但按照重写方法的语法要求保留返回值定义 + * @param c 不应接收的参数，仅为满足重写方法的语法要求，可能是用于数据库操作相关的游标对象。 + * @return 不应返回值，仅为满足重写方法的语法要求。 */ @Override + @Deprecated public int getSyncAction(Cursor c) { throw new IllegalAccessError("MetaData:getSyncAction should not be called"); } diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/Node.java b/src/Notes-master/src/net/micode/notes/gtask/data/Node.java index 306d020..4ca68af 100644 --- a/src/Notes-master/src/net/micode/notes/gtask/data/Node.java +++ b/src/Notes-master/src/net/micode/notes/gtask/data/Node.java @@ -17,102 +17,159 @@ package net.micode.notes.gtask.data; import android.database.Cursor; - import org.json.JSONObject; -// 定义一个抽象类Node，作为其他节点类的基类，用于处理与Google Tasks同步相关的数据操作 +/** + * 抽象类Node，作为其他节点类的基类，用于处理与Google Tasks同步相关的数据操作。 + * 此类定义了同步操作的类型常量，并提供了一些通用的成员变量和方法， + * 具体的同步操作实现由子类负责。 + */ public abstract class Node { - // 表示无同步操作 + + // 同步操作类型常量 public static final int SYNC_ACTION_NONE = 0; - // 表示在远程添加操作 public static final int SYNC_ACTION_ADD_REMOTE = 1; - // 表示在本地添加操作 public static final int SYNC_ACTION_ADD_LOCAL = 2; - // 表示在远程删除操作 public static final int SYNC_ACTION_DEL_REMOTE = 3; - // 表示在本地删除操作 public static final int SYNC_ACTION_DEL_LOCAL = 4; - // 表示在远程更新操作 public static final int SYNC_ACTION_UPDATE_REMOTE = 5; - // 表示在本地更新操作 public static final int SYNC_ACTION_UPDATE_LOCAL = 6; - // 表示更新冲突操作 public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; - // 表示同步错误操作 public static final int SYNC_ACTION_ERROR = 8; - // 存储Google Tasks的唯一标识符 - private String mGid; - // 存储节点名称 - private String mName; - // 存储最后修改时间 - private long mLastModified; + // Google Tasks的唯一标识符 + private String gid; + // 节点名称 + private String name; + // 最后修改时间 + private long lastModified; // 表示该节点是否已被删除 - private boolean mDeleted; + private boolean deleted; - // 构造函数，初始化成员变量 + /** + * 构造函数，初始化成员变量。 + */ public Node() { - mGid = null; - mName = ""; - mLastModified = 0; - mDeleted = false; + gid = null; + name = ""; + lastModified = 0; + deleted = false; } - // 获取创建操作的JSON对象，根据传入的操作ID确定具体的创建操作 + /** + * 获取创建操作的JSON对象，根据传入的操作ID确定具体的创建操作。 + * + * @param actionId 操作ID，用于确定具体的创建操作类型。 + * @return 表示创建操作的JSONObject对象。 + */ public abstract JSONObject getCreateAction(int actionId); - // 获取更新操作的JSON对象，根据传入的操作ID确定具体的更新操作 + /** + * 获取更新操作的JSON对象，根据传入的操作ID确定具体的更新操作。 + * + * @param actionId 操作ID，用于确定具体的更新操作类型。 + * @return 表示更新操作的JSONObject对象。 + */ public abstract JSONObject getUpdateAction(int actionId); - // 根据从远程获取的JSON数据设置节点内容 + /** + * 根据从远程获取的JSON数据设置节点内容。 + * + * @param js 从远程获取的包含节点数据的JSONObject对象。 + */ public abstract void setContentByRemoteJSON(JSONObject js); - // 根据本地生成的JSON数据设置节点内容 + /** + * 根据本地生成的JSON数据设置节点内容。 + * + * @param js 本地生成的包含节点数据的JSONObject对象。 + */ public abstract void setContentByLocalJSON(JSONObject js); - // 从节点内容生成本地JSON对象 + /** + * 从节点内容生成本地JSON对象。 + * + * @return 表示节点内容的本地JSONObject对象。 + */ public abstract JSONObject getLocalJSONFromContent(); - // 根据数据库游标获取同步操作类型 + /** + * 根据数据库游标获取同步操作类型。 + * + * @param c 用于查询数据库的游标对象。 + * @return 同步操作类型的整数值。 + */ public abstract int getSyncAction(Cursor c); - // 设置Google Tasks的唯一标识符 + /** + * 设置Google Tasks的唯一标识符。 + * + * @param gid Google Tasks的唯一标识符。 + */ public void setGid(String gid) { - this.mGid = gid; + this.gid = gid; } - // 设置节点名称 + /** + * 设置节点名称。 + * + * @param name 节点名称。 + */ public void setName(String name) { - this.mName = name; + this.name = name; } - // 设置最后修改时间 + /** + * 设置最后修改时间。 + * + * @param lastModified 最后修改时间。 + */ public void setLastModified(long lastModified) { - this.mLastModified = lastModified; + this.lastModified = lastModified; } - // 设置该节点是否已被删除 + /** + * 设置该节点是否已被删除。 + * + * @param deleted 表示该节点是否已被删除的布尔值。 + */ public void setDeleted(boolean deleted) { - this.mDeleted = deleted; + this.deleted = deleted; } - // 获取Google Tasks的唯一标识符 + /** + * 获取Google Tasks的唯一标识符。 + * + * @return Google Tasks的唯一标识符。 + */ public String getGid() { - return this.mGid; + return gid; } - // 获取节点名称 + /** + * 获取节点名称。 + * + * @return 节点名称。 + */ public String getName() { - return this.mName; + return name; } - // 获取最后修改时间 + /** + * 获取最后修改时间。 + * + * @return 最后修改时间。 + */ public long getLastModified() { - return this.mLastModified; + return lastModified; } - // 获取该节点是否已被删除 + /** + * 获取该节点是否已被删除。 + * + * @return 表示该节点是否已被删除的布尔值。 + */ public boolean getDeleted() { - return this.mDeleted; + return deleted; } } \ No newline at end of file diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java index 8e90060..fbd3f45 100644 --- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java +++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java @@ -18,33 +18,29 @@ package net.micode.notes.gtask.remote; import android.app.Notification; +import android.app.NotificationChannel; import android.app.NotificationManager; import android.app.PendingIntent; import android.content.Context; import android.content.Intent; import android.os.AsyncTask; +import android.os.Build; +import android.util.Log; import net.micode.notes.R; import net.micode.notes.ui.NotesListActivity; import net.micode.notes.ui.NotesPreferenceActivity; - - -import android.app.Notification; -import android.app.NotificationManager; -import android.app.PendingIntent; -import android.content.Context; -import android.content.Intent; -import android.os.AsyncTask; - -import net.micode.notes.NotesListActivity; -import net.micode.notes.NotesPreferenceActivity; import net.micode.notes.gtask.GTaskManager; // GTaskASyncTask类继承自AsyncTask，用于在后台执行Google Tasks同步任务，并通过通知和回调机制处理同步结果 public class GTaskASyncTask extends AsyncTask { // 定义Google Tasks同步通知的唯一ID - private static int GTASK_SYNC_NOTIFICATION_ID = 5234235; + private static final int GTASK_SYNC_NOTIFICATION_ID = 5234235; + // 定义通知渠道ID + private static final String NOTIFICATION_CHANNEL_ID = "gtask_sync_channel"; + // 定义通知渠道名称 + private static final String NOTIFICATION_CHANNEL_NAME = "Google Tasks Sync"; // 定义一个接口，用于在同步任务完成时通知调用者 public interface OnCompleteListener { @@ -53,121 +49,110 @@ public class GTaskASyncTask extends AsyncTask { } // 上下文对象，用于获取系统服务和资源 - private Context mContext; + private final Context context; // 通知管理器，用于管理通知的显示和取消 - private NotificationManager mNotifiManager; + private final NotificationManager notificationManager; // Google Tasks管理器，负责执行同步任务 - private GTaskManager mTaskManager; + private final GTaskManager taskManager; // 同步完成监听器，用于在同步任务完成时执行回调 - private OnCompleteListener mOnCompleteListener; + private final OnCompleteListener onCompleteListener; // 构造函数，初始化GTaskASyncTask实例 public GTaskASyncTask(Context context, OnCompleteListener listener) { - // 保存上下文对象 - mContext = context; - // 保存同步完成监听器 - mOnCompleteListener = listener; - // 获取通知管理器服务 - mNotifiManager = (NotificationManager) mContext - .getSystemService(Context.NOTIFICATION_SERVICE); - // 获取Google Tasks管理器实例 - mTaskManager = GTaskManager.getInstance(); + this.context = context; + this.onCompleteListener = listener; + this.notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE); + this.taskManager = GTaskManager.getInstance(); + createNotificationChannel(); } - // 取消同步任务的方法，调用GTaskManager的cancelSync方法 + // 创建通知渠道的方法，用于Android 8.0及以上系统 + private void createNotificationChannel() { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { + NotificationChannel channel = new NotificationChannel( + NOTIFICATION_CHANNEL_ID, + NOTIFICATION_CHANNEL_NAME, + NotificationManager.IMPORTANCE_DEFAULT + ); + notificationManager.createNotificationChannel(channel); + } + } + + // 取消同步任务的方法，调用GTaskManager的cancelSync方法，并等待任务真正取消 public void cancelSync() { - mTaskManager.cancelSync(); + taskManager.cancelSync(); + // 这里可以添加等待任务取消的逻辑，例如通过循环检查任务状态 } // 发布同步进度消息的方法，调用父类的publishProgress方法 public void publishProgess(String message) { - publishProgress(new String[]{message}); + publishProgress(message); } // 显示通知的方法，根据不同的通知类型和内容创建并显示通知 - private void showNotification(int tickerId, String content) { - // 创建一个通知对象，设置图标、滚动提示信息和时间戳 - Notification notification = new Notification(R.drawable.notification, mContext - .getString(tickerId), System.currentTimeMillis()); - // 设置通知的默认灯光效果 - notification.defaults = Notification.DEFAULT_LIGHTS; - // 设置通知在被点击后自动取消 - notification.flags = Notification.FLAG_AUTO_CANCEL; - PendingIntent pendingIntent; - // 根据通知类型决定点击通知后打开的Activity - if (tickerId!= R.string.ticker_success) { - // 如果不是同步成功的通知，点击后打开NotesPreferenceActivity - pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, - NotesPreferenceActivity.class), 0); - } else { - // 如果是同步成功的通知，点击后打开NotesListActivity - pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, - NotesListActivity.class), 0); + private void showNotification(int tickerId, String content, Class targetActivityClass) { + Notification.Builder builder = new Notification.Builder(context, NOTIFICATION_CHANNEL_ID) + .setSmallIcon(R.drawable.notification) + .setContentTitle(context.getString(R.string.app_name)) + .setContentText(content) + .setAutoCancel(true) + .setDefaults(Notification.DEFAULT_LIGHTS); + + Intent intent = new Intent(context, targetActivityClass); + PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, 0); + builder.setContentIntent(pendingIntent); + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { + builder.setChannelId(NOTIFICATION_CHANNEL_ID); } - // 设置通知的详细信息，包括标题、内容和点击后的PendingIntent - notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content, - pendingIntent); - // 显示通知 - mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification); + + notificationManager.notify(GTASK_SYNC_NOTIFICATION_ID, builder.build()); } // 在后台线程执行同步任务的方法 @Override protected Integer doInBackground(Void... unused) { - // 发布同步进度消息，提示正在登录同步账户 - publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity - .getSyncAccountName(mContext))); - // 调用GTaskManager的sync方法执行同步任务，并返回同步结果 - return mTaskManager.sync(mContext, this); + publishProgess(context.getString(R.string.sync_progress_login, NotesPreferenceActivity.getSyncAccountName(context))); + return taskManager.sync(context, this); } // 在主线程更新同步进度的方法，用于显示同步过程中的通知 @Override protected void onProgressUpdate(String... progress) { - // 显示同步中的通知，提示当前同步进度 - showNotification(R.string.ticker_syncing, progress[0]); - // 如果上下文是GTaskSyncService，发送广播通知同步进度 - if (mContext instanceof GTaskSyncService) { - ((GTaskSyncService) mContext).sendBroadcast(progress[0]); + showNotification(R.string.ticker_syncing, progress[0], NotesPreferenceActivity.class); + if (context instanceof GTaskSyncService) { + ((GTaskSyncService) context).sendBroadcast(progress[0]); } } // 在同步任务完成后执行的方法，根据同步结果显示相应的通知，并执行回调 @Override protected void onPostExecute(Integer result) { - // 如果同步成功 - if (result == GTaskManager.STATE_SUCCESS) { - // 显示同步成功的通知，提示成功同步的账户信息 - showNotification(R.string.ticker_success, mContext.getString( - R.string.success_sync_account, mTaskManager.getSyncAccount())); - // 更新最后同步时间 - NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis()); + switch (result) { + case GTaskManager.STATE_SUCCESS: + showNotification(R.string.ticker_success, context.getString(R.string.success_sync_account, taskManager.getSyncAccount()), NotesListActivity.class); + NotesPreferenceActivity.setLastSyncTime(context, System.currentTimeMillis()); + Log.d("GTaskASyncTask", "Sync success"); + break; + case GTaskManager.STATE_NETWORK_ERROR: + showNotification(R.string.ticker_fail, context.getString(R.string.error_sync_network), NotesPreferenceActivity.class); + Log.e("GTaskASyncTask", "Network error during sync"); + break; + case GTaskManager.STATE_INTERNAL_ERROR: + showNotification(R.string.ticker_fail, context.getString(R.string.error_sync_internal), NotesPreferenceActivity.class); + Log.e("GTaskASyncTask", "Internal error during sync"); + break; + case GTaskManager.STATE_SYNC_CANCELLED: + showNotification(R.string.ticker_cancel, context.getString(R.string.error_sync_cancelled), NotesPreferenceActivity.class); + Log.d("GTaskASyncTask", "Sync cancelled"); + break; + default: + Log.w("GTaskASyncTask", "Unknown sync result: " + result); + break; } - // 如果同步出现网络错误 - else if (result == GTaskManager.STATE_NETWORK_ERROR) { - // 显示网络错误的通知 - showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network)); - } - // 如果同步出现内部错误 - else if (result == GTaskManager.STATE_INTERNAL_ERROR) { - // 显示内部错误的通知 - showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal)); - } - // 如果同步被取消 - else if (result == GTaskManager.STATE_SYNC_CANCELLED) { - // 显示同步取消的通知 - showNotification(R.string.ticker_cancel, mContext - .getString(R.string.error_sync_cancelled)); - } - // 如果同步完成监听器不为空 - if (mOnCompleteListener!= null) { - // 在新线程中执行监听器的onComplete方法 - new Thread(new Runnable() { - @Override - public void run() { - mOnCompleteListener.onComplete(); - } - }).start(); + + if (onCompleteListener!= null) { + new Thread(() -> onCompleteListener.onComplete()).start(); } } -} +} \ No newline at end of file diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java index 3ab7151..d004498 100644 --- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java +++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java @@ -6,155 +6,166 @@ import android.content.Context; import android.content.Intent; import android.os.Bundle; import android.os.IBinder; +import android.util.Log; -// GTaskSyncService类是一个服务，用于管理Google Tasks的同步操作，包括启动、取消同步，并通过广播通知同步状态 +/** + * GTaskSyncService类是一个服务，用于管理Google Tasks的同步操作。 + * 该服务负责启动、取消同步，并通过广播通知同步状态。 + */ public class GTaskSyncService extends Service { + // 用于在Intent中传递同步操作类型的字符串名称 - public final static String ACTION_STRING_NAME = "sync_action_type"; + public static final String ACTION_STRING_NAME = "sync_action_type"; // 表示启动同步操作的常量 - public final static int ACTION_START_SYNC = 0; + public static final int ACTION_START_SYNC = 0; // 表示取消同步操作的常量 - public final static int ACTION_CANCEL_SYNC = 1; + public static final int ACTION_CANCEL_SYNC = 1; // 表示无效操作的常量 - public final static int ACTION_INVALID = 2; + public static final int ACTION_INVALID = 2; // 用于发送广播的名称，用于标识与Google Tasks同步服务相关的广播 - public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service"; + public static final String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service"; // 在广播Intent中用于表示是否正在同步的Extra键 - public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing"; + public static final String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing"; // 在广播Intent中用于传递同步进度消息的Extra键 - public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg"; + public static final String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg"; // 静态变量，用于存储当前正在执行的同步任务 - private static GTaskASyncTask mSyncTask = null; + private static GTaskASyncTask syncTask = null; // 静态变量，用于存储同步进度消息 - private static String mSyncProgress = ""; + private static String syncProgress = ""; - // 启动同步任务的方法 + /** + * 启动同步任务的方法。 + * 如果同步任务尚未创建，则创建并执行新的同步任务，并发送同步开始广播。 + * 如果同步任务已存在，可考虑记录日志或抛出异常，因为这种情况可能不应该发生。 + */ private void startSync() { - // 如果同步任务尚未创建 - if (mSyncTask == null) { - // 创建一个新的GTaskASyncTask实例，并传入当前服务上下文和同步完成监听器 - mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() { - // 同步完成时的回调方法 + if (syncTask == null) { + syncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() { + @Override public void onComplete() { - // 同步完成后，将mSyncTask设为null - mSyncTask = null; - // 发送广播，通知同步完成 + syncTask = null; sendBroadcast(""); - // 停止当前服务 stopSelf(); } }); - // 发送广播，通知同步开始 sendBroadcast(""); - // 执行同步任务 - mSyncTask.execute(); + syncTask.execute(); + } else { + Log.w("GTaskSyncService", "startSync called while a sync task is already running"); } } - // 取消同步任务的方法 + /** + * 取消同步任务的方法。 + * 如果同步任务正在执行，则调用其取消方法。 + * 可考虑添加逻辑等待任务真正取消后再进行后续操作（如果有必要）。 + */ private void cancelSync() { - // 如果同步任务正在执行 - if (mSyncTask!= null) { - // 调用同步任务的取消方法 - mSyncTask.cancelSync(); + if (syncTask!= null) { + syncTask.cancelSync(); } } - // 服务创建时的回调方法 + /** + * 服务创建时的回调方法。 + * 初始化时，将同步任务设为null。 + */ @Override public void onCreate() { - // 初始化时，将同步任务设为null - mSyncTask = null; + syncTask = null; } - // 服务启动命令的回调方法 + /** + * 服务启动命令的回调方法。 + * 根据Intent中传递的同步操作类型，执行相应的同步或取消操作。 + * 返回START_STICKY，以便在系统资源允许时重新启动服务。 + */ @Override public int onStartCommand(Intent intent, int flags, int startId) { - // 从Intent中获取附加的Bundle Bundle bundle = intent.getExtras(); - // 如果Bundle存在且包含同步操作类型的键 if (bundle!= null && bundle.containsKey(ACTION_STRING_NAME)) { - // 根据同步操作类型进行相应处理 - switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) { + int action = bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID); + switch (action) { case ACTION_START_SYNC: - // 启动同步任务 startSync(); break; case ACTION_CANCEL_SYNC: - // 取消同步任务 cancelSync(); break; default: break; } - // 返回START_STICKY，以便在系统资源允许时重新启动服务 return START_STICKY; } - // 如果Bundle不包含同步操作类型的键，调用父类的onStartCommand方法 return super.onStartCommand(intent, flags, startId); } - // 系统内存不足时的回调方法 + /** + * 系统内存不足时的回调方法。 + * 如果同步任务正在执行，则取消同步任务。 + */ @Override public void onLowMemory() { - // 如果同步任务正在执行 - if (mSyncTask!= null) { - // 取消同步任务 - mSyncTask.cancelSync(); + if (syncTask!= null) { + cancelSync(); } } - // 绑定服务时的回调方法，该服务不支持绑定，返回null + /** + * 绑定服务时的回调方法，该服务不支持绑定，返回null。 + */ + @Override public IBinder onBind(Intent intent) { return null; } - // 发送广播的方法，用于通知同步状态和进度 + /** + * 发送广播的方法，用于通知同步状态和进度。 + * 更新同步进度消息，并在Intent中添加是否正在同步和同步进度消息的Extra，然后发送广播。 + */ public void sendBroadcast(String msg) { - // 更新同步进度消息 - mSyncProgress = msg; - // 创建一个新的Intent，用于发送广播 + syncProgress = msg; Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME); - // 在Intent中添加是否正在同步的Extra - intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask!= null); - // 在Intent中添加同步进度消息的Extra + intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, syncTask!= null); intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg); - // 发送广播 sendBroadcast(intent); } - // 外部调用启动同步服务的静态方法 + /** + * 外部调用启动同步服务的静态方法。 + * 设置GTaskManager的活动上下文，并创建启动服务的Intent，添加启动同步操作的类型，然后启动服务。 + */ public static void startSync(Activity activity) { - // 设置GTaskManager的活动上下文 GTaskManager.getInstance().setActivityContext(activity); - // 创建一个启动服务的Intent Intent intent = new Intent(activity, GTaskSyncService.class); - // 在Intent中添加启动同步操作的类型 - intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC); - // 启动服务 + intent.putExtra(ACTION_STRING_NAME, ACTION_START_SYNC); activity.startService(intent); } - // 外部调用取消同步服务的静态方法 + /** + * 外部调用取消同步服务的静态方法。 + * 创建启动服务的Intent，添加取消同步操作的类型，然后启动服务。 + */ public static void cancelSync(Context context) { - // 创建一个启动服务的Intent Intent intent = new Intent(context, GTaskSyncService.class); - // 在Intent中添加取消同步操作的类型 - intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC); - // 启动服务 + intent.putExtra(ACTION_STRING_NAME, ACTION_CANCEL_SYNC); context.startService(intent); } - // 判断同步是否正在进行的静态方法 + /** + * 判断同步是否正在进行的静态方法。 + * 如果同步任务不为null，说明同步正在进行。 + */ public static boolean isSyncing() { - // 如果同步任务不为null，说明同步正在进行 - return mSyncTask!= null; + return syncTask!= null; } - // 获取同步进度字符串的静态方法 + /** + * 获取同步进度字符串的静态方法。 + * 返回同步进度消息。 + */ public static String getProgressString() { - // 返回同步进度消息 - return mSyncProgress; + return syncProgress; } } \ No newline at end of file