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-17 16:24:49 +08:00
parent 683dc6791e
commit 5cf47172f4
5 changed files with 770 additions and 400 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
powerbell/build.properties
View File

@@ -1,8 +1,8 @@
#Created by .winboll/winboll_app_build.gradle
#Wed Dec 17 07:16:02 GMT 2025
#Wed Dec 17 08:23:18 GMT 2025
stageCount=10
libraryProject=
baseVersion=15.14
publishVersion=15.14.9
buildCount=11
buildCount=16
baseBetaVersion=15.14.10

68
powerbell/src/main/java/cc/winboll/studio/powerbell/handlers/ControlCenterServiceHandler.java
View File

@@ -10,7 +10,7 @@ import cc.winboll.studio.powerbell.models.NotificationMessage;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/12/17 13:41
* @Describe 服务通信Handler：弱引用持有服务，避免内存泄漏，适配Java7+API30，统一处理服务消息
* @Describe 服务通信Handler：弱引用持有服务，避免内存泄漏，通知格式优化为 (+/-)(当前电量)(充电状态)
*/
public class ControlCenterServiceHandler extends Handler {
// ================================== 静态常量（置顶统一管理，清晰区分消息类型）=================================
@@ -26,11 +26,15 @@ public class ControlCenterServiceHandler extends Handler {
this.mwrControlCenterService = new WeakReference<>(service);
}
// ================================== 核心消息处理（重写handleMessage，按类型分发）=================================
// ================================== 核心消息处理（重写handleMessage，解析多参数消息）=================================
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
LogUtils.d(TAG, "接收消息，what：" + msg.what + "，obj：" + (msg.obj != null ? msg.obj : "null"));
// 解析线程传递的完整数据：obj=提醒类型(+/-)，arg1=当前电量，arg2=充电状态(1=充电中，0=未充电)
String remindType = (msg.obj != null) ? (String) msg.obj : "";
int currentBattery = msg.arg1;
boolean isCharging = msg.arg2 == 1;
LogUtils.d(TAG, "接收消息，what：" + msg.what + "，类型：" + remindType + "，电量：" + currentBattery + "，充电状态：" + isCharging);
// 弱引用获取服务，避免持有强引用导致内存泄漏
ControlCenterService service = mwrControlCenterService.get();
@@ -42,7 +46,7 @@ public class ControlCenterServiceHandler extends Handler {
// 按消息类型分发处理，避免逻辑冗余
switch (msg.what) {
case MSG_REMIND_TEXT:
handleRemindMessage(service, (String) msg.obj);
handleRemindMessage(service, remindType, currentBattery, isCharging);
break;
default:
LogUtils.w(TAG, "未知消息类型，what：" + msg.what);
@@ -50,41 +54,51 @@ public class ControlCenterServiceHandler extends Handler {
}
}
// ================================== 业务辅助方法（单独处理提醒消息，职责单一）=================================
// ================================== 业务辅助方法（重构通知内容，格式：(+/-)(当前电量)(充电状态)）=================================
/**
* 处理电量提醒消息，构建通知模型并调用工具类发送
* 处理电量提醒消息，构建带电量+充电状态的通知模型
* @param service 服务实例（非空，已前置校验）
* @param content 消息内容（+：充电提醒，-：耗电提醒）
* @param remindType 提醒类型（+：充电提醒，-：耗电提醒）
* @param currentBattery 当前电量（0-100）
* @param isCharging 充电状态（true=充电中，false=未充电）
*/
private void handleRemindMessage(ControlCenterService service, String content) {
LogUtils.d(TAG, "开始处理提醒消息，内容：" + content);
private void handleRemindMessage(ControlCenterService service, String remindType, int currentBattery, boolean isCharging) {
LogUtils.d(TAG, "开始处理提醒消息，类型：" + remindType + "，电量：" + currentBattery + "，充电状态：" + isCharging);
// 校验通知工具类，避免空指针
// 1. 前置校验：通知工具类+提醒类型+电量有效性
if (service.getNotificationManager() == null) {
LogUtils.e(TAG, "通知管理工具类为空，无法发送提醒");
return;
}
// 构建通知消息模型，区分充电/耗电场景
NotificationMessage remindMsg = new NotificationMessage();
if ("+".equals(content)) {
remindMsg.setTitle("充电提醒");
remindMsg.setContent("电池电量已达标，建议及时断电，保护电池寿命～");
remindMsg.setRemindMSG("charge_remind");
LogUtils.d(TAG, "构建充电提醒通知，标识：charge_remind");
} else if ("-".equals(content)) {
remindMsg.setTitle("耗电提醒");
remindMsg.setContent("电池电量偏低，建议及时充电，避免设备关机～");
remindMsg.setRemindMSG("usage_remind");
LogUtils.d(TAG, "构建耗电提醒通知，标识：usage_remind");
} else {
LogUtils.w(TAG, "无效提醒消息内容，跳过发送：" + content);
if (!"+".equals(remindType) && !"-".equals(remindType)) {
LogUtils.w(TAG, "无效提醒类型，跳过发送：" + remindType);
return;
}
if (currentBattery < 0 || currentBattery > 100) {
LogUtils.w(TAG, "无效当前电量，跳过发送：" + currentBattery);
return;
}
// 调用服务工具类发送通知，复用现有逻辑
// 2. 构建通知模型，按格式拼接内容（核心优化）
NotificationMessage remindMsg = new NotificationMessage();
String chargeStateDesc = isCharging ? "充电中" : "未充电"; // 充电状态文字描述
if ("+".equals(remindType)) {
// 充电提醒：格式 (+)(当前电量)(充电状态)
remindMsg.setTitle("充电提醒");
remindMsg.setContent("(+) 当前电量" + currentBattery + "%，" + chargeStateDesc + "，已达标建议及时断电，保护电池寿命～");
remindMsg.setRemindMSG("charge_remind");
LogUtils.d(TAG, "构建充电提醒通知，内容：" + remindMsg.getContent());
} else if ("-".equals(remindType)) {
// 耗电提醒：格式 (-)(当前电量)(充电状态)
remindMsg.setTitle("耗电提醒");
remindMsg.setContent("(-) 当前电量" + currentBattery + "%，" + chargeStateDesc + "，已偏低建议及时充电，避免设备关机～");
remindMsg.setRemindMSG("usage_remind");
LogUtils.d(TAG, "构建耗电提醒通知，内容：" + remindMsg.getContent());
}
// 3. 调用服务工具类发送通知，复用现有逻辑
service.getNotificationManager().showRemindNotification(service, remindMsg);
LogUtils.d(TAG, "提醒通知发送完成，标题：" + remindMsg.getTitle());
LogUtils.d(TAG, "提醒通知发送完成，标题：" + remindMsg.getTitle() + "，完整内容：" + remindMsg.getContent());
}
}

191
powerbell/src/main/java/cc/winboll/studio/powerbell/models/ControlCenterServiceBean.java
View File

@@ -1,99 +1,142 @@
package cc.winboll.studio.powerbell.models;
/**
* @Author ZhanGSKen<zhangsken@qq.com>
* @Date 2024/07/18 07:06:07
* @Describe 服务控制参数
*/
import android.os.Parcel;
import android.os.Parcelable;
import android.util.JsonReader;
import android.util.JsonWriter;
import cc.winboll.studio.libappbase.BaseBean;
import java.io.IOException;
import java.io.Serializable;
// 核心修正：实现 Parcelable + Serializable 接口（适配持久化+Intent传递，API30 必备）
import cc.winboll.studio.libappbase.BaseBean;
import cc.winboll.studio.libappbase.LogUtils;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/12/17 15:55
* @Describe 服务控制参数模型：管理服务启用状态，支持序列化、Parcel传递、JSON解析
*/
public class ControlCenterServiceBean extends BaseBean implements Parcelable, Serializable {
// ================================== 静态常量（置顶统一管理，避免魔法值）=================================
private static final long serialVersionUID = 1L; // Serializable 必备，保障反序列化兼容
private static final String TAG = "ControlCenterServiceBean";
// JSON 字段常量，避免硬编码，减少拼写错误
private static final String JSON_FIELD_IS_ENABLE_SERVICE = "isEnableService";
// 序列化版本号（Serializable 必备，避免反序列化崩溃）
private static final long serialVersionUID = 1L;
// ================================== 核心成员变量（私有封装，规范命名）=================================
private boolean isEnableService = false; // 服务启用状态：true=启用，false=禁用
public static final String TAG = "ControlCenterServiceBean";
boolean isEnableService = false;
public ControlCenterServiceBean() {
this.isEnableService = false;
}
public ControlCenterServiceBean(boolean isEnableService) {
this.isEnableService = isEnableService;
}
public void setIsEnableService(boolean isEnableService) {
this.isEnableService = isEnableService;
}
public boolean isEnableService() {
return isEnableService;
}
@Override
public String getName() {
return ControlCenterServiceBean.class.getName();
}
@Override
public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
super.writeThisToJsonWriter(jsonWriter);
ControlCenterServiceBean bean = this;
jsonWriter.name("isEnableService").value(bean.isEnableService());
}
@Override
public BaseBean readBeanFromJsonReader(JsonReader jsonReader) throws IOException {
ControlCenterServiceBean bean = new ControlCenterServiceBean();
jsonReader.beginObject();
while (jsonReader.hasNext()) {
String name = jsonReader.nextName();
if (name.equals("isEnableService")) {
bean.setIsEnableService(jsonReader.nextBoolean());
} else {
jsonReader.skipValue();
}
}
// 结束 JSON 对象
jsonReader.endObject();
return bean;
}
// ======================== 补全：Parcelable 接口实现（API30 持久化/Intent传递必备）========================
@Override
public int describeContents() {
return 0; // 无特殊内容描述，返回0即可
}
// 序列化：将对象属性写入 Parcel
@Override
public void writeToParcel(Parcel dest, int flags) {
// boolean 类型用 byte 存储（Parcel 无直接 writeBoolean 方法，Java7 适配）
dest.writeByte((byte) (isEnableService ? 1 : 0));
}
// 反序列化：从 Parcel 读取属性，创建对象（必须是 public static final 修饰）
// ================================== Parcelable 静态创建器（必须 public static final，适配 API30 传递）=================================
public static final Parcelable.Creator<ControlCenterServiceBean> CREATOR = new Parcelable.Creator<ControlCenterServiceBean>() {
@Override
public ControlCenterServiceBean createFromParcel(Parcel source) {
// 从 Parcel 读取 byte，转为 boolean
LogUtils.d(TAG, "Parcelable createFromParcel: 从Parcel反序列化对象");
// Java7 + API30 适配：Parcel 无直接 writeBoolean，用 byte 存储/读取
boolean isEnable = source.readByte() != 0;
return new ControlCenterServiceBean(isEnable);
ControlCenterServiceBean bean = new ControlCenterServiceBean(isEnable);
LogUtils.d(TAG, "Parcelable createFromParcel: 反序列化完成，isEnableService=" + isEnable);
return bean;
}
@Override
public ControlCenterServiceBean[] newArray(int size) {
LogUtils.d(TAG, "Parcelable newArray: 创建数组，长度=" + size);
return new ControlCenterServiceBean[size];
}
};
// ================================== 构造方法（无参+有参，满足不同初始化场景）=================================
/**
* 无参构造（JSON解析、反射创建必备）
*/
public ControlCenterServiceBean() {
this.isEnableService = false;
LogUtils.d(TAG, "无参构造：初始化服务状态为禁用（false）");
}
/**
* 有参构造（指定服务启用状态）
* @param isEnableService 服务启用状态
*/
public ControlCenterServiceBean(boolean isEnableService) {
this.isEnableService = isEnableService;
LogUtils.d(TAG, "有参构造：初始化服务状态，isEnableService=" + isEnableService);
}
// ================================== Getter/Setter 方法（封装成员变量，控制访问）=================================
public boolean isEnableService() {
LogUtils.d(TAG, "get isEnableService: 当前状态=" + isEnableService);
return isEnableService;
}
public void setIsEnableService(boolean isEnableService) {
LogUtils.d(TAG, "set isEnableService: 旧状态=" + this.isEnableService + "，新状态=" + isEnableService);
this.isEnableService = isEnableService;
}
// ================================== 父类 BaseBean 方法重写（核心业务逻辑）=================================
@Override
public String getName() {
String className = ControlCenterServiceBean.class.getName();
LogUtils.d(TAG, "getName: 返回类名=" + className);
return className;
}
/**
* 序列化对象到 JSON（适配数据持久化/网络传输）
*/
@Override
public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
LogUtils.d(TAG, "writeThisToJsonWriter: 开始将对象序列化到JSON");
super.writeThisToJsonWriter(jsonWriter);
// 写入服务启用状态字段
jsonWriter.name(JSON_FIELD_IS_ENABLE_SERVICE).value(this.isEnableService);
LogUtils.d(TAG, "writeThisToJsonWriter: JSON序列化完成，字段=" + JSON_FIELD_IS_ENABLE_SERVICE + "，值=" + this.isEnableService);
}
/**
* 从 JSON 反序列化创建对象（适配数据恢复）
*/
@Override
public BaseBean readBeanFromJsonReader(JsonReader jsonReader) throws IOException {
LogUtils.d(TAG, "readBeanFromJsonReader: 开始从JSON反序列化对象");
ControlCenterServiceBean bean = new ControlCenterServiceBean();
jsonReader.beginObject();
while (jsonReader.hasNext()) {
String fieldName = jsonReader.nextName();
if (JSON_FIELD_IS_ENABLE_SERVICE.equals(fieldName)) {
// 读取并设置服务启用状态
boolean isEnable = jsonReader.nextBoolean();
bean.setIsEnableService(isEnable);
LogUtils.d(TAG, "readBeanFromJsonReader: 读取JSON字段，" + fieldName + "=" + isEnable);
} else {
// 跳过未知字段，避免解析异常
jsonReader.skipValue();
LogUtils.w(TAG, "readBeanFromJsonReader: 跳过未知JSON字段=" + fieldName);
}
}
jsonReader.endObject();
LogUtils.d(TAG, "readBeanFromJsonReader: JSON反序列化完成");
return bean;
}
// ================================== Parcelable 接口方法实现（适配 Intent 组件间传递）=================================
@Override
public int describeContents() {
// 无特殊内容（如文件描述符），返回0即可（API30 标准实现）
LogUtils.d(TAG, "describeContents: 返回内容描述符=0");
return 0;
}
/**
* 序列化对象到 Parcel（Intent 传递必备，Java7 适配）
*/
@Override
public void writeToParcel(Parcel dest, int flags) {
LogUtils.d(TAG, "writeToParcel: 开始将对象序列化到Parcel，flags=" + flags);
// Java7 + API30 适配：Parcel 无 writeBoolean 方法，用 byte 存储（1=true，0=false）
dest.writeByte((byte) (this.isEnableService ? 1 : 0));
LogUtils.d(TAG, "writeToParcel: Parcel序列化完成，isEnableService=" + this.isEnableService + "（存储为byte=" + (this.isEnableService ? 1 : 0) + "）");
}
}

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

@@ -10,212 +10,218 @@ import android.os.IBinder;
import android.os.PowerManager;
import android.provider.Settings;
import android.text.TextUtils;
import java.io.Serializable;
import java.util.List;
import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.powerbell.handlers.ControlCenterServiceHandler;
import cc.winboll.studio.powerbell.models.AppConfigBean;
import cc.winboll.studio.powerbell.models.ControlCenterServiceBean;
import cc.winboll.studio.powerbell.models.NotificationMessage;
import cc.winboll.studio.powerbell.threads.RemindThread;
import cc.winboll.studio.powerbell.utils.NotificationManagerUtils;
import java.io.Serializable;
import java.util.List;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/12/17 15:48
* @Describe 电池提醒核心服务：通过本地持久化 ControlCenterServiceBean 控制自启动，统一管理线程、通知、配置，适配Java7+API30
*/
public class ControlCenterService extends Service {
// ================================== 静态常量（置顶统一管理，避免魔法值）=================================
private static final String TAG = "ControlCenterService";
// Intent指令常量（完整包名前缀，避免冲突）
// 服务指令常量（带包名前缀，防止冲突）
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";
// 核心成员变量
private ControlCenterServiceHandler mServiceHandler;
private RemindThread mRemindThread;
private NotificationManagerUtils mNotificationManager;
private NotificationMessage mForegroundNotifyMsg;
private AppConfigBean mCurrentConfigBean;
private boolean isServiceRunning = false;
private boolean mIsDestroyed = false; // 服务销毁状态标记（供Receiver判断）
private final Object mServiceLock = new Object(); // 并发锁（避免多线程冲突）
// ================================== 核心成员变量（按依赖优先级排序，私有封装）=================================
// 服务控制核心（本地持久化管理，替代Intent传递）
private ControlCenterServiceBean mServiceControlBean;
// 业务核心组件
private ControlCenterServiceHandler mServiceHandler; // 服务通信Handler
private RemindThread mRemindThread; // 电量提醒线程
private NotificationManagerUtils mNotificationManager; // 通知管理工具类
private AppConfigBean mCurrentConfigBean; // 当前应用配置
// 前台服务相关
private NotificationMessage mForegroundNotifyMsg; // 前台保活通知模型
// 状态标记（并发安全）
private boolean isServiceRunning = false; // 服务运行状态
private boolean mIsDestroyed = false; // 服务销毁标记
private final Object mServiceLock = new Object(); // 全局并发锁
// ================================== 服务生命周期方法（onCreate→onStartCommand→onDestroy）=================================
@Override
public void onCreate() {
super.onCreate();
LogUtils.d(TAG, "onCreate: 服务创建，初始化核心组件");
LogUtils.d(TAG, "onCreate: 服务开始创建");
synchronized (mServiceLock) {
isServiceRunning = true;
mIsDestroyed = false;
initNotificationManager();
startForegroundNotifyImmediately();
loadDefaultConfig();
initServiceBusinessLogic();
LogUtils.d(TAG, "onCreate: 服务初始化完成");
// 初始化服务控制配置：优先读取本地持久化配置，无则创建默认禁用配置
mServiceControlBean = ControlCenterServiceBean.loadBean(this, ControlCenterServiceBean.class);
if (mServiceControlBean == null) {
mServiceControlBean = new ControlCenterServiceBean(false);
ControlCenterServiceBean.saveBean(this, mServiceControlBean); // 持久化默认配置
LogUtils.d(TAG, "onCreate: 本地无控制配置，创建默认禁用配置并持久化");
} else {
LogUtils.d(TAG, "onCreate: 从本地读取服务控制配置，启用状态=" + mServiceControlBean.isEnableService());
}
}
LogUtils.d(TAG, "onCreate: 服务创建完成，当前服务控制状态：" + (mServiceControlBean.isEnableService() ? "启用" : "禁用"));
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
LogUtils.d(TAG, "onStartCommand: 触发服务启动命令，flags=" + flags);
handleExternalCommand(intent);
// 重新绑定前台服务，避免API30+状态丢失（加判空容错）
if (mNotificationManager != null && mNotificationManager.getForegroundServiceNotify() != null) {
try {
startForeground(NotificationManagerUtils.NOTIFY_ID_FOREGROUND_SERVICE,
mNotificationManager.getForegroundServiceNotify());
LogUtils.d(TAG, "onStartCommand: 重新绑定前台通知保活");
} catch (Exception e) {
LogUtils.e(TAG, "onStartCommand: 重新绑定前台通知异常", e);
}
}
return START_STICKY; // 服务回收后自动重启
}
// 处理外部指令（重启线程）- 加锁避免并发调用
private void handleExternalCommand(Intent intent) {
LogUtils.d(TAG, "handleExternalCommand: 处理外部指令");
if (intent == null) {
LogUtils.e(TAG, "handleExternalCommand: Intent为空，跳过");
return;
}
String action = intent.getAction();
if (TextUtils.isEmpty(action)) {
LogUtils.e(TAG, "handleExternalCommand: 指令Action为空，跳过");
return;
}
synchronized (mServiceLock) { // 关键：加锁，防止并发触发重启导致线程冲突
if (ACTION_RESTART_REMIND_THREAD.equals(action)) {
AppConfigBean newConfig = (AppConfigBean) intent.getSerializableExtra(EXTRA_APP_CONFIG_BEAN);
if (newConfig != null) {
mCurrentConfigBean = newConfig;
LogUtils.d(TAG, "handleExternalCommand: 收到重启指令，更新配置");
restartRemindThreadSafely();
} else {
LogUtils.e(TAG, "handleExternalCommand: 新配置为空，重启失败");
}
}
}
}
// 安全重启提醒线程 - 核心修复：彻底销毁旧线程，确保新线程是全新实例
public void restartRemindThreadSafely() {
LogUtils.d(TAG, "restartRemindThreadSafely: 重启提醒线程");
synchronized (mServiceLock) { // 加锁，避免与服务销毁/其他重启操作冲突
// 1. 先彻底停止旧线程（调用独立封装的安全停止方法）
stopRemindThreadSafely();
// 2. 校验服务状态，避免服务已停止时启动线程
if (!isServiceRunning || mServiceHandler == null || mIsDestroyed) {
LogUtils.e(TAG, "restartRemindThreadSafely: 服务未运行/已销毁/Handler为空，启动失败");
return;
}
// 3. 强制销毁RemindThread单例（关键：避免复用旧线程对象）
RemindThread.destroyInstance(); // 必须调用，确保getInstance返回新实例
// 4. 创建新线程实例（此时是全新Thread对象，未启动）
mRemindThread = RemindThread.getInstance(this, mServiceHandler);
syncConfigToRemindThread();
// 5. 双重校验线程状态，杜绝重复start()
if (mRemindThread != null && !mRemindThread.isAlive() && !mRemindThread.isThreadStarted()) {
try {
mRemindThread.start(); // 修复崩溃核心：仅对全新线程调用start()
LogUtils.d(TAG, "restartRemindThreadSafely: 新线程启动成功，ID=" + mRemindThread.getId());
} catch (IllegalThreadStateException e) {
// 兜底捕获：即使校验失败，也避免崩溃，打印详细日志
LogUtils.e(TAG, "restartRemindThreadSafely: 线程重复启动异常（致命错误）", e);
mRemindThread = null; // 启动失败，置空避免后续错误
} catch (Exception e) {
LogUtils.e(TAG, "restartRemindThreadSafely: 启动新线程异常", e);
mRemindThread = null;
}
} else {
LogUtils.w(TAG, "restartRemindThreadSafely: 线程已启动/实例异常，无需重复操作");
mRemindThread = null;
}
}
}
// 安全停止提醒线程 - 优化：确保线程彻底终止，无残留
private void stopRemindThreadSafely() {
LogUtils.d(TAG, "stopRemindThreadSafely: 安全停止提醒线程");
if (mRemindThread == null) {
LogUtils.w(TAG, "stopRemindThreadSafely: 线程实例为空，跳过");
return;
}
try {
// 1. 先通过线程内部方法标记停止（依赖RemindThread的stopThread实现）
if (mRemindThread.isThreadStarted() || mRemindThread.isAlive()) {
mRemindThread.setIsReminding(false); // 关闭提醒功能
mRemindThread.stopThread(); // 触发线程安全停止（置位退出标记+中断休眠）
LogUtils.d(TAG, "stopRemindThreadSafely: 触发线程内部停止逻辑");
// 2. 等待线程终止（最多1秒，避免阻塞服务，超时强制置空）
long waitStartTime = System.currentTimeMillis();
while (mRemindThread.isAlive()) {
if (System.currentTimeMillis() - waitStartTime > 1000) {
LogUtils.w(TAG, "stopRemindThreadSafely: 线程停止超时，强制终止处理");
mRemindThread.interrupt(); // 强制中断，加速退出
break;
}
Thread.yield(); // 让出CPU，优先执行线程退出逻辑
}
}
} catch (Exception e) {
LogUtils.e(TAG, "stopRemindThreadSafely: 线程停止异常", e);
} finally {
// 3. 彻底释放：置空实例+销毁单例，杜绝复用
mRemindThread = null;
RemindThread.destroyInstance(); // 关键：销毁单例，避免getInstance复用旧对象
LogUtils.d(TAG, "stopRemindThreadSafely: 线程停止完成，资源已释放");
}
}
// 同步配置到提醒线程 - 加锁避免并发修改
private void syncConfigToRemindThread() {
LogUtils.d(TAG, "syncConfigToRemindThread: 同步配置到线程");
LogUtils.d(TAG, "onStartCommand: 服务启动指令触发，flags=" + flags);
// 第一步：读取本地最新控制配置（优先级最高，实时同步用户设置）
loadLatestServiceControlConfig();
// 第二步：根据控制状态，分支执行逻辑
synchronized (mServiceLock) {
if (mRemindThread == null || mCurrentConfigBean == null) {
LogUtils.e(TAG, "syncConfigToRemindThread: 线程/配置为空，同步失败");
if (mServiceControlBean.isEnableService()) {
LogUtils.d(TAG, "onStartCommand: 服务已启用，执行核心逻辑");
// 启用状态：处理指令+绑定前台通知+启动业务，返回START_STICKY（回收后重启）
handleExternalCommand(intent);
rebindForegroundNotify();
initServiceBusinessIfNeed(); // 按需初始化业务（避免重复初始化）
LogUtils.d(TAG, "onStartCommand: 核心逻辑执行完成，返回START_STICKY");
return START_STICKY;
} else {
LogUtils.d(TAG, "onStartCommand: 服务已禁用，不执行核心逻辑");
// 禁用状态：停止所有业务+释放资源，返回父类默认值（回收后不主动重启）
stopAllBusinessSafely();
LogUtils.d(TAG, "onStartCommand: 已停止所有业务，返回父类默认onStartCommand结果");
return super.onStartCommand(intent, flags, startId);
}
}
}
@Override
public void onDestroy() {
super.onDestroy();
LogUtils.d(TAG, "onDestroy: 服务开始销毁，释放所有资源");
synchronized (mServiceLock) {
isServiceRunning = false;
mIsDestroyed = true;
}
// 顺序释放资源（前台服务→线程→Handler→通知→配置→控制Bean）
stopForegroundService();
stopRemindThreadSafely();
destroyHandler();
releaseNotificationResource();
clearAllReferences();
LogUtils.d(TAG, "onDestroy: 服务销毁完成");
}
@Override
public IBinder onBind(Intent intent) {
return null; // 无需绑定服务，返回null
}
// ================================== 核心：服务控制配置（本地持久化读写，替代Intent传递）=================================
/**
* 读取本地最新服务控制配置（实时同步，确保与用户设置一致）
*/
private void loadLatestServiceControlConfig() {
LogUtils.d(TAG, "loadLatestServiceControlConfig: 读取本地最新服务控制配置");
synchronized (mServiceLock) {
ControlCenterServiceBean latestControlBean = ControlCenterServiceBean.loadBean(this, ControlCenterServiceBean.class);
if (latestControlBean != null) {
boolean oldState = mServiceControlBean.isEnableService();
boolean newState = latestControlBean.isEnableService();
mServiceControlBean = latestControlBean;
LogUtils.d(TAG, "loadLatestServiceControlConfig: 控制配置更新完成，旧状态=" + oldState + "，新状态=" + newState);
} else {
LogUtils.w(TAG, "loadLatestServiceControlConfig: 本地无控制配置，沿用当前状态=" + mServiceControlBean.isEnableService());
}
}
LogUtils.d(TAG, "loadLatestServiceControlConfig: 控制配置读取完成，当前服务启用状态=" + mServiceControlBean.isEnableService());
}
/**
* 更新服务控制配置（本地持久化+内存同步，对外提供统一入口）
*/
private void updateAndSaveServiceControlConfig(ControlCenterServiceBean newControlBean) {
LogUtils.d(TAG, "updateAndSaveServiceControlConfig: 更新服务控制配置，新状态=" + newControlBean.isEnableService());
if (newControlBean == null) {
LogUtils.e(TAG, "updateAndSaveServiceControlConfig: 新控制配置为空，更新失败");
return;
}
mRemindThread.setAppConfigBean(mCurrentConfigBean); // 同步完整配置
mRemindThread.setIsReminding(true); // 开启提醒功能
LogUtils.d(TAG, "syncConfigToRemindThread: 配置同步完成");
synchronized (mServiceLock) {
// 内存同步+本地持久化（原子操作，确保一致性）
mServiceControlBean = newControlBean;
ControlCenterServiceBean.saveBean(this, mServiceControlBean);
LogUtils.d(TAG, "updateAndSaveServiceControlConfig: 控制配置更新并持久化完成");
}
}
// 加载默认配置 - 优化：补全必要配置项，避免空指针
private void loadDefaultConfig() {
LogUtils.d(TAG, "loadDefaultConfig: 加载默认配置");
mCurrentConfigBean = new AppConfigBean();
mCurrentConfigBean.setEnableChargeReminder(true);
mCurrentConfigBean.setChargeReminderValue(80);
mCurrentConfigBean.setEnableUsageReminder(true);
mCurrentConfigBean.setUsageReminderValue(20);
mCurrentConfigBean.setBatteryDetectInterval(1000); // 电池检测间隔（1秒）
LogUtils.d(TAG, "loadDefaultConfig: 默认配置加载完成");
// ================================== 业务按需初始化/停止方法（适配启用/禁用状态切换）=================================
/**
* 按需初始化核心业务（仅服务启用且未初始化时执行，避免重复创建）
*/
private void initServiceBusinessIfNeed() {
LogUtils.d(TAG, "initServiceBusinessIfNeed: 按需初始化业务");
synchronized (mServiceLock) {
// 校验：服务启用+未初始化+服务运行中
if (!mServiceControlBean.isEnableService() || mServiceHandler != null || !isServiceRunning || mIsDestroyed) {
LogUtils.w(TAG, "initServiceBusinessIfNeed: 无需初始化业务（禁用/已初始化/服务未运行）");
return;
}
// 初始化通知工具类 - 优化：移除无效调用，强化容错
// 初始化通知+配置+业务逻辑（完整启动核心流程）
initNotificationManager();
loadDefaultConfig();
initServiceBusinessLogic();
LogUtils.d(TAG, "initServiceBusinessIfNeed: 核心业务初始化完成");
}
}
/**
* 安全停止所有核心业务（服务禁用时执行，释放所有业务资源）
*/
private void stopAllBusinessSafely() {
LogUtils.d(TAG, "stopAllBusinessSafely: 停止所有核心业务");
synchronized (mServiceLock) {
// 停止线程+销毁Handler+释放通知+置空业务引用
stopRemindThreadSafely();
destroyHandler();
stopForegroundService();
releaseNotificationResource();
mCurrentConfigBean = null;
mForegroundNotifyMsg = null;
LogUtils.d(TAG, "stopAllBusinessSafely: 所有核心业务已停止");
}
}
// ================================== 核心业务初始化方法（按依赖顺序排列）=================================
/**
* 初始化通知管理工具类，构建前台保活通知模型
*/
private void initNotificationManager() {
LogUtils.d(TAG, "initNotificationManager: 初始化通知工具类");
try {
if (mNotificationManager == null) {
mNotificationManager = new NotificationManagerUtils(this);
}
if (mForegroundNotifyMsg == null) {
mForegroundNotifyMsg = new NotificationMessage();
mForegroundNotifyMsg.setTitle("电池提醒服务运行中");
mForegroundNotifyMsg.setContent("后台持续监测电池状态，确保提醒及时");
mForegroundNotifyMsg.setRemindMSG("service_running");
// 移除无效调用：getForegroundServiceNotify() 无需提前触发，启动时自动构建
// 启动前台保活通知
startForegroundNotifyImmediately();
}
LogUtils.d(TAG, "initNotificationManager: 通知工具类初始化完成");
} catch (Exception e) {
LogUtils.e(TAG, "initNotificationManager: 初始化失败", e);
stopSelf(); // 通知初始化失败，直接停止服务，避免后续异常
}
}
// 立即启动前台服务通知 - 优化：加try-catch避免启动失败崩溃
/**
* 立即启动前台保活通知（API26+ 前台服务必需）
*/
private void startForegroundNotifyImmediately() {
LogUtils.d(TAG, "startForegroundNotifyImmediately: 启动前台保活通知");
if (mNotificationManager == null || mForegroundNotifyMsg == null) {
LogUtils.e(TAG, "startForegroundNotifyImmediately: 依赖组件为空，启动失败");
stopSelf();
LogUtils.e(TAG, "startForegroundNotifyImmediately: 通知工具类/模型为空，启动失败");
return;
}
@@ -224,20 +230,256 @@ public class ControlCenterService extends Service {
LogUtils.d(TAG, "startForegroundNotifyImmediately: 前台通知启动成功，ID=" + NotificationManagerUtils.NOTIFY_ID_FOREGROUND_SERVICE);
} catch (Exception e) {
LogUtils.e(TAG, "startForegroundNotifyImmediately: 前台通知启动异常", e);
stopSelf(); // 前台服务启动失败，停止服务（API26+前台服务必须正常启动）
}
}
// 初始化业务逻辑 - 优化：复用重启方法，统一线程启动逻辑
/**
* 重新绑定前台通知（onStartCommand触发，防止保活状态丢失）
*/
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() {
LogUtils.d(TAG, "loadDefaultConfig: 加载默认配置");
if (mCurrentConfigBean == null) {
mCurrentConfigBean = new AppConfigBean();
mCurrentConfigBean.setEnableChargeReminder(true);
mCurrentConfigBean.setChargeReminderValue(80);
mCurrentConfigBean.setEnableUsageReminder(true);
mCurrentConfigBean.setUsageReminderValue(20);
mCurrentConfigBean.setBatteryDetectInterval(1000);
LogUtils.d(TAG, "loadDefaultConfig: 默认配置加载完成，充电阈值80%，耗电阈值20%");
} else {
LogUtils.d(TAG, "loadDefaultConfig: 配置已存在，无需重复加载");
}
}
/**
* 初始化业务核心逻辑（Handler+提醒线程）
*/
private void initServiceBusinessLogic() {
LogUtils.d(TAG, "initServiceBusinessLogic: 初始化业务组件");
LogUtils.d(TAG, "initServiceBusinessLogic: 初始化业务逻辑");
if (mServiceHandler == null) {
mServiceHandler = new ControlCenterServiceHandler(this);
// 关键：复用restartRemindThreadSafely，避免重复写启动逻辑
}
// 复用线程重启方法，统一启动逻辑
restartRemindThreadSafely();
LogUtils.d(TAG, "initServiceBusinessLogic: 业务组件初始化完成");
LogUtils.d(TAG, "initServiceBusinessLogic: 业务逻辑初始化完成");
}
// 启动服务（静态入口）- 优化：强化包名绑定，避免隐式启动失败
// ================================== 线程管理方法（安全启动/停止/重启，保障并发安全）=================================
/**
* 安全重启提醒线程（彻底销毁旧线程，创建全新实例，避免重复启动）
*/
public void restartRemindThreadSafely() {
LogUtils.d(TAG, "restartRemindThreadSafely: 开始重启提醒线程");
synchronized (mServiceLock) {
// 服务禁用/已销毁，直接返回
if (!isServiceRunning || mIsDestroyed || !mServiceControlBean.isEnableService()) {
LogUtils.e(TAG, "restartRemindThreadSafely: 服务未运行/已销毁/已禁用，启动失败");
return;
}
// 先停止旧线程
stopRemindThreadSafely();
// 校验Handler，避免无效启动
if (mServiceHandler == null) {
LogUtils.e(TAG, "restartRemindThreadSafely: Handler为空，启动失败");
return;
}
// 销毁旧单例，创建新线程实例
RemindThread.destroyInstance();
mRemindThread = RemindThread.getInstance(this, mServiceHandler);
// 同步配置并开启提醒
syncConfigToRemindThread();
// 双重校验，避免线程重复启动
if (mRemindThread != null && !mRemindThread.isAlive() && !mRemindThread.isThreadStarted()) {
try {
mRemindThread.start();
LogUtils.d(TAG, "restartRemindThreadSafely: 新线程启动成功，ID=" + mRemindThread.getId());
} catch (IllegalThreadStateException e) {
LogUtils.e(TAG, "restartRemindThreadSafely: 线程重复启动异常", e);
mRemindThread = null;
} catch (Exception e) {
LogUtils.e(TAG, "restartRemindThreadSafely: 启动线程异常", e);
mRemindThread = null;
}
} else {
LogUtils.w(TAG, "restartRemindThreadSafely: 线程已启动/实例异常，跳过启动");
mRemindThread = null;
}
}
LogUtils.d(TAG, "restartRemindThreadSafely: 线程重启流程结束");
}
/**
* 安全停止提醒线程（中断休眠+等待终止+释放资源，无残留）
*/
private void stopRemindThreadSafely() {
LogUtils.d(TAG, "stopRemindThreadSafely: 开始停止提醒线程");
if (mRemindThread == null) {
LogUtils.w(TAG, "stopRemindThreadSafely: 线程实例为空，跳过停止");
return;
}
try {
// 触发线程内部停止逻辑
if (mRemindThread.isThreadStarted() || mRemindThread.isAlive()) {
mRemindThread.setIsReminding(false);
mRemindThread.stopThread();
LogUtils.d(TAG, "stopRemindThreadSafely: 触发线程内部停止");
// 等待线程终止（超时1秒，避免阻塞服务）
long waitStartTime = System.currentTimeMillis();
while (mRemindThread.isAlive()) {
if (System.currentTimeMillis() - waitStartTime > 1000) {
LogUtils.w(TAG, "stopRemindThreadSafely: 线程停止超时，强制中断");
mRemindThread.interrupt();
break;
}
Thread.yield();
}
}
} catch (Exception e) {
LogUtils.e(TAG, "stopRemindThreadSafely: 停止线程异常", e);
} finally {
// 彻底释放资源
mRemindThread = null;
RemindThread.destroyInstance();
LogUtils.d(TAG, "stopRemindThreadSafely: 线程停止完成，资源已释放");
}
}
/**
* 同步配置到提醒线程（原子操作，避免并发修改）
*/
private void syncConfigToRemindThread() {
LogUtils.d(TAG, "syncConfigToRemindThread: 同步配置到线程");
synchronized (mServiceLock) {
if (mRemindThread == null || mCurrentConfigBean == null) {
LogUtils.e(TAG, "syncConfigToRemindThread: 线程/配置为空，同步失败");
return;
}
mRemindThread.setAppConfigBean(mCurrentConfigBean);
mRemindThread.setIsReminding(true);
LogUtils.d(TAG, "syncConfigToRemindThread: 配置同步完成");
}
}
// ================================== 外部指令处理方法（接收重启/更新配置指令，移除控制Bean传递）=================================
/**
* 处理外部发送的服务指令（如重启线程、更新配置）
*/
private void handleExternalCommand(Intent intent) {
LogUtils.d(TAG, "handleExternalCommand: 开始处理外部指令");
if (intent == null) {
LogUtils.e(TAG, "handleExternalCommand: Intent为空，跳过处理");
return;
}
String action = intent.getAction();
if (TextUtils.isEmpty(action)) {
LogUtils.e(TAG, "handleExternalCommand: 指令Action为空，跳过处理");
return;
}
// 处理线程重启指令（仅同步业务配置，服务控制配置从本地读取）
if (ACTION_RESTART_REMIND_THREAD.equals(action)) {
// 读取本地最新控制配置，确保状态同步
loadLatestServiceControlConfig();
// 仅启用状态下，更新业务配置并重启线程
synchronized (mServiceLock) {
if (mServiceControlBean.isEnableService()) {
AppConfigBean newConfig = (AppConfigBean) intent.getSerializableExtra(EXTRA_APP_CONFIG_BEAN);
if (newConfig != null) {
mCurrentConfigBean = newConfig;
LogUtils.d(TAG, "handleExternalCommand: 收到线程重启指令，已更新业务配置");
restartRemindThreadSafely();
} else {
LogUtils.e(TAG, "handleExternalCommand: 新业务配置为空，重启线程失败");
}
} else {
LogUtils.w(TAG, "handleExternalCommand: 服务已禁用，忽略线程重启指令");
}
}
}
LogUtils.d(TAG, "handleExternalCommand: 外部指令处理完成");
}
// ================================== 服务资源释放方法（顺序化释放，防内存泄漏）=================================
/**
* 停止前台服务（取消通知+移除前台状态）
*/
private void stopForegroundService() {
LogUtils.d(TAG, "stopForegroundService: 停止前台服务");
// 取消前台通知
if (mNotificationManager != null) {
mNotificationManager.cancelForegroundServiceNotify();
}
// 移除前台服务状态
try {
stopForeground(STOP_FOREGROUND_REMOVE);
LogUtils.d(TAG, "stopForegroundService: 前台服务状态移除成功");
} catch (Exception e) {
LogUtils.e(TAG, "stopForegroundService: 移除前台状态异常", e);
}
}
/**
* 销毁Handler（移除所有任务，避免内存泄漏）
*/
private void destroyHandler() {
LogUtils.d(TAG, "destroyHandler: 销毁服务Handler");
if (mServiceHandler != null) {
mServiceHandler.removeCallbacksAndMessages(null);
mServiceHandler = null;
LogUtils.d(TAG, "destroyHandler: Handler销毁完成");
}
}
/**
* 释放通知资源（调用工具类释放方法）
*/
private void releaseNotificationResource() {
LogUtils.d(TAG, "releaseNotificationResource: 释放通知资源");
if (mNotificationManager != null) {
mNotificationManager.release();
mNotificationManager = null;
LogUtils.d(TAG, "releaseNotificationResource: 通知资源释放完成");
}
}
/**
* 置空所有引用，帮助GC回收
*/
private void clearAllReferences() {
mForegroundNotifyMsg = null;
mCurrentConfigBean = null;
mServiceControlBean = null;
LogUtils.d(TAG, "clearAllReferences: 所有引用已置空");
}
// ================================== 静态工具方法（服务启动/停止/状态判断/电池优化，简化控制Bean传递）=================================
/**
* 启动服务（静态入口，从本地读取控制配置，显式绑定包名，适配API30+）
*/
public static void startControlCenterService(Context context) {
LogUtils.d(TAG, "startControlCenterService: 启动服务入口");
if (context == null) {
@@ -245,12 +487,15 @@ public class ControlCenterService extends Service {
return;
}
if (isServiceRunning(context, ControlCenterService.class)) {
LogUtils.d(TAG, "startControlCenterService: 服务已运行，跳过启动");
LogUtils.d(TAG, "startControlCenterService: 服务已运行，同步本地控制配置");
// 服务已运行，触发onStartCommand同步最新配置
sendSyncConfigCommand(context);
return;
}
Intent intent = new Intent(context, ControlCenterService.class);
intent.setPackage(context.getPackageName()); // 显式绑定包名，避免组件冲突
intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES); // 兼容服务被停止的场景
intent.setPackage(context.getPackageName());
intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
try {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
context.startForegroundService(intent);
@@ -263,7 +508,9 @@ public class ControlCenterService extends Service {
}
}
// 停止服务（静态入口）- 优化：强化包名绑定
/**
* 停止服务（静态入口，显式绑定包名）
*/
public static void stopControlCenterService(Context context) {
LogUtils.d(TAG, "stopControlCenterService: 停止服务入口");
if (context == null) {
@@ -274,52 +521,121 @@ public class ControlCenterService extends Service {
LogUtils.d(TAG, "stopControlCenterService: 服务未运行，跳过停止");
return;
}
Intent intent = new Intent(context, ControlCenterService.class);
intent.setPackage(context.getPackageName());
context.stopService(intent);
LogUtils.d(TAG, "stopControlCenterService: 服务停止指令发送成功");
}
// 判断服务是否运行 - 优化：适配API30+ ActivityManager限制
private static boolean isServiceRunning(Context context, Class<?> serviceClass) {
if (context == null || serviceClass == null) return false;
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
if (am == null) return false;
/**
* 新增：更新服务控制配置（本地持久化，动态切换服务启用/禁用状态）
*/
public static void updateServiceControlConfig(Context context, ControlCenterServiceBean controlBean) {
LogUtils.d(TAG, "updateServiceControlConfig: 更新服务控制配置，新状态=" + controlBean.isEnableService());
if (context == null || controlBean == null) {
LogUtils.e(TAG, "updateServiceControlConfig: Context/控制配置为空，更新失败");
return;
}
// API30+ 限制：getRunningServices返回空，改用getRunningTasks兼容（或用JobScheduler，此处先兼容）
// 第一步：本地持久化配置
ControlCenterServiceBean.saveBean(context, controlBean);
LogUtils.d(TAG, "updateServiceControlConfig: 控制配置已持久化");
// 第二步：若服务已运行，触发同步（让服务立即生效）
if (isServiceRunning(context, ControlCenterService.class)) {
sendSyncConfigCommand(context);
LogUtils.d(TAG, "updateServiceControlConfig: 服务已运行，已触发配置同步");
} else {
// 服务未运行，按需启动服务（根据新配置决定是否启用业务）
startControlCenterService(context);
LogUtils.d(TAG, "updateServiceControlConfig: 服务未运行，已启动服务并加载新配置");
}
}
/**
* 新增：发送配置同步指令（触发服务读取本地最新配置，立即生效）
*/
private static void sendSyncConfigCommand(Context context) {
Intent intent = new Intent(context, ControlCenterService.class);
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);
}
} catch (Exception e) {
LogUtils.e(TAG, "sendSyncConfigCommand: 发送同步指令异常", e);
}
}
/**
* 判断服务是否运行（适配API30+ ActivityManager限制）
*/
private static boolean isServiceRunning(Context context, Class<?> serviceClass) {
if (context == null || serviceClass == null) {
LogUtils.w(TAG, "isServiceRunning: Context/服务类为空，返回false");
return false;
}
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
if (am == null) {
LogUtils.e(TAG, "isServiceRunning: ActivityManager获取失败，返回false");
return false;
}
// API30+ 兼容：getRunningServices失效，通过进程状态判断
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
try {
// 替代方案1：通过进程名判断（简单兼容）
String packageName = context.getPackageName();
List<ActivityManager.RunningAppProcessInfo> processes = am.getRunningAppProcesses();
if (processes != null && !processes.isEmpty()) {
for (ActivityManager.RunningAppProcessInfo process : processes) {
if (process.processName.equals(packageName) && process.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND_SERVICE) {
if (packageName.equals(process.processName)
&& process.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND_SERVICE) {
return true;
}
}
// 替代方案2：兜底判断（若进程在运行，且服务已启动，视为运行中）
}
// 兜底：进程存活则视为服务运行（适配部分机型）
return true;
} catch (Exception e) {
LogUtils.e(TAG, "isServiceRunning: API30+ 判断服务状态异常", e);
return false;
}
} else {
// API30-：通过RunningServiceInfo判断
List<ActivityManager.RunningServiceInfo> runningServices = am.getRunningServices(100);
if (runningServices != null && !runningServices.isEmpty()) {
String serviceClassName = serviceClass.getName();
for (ActivityManager.RunningServiceInfo info : runningServices) {
if (serviceClass.getName().equals(info.service.getClassName())) {
if (serviceClassName.equals(info.service.getClassName())) {
return true;
}
}
}
return false;
}
}
// 引导开启忽略电池优化 - 优化：加权限判断+异常捕获
/**
* 引导用户开启忽略电池优化（避免服务被后台杀死，适配API23+）
*/
public static void checkIgnoreBatteryOptimization(Context context) {
if (context == null) return;
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) return;
if (powerManager == null) {
LogUtils.e(TAG, "checkIgnoreBatteryOptimization: PowerManager获取失败，跳过检查");
return;
}
try {
boolean isIgnored = powerManager.isIgnoringBatteryOptimizations(context.getPackageName());
@@ -328,99 +644,28 @@ public class ControlCenterService extends Service {
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: 引导开启忽略电池优化");
LogUtils.d(TAG, "checkIgnoreBatteryOptimization: 已引导用户开启忽略电池优化");
} else {
LogUtils.d(TAG, "checkIgnoreBatteryOptimization: 已开启忽略电池优化，无需操作");
}
} catch (Exception e) {
LogUtils.e(TAG, "checkIgnoreBatteryOptimization: 引导优化异常（部分机型限制）", e);
}
} else {
LogUtils.d(TAG, "checkIgnoreBatteryOptimization: API<23，无需检查电池优化");
}
}
// ====================== 核心 Getter/Setter 方法 ======================
public RemindThread getRemindThread() {
return mRemindThread;
}
public void setCurrentConfigBean(AppConfigBean configBean) {
if (configBean != null) {
synchronized (mServiceLock) {
this.mCurrentConfigBean = configBean;
syncConfigToRemindThread(); // 更新配置后自动同步线程
LogUtils.d(TAG, "setCurrentConfigBean: 服务配置更新成功");
}
}
}
public NotificationManagerUtils getNotificationManager() {
return mNotificationManager;
}
public NotificationMessage getForegroundNotifyMsg() {
return mForegroundNotifyMsg;
}
public AppConfigBean getCurrentConfigBean() {
return mCurrentConfigBean;
}
public boolean isDestroyed() {
return mIsDestroyed;
}
// ====================== 服务销毁逻辑 - 优化：顺序化释放，避免资源泄漏 ======================
@Override
public void onDestroy() {
super.onDestroy();
LogUtils.d(TAG, "onDestroy: 服务销毁，释放所有资源");
synchronized (mServiceLock) { // 加锁，避免与重启线程操作冲突
isServiceRunning = false;
mIsDestroyed = true;
// 1. 停止前台服务（顺序：先取消通知 → 再移除前台状态）
if (mNotificationManager != null) {
mNotificationManager.cancelForegroundServiceNotify(); // 取消前台通知
}
try {
stopForeground(STOP_FOREGROUND_REMOVE); // 移除前台服务状态（API26+）
LogUtils.d(TAG, "onDestroy: 前台服务状态已移除");
} catch (Exception e) {
LogUtils.e(TAG, "onDestroy: 移除前台状态异常", e);
}
// 2. 安全停止提醒线程（彻底终止，无残留）
stopRemindThreadSafely();
// 3. 销毁Handler（移除所有任务，避免内存泄漏）
if (mServiceHandler != null) {
mServiceHandler.removeCallbacksAndMessages(null);
mServiceHandler = null;
LogUtils.d(TAG, "onDestroy: Handler已销毁");
}
// 4. 释放通知资源（调用工具类释放方法）
if (mNotificationManager != null) {
mNotificationManager.release();
mNotificationManager = null;
LogUtils.d(TAG, "onDestroy: 通知资源已释放");
}
// 5. 置空所有引用，帮助GC回收
mForegroundNotifyMsg = null;
mCurrentConfigBean = null;
}
LogUtils.d(TAG, "onDestroy: 服务销毁完成");
}
@Override
public IBinder onBind(Intent intent) {
return null; // 无需绑定服务
}
// 更新服务配置（对外入口）- 优化：强化兼容性，加异常捕获
/**
* 更新服务配置（对外静态入口，触发线程重启，控制配置从本地读取）
*/
public static void updateStatus(Context context, AppConfigBean configBean) {
if (context == null || configBean == null) return;
LogUtils.d(TAG, "updateStatus: 发送配置更新指令");
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);
@@ -433,10 +678,71 @@ public class ControlCenterService extends Service {
} else {
context.startService(intent);
}
LogUtils.d(TAG, "updateStatus: 配置更新指令发送成功");
LogUtils.d(TAG, "updateStatus: 业务配置更新指令发送成功");
} catch (Exception e) {
LogUtils.e(TAG, "updateStatus: 发送指令异常", e);
}
}
// ================================== Getter/Setter 方法（按需提供，线程安全）=================================
public RemindThread getRemindThread() {
synchronized (mServiceLock) {
return mRemindThread;
}
}
public void setCurrentConfigBean(AppConfigBean configBean) {
LogUtils.d(TAG, "setCurrentConfigBean: 更新服务配置");
if (configBean != null) {
synchronized (mServiceLock) {
this.mCurrentConfigBean = configBean;
syncConfigToRemindThread();
}
LogUtils.d(TAG, "setCurrentConfigBean: 配置更新成功");
} else {
LogUtils.e(TAG, "setCurrentConfigBean: 配置为空，更新失败");
}
}
// 更新服务控制配置（内存+本地持久化同步）
public void setServiceControlBean(ControlCenterServiceBean controlBean) {
LogUtils.d(TAG, "setServiceControlBean: 更新服务控制配置");
if (controlBean != null) {
updateAndSaveServiceControlConfig(controlBean);
} else {
LogUtils.e(TAG, "setServiceControlBean: 控制配置为空，更新失败");
}
}
// 获取服务控制配置（外部查询启用状态）
public ControlCenterServiceBean getServiceControlBean() {
synchronized (mServiceLock) {
return mServiceControlBean;
}
}
public NotificationManagerUtils getNotificationManager() {
synchronized (mServiceLock) {
return mNotificationManager;
}
}
public NotificationMessage getForegroundNotifyMsg() {
synchronized (mServiceLock) {
return mForegroundNotifyMsg;
}
}
public AppConfigBean getCurrentConfigBean() {
synchronized (mServiceLock) {
return mCurrentConfigBean;
}
}
public boolean isDestroyed() {
synchronized (mServiceLock) {
return mIsDestroyed;
}
}
}

