Studio/WinBoLL
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

源码整理。

Browse Source
This commit is contained in:
ZhangShaojian
2025-12-18 13:14:04 +08:00
parent b3f4571b57
commit 796d826331
1 changed files with 180 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files

569
powerbell/src/main/java/cc/winboll/studio/powerbell/services/ControlCenterService.java
View File

@@ -26,7 +26,7 @@ import java.util.List;
/** /**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com> * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/12/17 15:48 * @Date 2025/12/17 15:48
* @Describe 电池提醒核心服务：修复前台服务超时异常，优先在onCreate发送通知，适配Java7+API36 * @Describe 电池提醒核心服务：修复前台服务超时异常，优先在onCreate发送通知，适配Java7+API30
*/ */
public class ControlCenterService extends Service { public class ControlCenterService extends Service {
// ================================== 静态常量（置顶统一管理，避免魔法值）================================= // ================================== 静态常量（置顶统一管理，避免魔法值）=================================
@@ -34,28 +34,22 @@ public class ControlCenterService extends Service {
// 服务指令常量（带包名前缀，防止冲突） // 服务指令常量（带包名前缀，防止冲突）
public static final String ACTION_RESTART_REMIND_THREAD = "cc.winboll.studio.powerbell.action.RESTART_REMIND_THREAD"; public static final String ACTION_RESTART_REMIND_THREAD = "cc.winboll.studio.powerbell.action.RESTART_REMIND_THREAD";
public static final String EXTRA_APP_CONFIG_BEAN = "cc.winboll.studio.powerbell.extra.APP_CONFIG_BEAN"; public static final String EXTRA_APP_CONFIG_BEAN = "cc.winboll.studio.powerbell.extra.APP_CONFIG_BEAN";
// 新增：应用前台/后台状态同步指令（用于MainActivity与服务联动）
// public static final String ACTION_SYNC_APP_FOREGROUND_STATE = "cc.winboll.studio.powerbell.action.SYNC_APP_FOREGROUND_STATE";
// public static final String EXTRA_APP_FOREGROUND_STATE = "cc.winboll.studio.powerbell.extra.APP_FOREGROUND_STATE";
// ================================== 核心成员变量（按依赖优先级排序，私有封装）================================= // ================================== 成员变量（按功能分类，私有封装+并发锁保护）=================================
// 服务控制核心（本地持久化管理，替代Intent传递） // 服务控制核心
private ControlCenterServiceBean mServiceControlBean; private ControlCenterServiceBean mServiceControlBean;
// 业务核心组件 // 业务核心组件
private ControlCenterServiceHandler mServiceHandler; // 服务通信Handler private ControlCenterServiceHandler mServiceHandler;
private RemindThread mRemindThread; // 电量提醒线程 private RemindThread mRemindThread;
private NotificationManagerUtils mNotificationManager; // 通知管理工具类 private NotificationManagerUtils mNotificationManager;
private AppConfigBean mCurrentConfigBean; // 当前应用配置 private AppConfigBean mCurrentConfigBean;
// 前台服务相关 private NotificationMessage mForegroundNotifyMsg;
private NotificationMessage mForegroundNotifyMsg; // 前台保活通知模型 // 状态标记
// 新增：应用前台状态标记（内存缓存，同步MainActivity状态） private boolean isServiceRunning;
private boolean mIsAppForeground = false; private boolean mIsDestroyed;
// 状态标记（并发安全） private final Object mServiceLock = new Object();
private boolean isServiceRunning = false; // 服务运行状态
private boolean mIsDestroyed = false; // 服务销毁标记
private final Object mServiceLock = new Object(); // 全局并发锁
// ================================== 服务生命周期方法（核心修复：onCreate优先发送通知）================================= // ================================== 服务生命周期方法（核心流程入口）=================================
@Override @Override
public void onCreate() { public void onCreate() {
super.onCreate(); super.onCreate();
@@ -63,45 +57,33 @@ public class ControlCenterService extends Service {
synchronized (mServiceLock) { synchronized (mServiceLock) {
isServiceRunning = true; isServiceRunning = true;
mIsDestroyed = false; mIsDestroyed = false;
// 优先发送前台通知，避免5秒超时异常
// ================================== 【修复点1：最优先执行前台通知发送】=================================
initForegroundNotificationImmediately(); initForegroundNotificationImmediately();
// 加载本地服务控制配置
// 原有逻辑：读取本地服务控制配置
mServiceControlBean = ControlCenterServiceBean.loadBean(this, ControlCenterServiceBean.class); mServiceControlBean = ControlCenterServiceBean.loadBean(this, ControlCenterServiceBean.class);
if (mServiceControlBean == null) { if (mServiceControlBean == null) {
mServiceControlBean = new ControlCenterServiceBean(false); mServiceControlBean = new ControlCenterServiceBean(false);
ControlCenterServiceBean.saveBean(this, mServiceControlBean); // 持久化默认配置 ControlCenterServiceBean.saveBean(this, mServiceControlBean);
LogUtils.d(TAG, "onCreate: 本地无控制配置，创建默认禁用配置并持久化"); LogUtils.d(TAG, "onCreate: 本地无配置，创建默认禁用配置并持久化");
} else {
LogUtils.d(TAG, "onCreate: 从本地读取服务控制配置，启用状态=" + mServiceControlBean.isEnableService());
} }
} }
LogUtils.d(TAG, "onCreate: 服务创建完成，前台通知已发送，当前服务控制状态：" + (mServiceControlBean.isEnableService() ? "启用" : "禁用")); LogUtils.d(TAG, "onCreate: 服务创建完成，前台通知已发送，启用状态=" + mServiceControlBean.isEnableService());
} }
@Override @Override
public int onStartCommand(Intent intent, int flags, int startId) { public int onStartCommand(Intent intent, int flags, int startId) {
LogUtils.d(TAG, "onStartCommand: 服务启动指令触发，flags=" + flags); LogUtils.d(TAG, "onStartCommand: 服务启动指令触发");
// 第一步：读取本地最新控制配置（优先级最高，实时同步用户设置） // 读取最新控制配置
loadLatestServiceControlConfig(); loadLatestServiceControlConfig();
// 第二步：根据控制状态，分支执行逻辑
synchronized (mServiceLock) { synchronized (mServiceLock) {
if (mServiceControlBean.isEnableService()) { if (mServiceControlBean.isEnableService()) {
LogUtils.d(TAG, "onStartCommand: 服务已启用，执行核心逻辑"); LogUtils.d(TAG, "onStartCommand: 服务已启用，处理外部指令并初始化业务");
// 启用状态：处理指令+启动业务，返回START_STICKY（回收后重启）
handleExternalCommand(intent); handleExternalCommand(intent);
// ================================== 【修复点2：删除rebindForegroundNotify()，避免重复调用】================================= initServiceBusinessIfNeed();
initServiceBusinessIfNeed(); // 按需初始化业务（避免重复初始化）
// // 新增：业务初始化完成后，同步应用前台状态到线程（防止状态丢失）
// syncAppForegroundStateToThread();
LogUtils.d(TAG, "onStartCommand: 核心逻辑执行完成，返回START_STICKY");
return START_STICKY; return START_STICKY;
} else { } else {
LogUtils.d(TAG, "onStartCommand: 服务已禁用，不执行核心逻辑"); LogUtils.d(TAG, "onStartCommand: 服务已禁用，停止所有业务");
// 禁用状态：停止所有业务+释放资源，返回父类默认值（回收后不主动重启）
stopAllBusinessSafely(); stopAllBusinessSafely();
LogUtils.d(TAG, "onStartCommand: 已停止所有业务，返回父类默认onStartCommand结果");
return super.onStartCommand(intent, flags, startId); return super.onStartCommand(intent, flags, startId);
} }
} }
@@ -110,13 +92,12 @@ public class ControlCenterService extends Service {
@Override @Override
public void onDestroy() { public void onDestroy() {
super.onDestroy(); super.onDestroy();
LogUtils.d(TAG, "onDestroy: 服务开始销毁，释放所有资源"); LogUtils.d(TAG, "onDestroy: 服务开始销毁");
synchronized (mServiceLock) { synchronized (mServiceLock) {
isServiceRunning = false; isServiceRunning = false;
mIsDestroyed = true; mIsDestroyed = true;
mIsAppForeground = false; // 新增：重置前台状态
} }
// 顺序释放资源（前台服务→线程→Handler→通知→配置→控制Bean） // 顺序释放资源
stopForegroundService(); stopForegroundService();
stopRemindThreadSafely(); stopRemindThreadSafely();
destroyHandler(); destroyHandler();
@@ -127,109 +108,95 @@ public class ControlCenterService extends Service {
@Override @Override
public IBinder onBind(Intent intent) { public IBinder onBind(Intent intent) {
return null; // 无需绑定服务，返回null return null;
} }
// ================================== 【新增核心方法：优先发送前台通知，带兜底方案】================================= // ================================== 前台通知核心方法（优先执行，防止超时）=================================
/** /**
* 独立初始化前台通知并立即发送，不依赖任何业务逻辑，确保5秒内完成startForeground() * 立即初始化前台通知，内置兜底方案
* 防止工具类异常导致超时，内置兜底方案
*/ */
private void initForegroundNotificationImmediately() { private void initForegroundNotificationImmediately() {
LogUtils.d(TAG, "initForegroundNotificationImmediately: 强制初始化前台通知"); LogUtils.d(TAG, "initForegroundNotificationImmediately: 初始化前台通知");
try { try {
// 1. 初始化通知工具类
if (mNotificationManager == null) { if (mNotificationManager == null) {
mNotificationManager = new NotificationManagerUtils(this); mNotificationManager = new NotificationManagerUtils(this);
} }
// 2. 构建极简前台通知模型（不依赖业务配置，确保最快速度发送）
if (mForegroundNotifyMsg == null) { if (mForegroundNotifyMsg == null) {
mForegroundNotifyMsg = new NotificationMessage(); mForegroundNotifyMsg = new NotificationMessage();
mForegroundNotifyMsg.setTitle("电池监测服务"); mForegroundNotifyMsg.setTitle("电池监测服务");
mForegroundNotifyMsg.setContent("后台运行中"); mForegroundNotifyMsg.setContent("后台运行中");
mForegroundNotifyMsg.setRemindMSG("service_running"); mForegroundNotifyMsg.setRemindMSG("service_running");
} }
// 3. 立即调用工具类发送前台通知
mNotificationManager.startForegroundServiceNotify(this, mForegroundNotifyMsg); mNotificationManager.startForegroundServiceNotify(this, mForegroundNotifyMsg);
LogUtils.d(TAG, "initForegroundNotificationImmediately: 前台通知发送成功，ID=" + NotificationManagerUtils.NOTIFY_ID_FOREGROUND_SERVICE); LogUtils.d(TAG, "initForegroundNotificationImmediately: 前台通知发送成功，ID=" + NotificationManagerUtils.NOTIFY_ID_FOREGROUND_SERVICE);
} catch (Exception e) { } catch (Exception e) {
LogUtils.e(TAG, "initForegroundNotificationImmediately: 工具类发送失败，执行兜底方案", e); LogUtils.e(TAG, "initForegroundNotificationImmediately: 工具类发送失败，执行兜底方案", e);
// 兜底方案：绕过工具类，直接构建Notification调用startForeground
fallbackStartForeground(); fallbackStartForeground();
} }
} }
/** /**
* 前台通知兜底方案：当工具类异常时，直接创建通知，确保不触发超时异常 * 前台通知兜底方案，直接构建Notification
*/ */
private void fallbackStartForeground() { private void fallbackStartForeground() {
try { try {
Notification notification = new NotificationCompat.Builder(this, NotificationManagerUtils.CHANNEL_ID_FOREGROUND) Notification notification = new NotificationCompat.Builder(this, NotificationManagerUtils.CHANNEL_ID_FOREGROUND)
.setContentTitle("电池监测服务") .setContentTitle("电池监测服务")
.setContentText("后台运行中") .setContentText("后台运行中")
.setSmallIcon(R.drawable.ic_launcher) // 必须设置小图标，否则通知不显示 .setSmallIcon(R.drawable.ic_launcher)
.setPriority(NotificationCompat.PRIORITY_LOW) .setPriority(NotificationCompat.PRIORITY_LOW)
.build(); .build();
// 直接调用startForeground，不依赖任何外部工具
startForeground(NotificationManagerUtils.NOTIFY_ID_FOREGROUND_SERVICE, notification); startForeground(NotificationManagerUtils.NOTIFY_ID_FOREGROUND_SERVICE, notification);
LogUtils.d(TAG, "fallbackStartForeground: 兜底前台通知发送成功"); LogUtils.d(TAG, "fallbackStartForeground: 兜底前台通知发送成功");
} catch (Exception e) { } catch (Exception e) {
LogUtils.e(TAG, "fallbackStartForeground: 兜底发送失败，服务会被系统强制杀死", e); LogUtils.e(TAG, "fallbackStartForeground: 兜底发送失败，服务会被系统杀死", e);
} }
} }
// ================================== 核心：服务控制配置（本地持久化读写，替代Intent传递）================================= // ================================== 服务控制配置管理（本地持久化+内存同步）=================================
/** /**
* 读取本地最新服务控制配置（实时同步，确保与用户设置一致） * 读取本地最新服务控制配置
*/ */
private void loadLatestServiceControlConfig() { private void loadLatestServiceControlConfig() {
LogUtils.d(TAG, "loadLatestServiceControlConfig: 读取本地最新服务控制配置"); LogUtils.d(TAG, "loadLatestServiceControlConfig: 读取本地配置");
synchronized (mServiceLock) { synchronized (mServiceLock) {
ControlCenterServiceBean latestControlBean = ControlCenterServiceBean.loadBean(this, ControlCenterServiceBean.class); ControlCenterServiceBean latestBean = ControlCenterServiceBean.loadBean(this, ControlCenterServiceBean.class);
if (latestControlBean != null) { if (latestBean != null) {
boolean oldState = mServiceControlBean.isEnableService(); mServiceControlBean = latestBean;
boolean newState = latestControlBean.isEnableService(); LogUtils.d(TAG, "loadLatestServiceControlConfig: 配置更新完成，启用状态=" + mServiceControlBean.isEnableService());
mServiceControlBean = latestControlBean;
LogUtils.d(TAG, "loadLatestServiceControlConfig: 控制配置更新完成，旧状态=" + oldState + "，新状态=" + newState);
} else { } else {
LogUtils.w(TAG, "loadLatestServiceControlConfig: 本地无控制配置，沿用当前状态=" + mServiceControlBean.isEnableService()); LogUtils.w(TAG, "loadLatestServiceControlConfig: 本地无配置，沿用当前状态");
} }
} }
LogUtils.d(TAG, "loadLatestServiceControlConfig: 控制配置读取完成，当前服务启用状态=" + mServiceControlBean.isEnableService());
} }
/** /**
* 更新服务控制配置（本地持久化+内存同步，对外提供统一入口） * 更新并持久化服务控制配置
*/ */
private void updateAndSaveServiceControlConfig(ControlCenterServiceBean newControlBean) { private void updateAndSaveServiceControlConfig(ControlCenterServiceBean newControlBean) {
LogUtils.d(TAG, "updateAndSaveServiceControlConfig: 更新服务控制配置，新状态=" + newControlBean.isEnableService());
if (newControlBean == null) { if (newControlBean == null) {
LogUtils.e(TAG, "updateAndSaveServiceControlConfig: 新控制配置为空，更新失败"); LogUtils.e(TAG, "updateAndSaveServiceControlConfig: 配置为空，更新失败");
return; return;
} }
LogUtils.d(TAG, "updateAndSaveServiceControlConfig: 更新配置，启用状态=" + newControlBean.isEnableService());
synchronized (mServiceLock) { synchronized (mServiceLock) {
// 内存同步+本地持久化（原子操作，确保一致性）
mServiceControlBean = newControlBean; mServiceControlBean = newControlBean;
ControlCenterServiceBean.saveBean(this, mServiceControlBean); ControlCenterServiceBean.saveBean(this, mServiceControlBean);
LogUtils.d(TAG, "updateAndSaveServiceControlConfig: 控制配置更新并持久化完成");
} }
} }
// ================================== 业务按需初始化/停止方法（适配启用/禁用状态切换）================================= // ================================== 业务初始化与停止（按需加载，避免重复）=================================
/** /**
* 按需初始化核心业务（仅服务启用且未初始化时执行，避免重复创建） * 按需初始化核心业务
*/ */
private void initServiceBusinessIfNeed() { private void initServiceBusinessIfNeed() {
LogUtils.d(TAG, "initServiceBusinessIfNeed: 按需初始化业务"); LogUtils.d(TAG, "initServiceBusinessIfNeed: 校验业务初始化条件");
synchronized (mServiceLock) { synchronized (mServiceLock) {
// 校验：服务启用+未初始化+服务运行中
if (!mServiceControlBean.isEnableService() || mServiceHandler != null || !isServiceRunning || mIsDestroyed) { if (!mServiceControlBean.isEnableService() || mServiceHandler != null || !isServiceRunning || mIsDestroyed) {
LogUtils.w(TAG, "initServiceBusinessIfNeed: 无需初始化业务（禁用/已初始化/服务未运行）"); LogUtils.w(TAG, "initServiceBusinessIfNeed: 无需初始化业务");
return; return;
} }
// 初始化通知+配置+业务逻辑
// 初始化通知+配置+业务逻辑（完整启动核心流程）
initNotificationManager(); initNotificationManager();
loadDefaultConfig(); loadDefaultConfig();
initServiceBusinessLogic(); initServiceBusinessLogic();
@@ -238,85 +205,38 @@ public class ControlCenterService extends Service {
} }
/** /**
* 安全停止所有核心业务（服务禁用时执行，释放所有业务资源） * 安全停止所有核心业务
*/ */
private void stopAllBusinessSafely() { private void stopAllBusinessSafely() {
LogUtils.d(TAG, "stopAllBusinessSafely: 停止所有核心业务"); LogUtils.d(TAG, "stopAllBusinessSafely: 停止所有业务");
synchronized (mServiceLock) { synchronized (mServiceLock) {
// 停止线程+销毁Handler+释放通知+置空业务引用
stopRemindThreadSafely(); stopRemindThreadSafely();
destroyHandler(); destroyHandler();
stopForegroundService(); stopForegroundService();
releaseNotificationResource(); releaseNotificationResource();
mCurrentConfigBean = null; mCurrentConfigBean = null;
mForegroundNotifyMsg = null; mForegroundNotifyMsg = null;
mIsAppForeground = false; // 新增：重置前台状态
LogUtils.d(TAG, "stopAllBusinessSafely: 所有核心业务已停止");
} }
} }
// ================================== 核心业务初始化方法（按依赖顺序排列）=================================
/** /**
* 初始化通知管理工具类，构建前台保活通知模型 * 初始化通知管理工具类
* 【修复点3：移除内部的startForegroundNotifyImmediately()调用，避免重复发送】
*/ */
private void initNotificationManager() { private void initNotificationManager() {
LogUtils.d(TAG, "initNotificationManager: 初始化通知工具类"); LogUtils.d(TAG, "initNotificationManager: 初始化通知工具");
try {
if (mNotificationManager == null) { if (mNotificationManager == null) {
mNotificationManager = new NotificationManagerUtils(this); mNotificationManager = new NotificationManagerUtils(this);
} }
if (mForegroundNotifyMsg == null) { if (mForegroundNotifyMsg == null) {
mForegroundNotifyMsg = new NotificationMessage(); mForegroundNotifyMsg = new NotificationMessage();
mForegroundNotifyMsg.setTitle("电池提醒服务运行中"); mForegroundNotifyMsg.setTitle("电池提醒服务运行中");
mForegroundNotifyMsg.setContent("后台持续监测电池状态，确保提醒及时"); mForegroundNotifyMsg.setContent("后台持续监测电池状态");
mForegroundNotifyMsg.setRemindMSG("service_running"); mForegroundNotifyMsg.setRemindMSG("service_running");
// 移除：此处不再发送通知，通知已在onCreate中发送
}
LogUtils.d(TAG, "initNotificationManager: 通知工具类初始化完成");
} catch (Exception e) {
LogUtils.e(TAG, "initNotificationManager: 初始化失败", e);
} }
} }
/** /**
* 立即启动前台保活通知（API26+ 前台服务必需） * 加载默认应用配置
* 注：当前仅作为备用方法，实际已在initForegroundNotificationImmediately中调用
*/
private void startForegroundNotifyImmediately() {
LogUtils.d(TAG, "startForegroundNotifyImmediately: 启动前台保活通知");
if (mNotificationManager == null || mForegroundNotifyMsg == null) {
LogUtils.e(TAG, "startForegroundNotifyImmediately: 通知工具类/模型为空，启动失败");
return;
}
try {
mNotificationManager.startForegroundServiceNotify(this, mForegroundNotifyMsg);
LogUtils.d(TAG, "startForegroundNotifyImmediately: 前台通知启动成功，ID=" + NotificationManagerUtils.NOTIFY_ID_FOREGROUND_SERVICE);
} catch (Exception e) {
LogUtils.e(TAG, "startForegroundNotifyImmediately: 前台通知启动异常", e);
}
}
/**
* 重新绑定前台通知（已删除调用，防止重复执行startForeground）
*/
private void rebindForegroundNotify() {
if (mNotificationManager == null || mNotificationManager.getForegroundServiceNotify() == null) {
LogUtils.w(TAG, "rebindForegroundNotify: 通知工具类/前台通知为空，跳过绑定");
return;
}
try {
startForeground(NotificationManagerUtils.NOTIFY_ID_FOREGROUND_SERVICE, mNotificationManager.getForegroundServiceNotify());
LogUtils.d(TAG, "rebindForegroundNotify: 前台通知重新绑定成功");
} catch (Exception e) {
LogUtils.e(TAG, "rebindForegroundNotify: 重新绑定前台通知异常", e);
}
}
/**
* 加载默认应用配置（服务启动时兜底）
*/ */
private void loadDefaultConfig() { private void loadDefaultConfig() {
LogUtils.d(TAG, "loadDefaultConfig: 加载默认配置"); LogUtils.d(TAG, "loadDefaultConfig: 加载默认配置");
@@ -327,93 +247,71 @@ public class ControlCenterService extends Service {
mCurrentConfigBean.setEnableUsageReminder(true); mCurrentConfigBean.setEnableUsageReminder(true);
mCurrentConfigBean.setUsageReminderValue(20); mCurrentConfigBean.setUsageReminderValue(20);
mCurrentConfigBean.setBatteryDetectInterval(1000); mCurrentConfigBean.setBatteryDetectInterval(1000);
LogUtils.d(TAG, "loadDefaultConfig: 默认配置加载完成，充电阈值80%，耗电阈值20%"); LogUtils.d(TAG, "loadDefaultConfig: 默认配置加载完成");
} else {
LogUtils.d(TAG, "loadDefaultConfig: 配置已存在，无需重复加载");
} }
} }
/** /**
* 初始化业务核心逻辑（Handler+提醒线程） * 初始化业务核心逻辑（Handler+线程）
*/ */
private void initServiceBusinessLogic() { private void initServiceBusinessLogic() {
LogUtils.d(TAG, "initServiceBusinessLogic: 初始化业务逻辑"); LogUtils.d(TAG, "initServiceBusinessLogic: 初始化Handler与线程");
if (mServiceHandler == null) { if (mServiceHandler == null) {
mServiceHandler = new ControlCenterServiceHandler(this); mServiceHandler = new ControlCenterServiceHandler(this);
} }
// 复用线程重启方法，统一启动逻辑
restartRemindThreadSafely(); restartRemindThreadSafely();
LogUtils.d(TAG, "initServiceBusinessLogic: 业务逻辑初始化完成");
} }
// ================================== 线程管理方法（安全启动/停止/重启，保障并发安全）================================= // ================================== 提醒线程管理（安全启停，并发保护）=================================
/** /**
* 安全重启提醒线程（彻底销毁旧线程，创建全新实例，避免重复启动） * 安全重启提醒线程
*/ */
public void restartRemindThreadSafely() { public void restartRemindThreadSafely() {
LogUtils.d(TAG, "restartRemindThreadSafely: 开始重启提醒线程"); LogUtils.d(TAG, "restartRemindThreadSafely: 开始重启线程");
synchronized (mServiceLock) { synchronized (mServiceLock) {
// 服务禁用/已销毁，直接返回
if (!isServiceRunning || mIsDestroyed || !mServiceControlBean.isEnableService()) { if (!isServiceRunning || mIsDestroyed || !mServiceControlBean.isEnableService()) {
LogUtils.e(TAG, "restartRemindThreadSafely: 服务未运行/已销毁/已禁用，启动失败"); LogUtils.e(TAG, "restartRemindThreadSafely: 服务状态异常，启动失败");
return; return;
} }
// 停止旧线程
// 先停止旧线程
stopRemindThreadSafely(); stopRemindThreadSafely();
// 校验Handler，避免无效启动
if (mServiceHandler == null) { if (mServiceHandler == null) {
LogUtils.e(TAG, "restartRemindThreadSafely: Handler为空，启动失败"); LogUtils.e(TAG, "restartRemindThreadSafely: Handler为空，启动失败");
return; return;
} }
// 创建新线程实例
// 销毁旧单例，创建新线程实例
RemindThread.destroyInstance(); RemindThread.destroyInstance();
mRemindThread = RemindThread.getInstance(this, mServiceHandler); mRemindThread = RemindThread.getInstance(this, mServiceHandler);
// 同步配置并开启提醒
syncConfigToRemindThread(); syncConfigToRemindThread();
// // 新增：同步应用前台状态（确保新线程启动时状态正确） // 启动线程
// syncAppForegroundStateToThread();
// 双重校验，避免线程重复启动
if (mRemindThread != null && !mRemindThread.isAlive() && !mRemindThread.isThreadStarted()) { if (mRemindThread != null && !mRemindThread.isAlive() && !mRemindThread.isThreadStarted()) {
try { try {
mRemindThread.start(); mRemindThread.start();
LogUtils.d(TAG, "restartRemindThreadSafely: 新线程启动成功，ID=" + mRemindThread.getId() + "，前台状态=" + mIsAppForeground); LogUtils.d(TAG, "restartRemindThreadSafely: 新线程启动成功，ID=" + mRemindThread.getId());
} catch (IllegalThreadStateException e) { } catch (IllegalThreadStateException e) {
LogUtils.e(TAG, "restartRemindThreadSafely: 线程重复启动异常", e); LogUtils.e(TAG, "restartRemindThreadSafely: 线程重复启动异常", e);
mRemindThread = null; mRemindThread = null;
} catch (Exception e) {
LogUtils.e(TAG, "restartRemindThreadSafely: 启动线程异常", e);
mRemindThread = null;
} }
} else { } else {
LogUtils.w(TAG, "restartRemindThreadSafely: 线程已启动/实例异常，跳过启动"); LogUtils.w(TAG, "restartRemindThreadSafely: 线程状态异常，跳过启动");
mRemindThread = null;
} }
} }
LogUtils.d(TAG, "restartRemindThreadSafely: 线程重启流程结束");
} }
/** /**
* 安全停止提醒线程（中断休眠+等待终止+释放资源，无残留） * 安全停止提醒线程
*/ */
private void stopRemindThreadSafely() { private void stopRemindThreadSafely() {
LogUtils.d(TAG, "stopRemindThreadSafely: 开始停止提醒线程"); LogUtils.d(TAG, "stopRemindThreadSafely: 停止提醒线程");
if (mRemindThread == null) { if (mRemindThread == null) {
LogUtils.w(TAG, "stopRemindThreadSafely: 线程实例为空，跳过停止"); LogUtils.w(TAG, "stopRemindThreadSafely: 线程实例为空");
return; return;
} }
try { try {
// 触发线程内部停止逻辑
if (mRemindThread.isThreadStarted() || mRemindThread.isAlive()) { if (mRemindThread.isThreadStarted() || mRemindThread.isAlive()) {
mRemindThread.setIsReminding(false); mRemindThread.setIsReminding(false);
mRemindThread.stopThread(); mRemindThread.stopThread();
LogUtils.d(TAG, "stopRemindThreadSafely: 触发线程内部停止"); // 等待线程终止，超时1秒强制中断
// 等待线程终止（超时1秒，避免阻塞服务）
long waitStartTime = System.currentTimeMillis(); long waitStartTime = System.currentTimeMillis();
while (mRemindThread.isAlive()) { while (mRemindThread.isAlive()) {
if (System.currentTimeMillis() - waitStartTime > 1000) { if (System.currentTimeMillis() - waitStartTime > 1000) {
@@ -427,140 +325,95 @@ public class ControlCenterService extends Service {
} catch (Exception e) { } catch (Exception e) {
LogUtils.e(TAG, "stopRemindThreadSafely: 停止线程异常", e); LogUtils.e(TAG, "stopRemindThreadSafely: 停止线程异常", e);
} finally { } finally {
// 彻底释放资源
mRemindThread = null; mRemindThread = null;
RemindThread.destroyInstance(); RemindThread.destroyInstance();
LogUtils.d(TAG, "stopRemindThreadSafely: 线程停止完成，资源已释放");
} }
} }
/** /**
* 同步配置到提醒线程（原子操作，避免并发修改） * 同步配置到提醒线程
*/ */
private void syncConfigToRemindThread() { private void syncConfigToRemindThread() {
LogUtils.d(TAG, "syncConfigToRemindThread: 同步配置到线程"); LogUtils.d(TAG, "syncConfigToRemindThread: 同步配置");
synchronized (mServiceLock) { synchronized (mServiceLock) {
if (mRemindThread == null || mCurrentConfigBean == null) { if (mRemindThread == null || mCurrentConfigBean == null) {
LogUtils.e(TAG, "syncConfigToRemindThread: 线程/配置为空，同步失败"); LogUtils.e(TAG, "syncConfigToRemindThread: 线程或配置为空，同步失败");
return; return;
} }
mRemindThread.setAppConfigBean(mCurrentConfigBean); mRemindThread.setAppConfigBean(mCurrentConfigBean);
mRemindThread.setIsReminding(true); mRemindThread.setIsReminding(true);
LogUtils.d(TAG, "syncConfigToRemindThread: 配置同步完成");
} }
} }
// ================================== 外部指令处理（接收Intent指令）=================================
/** /**
* 新增：同步应用前台状态到RemindThread（核心联动逻辑） * 处理外部发送的服务指令
* 确保线程实时感知应用前台/后台状态，控制提醒开关
*/
// private void syncAppForegroundStateToThread() {
// LogUtils.d(TAG, "syncAppForegroundStateToThread: 同步前台状态，当前状态=" + mIsAppForeground);
// synchronized (mServiceLock) {
// if (mRemindThread == null || mIsDestroyed || !isServiceRunning) {
// LogUtils.w(TAG, "syncAppForegroundStateToThread: 线程未启动/服务已销毁，同步失败");
// return;
// }
// // 调用RemindThread新增方法，同步前台状态（线程安全）
// mRemindThread.setAppForeground(mIsAppForeground);
// LogUtils.d(TAG, "syncAppForegroundStateToThread: 前台状态同步完成");
// }
// }
// ================================== 外部指令处理方法（新增前台状态同步指令，完善链路）=================================
/**
* 处理外部发送的服务指令（如重启线程、更新配置、同步前台状态）
*/ */
private void handleExternalCommand(Intent intent) { private void handleExternalCommand(Intent intent) {
LogUtils.d(TAG, "handleExternalCommand: 开始处理外部指令"); LogUtils.d(TAG, "handleExternalCommand: 处理外部指令");
if (intent == null) { if (intent == null || TextUtils.isEmpty(intent.getAction())) {
LogUtils.e(TAG, "handleExternalCommand: Intent为空，跳过处理"); LogUtils.e(TAG, "handleExternalCommand: Intent或Action为空");
return; return;
} }
String action = intent.getAction(); String action = intent.getAction();
if (TextUtils.isEmpty(action)) {
LogUtils.e(TAG, "handleExternalCommand: 指令Action为空，跳过处理");
return;
}
// 1. 处理线程重启指令（仅同步业务配置，服务控制配置从本地读取）
if (ACTION_RESTART_REMIND_THREAD.equals(action)) { if (ACTION_RESTART_REMIND_THREAD.equals(action)) {
// 读取本地最新控制配置，确保状态同步
loadLatestServiceControlConfig();
// 仅启用状态下，更新业务配置并重启线程
synchronized (mServiceLock) { synchronized (mServiceLock) {
if (mServiceControlBean.isEnableService()) { if (mServiceControlBean.isEnableService()) {
AppConfigBean newConfig = (AppConfigBean) intent.getSerializableExtra(EXTRA_APP_CONFIG_BEAN); AppConfigBean newConfig = (AppConfigBean) intent.getSerializableExtra(EXTRA_APP_CONFIG_BEAN);
if (newConfig != null) { if (newConfig != null) {
mCurrentConfigBean = newConfig; mCurrentConfigBean = newConfig;
LogUtils.d(TAG, "handleExternalCommand: 收到线程重启指令，已更新业务配置"); LogUtils.d(TAG, "handleExternalCommand: 收到配置更新，重启线程");
restartRemindThreadSafely(); restartRemindThreadSafely();
} else { } else {
LogUtils.e(TAG, "handleExternalCommand: 新业务配置为空，重启线程失败"); LogUtils.e(TAG, "handleExternalCommand: 配置为空，重启失败");
} }
} else { } else {
LogUtils.w(TAG, "handleExternalCommand: 服务已禁用，忽略线程重启指令"); LogUtils.w(TAG, "handleExternalCommand: 服务已禁用，忽略指令");
} }
} }
} }
// else if (ACTION_SYNC_APP_FOREGROUND_STATE.equals(action)) {
// boolean isForeground = intent.getBooleanExtra(EXTRA_APP_FOREGROUND_STATE, false);
// synchronized (mServiceLock) {
// mIsAppForeground = isForeground;
// LogUtils.d(TAG, "handleExternalCommand: 收到前台状态同步指令，更新状态=" + isForeground);
// // 同步状态到线程（实时生效）
// syncAppForegroundStateToThread();
// }
// }
LogUtils.d(TAG, "handleExternalCommand: 外部指令处理完成");
} }
// ================================== 服务资源释放方法（顺序化释放，防内存泄漏）================================= // ================================== 资源释放方法（防止内存泄漏）=================================
/** /**
* 停止前台服务（取消通知+移除前台状态） * 停止前台服务
*/ */
private void stopForegroundService() { private void stopForegroundService() {
LogUtils.d(TAG, "stopForegroundService: 停止前台服务"); LogUtils.d(TAG, "stopForegroundService: 停止前台服务");
// 取消前台通知
if (mNotificationManager != null) { if (mNotificationManager != null) {
mNotificationManager.cancelForegroundServiceNotify(); mNotificationManager.cancelForegroundServiceNotify();
} }
// 移除前台服务状态
try { try {
stopForeground(STOP_FOREGROUND_REMOVE); stopForeground(STOP_FOREGROUND_REMOVE);
LogUtils.d(TAG, "stopForegroundService: 前台服务状态移除成功");
} catch (Exception e) { } catch (Exception e) {
LogUtils.e(TAG, "stopForegroundService: 移除前台状态异常", e); LogUtils.e(TAG, "stopForegroundService: 停止前台状态异常", e);
} }
} }
/** /**
* 销毁Handler（移除所有任务，避免内存泄漏） * 销毁Handler
*/ */
private void destroyHandler() { private void destroyHandler() {
LogUtils.d(TAG, "destroyHandler: 销毁服务Handler"); LogUtils.d(TAG, "destroyHandler: 销毁Handler");
if (mServiceHandler != null) { if (mServiceHandler != null) {
mServiceHandler.removeCallbacksAndMessages(null); mServiceHandler.removeCallbacksAndMessages(null);
mServiceHandler = null; mServiceHandler = null;
LogUtils.d(TAG, "destroyHandler: Handler销毁完成");
} }
} }
/** /**
* 释放通知资源（调用工具类释放方法） * 释放通知资源
*/ */
private void releaseNotificationResource() { private void releaseNotificationResource() {
LogUtils.d(TAG, "releaseNotificationResource: 释放通知资源"); LogUtils.d(TAG, "releaseNotificationResource: 释放通知资源");
if (mNotificationManager != null) { if (mNotificationManager != null) {
mNotificationManager.release(); mNotificationManager.release();
mNotificationManager = null; mNotificationManager = null;
LogUtils.d(TAG, "releaseNotificationResource: 通知资源释放完成");
} }
} }
/** /**
* 置空所有引用，帮助GC回收 * 置空所有引用
*/ */
private void clearAllReferences() { private void clearAllReferences() {
mForegroundNotifyMsg = null; mForegroundNotifyMsg = null;
@@ -569,142 +422,135 @@ public class ControlCenterService extends Service {
LogUtils.d(TAG, "clearAllReferences: 所有引用已置空"); LogUtils.d(TAG, "clearAllReferences: 所有引用已置空");
} }
// ================================== 静态工具方法（修复启停逻辑颠倒问题）================================= // ================================== 静态工具方法（对外提供服务入口）=================================
/** /**
* 启动服务（静态入口，从本地读取控制配置，显式绑定包名，适配API30+） * 启动服务
* 【修复点4：统一使用startForegroundService，适配API26+】
*/ */
public static void startControlCenterService(Context context) { public static void startControlCenterService(Context context) {
LogUtils.d(TAG, "startControlCenterService: 启动服务入口"); LogUtils.d(TAG, "startControlCenterService: 启动服务");
if (context == null) { if (context == null) {
LogUtils.e(TAG, "startControlCenterService: Context为空，启动失败"); LogUtils.e(TAG, "startControlCenterService: Context为空");
return; return;
} }
Intent intent = new Intent(context, ControlCenterService.class); Intent intent = new Intent(context, ControlCenterService.class);
// 修复：API26+必须调用startForegroundService，避免系统异常
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
context.startForegroundService(intent); context.startForegroundService(intent);
} else { } else {
context.startService(intent); context.startService(intent);
} }
LogUtils.d(TAG, "startControlCenterService: 服务启动指令发送成功");
} }
/** /**
* 停止服务（静态入口，显式绑定包名） * 停止服务
*/ */
public static void stopControlCenterService(Context context) { public static void stopControlCenterService(Context context) {
LogUtils.d(TAG, "stopControlCenterService: 停止服务入口"); LogUtils.d(TAG, "stopControlCenterService: 停止服务");
if (context == null) { if (context == null) {
LogUtils.e(TAG, "stopControlCenterService: Context为空，停止失败"); LogUtils.e(TAG, "stopControlCenterService: Context为空");
return; return;
} }
Intent intent = new Intent(context, ControlCenterService.class); Intent intent = new Intent(context, ControlCenterService.class);
context.stopService(intent); context.stopService(intent);
LogUtils.d(TAG, "stopControlCenterService: 服务停止指令发送成功");
} }
/** /**
* 新增：更新服务控制配置（本地持久化，动态切换服务启用/禁用状态） * 更新服务控制配置并启停服务
* 【修复点5：修复启停逻辑颠倒问题】
*/ */
public static void updateServiceControlConfig(Context context, ControlCenterServiceBean controlBean) { public static void updateServiceControlConfig(Context context, ControlCenterServiceBean controlBean) {
LogUtils.d(TAG, "updateServiceControlConfig: 更新服务控制配置，新状态=" + controlBean.isEnableService()); LogUtils.d(TAG, "updateServiceControlConfig: 更新控制配置，启用状态=" + controlBean.isEnableService());
if (context == null || controlBean == null) { if (context == null || controlBean == null) {
LogUtils.e(TAG, "updateServiceControlConfig: Context/控制配置为空，更新失败"); LogUtils.e(TAG, "updateServiceControlConfig: 参数为空");
return; return;
} }
// 第一步：本地持久化配置
ControlCenterServiceBean.saveBean(context, controlBean); ControlCenterServiceBean.saveBean(context, controlBean);
LogUtils.d(TAG, "updateServiceControlConfig: 控制配置已持久化");
// 第二步：启停服务（修复：启用则启动，禁用则停止）
if (controlBean.isEnableService()) { if (controlBean.isEnableService()) {
stopControlCenterService(context); stopControlCenterService(context);
startControlCenterService(context); startControlCenterService(context);
LogUtils.d(TAG, "updateServiceControlConfig: 服务已设置启动");
} else { } else {
stopControlCenterService(context); stopControlCenterService(context);
LogUtils.d(TAG, "updateServiceControlConfig: 服务已设置停止");
} }
} }
/** /**
* 新增：同步应用前台/后台状态到服务（MainActivity专用入口） * 更新业务配置并触发线程重启
* @param context 上下文
* @param isForeground true=前台，false=后台
*/ */
// public static void syncAppForegroundState(Context context, boolean isForeground) { public static void updateStatus(Context context, AppConfigBean configBean) {
// LogUtils.d(TAG, "syncAppForegroundState: 发送前台状态同步指令，状态=" + isForeground); LogUtils.d(TAG, "updateStatus: 发送配置更新指令");
// if (context == null) { if (context == null || configBean == null) {
// LogUtils.e(TAG, "syncAppForegroundState: Context为空，同步失败"); LogUtils.e(TAG, "updateStatus: 参数为空");
// return; return;
// } }
// if (!isServiceRunning(context, ControlCenterService.class)) { Intent intent = new Intent(context, ControlCenterService.class);
// LogUtils.w(TAG, "syncAppForegroundState: 服务未运行，跳过同步"); intent.setAction(ACTION_RESTART_REMIND_THREAD);
// return; intent.putExtra(EXTRA_APP_CONFIG_BEAN, (Serializable) configBean);
// } intent.setPackage(context.getPackageName());
// intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
// Intent intent = new Intent(context, ControlCenterService.class); try {
// intent.setAction(ACTION_SYNC_APP_FOREGROUND_STATE); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
// intent.putExtra(EXTRA_APP_FOREGROUND_STATE, isForeground); context.startForegroundService(intent);
// intent.setPackage(context.getPackageName()); } else {
// intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES); context.startService(intent);
// }
// try { } catch (Exception e) {
// if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { LogUtils.e(TAG, "updateStatus: 发送指令异常", e);
// context.startForegroundService(intent); }
// } else { }
// context.startService(intent);
// }
// LogUtils.d(TAG, "syncAppForegroundState: 前台状态同步指令发送成功");
// } catch (Exception e) {
// LogUtils.e(TAG, "syncAppForegroundState: 发送同步指令异常", e);
// }
// }
/** /**
* 判断服务是否运行（适配API30+ ActivityManager限制，优化判断逻辑） * 检查并引导用户开启忽略电池优化
*/
public static void checkIgnoreBatteryOptimization(Context context) {
LogUtils.d(TAG, "checkIgnoreBatteryOptimization: 检查电池优化状态");
if (context == null || Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
return;
}
PowerManager powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
if (powerManager == null) {
LogUtils.e(TAG, "checkIgnoreBatteryOptimization: PowerManager获取失败");
return;
}
try {
boolean isIgnored = powerManager.isIgnoringBatteryOptimizations(context.getPackageName());
if (!isIgnored) {
Intent intent = new Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
intent.setData(Uri.parse("package:" + context.getPackageName()));
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
context.startActivity(intent);
LogUtils.d(TAG, "checkIgnoreBatteryOptimization: 引导用户开启忽略电池优化");
}
} catch (Exception e) {
LogUtils.e(TAG, "checkIgnoreBatteryOptimization: 引导异常", e);
}
}
/**
* 判断服务是否运行（适配API30+）
*/ */
private static boolean isServiceRunning(Context context, Class<?> serviceClass) { private static boolean isServiceRunning(Context context, Class<?> serviceClass) {
if (context == null || serviceClass == null) { if (context == null || serviceClass == null) {
LogUtils.w(TAG, "isServiceRunning: Context/服务类为空，返回false");
return false; return false;
} }
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE); ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
if (am == null) { if (am == null) {
LogUtils.e(TAG, "isServiceRunning: ActivityManager获取失败，返回false"); LogUtils.e(TAG, "isServiceRunning: ActivityManager获取失败");
return false; return false;
} }
// API30+ 兼容：getRunningServices失效，通过进程状态判断（优化兜底逻辑）
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
try {
String packageName = context.getPackageName(); String packageName = context.getPackageName();
List<ActivityManager.RunningAppProcessInfo> processes = am.getRunningAppProcesses(); List<ActivityManager.RunningAppProcessInfo> processes = am.getRunningAppProcesses();
if (processes != null && !processes.isEmpty()) { if (processes != null) {
for (ActivityManager.RunningAppProcessInfo process : processes) { for (ActivityManager.RunningAppProcessInfo process : processes) {
if (packageName.equals(process.processName)) { if (packageName.equals(process.processName) &&
// 前台服务/前台进程均视为服务运行（适配部分机型保活机制） (process.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND_SERVICE ||
if (process.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND_SERVICE process.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND)) {
|| process.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
return true; return true;
} }
} }
} }
}
// 兜底：检查服务是否已启动（避免进程后台时误判）
return isServiceStarted(context, serviceClass); return isServiceStarted(context, serviceClass);
} catch (Exception e) {
LogUtils.e(TAG, "isServiceRunning: API30+ 判断服务状态异常", e);
return false;
}
} else { } else {
// API30-：通过RunningServiceInfo判断
List<ActivityManager.RunningServiceInfo> runningServices = am.getRunningServices(100); List<ActivityManager.RunningServiceInfo> runningServices = am.getRunningServices(100);
if (runningServices != null && !runningServices.isEmpty()) { if (runningServices != null) {
String serviceClassName = serviceClass.getName(); String serviceClassName = serviceClass.getName();
for (ActivityManager.RunningServiceInfo info : runningServices) { for (ActivityManager.RunningServiceInfo info : runningServices) {
if (serviceClassName.equals(info.service.getClassName())) { if (serviceClassName.equals(info.service.getClassName())) {
@@ -717,87 +563,19 @@ public class ControlCenterService extends Service {
} }
/** /**
* 新增：辅助判断服务是否已启动（API30+ 兜底，避免进程后台误判） * 兜底判断服务是否已启动
*/ */
private static boolean isServiceStarted(Context context, Class<?> serviceClass) { private static boolean isServiceStarted(Context context, Class<?> serviceClass) {
try { try {
// 通过ServiceControlBean状态兜底（服务启动时会初始化配置）
ControlCenterServiceBean controlBean = ControlCenterServiceBean.loadBean(context, ControlCenterServiceBean.class); ControlCenterServiceBean controlBean = ControlCenterServiceBean.loadBean(context, ControlCenterServiceBean.class);
return controlBean != null && controlBean.isEnableService(); return controlBean != null && controlBean.isEnableService();
} catch (Exception e) { } catch (Exception e) {
LogUtils.e(TAG, "isServiceStarted: 兜底判断服务状态异常", e); LogUtils.e(TAG, "isServiceStarted: 兜底判断异常", e);
return false; return false;
} }
} }
/** // ================================== Getter/Setter 方法（线程安全）=================================
* 引导用户开启忽略电池优化（避免服务被后台杀死，适配API23+，优化机型兼容）
*/
public static void checkIgnoreBatteryOptimization(Context context) {
LogUtils.d(TAG, "checkIgnoreBatteryOptimization: 检查电池优化状态");
if (context == null) {
LogUtils.e(TAG, "checkIgnoreBatteryOptimization: Context为空，跳过检查");
return;
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
PowerManager powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
if (powerManager == null) {
LogUtils.e(TAG, "checkIgnoreBatteryOptimization: PowerManager获取失败，跳过检查");
return;
}
try {
boolean isIgnored = powerManager.isIgnoringBatteryOptimizations(context.getPackageName());
if (!isIgnored) {
Intent intent = new Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
intent.setData(Uri.parse("package:" + context.getPackageName()));
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
// 适配部分机型限制，添加异常捕获
context.startActivity(intent);
LogUtils.d(TAG, "checkIgnoreBatteryOptimization: 已引导用户开启忽略电池优化");
} else {
LogUtils.d(TAG, "checkIgnoreBatteryOptimization: 已开启忽略电池优化，无需操作");
}
} catch (SecurityException e) {
LogUtils.e(TAG, "checkIgnoreBatteryOptimization: 机型限制，无法引导电池优化（系统权限管控）", e);
} catch (Exception e) {
LogUtils.e(TAG, "checkIgnoreBatteryOptimization: 引导优化异常（部分机型限制）", e);
}
} else {
LogUtils.d(TAG, "checkIgnoreBatteryOptimization: API<23，无需检查电池优化");
}
}
/**
* 更新服务配置（对外静态入口，触发线程重启，控制配置从本地读取）
*/
public static void updateStatus(Context context, AppConfigBean configBean) {
LogUtils.d(TAG, "updateStatus: 发送业务配置更新指令");
if (context == null || configBean == null) {
LogUtils.e(TAG, "updateStatus: Context/业务配置为空，发送失败");
return;
}
Intent intent = new Intent(context, ControlCenterService.class);
intent.setAction(ACTION_RESTART_REMIND_THREAD);
intent.putExtra(EXTRA_APP_CONFIG_BEAN, (Serializable) configBean);
intent.setPackage(context.getPackageName());
intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
try {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
context.startForegroundService(intent);
} else {
context.startService(intent);
}
LogUtils.d(TAG, "updateStatus: 业务配置更新指令发送成功");
} catch (Exception e) {
LogUtils.e(TAG, "updateStatus: 发送指令异常", e);
}
}
// ================================== Getter/Setter 方法（新增前台状态相关，线程安全）=================================
public RemindThread getRemindThread() { public RemindThread getRemindThread() {
synchronized (mServiceLock) { synchronized (mServiceLock) {
return mRemindThread; return mRemindThread;
@@ -805,29 +583,24 @@ public class ControlCenterService extends Service {
} }
public void setCurrentConfigBean(AppConfigBean configBean) { public void setCurrentConfigBean(AppConfigBean configBean) {
LogUtils.d(TAG, "setCurrentConfigBean: 更新服务配置"); LogUtils.d(TAG, "setCurrentConfigBean: 更新业务配置");
if (configBean != null) { if (configBean == null) {
LogUtils.e(TAG, "setCurrentConfigBean: 配置为空");
return;
}
synchronized (mServiceLock) { synchronized (mServiceLock) {
this.mCurrentConfigBean = configBean; this.mCurrentConfigBean = configBean;
syncConfigToRemindThread(); syncConfigToRemindThread();
} }
LogUtils.d(TAG, "setCurrentConfigBean: 配置更新成功");
} else {
LogUtils.e(TAG, "setCurrentConfigBean: 配置为空，更新失败");
}
} }
// 更新服务控制配置（内存+本地持久化同步）
public void setServiceControlBean(ControlCenterServiceBean controlBean) { public void setServiceControlBean(ControlCenterServiceBean controlBean) {
LogUtils.d(TAG, "setServiceControlBean: 更新服务控制配置"); LogUtils.d(TAG, "setServiceControlBean: 更新控制配置");
if (controlBean != null) { if (controlBean != null) {
updateAndSaveServiceControlConfig(controlBean); updateAndSaveServiceControlConfig(controlBean);
} else {
LogUtils.e(TAG, "setServiceControlBean: 控制配置为空，更新失败");
} }
} }
// 获取服务控制配置（外部查询启用状态）
public ControlCenterServiceBean getServiceControlBean() { public ControlCenterServiceBean getServiceControlBean() {
synchronized (mServiceLock) { synchronized (mServiceLock) {
return mServiceControlBean; return mServiceControlBean;
@@ -857,21 +630,5 @@ public class ControlCenterService extends Service {
return mIsDestroyed; return mIsDestroyed;
} }
} }
// 新增：获取应用前台状态（外部查询，线程安全）
public boolean isAppForeground() {
synchronized (mServiceLock) {
return mIsAppForeground;
}
}
// 新增：设置应用前台状态（内部/外部调用，同步到线程）
// public void setAppForeground(boolean isForeground) {
// LogUtils.d(TAG, "setAppForeground: 更新应用前台状态=" + isForeground);
// synchronized (mServiceLock) {
// mIsAppForeground = isForeground;
// syncAppForegroundStateToThread();
// }
// }
} }