diff --git a/contacts/build.properties b/contacts/build.properties
index 9a88b1f..321059e 100644
--- a/contacts/build.properties
+++ b/contacts/build.properties
@@ -1,8 +1,8 @@
#Created by .winboll/winboll_app_build.gradle
-#Sat Dec 13 05:41:14 GMT 2025
+#Sat Dec 13 07:01:07 GMT 2025
stageCount=1
libraryProject=
baseVersion=15.12
publishVersion=15.12.0
-buildCount=99
+buildCount=111
baseBetaVersion=15.12.1
diff --git a/contacts/src/main/AndroidManifest.xml b/contacts/src/main/AndroidManifest.xml
index fffec35..174e272 100644
--- a/contacts/src/main/AndroidManifest.xml
+++ b/contacts/src/main/AndroidManifest.xml
@@ -98,19 +98,22 @@
+ android:exported="false"
+ android:stopWithTask="false"/>
+ android:exported="false"
+ android:stopWithTask="false"/>
+ android:exported="false"
+ android:stopWithTask="false">
+ android:stopWithTask="false">
@@ -137,15 +140,16 @@
+ android:permission="android.permission.BIND_CALL_SCREENING_SERVICE"
+ android:exported="true"
+ android:stopWithTask="false">
-
+
@@ -153,7 +157,8 @@
+ android:exported="true"
+ android:stopWithTask="false">
@@ -167,7 +172,8 @@
-
+
diff --git a/contacts/src/main/java/cc/winboll/studio/contacts/activities/SettingsActivity.java b/contacts/src/main/java/cc/winboll/studio/contacts/activities/SettingsActivity.java
index d6601f7..4ca030b 100644
--- a/contacts/src/main/java/cc/winboll/studio/contacts/activities/SettingsActivity.java
+++ b/contacts/src/main/java/cc/winboll/studio/contacts/activities/SettingsActivity.java
@@ -41,39 +41,38 @@ import java.util.List;
* @Author ZhanGSKen&豆包大模型
* @Date 2025/02/21 05:37:42
* @Describe Contacts 设置页面（完全适配 API 30 + Java 7 语法）
- * 核心优化：1. 移除高版本API依赖 2. Java7规范写法 3. 强化内存泄漏防护 4. 版本判断硬编码
+ * 核心优化：1. 移除高版本API依赖 2. Java7规范写法 3. 强化内存泄漏防护 4. 版本判断硬编码 5. LogUtils统一日志管理
*/
public class SettingsActivity extends WinBollActivity implements IWinBoLLActivity {
- // ====================== 常量定义区 ======================
+ // ====================== 常量定义区（置顶，统一管理） ======================
public static final String TAG = "SettingsActivity";
- // API版本硬编码常量（替代Build.VERSION_CODES，适配API30）
+ // API版本硬编码（替代Build.VERSION_CODES，适配Java7）
private static final int ANDROID_6_API = 23;
- // ====================== 静态控件区 ======================
- static DuInfoTextView _DuInfoTextView;
+ // ====================== 静态成员属性区 ======================
+ private static DuInfoTextView sDuInfoTextView; // 规范命名：静态属性加s前缀
- // ====================== UI控件区 ======================
- private Toolbar mToolbar;
- private Switch swSilent;
- private SeekBar msbVolume;
- private TextView mtvVolume;
- private Switch mswMainService;
- private EditText etDunTotalCount;
- private EditText etDunResumeSecondCount;
- private EditText etDunResumeCount;
- private Switch swIsEnableDun;
- private RecyclerView recyclerView;
- private EditText etBoBullToonURL;
- private EditText etPhone;
+ // ====================== 数据业务属性区 ======================
+ private int mStreamMaxVolume; // 铃音最大音量
+ private int mStreamVolume; // 当前铃音音量
+ private List mRuleList; // 通话规则列表
+ private PhoneConnectRuleAdapter mRuleAdapter; // 规则列表适配器
- // ====================== 数据与业务参数区 ======================
- private int mnStreamMaxVolume;
- private int mnStreamVolume;
- private PhoneConnectRuleAdapter adapter;
- private List ruleList;
+ // ====================== UI控件属性区（统一归类，规范命名） ======================
+ private Toolbar mToolbar; // 顶部工具栏
+ private Switch mSwMainService; // 主服务开关
+ private SeekBar mSbVolume; // 音量调节条
+ private TextView mTvVolume; // 音量显示文本
+ private Switch mSwEnableDun; // 云盾功能开关
+ private EditText mEtDunTotalCount; // 云盾总次数输入框
+ private EditText mEtDunResumeSecondCount; // 云盾恢复秒数输入框
+ private EditText mEtDunResumeCount; // 云盾恢复次数输入框
+ private RecyclerView mRvRuleList; // 规则列表RecyclerView
+ private EditText mEtBoBullToonUrl; // BoBullToon地址输入框
+ private EditText mEtSearchPhone; // 号码查询输入框
- // ====================== 接口实现区 ======================
+ // ====================== 接口实现区（IWinBoLLActivity规范实现） ======================
@Override
public AppCompatActivity getActivity() {
return this;
@@ -84,25 +83,20 @@ public class SettingsActivity extends WinBollActivity implements IWinBoLLActivit
return TAG;
}
- // ====================== 生命周期函数区 ======================
+ // ====================== 生命周期函数区（按执行顺序排列） ======================
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
- LogUtils.d(TAG, "onCreate: 设置页面开始创建");
+ LogUtils.d(TAG, "onCreate: 设置页面启动");
setContentView(R.layout.activity_settings);
- // 初始化工具栏
- initToolbar();
- // 初始化主服务开关
- initMainServiceSwitch();
- // 初始化铃声音量调节
- initVolumeSeekBar();
- // 初始化规则列表
- initRuleRecyclerView();
- // 初始化云盾设置
- initDunSettings();
- // 初始化BoBullToon相关控件
- initBoBullToonViews();
+ // 初始化核心流程（按优先级执行）
+ initToolbar(); // 工具栏初始化（优先）
+ initMainServiceSwitch();// 主服务开关初始化
+ initVolumeControl(); // 音量控制初始化
+ initRuleRecyclerView(); // 规则列表初始化
+ initDunSettings(); // 云盾设置初始化
+ initBoBullToonViews(); // BoBullToon功能初始化
LogUtils.d(TAG, "onCreate: 设置页面初始化完成");
}
@@ -110,56 +104,70 @@ public class SettingsActivity extends WinBollActivity implements IWinBoLLActivit
@Override
protected void onDestroy() {
super.onDestroy();
- LogUtils.d(TAG, "onDestroy: 设置页面开始销毁");
- // 清空静态引用 + 置空所有控件引用，彻底避免内存泄漏
- _DuInfoTextView = null;
+ LogUtils.d(TAG, "onDestroy: 设置页面销毁");
+ // 内存泄漏防护：清空所有引用（静态+成员+UI）
+ sDuInfoTextView = null;
+ mRuleList = null;
+ mRuleAdapter = null;
mToolbar = null;
- mswMainService = null;
- msbVolume = null;
- mtvVolume = null;
- recyclerView = null;
- adapter = null;
- ruleList = null;
- LogUtils.d(TAG, "onDestroy: 设置页面销毁完成");
+ mSwMainService = null;
+ mSbVolume = null;
+ mTvVolume = null;
+ mSwEnableDun = null;
+ mEtDunTotalCount = null;
+ mEtDunResumeSecondCount = null;
+ mEtDunResumeCount = null;
+ mRvRuleList = null;
+ mEtBoBullToonUrl = null;
+ mEtSearchPhone = null;
+ LogUtils.d(TAG, "onDestroy: 设置页面资源清理完成");
}
- // ====================== 控件初始化函数区 ======================
+ // ====================== 初始化函数区（按功能模块归类） ======================
+ /**
+ * 初始化顶部工具栏（后退按钮+标题）
+ */
private void initToolbar() {
LogUtils.d(TAG, "initToolbar: 初始化工具栏");
mToolbar = (Toolbar) findViewById(R.id.activitymainToolbar1);
setSupportActionBar(mToolbar);
- // 显示后退按钮（添加空指针防护）
+
+ // 显示后退按钮（空指针防护）
if (getSupportActionBar() != null) {
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
- getSupportActionBar().setSubtitle(getTag());
+ getSupportActionBar().setSubtitle(TAG);
}
- // Java7 匿名内部类实现点击监听，禁止Lambda
+
+ // 后退按钮点击事件（Java7匿名内部类）
mToolbar.setNavigationOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
- LogUtils.d(TAG, "initToolbar: 点击导航栏返回按钮");
+ LogUtils.d(TAG, "initToolbar: 点击后退按钮，关闭页面");
finish();
}
});
}
+ /**
+ * 初始化主服务开关（联动MainService启停）
+ */
private void initMainServiceSwitch() {
LogUtils.d(TAG, "initMainServiceSwitch: 初始化主服务开关");
- mswMainService = (Switch) findViewById(R.id.sw_mainservice);
- MainServiceBean mMainServiceBean = MainServiceBean.loadBean(this, MainServiceBean.class);
- // 空指针防护：避免MainServiceBean为null导致崩溃
- if (mMainServiceBean != null) {
- mswMainService.setChecked(mMainServiceBean.isEnable());
- } else {
- mswMainService.setChecked(false);
- LogUtils.w(TAG, "initMainServiceSwitch: MainServiceBean为null，默认关闭开关");
- }
+ mSwMainService = (Switch) findViewById(R.id.sw_mainservice);
+ MainServiceBean serviceBean = MainServiceBean.loadBean(this, MainServiceBean.class);
- mswMainService.setOnClickListener(new View.OnClickListener() {
+ // 加载开关状态（空指针防护）
+ boolean isServiceEnable = serviceBean != null && serviceBean.isEnable();
+ mSwMainService.setChecked(isServiceEnable);
+ LogUtils.d(TAG, "initMainServiceSwitch: 主服务当前状态：" + (isServiceEnable ? "启用" : "禁用"));
+
+ // 开关点击事件
+ mSwMainService.setOnClickListener(new View.OnClickListener() {
@Override
- public void onClick(View arg0) {
- LogUtils.d(TAG, "initMainServiceSwitch: 主服务开关状态变更，checked=" + mswMainService.isChecked());
- if (mswMainService.isChecked()) {
+ public void onClick(View v) {
+ boolean isChecked = mSwMainService.isChecked();
+ LogUtils.d(TAG, "initMainServiceSwitch: 主服务开关切换：" + (isChecked ? "启用" : "禁用"));
+ if (isChecked) {
MainService.startMainServiceAndSaveStatus(SettingsActivity.this);
} else {
MainService.stopMainServiceAndSaveStatus(SettingsActivity.this);
@@ -168,40 +176,44 @@ public class SettingsActivity extends WinBollActivity implements IWinBoLLActivit
});
}
- private void initVolumeSeekBar() {
- LogUtils.d(TAG, "initVolumeSeekBar: 初始化音量调节条");
- msbVolume = (SeekBar) findViewById(R.id.bellvolume);
- mtvVolume = (TextView) findViewById(R.id.tv_volume);
+ /**
+ * 初始化音量控制（SeekBar+音量显示+配置保存）
+ */
+ private void initVolumeControl() {
+ LogUtils.d(TAG, "initVolumeControl: 初始化音量控制");
+ mSbVolume = (SeekBar) findViewById(R.id.bellvolume);
+ mTvVolume = (TextView) findViewById(R.id.tv_volume);
final AudioManager audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
- // 空指针防护：AudioManager可能为null
+ // 空指针防护：AudioManager获取失败直接返回
if (audioManager == null) {
- LogUtils.e(TAG, "initVolumeSeekBar: AudioManager获取失败，跳过音量初始化");
+ LogUtils.e(TAG, "initVolumeControl: AudioManager获取失败，音量控制初始化失败");
return;
}
- // 设置SeekBar最大值和初始进度
- mnStreamMaxVolume = audioManager.getStreamMaxVolume(AudioManager.STREAM_RING);
- msbVolume.setMax(mnStreamMaxVolume);
- mnStreamVolume = audioManager.getStreamVolume(AudioManager.STREAM_RING);
- msbVolume.setProgress(mnStreamVolume);
- updateStreamVolumeTextView();
+ // 初始化音量参数
+ mStreamMaxVolume = audioManager.getStreamMaxVolume(AudioManager.STREAM_RING);
+ mStreamVolume = audioManager.getStreamVolume(AudioManager.STREAM_RING);
+ mSbVolume.setMax(mStreamMaxVolume);
+ mSbVolume.setProgress(mStreamVolume);
+ updateVolumeDisplay(); // 更新音量文本显示
- // 音量调节监听（Java7匿名内部类）
- msbVolume.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
+ // 音量调节监听
+ mSbVolume.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
@Override
public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
if (fromUser) {
- LogUtils.d(TAG, "initVolumeSeekBar: 音量调节至" + progress);
+ LogUtils.d(TAG, "initVolumeControl: 音量调节至：" + progress + "/" + mStreamMaxVolume);
+ // 实时更新系统音量+保存配置
audioManager.setStreamVolume(AudioManager.STREAM_RING, progress, 0);
- RingTongBean bean = RingTongBean.loadBean(SettingsActivity.this, RingTongBean.class);
- if (bean == null) {
- bean = new RingTongBean();
+ RingTongBean ringBean = RingTongBean.loadBean(SettingsActivity.this, RingTongBean.class);
+ if (ringBean == null) {
+ ringBean = new RingTongBean();
}
- bean.setStreamVolume(progress);
- RingTongBean.saveBean(SettingsActivity.this, bean);
- mnStreamVolume = progress;
- updateStreamVolumeTextView();
+ ringBean.setStreamVolume(progress);
+ RingTongBean.saveBean(SettingsActivity.this, ringBean);
+ mStreamVolume = progress;
+ updateVolumeDisplay();
}
}
@@ -213,253 +225,340 @@ public class SettingsActivity extends WinBollActivity implements IWinBoLLActivit
});
}
+ /**
+ * 初始化通话规则列表（加载黑白名单规则）
+ */
private void initRuleRecyclerView() {
LogUtils.d(TAG, "initRuleRecyclerView: 初始化规则列表");
- recyclerView = (RecyclerView) findViewById(R.id.recycler_view);
- recyclerView.setLayoutManager(new LinearLayoutManager(this));
- ruleList = Rules.getInstance(this).getPhoneBlacRuleBeanList();
- adapter = new PhoneConnectRuleAdapter(this, ruleList);
- recyclerView.setAdapter(adapter);
- LogUtils.d(TAG, "initRuleRecyclerView: 规则列表加载完成，共" + ruleList.size() + "条规则");
+ mRvRuleList = (RecyclerView) findViewById(R.id.recycler_view);
+ mRvRuleList.setLayoutManager(new LinearLayoutManager(this));
+
+ // 加载规则数据
+ Rules rules = Rules.getInstance(this);
+ if (rules == null) {
+ LogUtils.e(TAG, "initRuleRecyclerView: Rules实例获取失败，列表初始化失败");
+ return;
+ }
+ mRuleList = rules.getPhoneBlacRuleBeanList();
+ mRuleAdapter = new PhoneConnectRuleAdapter(this, mRuleList);
+ mRvRuleList.setAdapter(mRuleAdapter);
+ LogUtils.d(TAG, "initRuleRecyclerView: 规则列表加载完成，共" + mRuleList.size() + "条规则");
}
+ /**
+ * 初始化云盾设置（参数加载+开关联动）
+ */
private void initDunSettings() {
LogUtils.d(TAG, "initDunSettings: 初始化云盾设置");
- _DuInfoTextView = (DuInfoTextView) findViewById(R.id.tv_DunInfo);
- etDunTotalCount = (EditText) findViewById(R.id.et_DunTotalCount);
- etDunResumeSecondCount = (EditText) findViewById(R.id.et_DunResumeSecondCount);
- etDunResumeCount = (EditText) findViewById(R.id.et_DunResumeCount);
- swIsEnableDun = (Switch) findViewById(R.id.sw_IsEnableDun);
+ sDuInfoTextView = (DuInfoTextView) findViewById(R.id.tv_DunInfo);
+ mSwEnableDun = (Switch) findViewById(R.id.sw_IsEnableDun);
+ mEtDunTotalCount = (EditText) findViewById(R.id.et_DunTotalCount);
+ mEtDunResumeSecondCount = (EditText) findViewById(R.id.et_DunResumeSecondCount);
+ mEtDunResumeCount = (EditText) findViewById(R.id.et_DunResumeCount);
- SettingsBean settingsModel = Rules.getInstance(this).getSettingsModel();
- // 空指针防护：避免SettingsModel为null
- if (settingsModel != null) {
- etDunTotalCount.setText(Integer.toString(settingsModel.getDunTotalCount()));
- etDunResumeSecondCount.setText(Integer.toString(settingsModel.getDunResumeSecondCount()));
- etDunResumeCount.setText(Integer.toString(settingsModel.getDunResumeCount()));
- swIsEnableDun.setChecked(settingsModel.isEnableDun());
-
- boolean isEnableDun = settingsModel.isEnableDun();
- etDunTotalCount.setEnabled(!isEnableDun);
- etDunResumeSecondCount.setEnabled(!isEnableDun);
- etDunResumeCount.setEnabled(!isEnableDun);
- } else {
- LogUtils.e(TAG, "initDunSettings: SettingsModel为null，云盾设置初始化失败");
- }
- }
-
- private void initBoBullToonViews() {
- LogUtils.d(TAG, "initBoBullToonViews: 初始化BoBullToon相关控件");
- etBoBullToonURL = (EditText) findViewById(R.id.bobulltoonurl_et);
- etPhone = (EditText) findViewById(R.id.activitysettingsEditText1);
- // 空指针防护：避免Rules.getInstance返回null
+ // 加载云盾配置
Rules rules = Rules.getInstance(this);
- if (rules != null) {
- etBoBullToonURL.setText(rules.getBoBullToonURL());
+ if (rules == null) {
+ LogUtils.e(TAG, "initDunSettings: Rules实例获取失败，云盾初始化失败");
+ return;
}
- }
-
- // ====================== 工具函数区 ======================
- private void updateStreamVolumeTextView() {
- // Java7 字符串拼接，避免String.format可能的空指针
- mtvVolume.setText(mnStreamVolume + "/" + mnStreamMaxVolume);
- }
-
- // ====================== 静态通知函数区 ======================
- public static void notifyDunInfoUpdate() {
- if (_DuInfoTextView != null) {
- LogUtils.d(TAG, "notifyDunInfoUpdate: 更新云盾信息展示");
- _DuInfoTextView.notifyInfoUpdate();
- } else {
- LogUtils.w(TAG, "notifyDunInfoUpdate: 云盾信息控件为空，跳过更新");
- }
- }
-
- // ====================== 点击事件回调函数区 ======================
- public void onSW_IsEnableDun(View view) {
- LogUtils.d(TAG, "onSW_IsEnableDun: 云盾开关状态变更，checked=" + swIsEnableDun.isChecked());
- boolean isEnableDun = swIsEnableDun.isChecked();
- etDunTotalCount.setEnabled(!isEnableDun);
- etDunResumeSecondCount.setEnabled(!isEnableDun);
- etDunResumeCount.setEnabled(!isEnableDun);
-
- SettingsBean settingsModel = Rules.getInstance(this).getSettingsModel();
- // 空指针防护：SettingsModel为null时直接返回
- if (settingsModel == null) {
- LogUtils.e(TAG, "onSW_IsEnableDun: SettingsModel为null，操作失败");
- swIsEnableDun.setChecked(false);
+ SettingsBean dunSettings = rules.getSettingsModel();
+ if (dunSettings == null) {
+ LogUtils.e(TAG, "initDunSettings: 云盾配置获取失败");
return;
}
- if (isEnableDun) {
+ // 填充配置参数
+ mEtDunTotalCount.setText(String.valueOf(dunSettings.getDunTotalCount()));
+ mEtDunResumeSecondCount.setText(String.valueOf(dunSettings.getDunResumeSecondCount()));
+ mEtDunResumeCount.setText(String.valueOf(dunSettings.getDunResumeCount()));
+ mSwEnableDun.setChecked(dunSettings.isEnableDun());
+
+ // 开关联动：启用云盾时禁用参数编辑
+ boolean isDunEnable = dunSettings.isEnableDun();
+ mEtDunTotalCount.setEnabled(!isDunEnable);
+ mEtDunResumeSecondCount.setEnabled(!isDunEnable);
+ mEtDunResumeCount.setEnabled(!isDunEnable);
+ LogUtils.d(TAG, "initDunSettings: 云盾当前状态：" + (isDunEnable ? "启用" : "禁用"));
+ }
+
+ /**
+ * 初始化BoBullToon功能（地址配置+号码查询）
+ */
+ private void initBoBullToonViews() {
+ LogUtils.d(TAG, "initBoBullToonViews: 初始化BoBullToon功能");
+ mEtBoBullToonUrl = (EditText) findViewById(R.id.bobulltoonurl_et);
+ mEtSearchPhone = (EditText) findViewById(R.id.activitysettingsEditText1);
+
+ // 加载保存的地址
+ Rules rules = Rules.getInstance(this);
+ if (rules != null) {
+ mEtBoBullToonUrl.setText(rules.getBoBullToonURL());
+ LogUtils.d(TAG, "initBoBullToonViews: 加载BoBullToon地址完成");
+ } else {
+ LogUtils.e(TAG, "initBoBullToonViews: Rules实例获取失败，地址加载失败");
+ }
+ }
+
+ // ====================== 点击事件回调区（按功能模块归类） ======================
+ /**
+ * 云盾开关点击事件（联动参数编辑权限+配置保存）
+ */
+ public void onSW_IsEnableDun(View view) {
+ boolean isChecked = mSwEnableDun.isChecked();
+ LogUtils.d(TAG, "onSW_IsEnableDun: 云盾开关切换：" + (isChecked ? "启用" : "禁用"));
+
+ // 联动参数编辑权限
+ mEtDunTotalCount.setEnabled(!isChecked);
+ mEtDunResumeSecondCount.setEnabled(!isChecked);
+ mEtDunResumeCount.setEnabled(!isChecked);
+
+ // 保存配置
+ Rules rules = Rules.getInstance(this);
+ if (rules == null) {
+ LogUtils.e(TAG, "onSW_IsEnableDun: Rules实例获取失败，配置保存失败");
+ mSwEnableDun.setChecked(false);
+ return;
+ }
+ SettingsBean dunSettings = rules.getSettingsModel();
+ if (dunSettings == null) {
+ LogUtils.e(TAG, "onSW_IsEnableDun: 云盾配置获取失败，保存失败");
+ mSwEnableDun.setChecked(false);
+ return;
+ }
+
+ // 启用云盾时校验参数合法性
+ if (isChecked) {
try {
- String totalCountStr = etDunTotalCount.getText().toString().trim();
- String resumeSecondStr = etDunResumeSecondCount.getText().toString().trim();
- String resumeCountStr = etDunResumeCount.getText().toString().trim();
- // 空字符串校验
- if (totalCountStr.isEmpty() || resumeSecondStr.isEmpty() || resumeCountStr.isEmpty()) {
+ String totalCountStr = mEtDunTotalCount.getText().toString().trim();
+ String resumeSecStr = mEtDunResumeSecondCount.getText().toString().trim();
+ String resumeCountStr = mEtDunResumeCount.getText().toString().trim();
+
+ // 空参数校验
+ if (totalCountStr.isEmpty() || resumeSecStr.isEmpty() || resumeCountStr.isEmpty()) {
throw new NumberFormatException("参数不能为空");
}
+
+ // 转换参数并保存
int totalCount = Integer.parseInt(totalCountStr);
- int resumeSecond = Integer.parseInt(resumeSecondStr);
+ int resumeSec = Integer.parseInt(resumeSecStr);
int resumeCount = Integer.parseInt(resumeCountStr);
- settingsModel.setDunTotalCount(totalCount);
- settingsModel.setDunResumeSecondCount(resumeSecond);
- settingsModel.setDunResumeCount(resumeCount);
- // Java7 条件判断 + 字符串拼接
- String toastMsg = (totalCount == 1) ? "电话骚扰防御力几乎为0。" : "以下设置将在连拨" + totalCount + "次后接通电话。";
+ dunSettings.setDunTotalCount(totalCount);
+ dunSettings.setDunResumeSecondCount(resumeSec);
+ dunSettings.setDunResumeCount(resumeCount);
+ LogUtils.d(TAG, "onSW_IsEnableDun: 云盾参数保存完成，总次数：" + totalCount + "，恢复秒数：" + resumeSec);
+
+ // 提示信息
+ String toastMsg = totalCount == 1 ? "电话骚扰防御力几乎为0" : "连拨" + totalCount + "次后接通电话";
ToastUtils.show(toastMsg);
- LogUtils.d(TAG, "onSW_IsEnableDun: 云盾参数更新完成，totalCount=" + totalCount);
} catch (NumberFormatException e) {
LogUtils.e(TAG, "onSW_IsEnableDun: 云盾参数格式错误", e);
ToastUtils.show("参数格式错误，请输入整数");
- swIsEnableDun.setChecked(false);
+ mSwEnableDun.setChecked(false);
return;
}
}
- settingsModel.setIsEnableDun(isEnableDun);
- Rules.getInstance(this).saveDun();
- Rules.getInstance(this).reload();
- // 刷新参数显示
- etDunTotalCount.setText(Integer.toString(settingsModel.getDunTotalCount()));
- etDunResumeSecondCount.setText(Integer.toString(settingsModel.getDunResumeSecondCount()));
- etDunResumeCount.setText(Integer.toString(settingsModel.getDunResumeCount()));
- }
-
- public void onUnitTest(View view) {
- LogUtils.d(TAG, "onUnitTest: 点击进入单元测试页面");
- Intent intent = new Intent(this, UnitTestActivity.class);
- startActivity(intent);
+ // 保存开关状态并刷新配置
+ dunSettings.setIsEnableDun(isChecked);
+ rules.saveDun();
+ rules.reload();
+ LogUtils.d(TAG, "onSW_IsEnableDun: 云盾配置保存完成");
}
+ /**
+ * 添加新通话规则（黑白名单）
+ */
public void onAddNewConnectionRule(View view) {
- LogUtils.d(TAG, "onAddNewConnectionRule: 添加新的连接规则");
+ LogUtils.d(TAG, "onAddNewConnectionRule: 添加新通话规则");
Rules rules = Rules.getInstance(this);
- if (rules != null) {
- rules.getPhoneBlacRuleBeanList().add(new PhoneConnectRuleBean());
- rules.saveRules();
- adapter.notifyDataSetChanged();
- } else {
- LogUtils.e(TAG, "onAddNewConnectionRule: Rules实例为null，添加规则失败");
+ if (rules == null) {
+ LogUtils.e(TAG, "onAddNewConnectionRule: Rules实例获取失败，添加失败");
+ return;
}
+ mRuleList.add(new PhoneConnectRuleBean());
+ rules.saveRules();
+ mRuleAdapter.notifyDataSetChanged();
+ LogUtils.d(TAG, "onAddNewConnectionRule: 规则添加完成，当前共" + mRuleList.size() + "条规则");
}
+ /**
+ * 跳转默认电话应用设置
+ */
public void onDefaultPhone(View view) {
- LogUtils.d(TAG, "onDefaultPhone: 跳转到默认电话应用设置");
- Intent intent = new Intent(Settings.ACTION_MANAGE_DEFAULT_APPS_SETTINGS);
- startActivity(intent);
+ LogUtils.d(TAG, "onDefaultPhone: 跳转默认电话应用设置");
+ startActivity(new Intent(Settings.ACTION_MANAGE_DEFAULT_APPS_SETTINGS));
}
+ /**
+ * 悬浮窗权限检查与请求
+ */
public void onCanDrawOverlays(View view) {
LogUtils.d(TAG, "onCanDrawOverlays: 检查悬浮窗权限");
- // 版本判断硬编码（替代Build.VERSION_CODES.M），适配API30
+ // API6.0+校验权限
if (Build.VERSION.SDK_INT >= ANDROID_6_API && !Settings.canDrawOverlays(this)) {
- askForDrawOverlay();
+ LogUtils.d(TAG, "onCanDrawOverlays: 未开启悬浮窗权限，发起请求");
+ showDrawOverlayRequestDialog();
} else {
- ToastUtils.show("悬浮窗已开启");
+ ToastUtils.show("悬浮窗权限已开启");
}
}
+ /**
+ * 清理BoBullToon本地数据
+ */
public void onCleanBoBullToonData(View view) {
LogUtils.d(TAG, "onCleanBoBullToonData: 清理BoBullToon数据");
TomCat tomCat = TomCat.getInstance(this);
if (tomCat != null) {
tomCat.cleanBoBullToon();
ToastUtils.show("BoBullToon数据已清理");
+ LogUtils.d(TAG, "onCleanBoBullToonData: 数据清理完成");
+ } else {
+ LogUtils.e(TAG, "onCleanBoBullToonData: TomCat实例获取失败，清理失败");
}
}
+ /**
+ * 重置BoBullToon默认地址
+ */
public void onResetBoBullToonURL(View view) {
- LogUtils.d(TAG, "onResetBoBullToonURL: 重置BoBullToon URL");
+ LogUtils.d(TAG, "onResetBoBullToonURL: 重置BoBullToon地址");
Rules rules = Rules.getInstance(this);
- if (rules != null) {
- rules.resetDefaultBoBullToonURL();
- etBoBullToonURL.setText(rules.getBoBullToonURL());
- ToastUtils.show("已重置 BoBullToon URL。");
+ if (rules == null) {
+ LogUtils.e(TAG, "onResetBoBullToonURL: Rules实例获取失败，重置失败");
+ return;
}
+ rules.resetDefaultBoBullToonURL();
+ mEtBoBullToonUrl.setText(rules.getBoBullToonURL());
+ ToastUtils.show("BoBullToon地址已重置为默认");
+ LogUtils.d(TAG, "onResetBoBullToonURL: 地址重置完成");
}
+ /**
+ * 下载BoBullToon数据（子线程执行，避免阻塞UI）
+ */
public void onDownloadBoBullToon(View view) {
LogUtils.d(TAG, "onDownloadBoBullToon: 开始下载BoBullToon数据");
Rules rules = Rules.getInstance(this);
if (rules == null) {
- LogUtils.e(TAG, "onDownloadBoBullToon: Rules实例为null，下载失败");
+ LogUtils.e(TAG, "onDownloadBoBullToon: Rules实例获取失败，下载失败");
return;
}
- String inputUrl = etBoBullToonURL.getText().toString().trim();
+
+ // 校验并更新地址
+ String inputUrl = mEtBoBullToonUrl.getText().toString().trim();
String savedUrl = rules.getBoBullToonURL();
if (!inputUrl.equals(savedUrl)) {
rules.setBoBullToonURL(inputUrl);
- LogUtils.d(TAG, "onDownloadBoBullToon: BoBullToon URL已更新为" + inputUrl);
+ LogUtils.d(TAG, "onDownloadBoBullToon: BoBullToon地址更新为：" + inputUrl);
}
+ // 子线程下载（Java7匿名内部类）
final TomCat tomCat = TomCat.getInstance(this);
- // Java7 匿名内部类实现Runnable，禁止Lambda
new Thread(new Runnable() {
@Override
public void run() {
- if (tomCat != null && tomCat.downloadBoBullToon()) {
- LogUtils.d(TAG, "onDownloadBoBullToon: BoBullToon 下载成功");
- // 主线程更新UI（Java7 匿名内部类）
+ boolean downloadSuccess = tomCat != null && tomCat.downloadBoBullToon();
+ if (downloadSuccess) {
+ LogUtils.d(TAG, "onDownloadBoBullToon: 数据下载成功");
+ // 主线程更新UI
runOnUiThread(new Runnable() {
@Override
public void run() {
- ToastUtils.show("BoBullToon download OK!");
+ ToastUtils.show("BoBullToon下载成功");
}
});
+ // 重启主服务+刷新配置
MainService.restartMainService(SettingsActivity.this);
Rules.getInstance(SettingsActivity.this).reload();
} else {
- LogUtils.e(TAG, "onDownloadBoBullToon: BoBullToon 下载失败");
+ LogUtils.e(TAG, "onDownloadBoBullToon: 数据下载失败");
+ runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ ToastUtils.show("BoBullToon下载失败");
+ }
+ });
}
}
}).start();
}
+ /**
+ * 查询号码是否为BoBullToon号码
+ */
public void onSearchBoBullToonPhone(View view) {
- LogUtils.d(TAG, "onSearchBoBullToonPhone: 搜索BoBullToon号码");
- TomCat tomCat = TomCat.getInstance(this);
- String phone = etPhone.getText().toString().trim();
+ LogUtils.d(TAG, "onSearchBoBullToonPhone: 执行号码查询");
+ String phone = mEtSearchPhone.getText().toString().trim();
+ // 空号码校验
if (phone.isEmpty()) {
- ToastUtils.show("请输入要查询的号码");
+ LogUtils.w(TAG, "onSearchBoBullToonPhone: 查询号码为空，取消查询");
+ ToastUtils.show("请输入查询号码");
return;
}
- if (tomCat != null && tomCat.loadPhoneBoBullToon()) {
- boolean isBoBullToon = tomCat.isPhoneBoBullToon(phone);
- String toastMsg = isBoBullToon ? "It is a BoBullToon Phone!" : "Not in BoBullToon.";
- ToastUtils.show(toastMsg);
- LogUtils.d(TAG, "onSearchBoBullToonPhone: 号码" + phone + "查询结果：" + (isBoBullToon ? "是" : "否") + "为BoBullToon号码");
- } else {
- ToastUtils.show("没有下载 BoBullToon。");
+
+ // 执行查询
+ TomCat tomCat = TomCat.getInstance(this);
+ if (tomCat == null || !tomCat.loadPhoneBoBullToon()) {
+ LogUtils.w(TAG, "onSearchBoBullToonPhone: BoBullToon数据未加载，查询失败");
+ ToastUtils.show("请先下载BoBullToon数据");
+ return;
}
+
+ boolean isBoBullToon = tomCat.isPhoneBoBullToon(phone);
+ String resultMsg = isBoBullToon ? "是BoBullToon号码" : "非BoBullToon号码";
+ ToastUtils.show(resultMsg);
+ LogUtils.d(TAG, "onSearchBoBullToonPhone: 号码" + phone + "查询结果：" + resultMsg);
}
+ /**
+ * 跳转单元测试页面
+ */
+ public void onUnitTest(View view) {
+ LogUtils.d(TAG, "onUnitTest: 跳转单元测试页面");
+ startActivity(new Intent(this, UnitTestActivity.class));
+ }
+
+ /**
+ * 跳转关于页面
+ */
public void onAbout(View view) {
- LogUtils.d(TAG, "onAbout: 跳转到关于页面");
+ LogUtils.d(TAG, "onAbout: 跳转关于页面");
WinBoLLActivityManager.getInstance().startWinBoLLActivity(this, AboutActivity.class);
}
+ /**
+ * 跳转日志查看页面
+ */
public void onLogView(View view) {
- LogUtils.d(TAG, "onLogView: 跳转到日志页面");
+ LogUtils.d(TAG, "onLogView: 跳转日志页面");
WinBoLLActivityManager.getInstance().startLogActivity(this);
}
- // ====================== 悬浮窗权限请求函数区 ======================
- private void askForDrawOverlay() {
- LogUtils.d(TAG, "askForDrawOverlay: 弹出悬浮窗权限请求对话框");
- // Java7 匿名内部类实现Dialog监听
- AlertDialog alertDialog = new AlertDialog.Builder(this)
- .setTitle("允许显示悬浮框")
- .setMessage("为了使电话监听服务正常工作，请允许这项权限")
+ // ====================== 工具方法区（通用功能+权限相关） ======================
+ /**
+ * 更新音量显示文本（当前音量/最大音量）
+ */
+ private void updateVolumeDisplay() {
+ mTvVolume.setText(mStreamVolume + "/" + mStreamMaxVolume);
+ }
+
+ /**
+ * 显示悬浮窗权限请求对话框
+ */
+ private void showDrawOverlayRequestDialog() {
+ AlertDialog dialog = new AlertDialog.Builder(this)
+ .setTitle("权限请求")
+ .setMessage("为保证通话监听功能正常，需开启悬浮窗权限")
.setPositiveButton("去设置", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
- openDrawOverlaySettings();
dialog.dismiss();
+ jumpToDrawOverlaySettings();
}
})
- .setNegativeButton("稍后再说", new DialogInterface.OnClickListener() {
+ .setNegativeButton("稍后", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
@@ -467,30 +566,47 @@ public class SettingsActivity extends WinBollActivity implements IWinBoLLActivit
})
.create();
- if (alertDialog.getWindow() != null) {
- alertDialog.getWindow().setFlags(
+ // 解决对话框焦点问题
+ if (dialog.getWindow() != null) {
+ dialog.getWindow().setFlags(
WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE);
}
- alertDialog.show();
+ dialog.show();
}
- private void openDrawOverlaySettings() {
- LogUtils.d(TAG, "openDrawOverlaySettings: 跳转悬浮窗管理设置界面");
- // 版本判断硬编码
- if (Build.VERSION.SDK_INT >= ANDROID_6_API) {
- try {
- Context context = this;
- Class clazz = Settings.class;
- Field field = clazz.getDeclaredField("ACTION_MANAGE_OVERLAY_PERMISSION");
- Intent intent = new Intent(field.get(null).toString());
- intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
- intent.setData(Uri.parse("package:" + context.getPackageName()));
- context.startActivity(intent);
- } catch (Exception e) {
- LogUtils.e(TAG, "openDrawOverlaySettings: 跳转悬浮窗设置失败", e);
- Toast.makeText(this, "请在悬浮窗管理中打开权限", Toast.LENGTH_LONG).show();
- }
+ /**
+ * 跳转悬浮窗权限设置页面（反射适配低版本）
+ */
+ private void jumpToDrawOverlaySettings() {
+ LogUtils.d(TAG, "jumpToDrawOverlaySettings: 跳转悬浮窗权限设置");
+ try {
+ // 反射获取设置页面Action（避免高版本API依赖）
+ Class settingsClazz = Settings.class;
+ Field actionField = settingsClazz.getDeclaredField("ACTION_MANAGE_OVERLAY_PERMISSION");
+ String action = (String) actionField.get(null);
+
+ // 跳转当前应用权限设置页
+ Intent intent = new Intent(action);
+ intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+ intent.setData(Uri.parse("package:" + getPackageName()));
+ startActivity(intent);
+ } catch (Exception e) {
+ LogUtils.e(TAG, "jumpToDrawOverlaySettings: 跳转权限设置失败", e);
+ Toast.makeText(this, "请手动在设置中开启悬浮窗权限", Toast.LENGTH_LONG).show();
+ }
+ }
+
+ // ====================== 静态通知方法区（云盾信息更新） ======================
+ /**
+ * 通知云盾信息刷新（外部调用）
+ */
+ public static void notifyDunInfoUpdate() {
+ if (sDuInfoTextView != null) {
+ LogUtils.d(TAG, "notifyDunInfoUpdate: 刷新云盾信息显示");
+ sDuInfoTextView.notifyInfoUpdate();
+ } else {
+ LogUtils.w(TAG, "notifyDunInfoUpdate: 云盾信息控件未初始化，刷新失败");
}
}
}
diff --git a/contacts/src/main/java/cc/winboll/studio/contacts/listenphonecall/CallListenerService.java b/contacts/src/main/java/cc/winboll/studio/contacts/listenphonecall/CallListenerService.java
index f36a8e7..9230eb4 100644
--- a/contacts/src/main/java/cc/winboll/studio/contacts/listenphonecall/CallListenerService.java
+++ b/contacts/src/main/java/cc/winboll/studio/contacts/listenphonecall/CallListenerService.java
@@ -1,8 +1,5 @@
package cc.winboll.studio.contacts.listenphonecall;
-import android.app.Notification;
-import android.app.NotificationChannel;
-import android.app.NotificationManager;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
@@ -25,253 +22,371 @@ import android.widget.Button;
import android.widget.FrameLayout;
import android.widget.TextView;
import cc.winboll.studio.contacts.R;
+import cc.winboll.studio.contacts.model.MainServiceBean;
import cc.winboll.studio.contacts.phonecallui.PhoneCallActivity;
import cc.winboll.studio.contacts.phonecallui.PhoneCallService;
import cc.winboll.studio.libappbase.LogUtils;
/**
- * 终极优化版：onCreate 仅注册前台服务，其他逻辑延迟初始化，避免阻塞
- * 适配 Java7 + Android API30
+ * @Author ZhanGSKen&豆包大模型
+ * @Describe 通话监听服务（无前台服务），负责监听通话状态、显示通话悬浮窗、跳转通话界面
+ * 严格适配 Java7 语法 + Android API29-30 | 轻量稳定 | 避免内存泄漏
*/
public class CallListenerService extends Service {
- private static final String TAG = "CallListenerService";
- private static final String CHANNEL_ID = "call_listener_channel";
- private static final int NOTIFICATION_ID = 1003;
- private static final int FOREGROUND_SERVICE_TYPE_PHONE_CALL = 0x80;
- private static final int ANDROID_8_API = 26;
- private static final int ANDROID_10_API = 29;
- private static final int ANDROID_19_API = 19;
- // View 与服务相关属性
- private View phoneCallView;
- private TextView tvCallNumber;
- private Button btnOpenApp;
- private WindowManager windowManager;
- private WindowManager.LayoutParams params;
- private PhoneStateListener phoneStateListener;
- private TelephonyManager telephonyManager;
- private String callNumber;
- private boolean hasShown;
- private boolean isCallingIn;
- // 延迟初始化 Handler
- private Handler mDelayHandler;
+ // ====================== 常量定义区（精准适配API29-30，无冗余） ======================
+ public static final String TAG = "CallListenerService";
+ // Android版本常量（仅保留适配必需版本，精简无用定义）
+ private static final int ANDROID_8_API = 26; // 悬浮窗类型适配（API26+必需）
+ private static final int ANDROID_10_API = 29; // API29+ 悬浮窗权限/参数适配
+ private static final int ANDROID_19_API = 19; // 透明状态栏/导航栏适配
+
+ // 延迟初始化参数（让出主线程，避免启动阻塞）
+ private static final long DELAY_INIT_MS = 100L;
+
+ // ====================== 成员属性区（按功能归类，命名规范） ======================
+ // 延迟初始化核心
+ private Handler mDelayHandler; // 延迟处理器（避免onCreate阻塞）
+
+ // 通话监听核心
+ private TelephonyManager mTelephonyManager; // 电话管理器（监听通话状态）
+ private PhoneStateListener mPhoneStateListener;// 通话状态监听回调
+ private String mCallNumber; // 当前通话号码
+ private boolean mIsCallingIn; // 是否为来电（true=来电，false=去电）
+
+ // 悬浮窗核心
+ private WindowManager mWindowManager; // 窗口管理器（添加/移除悬浮窗）
+ private WindowManager.LayoutParams mWindowParams;// 悬浮窗参数配置
+ private View mPhoneCallView; // 通话悬浮窗根视图
+ private TextView mTvCallNumber; // 悬浮窗号码显示控件
+ private Button mBtnOpenApp; // 悬浮窗跳转APP按钮
+ private boolean mHasShown; // 悬浮窗显示状态标记（避免重复操作）
+
+ // ====================== Service生命周期方法区（按执行顺序排列） ======================
@Override
public void onCreate() {
super.onCreate();
- LogUtils.d(TAG, "onCreate: 服务启动，立即注册前台服务");
- // ========== 第一步：无条件优先执行前台服务注册，这是唯一必须同步做的事 ==========
- boolean foregroundSuccess = startForegroundImmediately();
- if (!foregroundSuccess) {
- LogUtils.e(TAG, "onCreate: 前台服务注册失败，直接停止服务");
- stopSelf();
- return;
- }
+ LogUtils.d(TAG, "===== onCreate: 通话监听服务启动 =====");
- // ========== 第二步：所有其他逻辑延迟 100ms 执行，让出主线程，避免阻塞 ==========
- mDelayHandler = new Handler(Looper.getMainLooper());
- mDelayHandler.postDelayed(new Runnable() {
- @Override
- public void run() {
- initDelayedLogic();
- }
- }, 100);
+ // 延迟初始化所有逻辑（让出主线程，避免启动阻塞，提升启动速度）
+ initDelayHandlerAndLogic();
+
+ LogUtils.d(TAG, "===== onCreate: 通话监听服务启动完成 =====");
+ }
+
+ @Override
+ public int onStartCommand(Intent intent, int flags, int startId) {
+ LogUtils.d(TAG, "onStartCommand: 服务被启动，startId=" + startId);
+
+ // 加载服务配置，决定重启策略（启用则自动重启，禁用则默认）
+ MainServiceBean serviceConfig = MainServiceBean.loadBean(this, MainServiceBean.class);
+ int startMode = (serviceConfig != null && serviceConfig.isEnable()) ? START_STICKY : super.onStartCommand(intent, flags, startId);
+ LogUtils.d(TAG, "onStartCommand: 服务启动模式：" + (startMode == START_STICKY ? "START_STICKY（自动重启）" : "默认模式"));
+
+ return startMode;
}
@Override
public IBinder onBind(Intent intent) {
+ LogUtils.d(TAG, "onBind: 服务无需绑定，返回null");
return null;
}
- /**
- * 核心：仅负责前台服务注册，无任何其他逻辑，确保 5 秒内完成
- * @return true 注册成功，false 失败
- */
- private boolean startForegroundImmediately() {
- try {
- Notification notification = createForegroundNotification();
- if (Build.VERSION.SDK_INT >= ANDROID_10_API) {
- startForeground(NOTIFICATION_ID, notification, FOREGROUND_SERVICE_TYPE_PHONE_CALL);
- } else {
- startForeground(NOTIFICATION_ID, notification);
- }
- LogUtils.d(TAG, "startForegroundImmediately: 前台服务注册成功");
- return true;
- } catch (Exception e) {
- LogUtils.e(TAG, "startForegroundImmediately: 注册失败", e);
- return false;
- }
- }
-
- /**
- * 简化通知创建逻辑，只保留必要参数，确保最快创建
- */
- private Notification createForegroundNotification() {
- NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
- // 8.0+ 创建渠道，极简配置
- if (Build.VERSION.SDK_INT >= ANDROID_8_API && manager != null) {
- NotificationChannel channel = new NotificationChannel(
- CHANNEL_ID, "通话监听", NotificationManager.IMPORTANCE_LOW);
- channel.setSound(null, null);
- channel.enableVibration(false);
- manager.createNotificationChannel(channel);
- }
-
- // 通知构建：必须确保小图标存在！！！替换为你项目中真实存在的图标资源
- Notification.Builder builder = new Notification.Builder(this);
- // 重点：这里的 ic_launcher 必须是 res/drawable 下存在的图标，否则通知创建失败
- builder.setSmallIcon(R.drawable.ic_launcher);
- builder.setContentTitle("通话监听");
- builder.setContentText("运行中");
- builder.setPriority(Notification.PRIORITY_LOW);
- if (Build.VERSION.SDK_INT >= ANDROID_8_API) {
- builder.setChannelId(CHANNEL_ID);
- }
- return builder.build();
- }
-
- /**
- * 延迟初始化所有非核心逻辑：电话监听、悬浮窗
- */
- private void initDelayedLogic() {
- LogUtils.d(TAG, "initDelayedLogic: 开始初始化延迟逻辑");
- initPhoneStateListener();
- initPhoneCallView();
- LogUtils.d(TAG, "initDelayedLogic: 延迟逻辑初始化完成");
- }
-
- private void initPhoneStateListener() {
- phoneStateListener = new PhoneStateListener() {
- @Override
- public void onCallStateChanged(int state, String incomingNumber) {
- super.onCallStateChanged(state, incomingNumber);
- callNumber = incomingNumber;
- switch (state) {
- case TelephonyManager.CALL_STATE_IDLE:
- dismiss();
- break;
- case TelephonyManager.CALL_STATE_RINGING:
- isCallingIn = true;
- updateUI();
- show();
- break;
- case TelephonyManager.CALL_STATE_OFFHOOK:
- updateUI();
- show();
- break;
- }
- }
- };
-
- telephonyManager = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
- if (telephonyManager != null) {
- telephonyManager.listen(phoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
- }
- }
-
- private void initPhoneCallView() {
- windowManager = (WindowManager) getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
- if (windowManager == null) {
- return;
- }
-
- int width = windowManager.getDefaultDisplay().getWidth();
- params = new WindowManager.LayoutParams();
- params.gravity = Gravity.CENTER_HORIZONTAL | Gravity.TOP;
- params.width = width;
- params.height = WindowManager.LayoutParams.WRAP_CONTENT;
- params.screenOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
- params.format = PixelFormat.TRANSLUCENT;
-
- if (Build.VERSION.SDK_INT >= ANDROID_8_API) {
- params.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
- } else {
- params.type = WindowManager.LayoutParams.TYPE_PHONE;
- }
-
- params.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;
- if (Build.VERSION.SDK_INT >= ANDROID_19_API) {
- params.flags |= WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS | WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION;
- }
-
- FrameLayout interceptorLayout = new FrameLayout(this) {
- @Override
- public boolean dispatchKeyEvent(KeyEvent event) {
- if (event.getAction() == KeyEvent.ACTION_DOWN && event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
- return true;
- }
- return super.dispatchKeyEvent(event);
- }
- };
-
- phoneCallView = LayoutInflater.from(this).inflate(R.layout.view_phone_call, interceptorLayout);
- tvCallNumber = (TextView) phoneCallView.findViewById(R.id.tv_call_number);
- btnOpenApp = (Button) phoneCallView.findViewById(R.id.btn_open_app);
- btnOpenApp.setOnClickListener(new OnClickListener() {
- @Override
- public void onClick(View v) {
- PhoneCallService.CallType type = isCallingIn ? PhoneCallService.CallType.CALL_IN : PhoneCallService.CallType.CALL_OUT;
- PhoneCallActivity.actionStart(CallListenerService.this, callNumber, type);
- }
- });
- }
-
- private void show() {
- if (!hasShown && phoneCallView != null && windowManager != null) {
- try {
- windowManager.addView(phoneCallView, params);
- hasShown = true;
- } catch (Exception e) {
- LogUtils.e(TAG, "show: 悬浮窗添加失败", e);
- }
- }
- }
-
- private void dismiss() {
- if (hasShown && phoneCallView != null && windowManager != null) {
- try {
- windowManager.removeView(phoneCallView);
- } catch (Exception e) {
- LogUtils.e(TAG, "dismiss: 悬浮窗移除失败", e);
- } finally {
- hasShown = false;
- isCallingIn = false;
- }
- }
- }
-
- private void updateUI() {
- if (tvCallNumber == null) {
- return;
- }
- String formatNumber = formatPhoneNumber(callNumber);
- tvCallNumber.setText(formatNumber);
- int drawableId = isCallingIn ? R.drawable.ic_phone_call_in : R.drawable.ic_phone_call_out;
- tvCallNumber.setCompoundDrawablesWithIntrinsicBounds(null, null, getResources().getDrawable(drawableId), null);
- }
-
- public static String formatPhoneNumber(String phoneNum) {
- if (!TextUtils.isEmpty(phoneNum) && phoneNum.length() == 11) {
- return phoneNum.substring(0, 3) + "-" + phoneNum.substring(3, 7) + "-" + phoneNum.substring(7);
- }
- return phoneNum;
- }
-
@Override
public void onDestroy() {
super.onDestroy();
- dismiss();
- if (telephonyManager != null) {
- telephonyManager.listen(phoneStateListener, PhoneStateListener.LISTEN_NONE);
+ LogUtils.d(TAG, "===== onDestroy: 通话监听服务开始销毁 =====");
+
+ // 全量清理资源，彻底避免内存泄漏
+ dismissFloatWindow(); // 移除悬浮窗
+ unregisterPhoneStateListener();// 注销通话监听
+ clearDelayHandler(); // 清空延迟任务
+ resetAllReferences(); // 置空所有成员属性
+
+ LogUtils.d(TAG, "===== onDestroy: 通话监听服务销毁完成 =====");
+ }
+
+ // ====================== 延迟初始化方法区（非阻塞启动，提升稳定性） ======================
+ /**
+ * 初始化延迟处理器，执行核心逻辑（通话监听+悬浮窗）
+ */
+ private void initDelayHandlerAndLogic() {
+ mDelayHandler = new Handler(Looper.getMainLooper());
+ mDelayHandler.postDelayed(new Runnable() {
+ @Override
+ public void run() {
+ LogUtils.d(TAG, "initDelayHandlerAndLogic: 开始延迟初始化核心逻辑");
+ initPhoneStateListener(); // 初始化通话状态监听
+ initFloatWindow(); // 初始化通话悬浮窗
+ LogUtils.d(TAG, "initDelayHandlerAndLogic: 延迟初始化完成，服务就绪");
+ }
+ }, DELAY_INIT_MS);
+ }
+
+ /**
+ * 初始化通话状态监听（注册TelephonyManager，响应通话状态变化）
+ */
+ private void initPhoneStateListener() {
+ // 1. 创建通话状态监听回调
+ mPhoneStateListener = new PhoneStateListener() {
+ @Override
+ public void onCallStateChanged(int callState, String incomingNumber) {
+ super.onCallStateChanged(callState, incomingNumber);
+ mCallNumber = incomingNumber;
+ LogUtils.d(TAG, "onCallStateChanged: 通话状态变化，状态=" + getCallStateDesc(callState) + "，号码=" + incomingNumber);
+
+ // 响应不同通话状态
+ switch (callState) {
+ case TelephonyManager.CALL_STATE_IDLE:
+ // 通话空闲（挂断/未通话）：隐藏悬浮窗
+ dismissFloatWindow();
+ break;
+ case TelephonyManager.CALL_STATE_RINGING:
+ // 来电响铃：标记来电状态，更新UI并显示悬浮窗
+ mIsCallingIn = true;
+ updateFloatWindowUI();
+ showFloatWindow();
+ break;
+ case TelephonyManager.CALL_STATE_OFFHOOK:
+ // 通话中（接听/拨号）：更新UI并显示悬浮窗
+ updateFloatWindowUI();
+ showFloatWindow();
+ break;
+ }
+ }
+ };
+
+ // 2. 注册通话监听（非空校验，避免崩溃）
+ mTelephonyManager = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
+ if (mTelephonyManager != null) {
+ mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
+ LogUtils.d(TAG, "initPhoneStateListener: 通话状态监听注册成功");
+ } else {
+ LogUtils.e(TAG, "initPhoneStateListener: TelephonyManager获取失败，监听注册失败");
}
+ }
+
+ /**
+ * 初始化通话悬浮窗（配置参数+加载布局+绑定事件，适配API29-30）
+ */
+ private void initFloatWindow() {
+ // 1. 获取窗口管理器（非空校验，避免后续崩溃）
+ mWindowManager = (WindowManager) getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
+ if (mWindowManager == null) {
+ LogUtils.e(TAG, "initFloatWindow: WindowManager获取失败，悬浮窗初始化失败");
+ return;
+ }
+
+ // 2. 配置悬浮窗参数（精准适配API29+，兼容悬浮窗权限）
+ initFloatWindowParams();
+
+ // 3. 加载悬浮窗布局（添加返回键拦截，避免误关闭）
+ FrameLayout keyInterceptorLayout = new FrameLayout(this) {
+ @Override
+ public boolean dispatchKeyEvent(KeyEvent event) {
+ // 拦截返回键，保障通话时悬浮窗正常显示
+ if (event.getAction() == KeyEvent.ACTION_DOWN && event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
+ LogUtils.d(TAG, "dispatchKeyEvent: 拦截悬浮窗返回键事件");
+ return true;
+ }
+ return super.dispatchKeyEvent(event);
+ }
+ };
+ mPhoneCallView = LayoutInflater.from(this).inflate(R.layout.view_phone_call, keyInterceptorLayout);
+
+ // 4. 绑定悬浮窗控件，设置跳转按钮事件
+ bindFloatWindowViews();
+
+ LogUtils.d(TAG, "initFloatWindow: 悬浮窗初始化完成");
+ }
+
+ /**
+ * 配置悬浮窗参数（适配API29+窗口类型，确保正常显示）
+ */
+ private void initFloatWindowParams() {
+ mWindowParams = new WindowManager.LayoutParams();
+ // 窗口位置：顶部居中
+ mWindowParams.gravity = Gravity.CENTER_HORIZONTAL | Gravity.TOP;
+ // 窗口大小：宽度全屏，高度自适应
+ mWindowParams.width = WindowManager.LayoutParams.MATCH_PARENT;
+ mWindowParams.height = WindowManager.LayoutParams.WRAP_CONTENT;
+ // 固定竖屏显示
+ mWindowParams.screenOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
+ // 窗口格式：半透明
+ mWindowParams.format = PixelFormat.TRANSLUCENT;
+
+ // 窗口类型（API29+ 强制用 TYPE_APPLICATION_OVERLAY，需悬浮窗权限）
+ if (Build.VERSION.SDK_INT >= ANDROID_10_API) {
+ mWindowParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
+ LogUtils.d(TAG, "initFloatWindowParams: API29+ 悬浮窗类型=TYPE_APPLICATION_OVERLAY（需开启悬浮窗权限）");
+ } else if (Build.VERSION.SDK_INT >= ANDROID_8_API) {
+ mWindowParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
+ } else {
+ mWindowParams.type = WindowManager.LayoutParams.TYPE_PHONE;
+ }
+
+ // 窗口标志：无焦点（不抢占输入）、全屏布局、兼容透明状态栏/导航栏
+ mWindowParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
+ | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;
+ if (Build.VERSION.SDK_INT >= ANDROID_19_API) {
+ mWindowParams.flags |= WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS
+ | WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION;
+ }
+ }
+
+ /**
+ * 绑定悬浮窗控件，设置跳转通话详情页事件
+ */
+ private void bindFloatWindowViews() {
+ mTvCallNumber = (TextView) mPhoneCallView.findViewById(R.id.tv_call_number);
+ mBtnOpenApp = (Button) mPhoneCallView.findViewById(R.id.btn_open_app);
+
+ // 跳转按钮点击事件
+ mBtnOpenApp.setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ if (TextUtils.isEmpty(mCallNumber)) {
+ LogUtils.w(TAG, "bindFloatWindowViews: 通话号码为空，跳过跳转");
+ return;
+ }
+ LogUtils.d(TAG, "bindFloatWindowViews: 点击跳转通话详情页，号码=" + mCallNumber);
+ PhoneCallService.CallType callType = mIsCallingIn ? PhoneCallService.CallType.CALL_IN : PhoneCallService.CallType.CALL_OUT;
+ PhoneCallActivity.actionStart(CallListenerService.this, mCallNumber, callType);
+ }
+ });
+ }
+
+ // ====================== 悬浮窗功能逻辑区（显示/隐藏/更新UI） ======================
+ /**
+ * 显示通话悬浮窗（避免重复添加，防止窗口泄露）
+ */
+ private void showFloatWindow() {
+ if (!mHasShown && mPhoneCallView != null && mWindowManager != null) {
+ try {
+ mWindowManager.addView(mPhoneCallView, mWindowParams);
+ mHasShown = true;
+ LogUtils.d(TAG, "showFloatWindow: 悬浮窗显示成功");
+ } catch (SecurityException e) {
+ LogUtils.e(TAG, "showFloatWindow: 悬浮窗显示失败（无悬浮窗权限，需引导用户开启）", e);
+ } catch (Exception e) {
+ LogUtils.e(TAG, "showFloatWindow: 悬浮窗显示异常", e);
+ }
+ } else {
+ LogUtils.d(TAG, "showFloatWindow: 悬浮窗已显示/组件未初始化，跳过显示");
+ }
+ }
+
+ /**
+ * 隐藏通话悬浮窗（避免重复移除，防止崩溃）
+ */
+ private void dismissFloatWindow() {
+ if (mHasShown && mPhoneCallView != null && mWindowManager != null) {
+ try {
+ mWindowManager.removeView(mPhoneCallView);
+ LogUtils.d(TAG, "dismissFloatWindow: 悬浮窗隐藏成功");
+ } catch (Exception e) {
+ LogUtils.e(TAG, "dismissFloatWindow: 悬浮窗隐藏异常", e);
+ } finally {
+ mHasShown = false;
+ mIsCallingIn = false; // 重置来电状态标记
+ }
+ } else {
+ LogUtils.d(TAG, "dismissFloatWindow: 悬浮窗已隐藏/组件未初始化，跳过隐藏");
+ }
+ }
+
+ /**
+ * 更新悬浮窗UI（显示格式化号码+通话类型图标）
+ */
+ private void updateFloatWindowUI() {
+ if (mTvCallNumber == null || TextUtils.isEmpty(mCallNumber)) {
+ LogUtils.w(TAG, "updateFloatWindowUI: 控件未初始化/号码为空，更新失败");
+ return;
+ }
+
+ // 格式化11位手机号（3-4-4分隔，提升可读性）
+ String formattedNumber = formatPhoneNumber(mCallNumber);
+ mTvCallNumber.setText(formattedNumber);
+
+ // 设置通话类型图标（来电/去电区分）
+ int iconResId = mIsCallingIn ? R.drawable.ic_phone_call_in : R.drawable.ic_phone_call_out;
+ mTvCallNumber.setCompoundDrawablesWithIntrinsicBounds(
+ null, null, getResources().getDrawable(iconResId), null
+ );
+ LogUtils.d(TAG, "updateFloatWindowUI: 悬浮窗UI更新完成，号码=" + formattedNumber + "，类型=" + (mIsCallingIn ? "来电" : "去电"));
+ }
+
+ // ====================== 资源清理方法区（服务销毁时全量释放） ======================
+ /**
+ * 注销通话状态监听（释放TelephonyManager资源）
+ */
+ private void unregisterPhoneStateListener() {
+ if (mTelephonyManager != null && mPhoneStateListener != null) {
+ mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
+ LogUtils.d(TAG, "unregisterPhoneStateListener: 通话监听已注销");
+ }
+ mTelephonyManager = null;
+ mPhoneStateListener = null;
+ }
+
+ /**
+ * 清空延迟处理器（移除未执行任务，避免内存泄漏）
+ */
+ private void clearDelayHandler() {
if (mDelayHandler != null) {
mDelayHandler.removeCallbacksAndMessages(null);
+ mDelayHandler = null;
+ LogUtils.d(TAG, "clearDelayHandler: 延迟处理器已清空");
+ }
+ }
+
+ /**
+ * 置空所有成员属性（彻底释放引用，避免内存泄漏）
+ */
+ private void resetAllReferences() {
+ mCallNumber = null;
+ mPhoneCallView = null;
+ mWindowParams = null;
+ mWindowManager = null;
+ mTvCallNumber = null;
+ mBtnOpenApp = null;
+ }
+
+ // ====================== 工具方法区（通用辅助功能，独立归类） ======================
+ /**
+ * 格式化手机号（11位手机号：3-4-4分隔，非11位保持原格式）
+ * @param phoneNum 待格式化的手机号
+ * @return 格式化后的号码
+ */
+ public static String formatPhoneNumber(String phoneNum) {
+ if (!TextUtils.isEmpty(phoneNum) && phoneNum.length() == 11) {
+ String formatted = phoneNum.substring(0, 3) + "-"
+ + phoneNum.substring(3, 7) + "-"
+ + phoneNum.substring(7);
+ LogUtils.d(TAG, "formatPhoneNumber: 号码格式化，原=" + phoneNum + "，新=" + formatted);
+ return formatted;
+ }
+ LogUtils.d(TAG, "formatPhoneNumber: 非11位号码，无需格式化，号码=" + phoneNum);
+ return phoneNum;
+ }
+
+ /**
+ * 转换通话状态为文字描述（便于日志查看，快速定位问题）
+ * @param callState 通话状态（TelephonyManager常量）
+ * @return 状态描述文字
+ */
+ private String getCallStateDesc(int callState) {
+ switch (callState) {
+ case TelephonyManager.CALL_STATE_IDLE:
+ return "空闲（挂断/未通话）";
+ case TelephonyManager.CALL_STATE_RINGING:
+ return "响铃（来电）";
+ case TelephonyManager.CALL_STATE_OFFHOOK:
+ return "通话中（接听/拨号）";
+ default:
+ return "未知状态";
}
- // 清空所有引用
- phoneStateListener = null;
- telephonyManager = null;
- windowManager = null;
- phoneCallView = null;
}
}
diff --git a/contacts/src/main/java/cc/winboll/studio/contacts/services/AssistantService.java b/contacts/src/main/java/cc/winboll/studio/contacts/services/AssistantService.java
index 001a427..22930c8 100644
--- a/contacts/src/main/java/cc/winboll/studio/contacts/services/AssistantService.java
+++ b/contacts/src/main/java/cc/winboll/studio/contacts/services/AssistantService.java
@@ -252,12 +252,8 @@ public class AssistantService extends Service {
Intent intent = new Intent(this, MainService.class);
// 根据应用前后台状态选择启动方式（Android 12+ 后台用 startForegroundService）
- if (Build.VERSION.SDK_INT >= ANDROID_12_API) {
- LogUtils.d(TAG, "wakeupAndBindMain: 应用后台，启动主服务为前台服务");
- startForegroundService(intent);
- } else {
- startService(intent);
- }
+ startForegroundService(intent);
+
// BIND_IMPORTANT：提高绑定优先级，主服务被杀时会回调断开
bindService(intent, mMyServiceConnection, Context.BIND_IMPORTANT);
LogUtils.d(TAG, "wakeupAndBindMain: 已启动并绑定主服务 MainService");
diff --git a/contacts/src/main/java/cc/winboll/studio/contacts/services/MainService.java b/contacts/src/main/java/cc/winboll/studio/contacts/services/MainService.java
index c465cff..db08f8e 100644
--- a/contacts/src/main/java/cc/winboll/studio/contacts/services/MainService.java
+++ b/contacts/src/main/java/cc/winboll/studio/contacts/services/MainService.java
@@ -32,68 +32,76 @@ import java.util.TimerTask;
* @Date 2025/02/13 06:56:41
* @Describe 拨号主服务，负责核心业务逻辑、守护进程绑定、铃声音量监控及通话监听启动
* 严格适配 Android API 30 + Java 7 语法规范 | 解决前台服务启动超时崩溃
- * 优化：移除延迟启动，非核心服务直接在 mainService() 中启动
+ * 核心优化：1. 移除延迟启动逻辑 2. 标准化日志管理 3. 强化资源清理 4. 结构分层重构
*/
public class MainService extends Service {
- // ====================== 常量定义区（全硬编码，杜绝高版本 API 依赖） ======================
+
+ // ====================== 常量定义区（全硬编码，无高版本API依赖） ======================
public static final String TAG = "MainService";
public static final int MSG_UPDATE_STATUS = 0;
- // 铃声音量检查定时器参数
- private static final long VOLUME_CHECK_DELAY = 1000L;
- private static final long VOLUME_CHECK_PERIOD = 60000L;
- // 前台服务通知配置
+
+ // 铃声音量监控参数（定时检查+恢复）
+ private static final long VOLUME_CHECK_DELAY = 1000L; // 首次检查延迟1s
+ private static final long VOLUME_CHECK_PERIOD = 60000L; // 后续每60s检查一次
+
+ // 前台服务配置（固定ID+渠道，避免重复创建）
private static final String FOREGROUND_CHANNEL_ID = "main_service_foreground_channel";
private static final int FOREGROUND_NOTIFICATION_ID = 1001;
- // 前台服务类型硬编码：dataSync(0x01) | 替代 Build.VERSION_CODES 高版本常量
- private static final int FOREGROUND_SERVICE_TYPE_DATA_SYNC = 0x00000001;
- // Android 版本常量硬编码 | Java 7 不支持 Build.VERSION_CODES 高版本引用
- private static final int ANDROID_8_API = 26;
- private static final int ANDROID_10_API = 29;
- private static final int ANDROID_12_API = 31;
- // 重试延迟时间（仅保留守护服务重绑定延迟，移除非核心服务延迟）
+ private static final int FOREGROUND_SERVICE_TYPE_DATA_SYNC = 0x00000001; // dataSync类型硬编码
+
+ // Android版本常量（替代Build.VERSION_CODES，适配Java7）
+ private static final int ANDROID_8_API = 26; // Android 8.0
+ private static final int ANDROID_10_API = 29; // Android 10
+ private static final int ANDROID_12_API = 31; // Android 12
+
+ // 守护服务重绑定延迟（仅保留核心重试逻辑）
private static final long RETRY_DELAY_MS = 3000L;
- // ====================== 静态成员变量区 ======================
- private static MainService sMainServiceInstance;
- private static volatile TomCat sTomCatInstance;
+ // ====================== 静态成员属性区（全局共享实例，统一前缀s） ======================
+ private static MainService sMainServiceInstance; // 主服务全局实例
+ private static volatile TomCat sTomCatInstance; // 号码识别核心实例（volatile保证可见性）
- // ====================== 成员变量区 ======================
- private volatile boolean mIsServiceRunning;
- private MainServiceBean mMainServiceBean;
- //private MainServiceThread mMainServiceThread;
- private MainServiceHandler mMainServiceHandler;
- private MyServiceConnection mMyServiceConnection;
- private AssistantService mAssistantService;
- private boolean mIsBound;
- private MainReceiver mMainReceiver;
- private Timer mStreamVolumeCheckTimer;
+ // ====================== 成员属性区（业务+UI+资源，统一前缀m） ======================
+ private volatile boolean mIsServiceRunning; // 服务运行状态标记（volatile防指令重排）
+ private MainServiceBean mMainServiceBean; // 服务配置实体（启用状态存储）
+ private MainServiceHandler mMainServiceHandler; // 服务消息处理器（主线程通信）
+ private MyServiceConnection mServiceConnection; // 守护服务连接实例
+ private AssistantService mAssistantService; // 绑定的守护服务实例
+ private boolean mIsAssistantBound; // 守护服务绑定状态标记
+ private MainReceiver mMainReceiver; // 全局广播接收器（监听系统事件）
+ private Timer mVolumeCheckTimer; // 铃声音量检查定时器（定时恢复配置）
- // ====================== Binder 内部类 ======================
+ // ====================== 内部类：Binder（服务绑定通信，优先定义） ======================
public class MyBinder extends Binder {
+ /**
+ * 外部组件绑定服务时，获取主服务实例
+ * @return MainService 主服务实例
+ */
public MainService getService() {
- LogUtils.d(TAG, "MyBinder.getService: 获取 MainService 实例");
+ LogUtils.d(TAG, "MyBinder.getService: 外部获取主服务实例");
return MainService.this;
}
}
- // ====================== ServiceConnection 内部类 ======================
+ // ====================== 内部类：ServiceConnection（守护服务绑定回调） ======================
private class MyServiceConnection implements ServiceConnection {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
if (service == null) {
- LogUtils.w(TAG, "MyServiceConnection.onServiceConnected: 绑定的 IBinder 为 null");
- mIsBound = false;
+ LogUtils.w(TAG, "MyServiceConnection.onServiceConnected: 绑定的IBinder为空，绑定失败");
+ mIsAssistantBound = false;
return;
}
try {
+ // 类型转换获取守护服务实例
AssistantService.MyBinder binder = (AssistantService.MyBinder) service;
mAssistantService = binder.getService();
- mIsBound = true;
- LogUtils.d(TAG, "MyServiceConnection.onServiceConnected: 守护服务绑定成功 | AssistantService=" + mAssistantService);
+ mIsAssistantBound = true;
+ LogUtils.d(TAG, "MyServiceConnection.onServiceConnected: 守护服务绑定成功");
} catch (ClassCastException e) {
- LogUtils.e(TAG, "MyServiceConnection.onServiceConnected: IBinder 类型转换失败", e);
- mIsBound = false;
+ LogUtils.e(TAG, "MyServiceConnection.onServiceConnected: IBinder类型转换失败", e);
+ mIsAssistantBound = false;
}
}
@@ -101,134 +109,166 @@ public class MainService extends Service {
public void onServiceDisconnected(ComponentName name) {
LogUtils.w(TAG, "MyServiceConnection.onServiceDisconnected: 守护服务连接断开");
mAssistantService = null;
- mIsBound = false;
+ mIsAssistantBound = false;
- // 服务启用则重试绑定
+ // 服务启用状态下，重试绑定守护服务（主服务存活核心保障）
if (mMainServiceBean != null && mMainServiceBean.isEnable()) {
- LogUtils.d(TAG, "MyServiceConnection.onServiceDisconnected: 重新唤醒并绑定守护服务");
+ LogUtils.d(TAG, "MyServiceConnection.onServiceDisconnected: " + RETRY_DELAY_MS + "ms后重试绑定守护服务");
new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
@Override
public void run() {
- wakeupAndBindAssistant();
+ wakeupAndBindAssistantService();
}
}, RETRY_DELAY_MS);
} else {
- LogUtils.w(TAG, "MyServiceConnection.onServiceDisconnected: 服务未启用，跳过重试");
+ LogUtils.w(TAG, "MyServiceConnection.onServiceDisconnected: 主服务已禁用，跳过重试绑定");
}
}
}
- // ====================== 对外静态方法区 ======================
+ // ====================== 对外静态方法区（服务启停/重启/状态查询，全局调用） ======================
+ /**
+ * 检查号码是否在BoBullToon库中（外部组件调用，静态入口）
+ * @param phone 待查询号码
+ * @return true=是BoBullToon号码，false=否/初始化失败
+ */
public static boolean isPhoneInBoBullToon(String phone) {
if (sTomCatInstance != null && phone != null && !phone.isEmpty()) {
- return sTomCatInstance.isPhoneBoBullToon(phone);
+ boolean result = sTomCatInstance.isPhoneBoBullToon(phone);
+ LogUtils.d(TAG, "isPhoneInBoBullToon: 号码" + phone + "查询结果：" + (result ? "是" : "否"));
+ return result;
}
- LogUtils.w(TAG, "isPhoneInBoBullToon: TomCat 未初始化或号码为空");
+ LogUtils.w(TAG, "isPhoneInBoBullToon: TomCat未初始化或号码为空，查询失败");
return false;
}
+ /**
+ * 停止主服务（仅停止，不修改配置）
+ * @param context 上下文（非空校验）
+ */
public static void stopMainService(Context context) {
if (context == null) {
- LogUtils.e(TAG, "stopMainService: Context 为 null，无法执行");
+ LogUtils.e(TAG, "stopMainService: 上下文为空，无法停止服务");
return;
}
LogUtils.d(TAG, "stopMainService: 执行停止主服务操作");
context.stopService(new Intent(context, MainService.class));
}
+ /**
+ * 启动主服务（仅启动，不修改配置）
+ * @param context 上下文（非空校验）
+ */
public static void startMainService(Context context) {
if (context == null) {
- LogUtils.e(TAG, "startMainService: Context 为 null，无法执行");
+ LogUtils.e(TAG, "startMainService: 上下文为空，无法启动服务");
return;
}
- LogUtils.d(TAG, "startMainService: 执行启动主服务操作");
+ LogUtils.d(TAG, "startMainService: 执行启动主服务操作（前台服务模式）");
Intent intent = new Intent(context, MainService.class);
- context.startForegroundService(intent);
+ context.startForegroundService(intent);
}
+ /**
+ * 重启主服务（先停后启，需服务已启用）
+ * @param context 上下文（非空校验）
+ */
public static void restartMainService(Context context) {
if (context == null) {
- LogUtils.e(TAG, "restartMainService: Context 为 null，无法执行");
+ LogUtils.e(TAG, "restartMainService: 上下文为空，无法重启服务");
return;
}
- LogUtils.d(TAG, "restartMainService: 执行重启主服务操作");
+ LogUtils.d(TAG, "restartMainService: 执行主服务重启流程");
- MainServiceBean bean = MainServiceBean.loadBean(context, MainServiceBean.class);
- if (bean != null && bean.isEnable()) {
+ MainServiceBean config = MainServiceBean.loadBean(context, MainServiceBean.class);
+ if (config != null && config.isEnable()) {
stopMainService(context);
startMainService(context);
LogUtils.i(TAG, "restartMainService: 主服务重启完成");
} else {
- LogUtils.w(TAG, "restartMainService: 主服务配置未启用，跳过重启");
+ LogUtils.w(TAG, "restartMainService: 服务未启用或配置为空，跳过重启");
}
}
+ /**
+ * 停止服务并保存禁用状态（更新配置+停止服务）
+ * @param context 上下文（非空校验）
+ */
public static void stopMainServiceAndSaveStatus(Context context) {
if (context == null) {
- LogUtils.e(TAG, "stopMainServiceAndSaveStatus: Context 为 null，无法执行");
+ LogUtils.e(TAG, "stopMainServiceAndSaveStatus: 上下文为空，操作失败");
return;
}
- LogUtils.d(TAG, "stopMainServiceAndSaveStatus: 停止服务并保存禁用状态");
- MainServiceBean bean = new MainServiceBean();
- bean.setIsEnable(false);
- MainServiceBean.saveBean(context, bean);
+ LogUtils.d(TAG, "stopMainServiceAndSaveStatus: 保存禁用状态并停止服务");
+ MainServiceBean config = new MainServiceBean();
+ config.setIsEnable(false);
+ MainServiceBean.saveBean(context, config);
stopMainService(context);
}
+ /**
+ * 启动服务并保存启用状态（更新配置+启动服务，先停后启避免重复）
+ * @param context 上下文（非空校验）
+ */
public static void startMainServiceAndSaveStatus(Context context) {
if (context == null) {
- LogUtils.e(TAG, "startMainServiceAndSaveStatus: Context 为 null，无法执行");
+ LogUtils.e(TAG, "startMainServiceAndSaveStatus: 上下文为空，操作失败");
return;
}
- LogUtils.d(TAG, "startMainServiceAndSaveStatus: 启动服务并保存启用状态");
- MainServiceBean bean = new MainServiceBean();
- bean.setIsEnable(true);
- MainServiceBean.saveBean(context, bean);
- stopMainService(context);
+ LogUtils.d(TAG, "startMainServiceAndSaveStatus: 保存启用状态并启动服务");
+ MainServiceBean config = new MainServiceBean();
+ config.setIsEnable(true);
+ MainServiceBean.saveBean(context, config);
+ stopMainService(context); // 先停止旧服务，避免冲突
startMainService(context);
}
- // ====================== 成员方法区 ======================
+ // ====================== 核心工具方法区（服务状态检查+前台通知创建，通用功能） ======================
/**
- * 补充缺失的 appenMessage 方法
+ * 补充消息追加方法（外部组件向服务发送消息）
+ * @param message 待追加消息（空值防护）
*/
public void appenMessage(String message) {
String msg = message == null ? "null" : message;
- LogUtils.d(TAG, "追加消息: " + msg);
+ LogUtils.d(TAG, "appenMessage: 接收外部消息：" + msg);
if (mMainServiceHandler != null) {
android.os.Message handlerMsg = android.os.Message.obtain();
handlerMsg.what = MSG_UPDATE_STATUS;
handlerMsg.obj = msg;
mMainServiceHandler.sendMessage(handlerMsg);
+ LogUtils.d(TAG, "appenMessage: 消息已发送至Handler处理");
+ } else {
+ LogUtils.w(TAG, "appenMessage: MainServiceHandler未初始化，消息发送失败");
}
}
/**
- * 创建前台服务通知
+ * 创建前台服务通知（Android8.0+需渠道，低版本兼容）
+ * @return Notification 前台服务通知实例
*/
private Notification createForegroundNotification() {
- // 1. 创建通知渠道（Android 8.0+ 必需）
+ // 1. Android8.0+创建通知渠道（必需，否则通知不显示）
if (Build.VERSION.SDK_INT >= ANDROID_8_API) {
NotificationChannel channel = new NotificationChannel(
- FOREGROUND_CHANNEL_ID,
- "拨号主服务",
- NotificationManager.IMPORTANCE_LOW
+ FOREGROUND_CHANNEL_ID,
+ "拨号主服务",
+ NotificationManager.IMPORTANCE_LOW
);
- channel.setDescription("主服务后台运行，保障拨号功能正常");
- channel.setSound(null, null);
- channel.enableVibration(false);
+ channel.setDescription("主服务后台运行，保障通话监听与号码识别功能正常");
+ channel.setSound(null, null); // 关闭通知声音
+ channel.enableVibration(false); // 关闭振动
- NotificationManager manager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
- if (manager != null) {
- manager.createNotificationChannel(channel);
- LogUtils.d(TAG, "createForegroundNotification: 通知渠道创建成功");
+ NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+ if (notificationManager != null) {
+ notificationManager.createNotificationChannel(channel);
+ LogUtils.d(TAG, "createForegroundNotification: Android8.0+通知渠道创建成功");
} else {
- LogUtils.e(TAG, "createForegroundNotification: NotificationManager 获取失败");
+ LogUtils.e(TAG, "createForegroundNotification: NotificationManager获取失败，渠道创建失败");
}
}
- // 2. 构建通知
+ // 2. 构建通知实例（分版本兼容Builder）
Notification.Builder builder;
if (Build.VERSION.SDK_INT >= ANDROID_8_API) {
builder = new Notification.Builder(this, FOREGROUND_CHANNEL_ID);
@@ -237,37 +277,43 @@ public class MainService extends Service {
}
builder.setSmallIcon(R.drawable.ic_launcher);
builder.setContentTitle("拨号服务运行中");
- builder.setContentText("正在后台保障通话监听与号码识别");
- builder.setPriority(Notification.PRIORITY_LOW);
- builder.setOngoing(true);
+ builder.setContentText("后台保障通话监听与号码识别，请勿手动关闭");
+ builder.setPriority(Notification.PRIORITY_LOW); // 低优先级，不打扰用户
+ builder.setOngoing(true); // 不可手动清除，保障服务存活
+ LogUtils.d(TAG, "createForegroundNotification: 前台服务通知构建完成");
return builder.build();
}
/**
- * 检查服务是否正在运行
+ * 检查指定服务是否正在运行（通过ActivityManager查询）
+ * @param serviceClass 待检查服务类
+ * @return true=运行中，false=未运行/查询失败
*/
private boolean isServiceRunning(Class serviceClass) {
if (serviceClass == null) {
- LogUtils.e(TAG, "isServiceRunning: 服务类参数为 null");
+ LogUtils.e(TAG, "isServiceRunning: 服务类为空，检查失败");
return false;
}
- ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
- if (manager == null) {
- LogUtils.w(TAG, "isServiceRunning: ActivityManager 获取失败");
+ ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
+ if (activityManager == null) {
+ LogUtils.w(TAG, "isServiceRunning: ActivityManager获取失败，检查失败");
return false;
}
- for (ActivityManager.RunningServiceInfo info : manager.getRunningServices(Integer.MAX_VALUE)) {
- if (serviceClass.getName().equals(info.service.getClassName())) {
+ // 遍历运行中服务，匹配类名
+ for (ActivityManager.RunningServiceInfo serviceInfo : activityManager.getRunningServices(Integer.MAX_VALUE)) {
+ if (serviceClass.getName().equals(serviceInfo.service.getClassName())) {
+ LogUtils.d(TAG, "isServiceRunning: 服务" + serviceClass.getSimpleName() + "正在运行");
return true;
}
}
+ LogUtils.d(TAG, "isServiceRunning: 服务" + serviceClass.getSimpleName() + "未运行");
return false;
}
- // ====================== Service 生命周期方法区 ======================
+ // ====================== Service生命周期方法区（按执行顺序：创建→绑定→启动→销毁） ======================
@Override
public void onCreate() {
super.onCreate();
@@ -275,74 +321,72 @@ public class MainService extends Service {
sMainServiceInstance = this;
mIsServiceRunning = false;
- // 仅初始化核心组件（移除 mDelayHandler 初始化，无需延迟启动）
+ // 初始化核心组件（无延迟，直接初始化）
mMainServiceBean = MainServiceBean.loadBean(this, MainServiceBean.class);
- mMyServiceConnection = new MyServiceConnection();
+ mServiceConnection = new MyServiceConnection();
mMainServiceHandler = new MainServiceHandler(this);
- // 初始化铃声音量检查定时器
+ // 初始化音量监控定时器（服务启动即开启，保障音量配置）
initVolumeCheckTimer();
- // 启动服务
- mainService();
+ // 执行核心业务启动逻辑（无延迟，优先启动）
+ startCoreBusiness();
- LogUtils.d(TAG, "===== onCreate: 主服务创建完成（仅初始化组件） =====");
+ LogUtils.d(TAG, "===== onCreate: 主服务创建完成 =====");
}
@Override
public IBinder onBind(Intent intent) {
- LogUtils.d(TAG, "onBind: 服务被绑定 | Intent=" + intent);
+ LogUtils.d(TAG, "onBind: 主服务被外部组件绑定，Intent=" + (intent != null ? intent.getAction() : "null"));
return new MyBinder();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
- LogUtils.d(TAG, "onStartCommand: 服务被启动 | startId=" + startId);
- mainService();
- return (mMainServiceBean != null && mMainServiceBean.isEnable()) ? START_STICKY : super.onStartCommand(intent, flags, startId);
+ LogUtils.d(TAG, "onStartCommand: 主服务被启动，startId=" + startId);
+ // 重复启动时再次执行核心业务（避免服务被杀死后重启失败）
+ startCoreBusiness();
+
+ // 服务启用则返回START_STICKY（系统杀死后自动重启），否则默认行为
+ int result = (mMainServiceBean != null && mMainServiceBean.isEnable()) ? START_STICKY : super.onStartCommand(intent, flags, startId);
+ LogUtils.d(TAG, "onStartCommand: 服务启动模式：" + (result == START_STICKY ? "START_STICKY（自动重启）" : "默认模式"));
+ return result;
}
- // ====================== onDestroy：强制全量清理，不改动 Bean 配置 ======================
@Override
public void onDestroy() {
super.onDestroy();
- LogUtils.d(TAG, "===== onDestroy: 主服务开始销毁（强制清理所有资源） =====");
+ LogUtils.d(TAG, "===== onDestroy: 主服务开始销毁，全量清理资源 =====");
- // 2. 释放定时器资源
+ // 1. 停止音量监控定时器（释放线程资源）
cancelVolumeCheckTimer();
- // 3. 强制解除守护服务绑定
- if (mIsBound && mMyServiceConnection != null) {
+ // 2. 解除守护服务绑定（避免内存泄漏）
+ if (mIsAssistantBound && mServiceConnection != null) {
try {
- unbindService(mMyServiceConnection);
- LogUtils.d(TAG, "onDestroy: 解除守护服务绑定成功");
+ unbindService(mServiceConnection);
+ LogUtils.d(TAG, "onDestroy: 守护服务绑定已解除");
} catch (IllegalArgumentException e) {
- LogUtils.w(TAG, "onDestroy: 解除绑定失败，服务未绑定", e);
+ LogUtils.w(TAG, "onDestroy: 解除守护服务绑定失败（服务未绑定）", e);
}
- mIsBound = false;
- mMyServiceConnection = null;
+ mIsAssistantBound = false;
+ mServiceConnection = null;
}
- // 4. 强制注销广播接收器
+ // 3. 注销广播接收器（释放系统资源）
if (mMainReceiver != null) {
mMainReceiver.unregisterAction(this);
mMainReceiver = null;
- LogUtils.d(TAG, "onDestroy: 广播接收器已注销");
+ LogUtils.d(TAG, "onDestroy: 全局广播接收器已注销");
}
- // 5. 强制停止主业务线程
-// if (mMainServiceThread != null) {
-// mMainServiceThread.setIsExit(true);
-// mMainServiceThread = null;
-// }
-
- // 6. 强制停止所有子服务
+ // 4. 停止所有子服务（强制停止，避免子服务残留）
stopService(new Intent(this, AssistantService.class));
stopService(new Intent(this, CallListenerService.class));
stopService(new Intent(this, MyCallScreeningService.class));
LogUtils.d(TAG, "onDestroy: 所有子服务已强制停止");
- // 7. 清空静态实例，避免内存泄漏（不改动 Bean 配置）
+ // 5. 清空所有引用（静态+成员，彻底避免内存泄漏，不修改配置Bean）
sMainServiceInstance = null;
sTomCatInstance = null;
mMainServiceHandler = null;
@@ -351,155 +395,201 @@ public class MainService extends Service {
// 标记服务为未运行
mIsServiceRunning = false;
- LogUtils.d(TAG, "===== onDestroy: 主服务销毁完成（资源全清理，Bean 配置无改动） =====");
+ LogUtils.d(TAG, "===== onDestroy: 主服务销毁完成，资源全清理 =====");
}
- // ====================== 核心业务逻辑：非核心服务直接启动，无延迟 ======================
- private synchronized void mainService() {
- LogUtils.d(TAG, "mainService: 执行核心业务逻辑");
-
- // 第一步：优先判断服务是否已运行，已运行则直接退出（不做任何动作）
- if (!mIsServiceRunning) {
- mIsServiceRunning = true;
- // 第二步：加载最新配置，校验服务是否启用（未启用则退出）
- mMainServiceBean = MainServiceBean.loadBean(this, MainServiceBean.class);
- if (mMainServiceBean == null && mMainServiceBean.isEnable()) {
- // 第三步：配置启用且服务未运行，执行启动流程
- LogUtils.i(TAG, "mainService: 服务未运行且配置已启用，开始启动核心流程");
-
- // 1. 启动前台服务（优先执行，避免超时）
- try {
- Notification foregroundNotification = createForegroundNotification();
- startForeground(FOREGROUND_NOTIFICATION_ID, foregroundNotification, FOREGROUND_SERVICE_TYPE_DATA_SYNC);
- //startForeground(FOREGROUND_NOTIFICATION_ID, foregroundNotification);
- } catch (IllegalArgumentException e) {
- LogUtils.e(TAG, "mainService: 启动前台服务失败，类型不匹配", e);
- mIsServiceRunning = false;
- stopSelf();
- return;
- } catch (Exception e) {
- LogUtils.e(TAG, "mainService: 启动前台服务异常", e);
- mIsServiceRunning = false;
- stopSelf();
- return;
- }
-
- // 2. 绑定守护服务
- wakeupAndBindAssistant();
-
- // 3. 初始化业务组件
- initTomCat();
- initMainReceiver();
- Rules.getInstance(this).loadRules();
- LogUtils.d(TAG, "mainService: 黑白名单规则已加载");
-
- // 4. 直接启动电话监听服务（移除延迟，校验通过则立即启动）
- Intent callListenerIntent = new Intent(this, CallListenerService.class);
- try {
- startForegroundService(callListenerIntent);
- //startService(callListenerIntent);
- } catch (Exception e) {
- LogUtils.e(TAG, "mainService: CallListenerService 启动失败", e);
- }
-
-
- // 5. 直接启动通话筛选服务（API 10+ 生效，无延迟）
- Intent screeningIntent = new Intent(this, MyCallScreeningService.class);
- try {
- startForegroundService(screeningIntent);
- //startService(screeningIntent);
- } catch (Exception e) {
- LogUtils.e(TAG, "mainService: MyCallScreeningService 启动失败", e);
- }
-
- // 6. 启动主业务线程
-// mMainServiceThread = MainServiceThread.getInstance(this, mMainServiceHandler);
-// mMainServiceThread.start();
- LogUtils.i(TAG, "mainService: 核心流程启动完成，主服务正常运行");
- }
- }
- }
-
- private void wakeupAndBindAssistant() {
- if (mMyServiceConnection == null) {
- LogUtils.e(TAG, "wakeupAndBindAssistant: 初始化失败，绑定失败");
+ // ====================== 核心业务逻辑区（服务启动核心流程，无延迟） ======================
+ /**
+ * 启动核心业务（主服务核心入口，避免重复启动）
+ */
+ private synchronized void startCoreBusiness() {
+ // 服务已运行则直接返回，避免重复执行启动流程
+ if (mIsServiceRunning) {
+ LogUtils.d(TAG, "startCoreBusiness: 主服务已运行，跳过重复启动");
return;
}
- Intent intent = new Intent(this, AssistantService.class);
- if (Build.VERSION.SDK_INT >= ANDROID_10_API) {
- LogUtils.d(TAG, "wakeupAndBindAssistant: 应用后台，启动 AssistantService 为前台服务");
- startForegroundService(intent);
- } else {
- startService(intent);
+ mIsServiceRunning = true;
+
+ // 重新加载最新配置（避免配置修改后未生效）
+ mMainServiceBean = MainServiceBean.loadBean(this, MainServiceBean.class);
+ if (mMainServiceBean == null || !mMainServiceBean.isEnable()) {
+ LogUtils.w(TAG, "startCoreBusiness: 服务配置未启用或配置为空，启动流程终止");
+ mIsServiceRunning = false;
+ stopSelf(); // 未启用则主动停止服务
+ return;
}
- bindService(intent, mMyServiceConnection, Context.BIND_IMPORTANT);
- LogUtils.d(TAG, "wakeupAndBindAssistant: 已启动并绑定守护服务");
+
+ LogUtils.i(TAG, "startCoreBusiness: 服务配置已启用，启动核心流程");
+
+ // 1. 优先启动前台服务（避免前台服务启动超时崩溃，核心优先级）
+ try {
+ Notification foregroundNotification = createForegroundNotification();
+ startForeground(FOREGROUND_NOTIFICATION_ID, foregroundNotification, FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+ LogUtils.i(TAG, "startCoreBusiness: 前台服务启动成功，通知ID=" + FOREGROUND_NOTIFICATION_ID);
+ } catch (IllegalArgumentException e) {
+ LogUtils.e(TAG, "startCoreBusiness: 前台服务启动失败（服务类型不匹配）", e);
+ mIsServiceRunning = false;
+ stopSelf();
+ return;
+ } catch (Exception e) {
+ LogUtils.e(TAG, "startCoreBusiness: 前台服务启动异常", e);
+ mIsServiceRunning = false;
+ stopSelf();
+ return;
+ }
+
+ // 2. 绑定守护服务（保障主服务存活，防系统杀死）
+ wakeupAndBindAssistantService();
+
+ // 3. 初始化核心业务组件（号码识别+黑白名单规则）
+ initTomCatComponent();
+ initRulesConfig();
+
+ // 4. 启动通话监听相关服务（无延迟，直接启动，保障功能生效）
+ startCallRelatedServices();
+
+ LogUtils.i(TAG, "startCoreBusiness: 主服务核心流程启动完成，服务正常运行");
}
- // ====================== 铃声音量监控相关方法区 ======================
+ /**
+ * 唤醒并绑定守护服务（分版本适配启动方式，Android10+前台服务启动）
+ */
+ private void wakeupAndBindAssistantService() {
+ if (mServiceConnection == null) {
+ LogUtils.e(TAG, "wakeupAndBindAssistantService: 服务连接实例未初始化，绑定失败");
+ return;
+ }
+
+ Intent assistantIntent = new Intent(this, AssistantService.class);
+ // Android10+应用后台启动服务需用前台服务模式
+ LogUtils.d(TAG, "wakeupAndBindAssistantService: Android10+，前台服务模式启动守护服务");
+ startForegroundService(assistantIntent);
+
+ // 绑定守护服务（BIND_IMPORTANT：高优先级绑定，断开时回调）
+ bindService(assistantIntent, mServiceConnection, Context.BIND_IMPORTANT);
+ LogUtils.d(TAG, "wakeupAndBindAssistantService: 守护服务启动并发起绑定请求");
+ }
+
+ // ====================== 铃声音量监控方法区（定时检查+恢复配置） ======================
+ /**
+ * 初始化音量检查定时器（先取消旧定时器，避免重复创建）
+ */
private void initVolumeCheckTimer() {
cancelVolumeCheckTimer();
- mStreamVolumeCheckTimer = new Timer();
- mStreamVolumeCheckTimer.schedule(new TimerTask() {
+ mVolumeCheckTimer = new Timer();
+ mVolumeCheckTimer.schedule(new TimerTask() {
@Override
public void run() {
checkAndRestoreRingerVolume();
}
}, VOLUME_CHECK_DELAY, VOLUME_CHECK_PERIOD);
- LogUtils.d(TAG, "initVolumeCheckTimer: 铃声音量检查定时器已启动");
+ LogUtils.d(TAG, "initVolumeCheckTimer: 铃声音量监控定时器启动，周期" + VOLUME_CHECK_PERIOD + "ms");
}
+ /**
+ * 检查并恢复铃声音量（对比配置值，不一致则恢复，保障用户配置生效）
+ */
private void checkAndRestoreRingerVolume() {
AudioManager audioManager = (AudioManager) getSystemService(AUDIO_SERVICE);
if (audioManager == null) {
- LogUtils.e(TAG, "checkAndRestoreRingerVolume: 获取 AudioManager 失败");
+ LogUtils.e(TAG, "checkAndRestoreRingerVolume: AudioManager获取失败，音量检查终止");
return;
}
- // 加载铃音配置（无配置则初始化）
- RingTongBean ringTongBean = RingTongBean.loadBean(this, RingTongBean.class);
- if (ringTongBean == null) {
- ringTongBean = new RingTongBean();
- RingTongBean.saveBean(this, ringTongBean);
- LogUtils.d(TAG, "checkAndRestoreRingerVolume: 铃音配置未存在，已初始化默认配置");
+ // 加载音量配置（无配置则初始化默认值）
+ RingTongBean ringConfig = RingTongBean.loadBean(this, RingTongBean.class);
+ if (ringConfig == null) {
+ ringConfig = new RingTongBean();
+ RingTongBean.saveBean(this, ringConfig);
+ LogUtils.d(TAG, "checkAndRestoreRingerVolume: 音量配置未存在，初始化默认配置");
+ return;
}
- // 检查并恢复音量
try {
int currentVolume = audioManager.getStreamVolume(AudioManager.STREAM_RING);
- int configVolume = ringTongBean.getStreamVolume();
+ int configVolume = ringConfig.getStreamVolume();
+ // 音量不一致则恢复配置值
if (currentVolume != configVolume) {
audioManager.setStreamVolume(AudioManager.STREAM_RING, configVolume, 0);
- LogUtils.d(TAG, "checkAndRestoreRingerVolume: 铃声音量已恢复 | 配置值=" + configVolume + " | 当前值=" + currentVolume);
+ LogUtils.d(TAG, "checkAndRestoreRingerVolume: 铃声音量已恢复，配置值=" + configVolume + "，原当前值=" + currentVolume);
+ } else {
+ LogUtils.v(TAG, "checkAndRestoreRingerVolume: 铃声音量与配置一致，无需调整");
}
} catch (SecurityException e) {
- LogUtils.e(TAG, "checkAndRestoreRingerVolume: 音量设置权限不足", e);
+ LogUtils.e(TAG, "checkAndRestoreRingerVolume: 音量设置权限不足，恢复失败", e);
}
}
+ /**
+ * 取消音量检查定时器（释放Timer资源，避免内存泄漏）
+ */
private void cancelVolumeCheckTimer() {
- if (mStreamVolumeCheckTimer != null) {
- mStreamVolumeCheckTimer.cancel();
- mStreamVolumeCheckTimer = null;
- LogUtils.d(TAG, "cancelVolumeCheckTimer: 铃声音量检查定时器已取消");
+ if (mVolumeCheckTimer != null) {
+ mVolumeCheckTimer.cancel();
+ mVolumeCheckTimer = null;
+ LogUtils.d(TAG, "cancelVolumeCheckTimer: 铃声音量监控定时器已取消");
}
}
- // ====================== 辅助初始化方法区 ======================
- private void initTomCat() {
+ // ====================== 辅助初始化方法区（业务组件初始化，统一归类） ======================
+ /**
+ * 初始化TomCat组件（号码识别核心，加载本地数据）
+ */
+ private void initTomCatComponent() {
sTomCatInstance = TomCat.getInstance(this);
- if (!sTomCatInstance.loadPhoneBoBullToon()) {
- LogUtils.w(TAG, "initTomCat: 未下载 BoBullToon 数据，参数加载失败");
+ if (sTomCatInstance.loadPhoneBoBullToon()) {
+ LogUtils.d(TAG, "initTomCatComponent: BoBullToon号码库加载成功");
} else {
- LogUtils.d(TAG, "initTomCat: BoBullToon 数据加载成功");
+ LogUtils.w(TAG, "initTomCatComponent: BoBullToon号码库未下载，加载失败（不影响服务运行）");
}
}
+ /**
+ * 初始化黑白名单规则配置（加载本地规则，保障通话筛选生效）
+ */
+ private void initRulesConfig() {
+ Rules rules = Rules.getInstance(this);
+ if (rules != null) {
+ rules.loadRules();
+ LogUtils.d(TAG, "initRulesConfig: 黑白名单通话规则加载完成");
+ } else {
+ LogUtils.e(TAG, "initRulesConfig: Rules实例获取失败，通话规则加载失败");
+ }
+ }
+
+ /**
+ * 初始化广播接收器（监听系统事件，如开机启动、网络变化）
+ */
private void initMainReceiver() {
if (mMainReceiver == null) {
mMainReceiver = new MainReceiver(this);
mMainReceiver.registerAction(this);
- LogUtils.d(TAG, "initMainReceiver: 广播接收器已注册");
+ LogUtils.d(TAG, "initMainReceiver: 全局广播接收器注册完成");
+ } else {
+ LogUtils.d(TAG, "initMainReceiver: 广播接收器已初始化，跳过重复注册");
+ }
+ }
+
+ /**
+ * 启动通话相关服务（通话监听+通话筛选，核心功能服务）
+ */
+ private void startCallRelatedServices() {
+ // 启动通话监听服务
+ try {
+ Intent callListenerIntent = new Intent(this, CallListenerService.class);
+ startService(callListenerIntent);
+ LogUtils.d(TAG, "startCallRelatedServices: CallListenerService启动成功");
+ } catch (Exception e) {
+ LogUtils.e(TAG, "startCallRelatedServices: CallListenerService启动失败", e);
+ }
+
+ // 启动通话筛选服务（API10+生效，低版本兼容）
+ try {
+ Intent screeningIntent = new Intent(this, MyCallScreeningService.class);
+ startService(screeningIntent);
+ LogUtils.d(TAG, "startCallRelatedServices: MyCallScreeningService启动成功");
+ } catch (Exception e) {
+ LogUtils.e(TAG, "startCallRelatedServices: MyCallScreeningService启动失败", e);
}
}
}
diff --git a/contacts/src/main/java/cc/winboll/studio/contacts/services/MyCallScreeningService.java b/contacts/src/main/java/cc/winboll/studio/contacts/services/MyCallScreeningService.java
index 4d390c2..95a0884 100644
--- a/contacts/src/main/java/cc/winboll/studio/contacts/services/MyCallScreeningService.java
+++ b/contacts/src/main/java/cc/winboll/studio/contacts/services/MyCallScreeningService.java
@@ -1,147 +1,237 @@
package cc.winboll.studio.contacts.services;
-import android.app.Notification;
-import android.app.NotificationChannel;
-import android.app.NotificationManager;
import android.content.Context;
+import android.content.Intent;
import android.net.Uri;
import android.os.Build;
import android.telecom.CallScreeningService;
import android.telephony.TelephonyManager;
import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
-import cc.winboll.studio.contacts.R;
+import cc.winboll.studio.contacts.model.MainServiceBean;
import cc.winboll.studio.libappbase.LogUtils;
/**
* @Author ZhanGSKen&豆包大模型
- * @Date 2025/12/12 19:00
- * @Describe 通话筛选服务（完全匹配 API 30 父类方法原型，严格 Java 7 兼容）
- * 修复：1. 前台服务启动超时异常 2. 移除所有 Build.VERSION_CODES 高版本依赖 3. 强化空指针防护
+ * @Describe 通话筛选服务（无前台服务），负责识别通话类型、拦截指定号码、处理正常通话逻辑
+ * 严格适配 Java7 语法 + Android API29-30 | 轻量稳定 | 强化空指针防护 | 无冗余代码
*/
-@RequiresApi(api = 29) // API 29 = Android 10 = Build.VERSION_CODES.Q，直接写数值避免依赖
+@RequiresApi(api = 29) // 父类 CallScreeningService 最低要求 API29，明确标注
public class MyCallScreeningService extends CallScreeningService {
- // ====================== 常量定义区（全硬编码，杜绝高版本 API 依赖） ======================
+
+ // ====================== 常量定义区（全硬编码，无高版本API依赖） ======================
public static final String TAG = "MyCallScreeningService";
- // 前台服务配置
- private static final int FOREGROUND_NOTIFICATION_ID = 1003;
- private static final String FOREGROUND_CHANNEL_ID = "call_screening_service_channel";
- // API 版本常量（直接写数值，替代 Build.VERSION_CODES）
- private static final int ANDROID_8_API = 26; // Android 8.0，通知渠道最低版本
- private static final int ANDROID_12_API = 31; // Android 12，stopForeground 带参数版本
- // stopForeground 参数常量（硬编码 1，替代 STOP_FOREGROUND_REMOVE）
- private static final int STOP_FOREGROUND_REMOVE = 1;
- // 通话方向常量（直接写数值，替代 Call.Details 中的常量，适配 API 30）
- private static final int CALL_DIRECTION_INCOMING = 1;
- private static final int CALL_DIRECTION_OUTGOING = 2;
- // 成员变量
- private Context mContext;
+ // 通话方向常量（硬编码替代 Call.Details 高版本字段，适配API29-30）
+ private static final int CALL_DIRECTION_INCOMING = 1; // 来电
+ private static final int CALL_DIRECTION_OUTGOING = 2; // 外拨
- // ====================== Service 生命周期方法 ======================
+ // ====================== 成员属性区（精简必要属性，命名规范） ======================
+ private Context mContext; // 上下文对象，避免重复调用 getApplicationContext()
+
+ // ====================== Service生命周期方法区（按执行顺序排列） ======================
@Override
public void onCreate() {
super.onCreate();
mContext = this;
- LogUtils.d(TAG, "onCreate: 通话筛选服务启动");
-
- // ========== 核心优化：优先启动前台服务，放在 onCreate 最前端，避免超时 ==========
- try {
- Notification foregroundNotification = createForegroundNotification();
- startForeground(FOREGROUND_NOTIFICATION_ID, foregroundNotification);
- LogUtils.d(TAG, "onCreate: 前台服务启动成功");
- } catch (Exception e) {
- LogUtils.e(TAG, "onCreate: 前台服务启动失败", e);
- stopSelf(); // 启动失败直接停止服务，避免系统抛出异常
- return;
- }
+ LogUtils.d(TAG, "===== onCreate: 通话筛选服务启动 =====");
}
- /**
- * 100% 匹配 API 30 CallScreeningService 抽象方法原型
- * 完全移除高版本依赖，使用硬编码常量
- */
@Override
- @RequiresApi(api = 29) // 与类注解一致，明确最低 API 要求
- public void onScreenCall(@NonNull android.telecom.Call.Details details) {
- // 1. 获取通话号码：多层空指针防护，Java 7 规范写法
- String phoneNumber = "未知号码";
- Uri handle = details.getHandle();
- if (handle != null) {
- String schemePart = handle.getSchemeSpecificPart();
- if (schemePart != null && !schemePart.trim().isEmpty()) {
- phoneNumber = schemePart.trim();
- }
- }
+ public int onStartCommand(Intent intent, int flags, int startId) {
+ LogUtils.d(TAG, "onStartCommand: 服务被启动，startId=" + startId);
- // 2. 判断通话方向：用硬编码常量替代 API 高版本字段
- String callTypeStr;
- int callType;
- int direction = details.getCallDirection();
- if (direction == CALL_DIRECTION_INCOMING) {
- callTypeStr = "来电";
- callType = TelephonyManager.CALL_STATE_RINGING;
- } else if (direction == CALL_DIRECTION_OUTGOING) {
- callTypeStr = "外拨";
- callType = TelephonyManager.CALL_STATE_OFFHOOK;
- } else {
- callTypeStr = "未知类型";
- callType = TelephonyManager.CALL_STATE_IDLE;
- }
+ // 加载服务配置，决定重启策略（启用则自动重启，禁用则默认）
+ MainServiceBean serviceConfig = MainServiceBean.loadBean(this, MainServiceBean.class);
+ int startMode = (serviceConfig != null && serviceConfig.isEnable()) ? START_STICKY : super.onStartCommand(intent, flags, startId);
+ LogUtils.d(TAG, "onStartCommand: 服务启动模式：" + (startMode == START_STICKY ? "START_STICKY（自动重启）" : "默认模式"));
- // Java 7 字符串拼接，避免 String.format 兼容性问题
- LogUtils.d(TAG, "检测到" + callTypeStr + "：" + phoneNumber);
-
- // 3. 自定义拦截逻辑：示例拦截 10086
- boolean shouldBlock = "10086".equals(phoneNumber);
-
- // 4. 构建筛选响应：Java 7 分步调用，不使用链式写法
- CallResponse.Builder responseBuilder = new CallResponse.Builder();
- responseBuilder.setDisallowCall(shouldBlock);
- responseBuilder.setRejectCall(shouldBlock);
- responseBuilder.setSkipCallLog(!shouldBlock);
- responseBuilder.setSkipNotification(!shouldBlock);
- CallResponse response = responseBuilder.build();
-
- // 5. 提交筛选结果（API 30 父类方法，直接调用）
- respondToCall(details, response);
-
- // 6. 处理业务逻辑
- if (!shouldBlock) {
- handleNormalCall(phoneNumber, callType);
- } else {
- LogUtils.d(TAG, "已拦截通话：" + phoneNumber);
- }
+ return startMode;
}
@Override
public void onDestroy() {
super.onDestroy();
- LogUtils.d(TAG, "onDestroy: 通话筛选服务销毁");
- // 适配 Android 12+ stopForeground 参数，硬编码常量避免依赖
- if (Build.VERSION.SDK_INT >= ANDROID_12_API) {
- stopForeground(STOP_FOREGROUND_REMOVE);
+ // 置空上下文，释放引用，避免内存泄漏
+ mContext = null;
+ LogUtils.d(TAG, "===== onDestroy: 通话筛选服务销毁完成 =====");
+ }
+
+ // ====================== 核心通话筛选方法区（父类抽象方法实现） ======================
+ /**
+ * 核心：通话筛选入口（API29-30标准方法，100%兼容）
+ * 功能：识别通话号码/类型、拦截指定号码、处理正常通话
+ */
+ @Override
+ @RequiresApi(api = 29)
+ public void onScreenCall(@NonNull android.telecom.Call.Details details) {
+ LogUtils.d(TAG, "===== onScreenCall: 开始筛选通话 =====");
+
+ // 1. 安全获取通话号码（多层空指针防护，Java7规范写法）
+ String phoneNumber = getSafePhoneNumber(details);
+ // 2. 识别通话方向（来电/外拨/未知）
+ int callDirection = details.getCallDirection();
+ String callTypeDesc = getCallDirectionDesc(callDirection);
+ int callState = getCallStateByDirection(callDirection);
+
+ LogUtils.d(TAG, "筛选结果：通话类型=" + callTypeDesc + "，号码=" + phoneNumber);
+
+ // 3. 自定义拦截逻辑（示例：拦截指定号码10086，可按需扩展黑白名单）
+ boolean isNeedBlock = isTargetBlockNumber(phoneNumber);
+
+ // 4. 构建筛选响应（Java7分步调用，不使用链式写法，避免兼容问题）
+ CallResponse callResponse = buildCallScreeningResponse(isNeedBlock);
+
+ // 5. 提交筛选结果（必须调用父类方法，完成拦截/放行逻辑）
+ respondToCall(details, callResponse);
+
+ // 6. 分场景处理后续逻辑（拦截日志/正常通话业务）
+ handleCallAfterScreening(phoneNumber, callTypeDesc, isNeedBlock);
+
+ LogUtils.d(TAG, "===== onScreenCall: 通话筛选完成 =====");
+ }
+
+ // ====================== 业务逻辑方法区（按功能拆分，低耦合） ======================
+ /**
+ * 安全获取通话号码（多层空指针+空字符串防护，避免崩溃）
+ */
+ private String getSafePhoneNumber(android.telecom.Call.Details details) {
+ String phoneNumber = "未知号码";
+ if (details == null) {
+ LogUtils.w(TAG, "getSafePhoneNumber: 通话详情为空，无法获取号码");
+ return phoneNumber;
+ }
+
+ Uri handle = details.getHandle();
+ if (handle != null) {
+ String schemePart = handle.getSchemeSpecificPart();
+ if (schemePart != null && !schemePart.trim().isEmpty()) {
+ phoneNumber = schemePart.trim();
+ LogUtils.d(TAG, "getSafePhoneNumber: 成功获取号码，原始值=" + schemePart + "，处理后=" + phoneNumber);
+ } else {
+ LogUtils.w(TAG, "getSafePhoneNumber: 号码格式异常，schemePart=" + schemePart);
+ }
+ } else {
+ LogUtils.w(TAG, "getSafePhoneNumber: 通话 handle 为空，无法获取号码");
+ }
+ return phoneNumber;
+ }
+
+ /**
+ * 判断是否为目标拦截号码（可扩展黑白名单逻辑，当前示例拦截10086）
+ */
+ private boolean isTargetBlockNumber(String phoneNumber) {
+ if (phoneNumber == null || phoneNumber.trim().isEmpty()) {
+ LogUtils.w(TAG, "isTargetBlockNumber: 号码为空，不拦截");
+ return false;
+ }
+
+ // 示例拦截逻辑：拦截 10086（实际可替换为黑白名单查询）
+ boolean isBlock = "10086".equals(phoneNumber.trim());
+ if (isBlock) {
+ LogUtils.d(TAG, "isTargetBlockNumber: 命中拦截规则，号码=" + phoneNumber);
+ } else {
+ LogUtils.d(TAG, "isTargetBlockNumber: 未命中拦截规则，号码=" + phoneNumber);
+ }
+ return isBlock;
+ }
+
+ /**
+ * 构建通话筛选响应（按需配置拦截/放行参数，适配API29-30）
+ */
+ private CallResponse buildCallScreeningResponse(boolean isNeedBlock) {
+ CallResponse.Builder responseBuilder = new CallResponse.Builder();
+ // 拦截配置：是否禁止通话+是否拒绝通话（两者配合实现拦截）
+ responseBuilder.setDisallowCall(isNeedBlock);
+ responseBuilder.setRejectCall(isNeedBlock);
+ // 日志/通知配置：拦截的通话跳过日志和通知，正常通话保留
+ responseBuilder.setSkipCallLog(isNeedBlock);
+ responseBuilder.setSkipNotification(isNeedBlock);
+
+ CallResponse response = responseBuilder.build();
+ LogUtils.d(TAG, "buildCallScreeningResponse: 响应构建完成，拦截状态=" + isNeedBlock);
+ return response;
+ }
+
+ /**
+ * 筛选后分场景处理（拦截日志/正常通话业务扩展）
+ */
+ private void handleCallAfterScreening(String phoneNumber, String callTypeDesc, boolean isNeedBlock) {
+ if (isNeedBlock) {
+ // 拦截场景：仅打日志（可扩展：添加拦截记录、本地存储等）
+ LogUtils.d(TAG, "handleCallAfterScreening: 已拦截通话，类型=" + callTypeDesc + "，号码=" + phoneNumber);
+ } else {
+ // 正常通话场景：处理业务逻辑（可扩展：通话记录、广播通知、号码识别等）
+ int callState = getCallStateByDirection(getCallDirectionFromDesc(callTypeDesc));
+ handleNormalCallBusiness(phoneNumber, callState);
}
}
- // ====================== 业务逻辑方法 ======================
/**
- * 处理正常通话的扩展逻辑，Java 7 规范写法，添加空指针防护
+ * 正常通话业务处理（核心业务扩展入口，强化空指针防护）
*/
- private void handleNormalCall(String phoneNumber, int callType) {
+ private void handleNormalCallBusiness(String phoneNumber, int callState) {
if (phoneNumber == null || phoneNumber.trim().isEmpty()) {
- LogUtils.w(TAG, "handleNormalCall: 号码为空，跳过处理");
+ LogUtils.w(TAG, "handleNormalCallBusiness: 号码为空，跳过业务处理");
return;
}
- LogUtils.d(TAG, "处理正常通话：" + phoneNumber + " | 状态：" + getCallStateStr(callType));
- // 可在此添加通话记录、广播通知等逻辑
+
+ String callStateDesc = getCallStateDesc(callState);
+ LogUtils.d(TAG, "handleNormalCallBusiness: 处理正常通话业务，号码=" + phoneNumber + "，状态=" + callStateDesc);
+
+ // 此处可扩展业务逻辑（示例）：
+ // 1. 保存通话记录到本地
+ // 2. 发送广播通知其他组件（如通话监听服务）
+ // 3. 调用号码识别接口，匹配联系人信息
+ }
+
+ // ====================== 工具辅助方法区（统一归类，复用性强） ======================
+ /**
+ * 通话方向转文字描述（便于日志查看，快速定位场景）
+ */
+ private String getCallDirectionDesc(int callDirection) {
+ switch (callDirection) {
+ case CALL_DIRECTION_INCOMING:
+ return "来电";
+ case CALL_DIRECTION_OUTGOING:
+ return "外拨";
+ default:
+ return "未知通话";
+ }
}
/**
- * 辅助方法：将通话状态转为字符串，避免重复代码
+ * 文字描述转通话方向（配合业务逻辑反向匹配，避免重复判断）
*/
- private String getCallStateStr(int callType) {
- switch (callType) {
+ private int getCallDirectionFromDesc(String callTypeDesc) {
+ if ("来电".equals(callTypeDesc)) {
+ return CALL_DIRECTION_INCOMING;
+ } else if ("外拨".equals(callTypeDesc)) {
+ return CALL_DIRECTION_OUTGOING;
+ } else {
+ return -1; // 未知方向
+ }
+ }
+
+ /**
+ * 通话方向转 TelephonyManager 状态（统一状态标准，便于业务复用）
+ */
+ private int getCallStateByDirection(int callDirection) {
+ switch (callDirection) {
+ case CALL_DIRECTION_INCOMING:
+ return TelephonyManager.CALL_STATE_RINGING; // 来电=响铃中
+ case CALL_DIRECTION_OUTGOING:
+ return TelephonyManager.CALL_STATE_OFFHOOK; // 外拨=通话中
+ default:
+ return TelephonyManager.CALL_STATE_IDLE; // 未知=空闲
+ }
+ }
+
+ /**
+ * TelephonyManager 状态转文字描述（统一日志格式，提升可读性）
+ */
+ private String getCallStateDesc(int callState) {
+ switch (callState) {
case TelephonyManager.CALL_STATE_RINGING:
return "响铃中";
case TelephonyManager.CALL_STATE_OFFHOOK:
@@ -149,53 +239,8 @@ public class MyCallScreeningService extends CallScreeningService {
case TelephonyManager.CALL_STATE_IDLE:
return "空闲";
default:
- return "未知";
+ return "未知状态";
}
}
-
- // ====================== 前台服务通知构建方法 ======================
- /**
- * 创建前台服务通知：严格 Java 7 分步构建，强化异常防护
- * @return 可用的 Notification 实例
- */
- private Notification createForegroundNotification() {
- // 1. 创建 Android 8.0+ 通知渠道，添加空指针防护
- if (Build.VERSION.SDK_INT >= ANDROID_8_API) {
- NotificationChannel channel = new NotificationChannel(
- FOREGROUND_CHANNEL_ID,
- "来电筛查服务",
- NotificationManager.IMPORTANCE_LOW
- );
- channel.setDescription("后台处理来电筛查，防止服务被系统回收");
- // 关闭通知音效和震动，避免打扰用户
- channel.setSound(null, null);
- channel.enableVibration(false);
-
- NotificationManager manager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
- if (manager != null) {
- manager.createNotificationChannel(channel);
- LogUtils.d(TAG, "createForegroundNotification: 通知渠道创建成功");
- } else {
- LogUtils.e(TAG, "createForegroundNotification: NotificationManager 获取失败");
- }
- }
-
- // 2. 构建 Notification：Java 7 分步设置，不使用链式调用
- Notification.Builder builder;
- if (Build.VERSION.SDK_INT >= ANDROID_8_API) {
- builder = new Notification.Builder(mContext, FOREGROUND_CHANNEL_ID);
- } else {
- builder = new Notification.Builder(mContext);
- }
-
- // 关键：确保小图标资源存在，替换为项目实际图标
- builder.setSmallIcon(R.drawable.ic_launcher);
- builder.setContentTitle("来电筛查服务运行中");
- builder.setContentText("正在监控来电状态");
- builder.setPriority(Notification.PRIORITY_LOW);
- builder.setOngoing(true); // 前台服务通知不可手动取消
-
- return builder.build();
- }
}