p5fnrwyt6
/
micode
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

代码功能优化

Browse Source
develop
董春阳 1 year ago
parent b78b7b37e8
commit 8aefa300e7
4 changed files with 297 additions and 244 deletions
Show Stats Download Patch File Download Diff File

68
src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java
Unescape View File

@ -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");
}

147
src/Notes-master/src/net/micode/notes/gtask/data/Node.java
Unescape View File

@ -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;
}
}

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

@ -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<Void, String, Integer> {
// 定义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<Void, String, Integer> {
}
// 上下文对象，用于获取系统服务和资源
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();
}
}
}
}

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

@ -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;
}
}
Write Preview
Loading…
Cancel
Save