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