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 14:01:57 +08:00
parent 29b9f3c82b
commit 740ab932a4
1 changed files with 126 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

232
powerbell/src/main/java/cc/winboll/studio/powerbell/utils/AppConfigUtils.java
View File

@@ -2,7 +2,6 @@ package cc.winboll.studio.powerbell.utils;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.powerbell.App;
import cc.winboll.studio.powerbell.MainActivity;
@@ -12,8 +11,10 @@ import cc.winboll.studio.powerbell.models.ControlCenterServiceBean;
import cc.winboll.studio.powerbell.services.ControlCenterService;
/**
* 应用配置工具类：管理应用核心配置（服务开关、电池提醒阈值、背景设置等）
* 适配：Java7 | API29-30 | 小米手机，单例模式，线程安全，配置持久化
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/12/17 13:59
* @Describe 应用配置工具类：管理应用核心配置（服务开关、电池提醒阈值、背景设置等）
* 适配：Java7 | API30 | 小米手机，单例模式，线程安全，配置持久化
*/
public class AppConfigUtils {
// ======================== 静态常量（顶部统一管理，抽离魔法值）========================
@@ -22,29 +23,30 @@ public class AppConfigUtils {
private static final int MIN_REMINDER_VALUE = 0; // 提醒阈值最小值
private static final int MAX_REMINDER_VALUE = 100; // 提醒阈值最大值
private static final int MIN_INTERVAL_TIME = 1000; // 最小提醒间隔（ms）
private static final int MIN_DETECT_INTERVAL = 500; // 最小电量检测间隔（ms）
private static final String CONFIRM_TITLE = "配置变更确认";
private static final String CONFIRM_MSG = "是否确认更改该配置？";
private static final String SAVE_ALL_CONFIRM_MSG = "是否保存当前所有配置？";
// ======================== 静态成员（单例实例，严格控制初始化）========================
private static AppConfigUtils sInstance; // 单例实例（私有，禁止外部直接创建）
// ======================== 成员属性（按功能分类，volatile保障线程安全）========================
// 核心依赖（优先排列，final避免空指针）
private final Context mContext;
private App mApplication;
// ======================== 核心依赖属性（优先排列，final保障安全）========================
private final Context mContext; // 应用上下文（避免内存泄漏）
private App mApplication; // 应用Application实例
// 配置Bean（持久化存储核心）
public volatile AppConfigBean mAppConfigBean;
private volatile ControlCenterServiceBean mServiceConfigBean;
// ======================== 配置Bean属性（持久化核心，volatile保障线程安全）========================
public volatile AppConfigBean mAppConfigBean; // 应用配置Bean
private volatile ControlCenterServiceBean mServiceConfigBean; // 服务配置Bean
// ======================== 缓存状态属性（减少Bean读取次数，提升性能）========================
private volatile boolean mIsServiceEnabled = false; // 服务开关缓存状态
// 缓存状态（减少Bean读取次数，提升性能）
private volatile boolean mIsServiceEnabled = false;
// ======================== 单例构造方法（私有，禁止外部实例化）========================
private AppConfigUtils(Context context) {
LogUtils.d(TAG, "初始化配置工具类");
this.mContext = context.getApplicationContext(); // 取应用上下文，避免Activity内存泄漏
// 初始化Application实例（补全：之前未赋值）
this.mContext = context.getApplicationContext(); // 强制取应用上下文，杜绝内存泄漏
this.mApplication = (App) context.getApplicationContext();
// 初始化配置Bean
mAppConfigBean = new AppConfigBean();
@@ -54,62 +56,62 @@ public class AppConfigUtils {
LogUtils.d(TAG, "配置工具类初始化完成");
}
// ======================== 单例获取方法（双重校验锁，线程安全）========================
// ======================== 单例获取方法（双重校验锁，线程安全，适配多线程）========================
public static AppConfigUtils getInstance(Context context) {
if (context == null) {
LogUtils.e(TAG, "获取实例失败：Context不能为空");
LogUtils.e(TAG, "getInstance: Context不能为空，获取实例失败");
throw new IllegalArgumentException("Context cannot be null");
}
// 双重校验锁，适配多线程并发场景
if (sInstance == null) {
synchronized (AppConfigUtils.class) {
if (sInstance == null) {
sInstance = new AppConfigUtils(context);
LogUtils.d(TAG, "getInstance: 单例实例创建成功");
}
}
}
return sInstance;
}
// ======================== 核心配置读写方法（优先排列，保障配置稳定性）========================
// ======================== 核心配置加载/保存方法（内部核心逻辑，优先排列）========================
/**
* 加载所有配置（应用配置+服务配置，统一入口）
* 加载所有配置（应用配置+服务配置，统一入口，初始化/重载通用）
*/
private void loadAllConfig() {
LogUtils.d(TAG, "开始加载所有配置");
// 加载应用配置（补全：BaseBean 通用持久化逻辑，适配序列化存储）
LogUtils.d(TAG, "loadAllConfig: 开始加载所有配置");
// 加载应用配置
AppConfigBean savedAppBean = (AppConfigBean) AppConfigBean.loadBean(mContext, AppConfigBean.class);
if (savedAppBean != null) {
mAppConfigBean = savedAppBean;
LogUtils.d(TAG, "应用配置加载成功");
LogUtils.d(TAG, "loadAllConfig: 应用配置加载成功");
} else {
AppConfigBean.saveBean(mContext, mAppConfigBean);
LogUtils.d(TAG, "无已保存应用配置，使用默认值并持久化");
LogUtils.d(TAG, "loadAllConfig: 无已保存应用配置，使用默认值并持久化");
}
// 加载服务配置（补全：BaseBean 通用持久化逻辑）
// 加载服务配置
ControlCenterServiceBean savedServiceBean = (ControlCenterServiceBean) ControlCenterServiceBean.loadBean(mContext, ControlCenterServiceBean.class);
if (savedServiceBean != null) {
mServiceConfigBean = savedServiceBean;
mIsServiceEnabled = savedServiceBean.isEnableService();
LogUtils.d(TAG, "服务配置加载成功，服务状态：" + (mIsServiceEnabled ? "开启" : "关闭"));
LogUtils.d(TAG, "loadAllConfig: 服务配置加载成功，服务状态：" + (mIsServiceEnabled ? "开启" : "关闭"));
} else {
ControlCenterServiceBean.saveBean(mContext, mServiceConfigBean);
mIsServiceEnabled = false;
LogUtils.d(TAG, "无已保存服务配置，使用默认值并持久化");
LogUtils.d(TAG, "loadAllConfig: 无已保存服务配置，使用默认值并持久化");
}
}
/**
* 保存应用配置（内部核心方法，无弹窗，直接持久化）
* 保存应用配置（内部核心方法，无弹窗，直接持久化，同步通知服务+Activity）
*/
private void saveAppConfig() {
// 补全：BaseBean 通用保存逻辑，传入Bean类名作为存储Key
AppConfigBean.saveBean(mContext, mAppConfigBean);
// 通知服务和Activity更新配置（补全：ControlCenterService 新增 updateStatus 静态方法）
// 通知服务和Activity更新配置（适配API30服务通信规范）
ControlCenterService.updateStatus(mContext, mAppConfigBean);
MainActivity.reloadAppConfig();
LogUtils.d(TAG, "应用配置保存成功，已通知服务和Activity更新");
LogUtils.d(TAG, "saveAppConfig: 应用配置保存成功，已同步服务和Activity");
}
/**
@@ -117,60 +119,60 @@ public class AppConfigUtils {
*/
private void saveServiceConfig() {
mServiceConfigBean.setIsEnableService(mIsServiceEnabled);
// 补全：BaseBean 通用保存逻辑
ControlCenterServiceBean.saveBean(mContext, mServiceConfigBean);
LogUtils.d(TAG, "服务配置保存成功，服务状态：" + (mIsServiceEnabled ? "开启" : "关闭"));
LogUtils.d(TAG, "saveServiceConfig: 服务配置保存成功，服务状态：" + (mIsServiceEnabled ? "开启" : "关闭"));
}
// ======================== 通用确认弹窗方法（抽取复用，减少冗余）========================
// ======================== 通用工具方法（抽取复用，减少冗余）========================
/**
* 配置变更确认弹窗（所有配置修改统一调用）
* 配置变更确认弹窗（所有配置修改统一调用，适配API30对话框规范）
* @param activity 宿主Activity（非空校验）
* @param confirmAction 确认后执行的逻辑
*/
private void showConfigConfirmDialog(Activity activity, final Runnable confirmAction) {
if (activity == null || activity.isFinishing()) {
// 兼容Java7：Activity.isDestroyed() 是API17+方法，直接判断isFinishing()即可，避免API兼容问题
LogUtils.e(TAG, "弹窗显示失败：Activity无效");
LogUtils.e(TAG, "showConfigConfirmDialog: Activity无效，弹窗显示失败");
return;
}
YesNoAlertDialog.show(activity, CONFIRM_TITLE, CONFIRM_MSG, new YesNoAlertDialog.OnDialogResultListener() {
@Override
public void onYes() {
LogUtils.d(TAG, "用户确认更改配置");
confirmAction.run(); // 执行确认后的配置变更逻辑
LogUtils.d(TAG, "showConfigConfirmDialog: 用户确认配置变更");
confirmAction.run();
}
@Override
public void onNo() {
LogUtils.d(TAG, "用户取消更改配置");
// 取消后刷新配置显示，保持界面与实际配置一致
LogUtils.d(TAG, "showConfigConfirmDialog: 用户取消配置变更，刷新配置显示");
MainActivity.reloadAppConfig();
}
});
}
// ======================== 服务开关配置方法（单独归类，逻辑聚焦）========================
/**
* 设置服务开关状态（带弹窗确认，适配小米手机交互规范）
* 设置服务开关状态（带弹窗确认，适配API30后台服务启停规范）
* @param activity 宿主Activity
* @param isEnabled 目标状态（true=开启，false=关闭）
*/
public void setServiceEnabled(Activity activity, final boolean isEnabled) {
// 状态无变化，直接返回
if (isEnabled == mIsServiceEnabled) {
LogUtils.d(TAG, "服务状态无变化，无需操作");
LogUtils.d(TAG, "setServiceEnabled: 服务状态无变化，无需操作");
return;
}
// 调用通用确认弹窗
showConfigConfirmDialog(activity, new Runnable() {
@Override
public void run() {
mIsServiceEnabled = isEnabled;
saveServiceConfig();
// 启停服务（适配API29-30后台服务规范）
// 启停服务（适配API30后台服务限制）
if (mIsServiceEnabled) {
LogUtils.d(TAG, "启动ControlCenterService");
LogUtils.d(TAG, "setServiceEnabled: 启动ControlCenterService");
ControlCenterService.startControlCenterService(mContext);
} else {
LogUtils.d(TAG, "停止ControlCenterService");
LogUtils.d(TAG, "setServiceEnabled: 停止ControlCenterService");
ControlCenterService.stopControlCenterService(mContext);
}
}
@@ -179,213 +181,230 @@ public class AppConfigUtils {
/**
* 获取服务开关状态（直接返回缓存值，提升性能）
* @return 服务状态（true=开启，false=关闭）
*/
public boolean isServiceEnabled() {
LogUtils.d(TAG, "获取服务状态：" + (mIsServiceEnabled ? "开启" : "关闭"));
LogUtils.d(TAG, "isServiceEnabled: 获取服务状态=" + (mIsServiceEnabled ? "开启" : "关闭"));
return mIsServiceEnabled;
}
// ======================== 充电提醒配置方法（单独归类，逻辑聚焦）========================
/**
* 设置充电提醒开关状态（带弹窗确认）
* @param activity 宿主Activity
* @param isEnabled 目标状态（true=开启，false=关闭）
*/
public void setChargeReminderEnabled(Activity activity, final boolean isEnabled) {
if (isEnabled == mAppConfigBean.isEnableChargeReminder()) {
LogUtils.d(TAG, "充电提醒状态无变化，无需操作");
LogUtils.d(TAG, "setChargeReminderEnabled: 充电提醒状态无变化，无需操作");
return;
}
showConfigConfirmDialog(activity, new Runnable() {
@Override
public void run() {
mAppConfigBean.setEnableChargeReminder(isEnabled);
saveAppConfig();
LogUtils.d(TAG, "充电提醒状态更新为：" + (isEnabled ? "开启" : "关闭"));
LogUtils.d(TAG, "setChargeReminderEnabled: 充电提醒状态更新为=" + (isEnabled ? "开启" : "关闭"));
}
});
}
/**
* 获取充电提醒开关状态
* @return 充电提醒状态（true=开启，false=关闭）
*/
public boolean isChargeReminderEnabled() {
boolean isEnabled = mAppConfigBean.isEnableChargeReminder();
LogUtils.d(TAG, "获取充电提醒状态：" + (isEnabled ? "开启" : "关闭"));
LogUtils.d(TAG, "isChargeReminderEnabled: 获取充电提醒状态=" + (isEnabled ? "开启" : "关闭"));
return isEnabled;
}
/**
* 设置充电提醒阈值（带弹窗确认，API29-30数据安全适配）
* 设置充电提醒阈值（带弹窗确认，自动校准范围，适配API30数据安全）
* @param activity 宿主Activity
* @param value 目标阈值（自动校准0-100）
*/
public void setChargeReminderValue(Activity activity, final int value) {
// 校准阈值范围，避免异常值
final int calibratedValue = Math.min(Math.max(value, MIN_REMINDER_VALUE), MAX_REMINDER_VALUE);
if (calibratedValue == mAppConfigBean.getChargeReminderValue()) {
LogUtils.d(TAG, "充电提醒阈值无变化，无需操作");
LogUtils.d(TAG, "setChargeReminderValue: 充电提醒阈值无变化，无需操作");
return;
}
showConfigConfirmDialog(activity, new Runnable() {
@Override
public void run() {
mAppConfigBean.setChargeReminderValue(calibratedValue);
saveAppConfig();
LogUtils.d(TAG, "充电提醒阈值更新为：" + calibratedValue + "%");
LogUtils.d(TAG, "setChargeReminderValue: 充电提醒阈值更新为=" + calibratedValue + "%");
}
});
}
/**
* 获取充电提醒阈值
* @return 充电提醒阈值（0-100）
*/
public int getChargeReminderValue() {
int value = mAppConfigBean.getChargeReminderValue();
LogUtils.d(TAG, "获取充电提醒阈值：" + value + "%");
LogUtils.d(TAG, "getChargeReminderValue: 获取充电提醒阈值=" + value + "%");
return value;
}
// ======================== 耗电提醒配置方法（单独归类，逻辑聚焦）========================
/**
* 设置耗电提醒开关状态（带弹窗确认）
* @param activity 宿主Activity
* @param isEnabled 目标状态（true=开启，false=关闭）
*/
public void setUsageReminderEnabled(Activity activity, final boolean isEnabled) {
if (isEnabled == mAppConfigBean.isEnableUsageReminder()) {
LogUtils.d(TAG, "耗电提醒状态无变化，无需操作");
LogUtils.d(TAG, "setUsageReminderEnabled: 耗电提醒状态无变化，无需操作");
return;
}
showConfigConfirmDialog(activity, new Runnable() {
@Override
public void run() {
mAppConfigBean.setEnableUsageReminder(isEnabled);
saveAppConfig();
LogUtils.d(TAG, "耗电提醒状态更新为：" + (isEnabled ? "开启" : "关闭"));
LogUtils.d(TAG, "setUsageReminderEnabled: 耗电提醒状态更新为=" + (isEnabled ? "开启" : "关闭"));
}
});
}
/**
* 获取耗电提醒开关状态
* @return 耗电提醒状态（true=开启，false=关闭）
*/
public boolean isUsageReminderEnabled() {
boolean isEnabled = mAppConfigBean.isEnableUsageReminder();
LogUtils.d(TAG, "获取耗电提醒状态：" + (isEnabled ? "开启" : "关闭"));
LogUtils.d(TAG, "isUsageReminderEnabled: 获取耗电提醒状态=" + (isEnabled ? "开启" : "关闭"));
return isEnabled;
}
/**
* 设置耗电提醒阈值（带弹窗确认，API29-30数据安全适配）
* 设置耗电提醒阈值（带弹窗确认，自动校准范围，适配小米手机电量跳变）
* @param activity 宿主Activity
* @param value 目标阈值（自动校准0-100）
*/
public void setUsageReminderValue(Activity activity, final int value) {
// 校准阈值范围，适配小米手机电量跳变场景
final int calibratedValue = Math.min(Math.max(value, MIN_REMINDER_VALUE), MAX_REMINDER_VALUE);
if (calibratedValue == mAppConfigBean.getUsageReminderValue()) {
LogUtils.d(TAG, "耗电提醒阈值无变化，无需操作");
LogUtils.d(TAG, "setUsageReminderValue: 耗电提醒阈值无变化，无需操作");
return;
}
showConfigConfirmDialog(activity, new Runnable() {
@Override
public void run() {
mAppConfigBean.setUsageReminderValue(calibratedValue);
saveAppConfig();
LogUtils.d(TAG, "耗电提醒阈值更新为：" + calibratedValue + "%");
LogUtils.d(TAG, "setUsageReminderValue: 耗电提醒阈值更新为=" + calibratedValue + "%");
}
});
}
/**
* 获取耗电提醒阈值
* @return 耗电提醒阈值（0-100）
*/
public int getUsageReminderValue() {
int value = mAppConfigBean.getUsageReminderValue();
LogUtils.d(TAG, "获取耗电提醒阈值：" + value + "%");
LogUtils.d(TAG, "getUsageReminderValue: 获取耗电提醒阈值=" + value + "%");
return value;
}
// ======================== 实时电池状态配置方法（临时状态，不持久化，无需弹窗）========================
// ======================== 实时电池状态配置方法（临时缓存，不持久化，无需弹窗）========================
/**
* 设置当前充电状态（仅内存缓存，不持久化）
* @param isCharging 充电状态（true=充电中，false=未充电）
*/
public void setCharging(boolean isCharging) {
if (isCharging == mAppConfigBean.isCharging()) {
LogUtils.d(TAG, "充电状态无变化，无需操作");
LogUtils.d(TAG, "setCharging: 充电状态无变化，无需操作");
return;
}
mAppConfigBean.setIsCharging(isCharging);
LogUtils.d(TAG, "充电状态更新为：" + (isCharging ? "充电中" : "未充电"));
LogUtils.d(TAG, "setCharging: 充电状态更新为=" + (isCharging ? "充电中" : "未充电"));
}
/**
* 获取当前充电状态
* @return 充电状态（true=充电中，false=未充电）
*/
public boolean isCharging() {
boolean isCharging = mAppConfigBean.isCharging();
LogUtils.d(TAG, "获取充电状态：" + (isCharging ? "充电中" : "未充电"));
LogUtils.d(TAG, "isCharging: 获取充电状态=" + (isCharging ? "充电中" : "未充电"));
return isCharging;
}
/**
* 设置当前电池电量（仅内存缓存，不持久化）
* 设置当前电池电量（仅内存缓存，不持久化，自动校准范围）
* @param value 当前电量（自动校准0-100）
*/
public void setCurrentBatteryValue(int value) {
// 校准电量范围，适配小米手机电量跳变场景
int calibratedValue = Math.min(Math.max(value, MIN_REMINDER_VALUE), MAX_REMINDER_VALUE);
if (calibratedValue == mAppConfigBean.getCurrentBatteryValue()) {
LogUtils.d(TAG, "电池电量无变化，无需操作");
LogUtils.d(TAG, "setCurrentBatteryValue: 电池电量无变化，无需操作");
return;
}
mAppConfigBean.setCurrentBatteryValue(calibratedValue);
LogUtils.d(TAG, "电池电量更新为：" + calibratedValue + "%");
LogUtils.d(TAG, "setCurrentBatteryValue: 电池电量更新为=" + calibratedValue + "%");
}
/**
* 获取当前电池电量
* @return 当前电池电量（0-100）
*/
public int getCurrentBatteryValue() {
int value = mAppConfigBean.getCurrentBatteryValue();
LogUtils.d(TAG, "获取电池电量：" + value + "%");
LogUtils.d(TAG, "getCurrentBatteryValue: 获取电池电量=" + value + "%");
return value;
}
// ======================== 提醒间隔配置方法（持久化存储，带弹窗确认）========================
// ======================== 间隔配置方法（持久化存储，带弹窗确认）========================
/**
* 设置提醒间隔时间（带弹窗确认，单位：ms，最小1000ms）
* 设置提醒间隔时间（带弹窗确认，自动校准最小1000ms）
* @param activity 宿主Activity
* @param interval 目标间隔（单位：ms）
*/
public void setReminderIntervalTime(Activity activity, final int interval) {
final int calibratedInterval = Math.max(interval, MIN_INTERVAL_TIME);
if (calibratedInterval == mAppConfigBean.getReminderIntervalTime()) {
LogUtils.d(TAG, "提醒间隔无变化，无需操作");
LogUtils.d(TAG, "setReminderIntervalTime: 提醒间隔无变化，无需操作");
return;
}
showConfigConfirmDialog(activity, new Runnable() {
@Override
public void run() {
mAppConfigBean.setReminderIntervalTime(calibratedInterval);
saveAppConfig();
LogUtils.d(TAG, "提醒间隔更新为：" + calibratedInterval + "ms");
LogUtils.d(TAG, "setReminderIntervalTime: 提醒间隔更新为=" + calibratedInterval + "ms");
}
});
}
/**
* 获取提醒间隔时间（单位：ms）
* 获取提醒间隔时间
* @return 提醒间隔（单位：ms）
*/
public int getReminderIntervalTime() {
int interval = mAppConfigBean.getReminderIntervalTime();
LogUtils.d(TAG, "获取提醒间隔：" + interval + "ms");
LogUtils.d(TAG, "getReminderIntervalTime: 获取提醒间隔=" + interval + "ms");
return interval;
}
// ======================== 新增：电量检测间隔配置（适配 AppConfigBean 新增字段）========================
/**
* 设置电量检测间隔（带弹窗确认，单位：ms，最小500ms）
* 设置电量检测间隔（带弹窗确认，自动校准最小500ms，与RemindThread同步）
* @param activity 宿主Activity
* @param interval 目标间隔（单位：ms）
*/
public void setBatteryDetectInterval(Activity activity, final int interval) {
final int calibratedInterval = Math.max(interval, 500); // 与 RemindThread MIN_SLEEP_TIME 一致
final int calibratedInterval = Math.max(interval, MIN_DETECT_INTERVAL);
if (calibratedInterval == mAppConfigBean.getBatteryDetectInterval()) {
LogUtils.d(TAG, "检测间隔无变化，无需操作");
LogUtils.d(TAG, "setBatteryDetectInterval: 检测间隔无变化，无需操作");
return;
}
showConfigConfirmDialog(activity, new Runnable() {
@@ -393,40 +412,42 @@ public class AppConfigUtils {
public void run() {
mAppConfigBean.setBatteryDetectInterval(calibratedInterval);
saveAppConfig();
LogUtils.d(TAG, "电量检测间隔更新为：" + calibratedInterval + "ms");
LogUtils.d(TAG, "setBatteryDetectInterval: 电量检测间隔更新为=" + calibratedInterval + "ms");
}
});
}
/**
* 获取电量检测间隔（单位：ms）
* 获取电量检测间隔
* @return 电量检测间隔（单位：ms）
*/
public int getBatteryDetectInterval() {
int interval = mAppConfigBean.getBatteryDetectInterval();
LogUtils.d(TAG, "获取电量检测间隔：" + interval + "ms");
LogUtils.d(TAG, "getBatteryDetectInterval: 获取电量检测间隔=" + interval + "ms");
return interval;
}
// ======================== 外部配置操作入口（带用户确认）========================
// ======================== 外部配置操作入口（带用户确认，供Activity调用）========================
/**
* 保存配置（带弹窗确认，MainActivity专用入口）
* 保存所有配置（带弹窗确认，MainActivity专用入口）
* @param activity MainActivity实例
*/
public void saveConfigWithConfirm(final MainActivity activity) {
if (activity == null || activity.isFinishing()) {
LogUtils.e(TAG, "保存配置失败：Activity无效");
LogUtils.e(TAG, "saveConfigWithConfirm: Activity无效，保存配置失败");
return;
}
YesNoAlertDialog.show(activity, CONFIRM_TITLE, "是否保存当前所有配置？", new YesNoAlertDialog.OnDialogResultListener() {
YesNoAlertDialog.show(activity, CONFIRM_TITLE, SAVE_ALL_CONFIRM_MSG, new YesNoAlertDialog.OnDialogResultListener() {
@Override
public void onYes() {
saveAppConfig();
LogUtils.d(TAG, "用户确认保存所有配置");
LogUtils.d(TAG, "saveConfigWithConfirm: 用户确认保存所有配置");
}
@Override
public void onNo() {
LogUtils.d(TAG, "用户取消保存，重新加载配置");
LogUtils.d(TAG, "saveConfigWithConfirm: 用户取消保存，重新加载配置");
loadAllConfig();
MainActivity.reloadAppConfig();
}
@@ -437,20 +458,19 @@ public class AppConfigUtils {
* 重新加载所有配置（外部调用，适配手动修改配置场景）
*/
public void reloadAllConfig() {
LogUtils.d(TAG, "开始重新加载所有配置");
LogUtils.d(TAG, "reloadAllConfig: 开始重新加载所有配置");
loadAllConfig();
MainActivity.reloadAppConfig();
LogUtils.d(TAG, "配置重新加载完成");
LogUtils.d(TAG, "reloadAllConfig: 配置重新加载完成");
}
// ======================== 补全：ControlCenterService 新增 updateStatus 静态方法（内部适配）========================
// ======================== 适配辅助类（补全服务更新方法，避免编译报错）========================
/**
* 给 ControlCenterService 补充 updateStatus 静态方法（通知服务更新配置）
* 实际项目中可直接复制到 ControlCenterService 类中，此处为临时补全，避免编译报错
* 辅助类：补全ControlCenterService的updateStatus静态方法适配（实际项目可移至Service类）
*/
public static class ControlCenterServiceHelper {
// 空实现，仅用于编译通过，实际逻辑需在ControlCenterService中实现
}
}