33
powerbell/src/main/java/cc/winboll/studio/powerbell/threads/RemindThread.java
View File

@@ -10,7 +10,7 @@ import java.lang.ref.WeakReference;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/12/17 13:38
* @Describe 提醒线程（单例模式）：统一管理充电/耗电提醒逻辑，适配Java7+API30+，保障线程安全与内存安全
* @Describe 提醒线程（单例模式）：统一管理充电/耗电提醒逻辑，适配Java7+API30+，发送提醒时同步携带当前电量+充电状态
*/
public class RemindThread extends Thread {
// ================================== 静态常量（置顶，统一管理魔法值）=================================
@@ -18,7 +18,7 @@ public class RemindThread extends Thread {
private static final long INIT_DELAY_TIME = 500L; // 初始化延迟（ms，等待服务就绪）
private static final int MIN_SLEEP_TIME = 500; // 最小检测间隔（ms，防高频轮询）
private static final int DEFAULT_SLEEP_TIME = 1000; // 默认检测间隔（ms）
private static final long REMIND_INTERVAL = 30000L; // 重复提醒间隔（ms，防骚扰）
private static final long REMIND_INTERVAL = 3000L; // 重复提醒间隔（ms，防骚扰）
private static final int CONFIG_RETRY_MAX = 3; // 配置同步重试次数（兜底）
// ================================== 单例核心（线程安全，避免复用旧实例）=================================
@@ -166,17 +166,17 @@ public class RemindThread extends Thread {
continue;
}
// 充电提醒触发
// 充电提醒触发（新增：携带当前电量+充电状态发送）
if (isCharging && isEnableChargeReminder && quantityOfElectricity >= chargeReminderValue) {
LogUtils.d(TAG, "触发充电提醒：电量" + quantityOfElectricity + "≥阈值" + chargeReminderValue);
sendNotificationMessage("+");
LogUtils.d(TAG, "触发充电提醒：充电中，电量" + quantityOfElectricity + "≥阈值" + chargeReminderValue);
sendNotificationMessage("+", quantityOfElectricity, isCharging);
lastRemindTime = currentTime;
startRemindRecoveryTimer();
}
// 耗电提醒触发
// 耗电提醒触发（新增：携带当前电量+充电状态发送）
else if (!isCharging && isEnableUsageReminder && quantityOfElectricity <= usageReminderValue) {
LogUtils.d(TAG, "触发耗电提醒：电量" + quantityOfElectricity + "≤阈值" + usageReminderValue);
sendNotificationMessage("-");
LogUtils.d(TAG, "触发耗电提醒：未充电，电量" + quantityOfElectricity + "≤阈值" + usageReminderValue);
sendNotificationMessage("-", quantityOfElectricity, isCharging);
lastRemindTime = currentTime;
startRemindRecoveryTimer();
}
@@ -228,10 +228,13 @@ public class RemindThread extends Thread {
}
/**
* 发送提醒消息（弱引用Handler+Message复用，防泄漏）
* 发送提醒消息（新增：携带当前电量+充电状态，弱引用Handler+Message复用，防泄漏）
* @param type 提醒类型（+：充电提醒，-：耗电提醒）
* @param battery 当前电量（0-100）
* @param isCharging 当前充电状态（true=充电中）
*/
private void sendNotificationMessage(String content) {
LogUtils.d(TAG, "准备发送提醒消息：" + content);
private void sendNotificationMessage(String type, int battery, boolean isCharging) {
LogUtils.d(TAG, "准备发送提醒消息：类型=" + type + "，电量=" + battery + "，充电状态=" + isCharging);
if (isExist || !isReminding) {
LogUtils.d(TAG, "线程退出/提醒关闭，跳过发送");
return;
@@ -243,10 +246,14 @@ public class RemindThread extends Thread {
return;
}
Message message = Message.obtain(handler, ControlCenterServiceHandler.MSG_REMIND_TEXT, content);
// 构建消息：what=提醒标识，obj=类型，arg1=当前电量，arg2=充电状态（0=未充电，1=充电中）
Message message = Message.obtain(handler, ControlCenterServiceHandler.MSG_REMIND_TEXT);
message.obj = type;
message.arg1 = battery;
message.arg2 = isCharging ? 1 : 0; // boolean转int（Message无boolean参数，兼容Java7）
try {
handler.sendMessage(message);
LogUtils.d(TAG, "提醒消息发送成功");
LogUtils.d(TAG, "提醒消息发送成功：类型=" + type + "，电量=" + battery + "，充电状态=" + isCharging);
} catch (Exception e) {
LogUtils.e(TAG, "消息发送异常", e);
if (message != null) message.recycle();