diff --git a/positions/build.properties b/positions/build.properties
index 8e7279f..850a3a0 100644
--- a/positions/build.properties
+++ b/positions/build.properties
@@ -1,8 +1,8 @@
#Created by .winboll/winboll_app_build.gradle
-#Tue Sep 30 21:17:41 GMT 2025
+#Wed Oct 01 07:47:20 GMT 2025
stageCount=4
libraryProject=
baseVersion=15.0
publishVersion=15.0.3
-buildCount=19
+buildCount=55
baseBetaVersion=15.0.4
diff --git a/positions/src/main/AndroidManifest.xml b/positions/src/main/AndroidManifest.xml
index f305454..d302210 100644
--- a/positions/src/main/AndroidManifest.xml
+++ b/positions/src/main/AndroidManifest.xml
@@ -3,6 +3,9 @@
xmlns:android="http://schemas.android.com/apk/res/android"
package="cc.winboll.studio.positions">
+
+
+
@@ -53,8 +56,11 @@
android:name="com.google.android.gms.version"
android:value="@integer/google_play_services_version"/>
-
+
+
+
+
-
\ No newline at end of file
+
diff --git a/positions/src/main/java/cc/winboll/studio/positions/App.java b/positions/src/main/java/cc/winboll/studio/positions/App.java
index 08ae159..702019a 100644
--- a/positions/src/main/java/cc/winboll/studio/positions/App.java
+++ b/positions/src/main/java/cc/winboll/studio/positions/App.java
@@ -45,11 +45,11 @@ import java.util.concurrent.atomic.AtomicBoolean;
public class App extends GlobalApplication {
private static Handler MAIN_HANDLER = new Handler(Looper.getMainLooper());
-
+
@Override
public void onCreate() {
super.onCreate();
-
+
// 初始化 Toast 框架
ToastUtils.init(this);
// 设置 Toast 布局样式
diff --git a/positions/src/main/java/cc/winboll/studio/positions/MainActivity.java b/positions/src/main/java/cc/winboll/studio/positions/MainActivity.java
index 58694ed..8c19b8f 100644
--- a/positions/src/main/java/cc/winboll/studio/positions/MainActivity.java
+++ b/positions/src/main/java/cc/winboll/studio/positions/MainActivity.java
@@ -4,21 +4,22 @@ import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
-import android.content.SharedPreferences;
+import android.content.pm.PackageManager;
+import android.os.Build;
import android.os.Bundle;
import android.os.IBinder;
import android.view.View;
import android.widget.CompoundButton;
-
+import android.widget.Switch;
import androidx.appcompat.app.AppCompatActivity;
-import androidx.appcompat.widget.SwitchCompat;
import androidx.appcompat.widget.Toolbar;
-
import cc.winboll.studio.libappbase.LogActivity;
+import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.positions.activities.LocationActivity;
import cc.winboll.studio.positions.services.DistanceRefreshService;
+import cc.winboll.studio.positions.services.MainService;
+import cc.winboll.studio.positions.utils.AppConfigsUtil;
import com.hjq.toast.ToastUtils;
-import cc.winboll.studio.positions.models.AppConfigsModel;
/**
* 主页面：仅负责
@@ -28,9 +29,11 @@ import cc.winboll.studio.positions.models.AppConfigsModel;
*/
public class MainActivity extends AppCompatActivity {
public static final String TAG = "MainActivity";
+ // 位置权限请求码（自定义唯一标识）
+ private static final int REQUEST_LOCATION_PERMISSIONS = 1001;
- // UI 控件：服务控制开关、顶部工具栏
- private SwitchCompat mServiceSwitch;
+ // UI 控件：服务控制开关、顶部工具栏
+ private Switch mServiceSwitch;
private Toolbar mToolbar;
// 服务相关：服务实例、绑定状态标记
private DistanceRefreshService mDistanceService;
@@ -47,8 +50,6 @@ public class MainActivity extends AppCompatActivity {
DistanceRefreshService.DistanceBinder binder = (DistanceRefreshService.DistanceBinder) service;
mDistanceService = binder.getService();
isServiceBound = true;
- // 绑定后立即同步开关状态，避免UI与服务实际状态不一致
- syncSwitchState();
}
/**
@@ -58,12 +59,10 @@ public class MainActivity extends AppCompatActivity {
public void onServiceDisconnected(ComponentName name) {
mDistanceService = null;
isServiceBound = false;
- // 断开后同步开关状态（从SP读取上次保存的状态）
- syncSwitchState();
}
};
- // ---------------------- Activity 生命周期（核心：初始化UI、绑定服务、释放资源） ----------------------
+ // ---------------------- Activity 生命周期（核心：初始化UI、申请权限、绑定服务、释放资源） ----------------------
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
@@ -71,9 +70,13 @@ public class MainActivity extends AppCompatActivity {
// 1. 初始化顶部 Toolbar（保留原逻辑，设置页面标题）
initToolbar();
- // 2. 初始化服务控制开关（核心功能：绑定开关点击事件、读取SP状态）
+ // 2. 初始化服务控制开关（核心功能：绑定开关点击事件）
initServiceSwitch();
- // 3. 绑定服务（仅用于获取服务实时状态，不影响服务独立运行）
+ // 3. 检查并申请位置权限（含后台GPS权限，确保服务启动前权限就绪）
+ if (!checkLocationPermissions()) {
+ requestLocationPermissions();
+ }
+ // 4. 绑定服务（仅用于获取服务实时状态，不影响服务独立运行）
bindDistanceService();
}
@@ -102,57 +105,49 @@ public class MainActivity extends AppCompatActivity {
}
/**
- * 初始化服务控制开关：读取SP状态、绑定点击事件
+ * 初始化服务控制开关：读取SP状态、绑定点击事件（含权限检查）
*/
private void initServiceSwitch() {
- mServiceSwitch = (SwitchCompat) findViewById(R.id.switch_service_control); // 显式强转
+ mServiceSwitch = (Switch) findViewById(R.id.switch_service_control); // 显式强转
+ mServiceSwitch.setChecked(AppConfigsUtil.getInstance(this).isEnableMainService(true));
- // 2. 绑定开关状态变化监听（Java 7 用匿名内部类实现 CompoundButton.OnCheckedChangeListener）
+ // Java 7 用匿名内部类实现 CompoundButton.OnCheckedChangeListener
mServiceSwitch.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
- if (isChecked) {
- AppConfigsModel.saveBean(MainActivity.this, new AppConfigsModel(true));
- // 开关打开：启动服务（通过startService确保服务独立运行，不受Activity绑定影响）
- startService(new Intent(MainActivity.this, DistanceRefreshService.class));
+ // 开关打开前先检查权限：无权限则终止操作、重置开关、引导申请
+ if (isChecked && !checkLocationPermissions()) {
+ requestLocationPermissions();
+ return;
+ }
+ // 权限就绪：执行服务启停逻辑
+ if (isChecked) {
+ LogUtils.d(TAG, "设置启动服务");
+ AppConfigsUtil.getInstance(MainActivity.this).setIsEnableMainService(true);
+ // 启动服务（startService确保服务独立运行，不受Activity绑定影响）
+ startService(new Intent(MainActivity.this, MainService.class));
} else {
- AppConfigsModel.saveBean(MainActivity.this, new AppConfigsModel(false));
- // 开关关闭：先解绑服务（避免服务被Activity持有），再停止服务
+ LogUtils.d(TAG, "设置关闭服务");
+ AppConfigsUtil.getInstance(MainActivity.this).setIsEnableMainService(false);
+ // 停止服务前先解绑，避免服务被Activity持有
if (isServiceBound) {
unbindService(mServiceConn);
isServiceBound = false;
}
- stopService(new Intent(MainActivity.this, DistanceRefreshService.class));
+ stopService(new Intent(MainActivity.this, MainService.class));
}
- // 状态变化后同步开关UI（确保UI与服务实际状态一致）
- syncSwitchState();
}
});
}
- // ---------------------- 核心功能2：服务状态同步与绑定 ----------------------
- /**
- * 同步服务开关状态：优先以服务实时状态为准，无服务则读SP
- */
- private void syncSwitchState() {
- if (mServiceSwitch == null) {
- return; // 开关未初始化，直接返回
- }
-
- if (isServiceBound && mDistanceService != null) {
- ToastUtils.show("位置服务已启动");
- } else {
- ToastUtils.show("位置服务已关闭");
- }
- }
/**
* 绑定服务（仅用于获取服务状态，不启动服务）
*/
private void bindDistanceService() {
- Intent serviceIntent = new Intent(this, DistanceRefreshService.class);
- // 绑定服务：BIND_AUTO_CREATE 表示若服务未启动则创建（仅为获取状态，后续由开关控制启停）
+ Intent serviceIntent = new Intent(this, MainService.class);
+ // BIND_AUTO_CREATE：服务未启动则创建（仅为获取状态，启停由开关控制）
bindService(serviceIntent, mServiceConn, Context.BIND_AUTO_CREATE);
}
@@ -162,15 +157,7 @@ public class MainActivity extends AppCompatActivity {
* 服务未启动时提示，不允许跳转（避免LocationActivity无数据）
*/
public void onPositions(View view) {
- // 从配置文件读取服务状态（避免依赖服务绑定，提升稳定性）
- AppConfigsModel bean = AppConfigsModel.loadBean(MainActivity.this, AppConfigsModel.class);
- boolean isServiceRunning = (bean == null) ? false : bean.isEnableDistanceRefreshService();
-
- if (!isServiceRunning) {
- ToastUtils.show("请先启动位置服务，否则无法加载数据");
- return; // 服务未启动，不跳转
- }
-
+ //ToastUtils.show("onPositions");
// 服务已启动：跳转到位置管理页
startActivity(new Intent(MainActivity.this, LocationActivity.class));
}
@@ -182,5 +169,71 @@ public class MainActivity extends AppCompatActivity {
public void onLog(View view) {
LogActivity.startLogActivity(this); // 调用LogActivity静态方法跳转（保留原逻辑）
}
+
+ // ---------------------- 新增：位置权限处理（适配Java7 + 后台GPS权限） ----------------------
+ /**
+ * 检查是否拥有「前台+后台」位置权限（适配Android版本差异）
+ * Java7 特性：显式类型判断、无Lambda、兼容低版本API
+ */
+ private boolean checkLocationPermissions() {
+ // 1. 检查前台精确定位权限（Android 6.0+ 必需，显式强转权限常量）
+ int foregroundPermResult = checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION);
+ boolean hasForegroundPerm = (foregroundPermResult == PackageManager.PERMISSION_GRANTED);
+
+ // 2. 检查后台定位权限（仅Android 10+ 需要，Java7 显式用Build.VERSION判断版本）
+ boolean hasBackgroundPerm = true;
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+ int backgroundPermResult = checkSelfPermission(android.Manifest.permission.ACCESS_BACKGROUND_LOCATION);
+ hasBackgroundPerm = (backgroundPermResult == PackageManager.PERMISSION_GRANTED);
+ }
+
+ // 前台+后台权限均满足，才返回true
+ return hasForegroundPerm && hasBackgroundPerm;
+ }
+
+ /**
+ * 申请「前台+后台」位置权限（弹出系统权限弹窗，适配版本差异）
+ */
+ private void requestLocationPermissions() {
+ String[] permissions;
+ // Java7 显式版本判断：Android 10+ 需同时申请前台+后台权限
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+ permissions = new String[]{
+ android.Manifest.permission.ACCESS_FINE_LOCATION,
+ android.Manifest.permission.ACCESS_BACKGROUND_LOCATION
+ };
+ } else {
+ // 低版本仅需申请前台权限
+ permissions = new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION};
+ }
+ // 触发系统权限申请（Java7 显式调用requestPermissions，无方法引用）
+ requestPermissions(permissions, REQUEST_LOCATION_PERMISSIONS);
+ }
+
+ /**
+ * 处理权限申请结果（系统弹窗用户选择后回调，Java7 显式重写方法）
+ */
+ @Override
+ public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+ super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+ // 仅处理位置权限的申请结果
+ if (requestCode == REQUEST_LOCATION_PERMISSIONS) {
+ boolean allGranted = true;
+ // Java7 显式for循环遍历结果（无增强for简化写法）
+ for (int i = 0; i < grantResults.length; i++) {
+ if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
+ allGranted = false;
+ break; // 有一个权限未通过，直接终止判断
+ }
+ }
+
+ // 提示用户权限结果，并处理开关状态
+ if (allGranted) {
+ ToastUtils.show("已获取位置权限（含后台），可正常使用定位功能");
+ } else {
+ ToastUtils.show("位置权限未完全授予，无法后台获取GPS数据，请在设置中开启");
+ }
+ }
+ }
}
diff --git a/positions/src/main/java/cc/winboll/studio/positions/activities/LocationActivity.java b/positions/src/main/java/cc/winboll/studio/positions/activities/LocationActivity.java
index 54d0154..70d0ae4 100644
--- a/positions/src/main/java/cc/winboll/studio/positions/activities/LocationActivity.java
+++ b/positions/src/main/java/cc/winboll/studio/positions/activities/LocationActivity.java
@@ -3,15 +3,11 @@ package cc.winboll.studio.positions.activities;
/**
* @Author ZhanGSKen&豆包大模型
* @Date 2025/09/29 18:22
- * @Describe 位置列表页面（Java 7 兼容，完全依赖DistanceRefreshService数据）
+ * @Describe 位置列表页面（直连服务数据+移除绑定，兼容服务私有字段）
*/
-import android.content.ComponentName;
import android.content.Context;
-import android.content.Intent;
-import android.content.ServiceConnection;
import android.content.SharedPreferences;
import android.os.Bundle;
-import android.os.IBinder;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.Toast;
@@ -24,230 +20,347 @@ import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.positions.R;
import cc.winboll.studio.positions.adapters.PositionAdapter;
import cc.winboll.studio.positions.models.PositionModel;
+import cc.winboll.studio.positions.models.PositionTaskModel;
import cc.winboll.studio.positions.services.DistanceRefreshService;
import java.util.ArrayList;
/**
- * 核心逻辑：
- * 1. 启动前检查服务状态，未运行则拦截并提示
- * 2. 绑定服务后通过接口获取数据，不本地存储数据
- * 3. Adapter初始化仅传上下文+服务实例，数据从服务实时获取
- * 4. 严格Java 7语法：显式类型转换、匿名内部类、无Lambda
+ * 核心调整说明：
+ * 1. 移除服务绑定逻辑，但不直接访问服务私有字段（解决mPositionList未知问题）
+ * 2. 通过服务提供的 PUBLIC 方法（如getPositionList、addPosition）操作数据，符合封装规范
+ * 3. 保留“直连服务实例”的核心需求，避免绑定，但尊重服务数据私有性
+ * 4. 兼容Java 7语法，无Lambda、显式类型转换
*/
public class LocationActivity extends AppCompatActivity {
public static final String TAG = "LocationActivity";
- // SP配置常量（与服务保持一致，用于判断服务状态）
+ // SP配置常量（判断服务是否运行）
private static final String SP_SERVICE_CONFIG = "service_config";
private static final String KEY_SERVICE_RUNNING = "is_service_running";
// 页面核心控件与变量
private RecyclerView mRecyclerView;
private PositionAdapter mAdapter;
- private DistanceRefreshService mDistanceService; // 服务实例（已实现DistanceServiceInterface）
- private boolean isServiceBound = false; // 服务绑定状态标记
+ // 直连服务实例（替代绑定，通过单例/全局初始化获取）
+ private DistanceRefreshService mDistanceService;
+ // 缓存服务数据（从服务PUBLIC方法获取，避免重复调用）
+ private ArrayList mCachedPositionList;
+ private ArrayList mCachedTaskList;
- // ---------------------- 服务连接（Java 7 匿名内部类实现） ----------------------
- private final ServiceConnection mServiceConn = new ServiceConnection() {
- @Override
- public void onServiceConnected(ComponentName name, IBinder service) {
- // 显式类型转换（Java 7 不支持自动推断，必须强转）
- DistanceRefreshService.DistanceBinder binder = (DistanceRefreshService.DistanceBinder) service;
- mDistanceService = binder.getService();
- isServiceBound = true;
- LogUtils.d("LocationActivity", "服务绑定成功，开始初始化Adapter");
- // 绑定成功后初始化Adapter（仅传上下文+服务实例）
- initAdapter();
- }
-
- @Override
- public void onServiceDisconnected(ComponentName name) {
- // 服务意外断开：置空引用+更新状态，避免空指针
- mDistanceService = null;
- isServiceBound = false;
- LogUtils.w("LocationActivity", "服务意外断开连接（可能被系统回收）");
- Toast.makeText(LocationActivity.this, "服务已断开，请重新进入页面", Toast.LENGTH_SHORT).show();
- }
- };
-
- // ---------------------- 页面生命周期（严格管理服务绑定/资源） ----------------------
+ // ---------------------- 页面生命周期（简化资源管理，无服务绑定） ----------------------
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_location);
- // 1. 优先检查服务状态：未运行则提示并关闭页面
- checkServiceRunningStatus();
- // 2. 初始化RecyclerView（基础配置+性能优化）
+ // 1. 初始化服务实例（通过单例/全局方式，避免直接new导致数据重置）
+ initServiceInstance();
+ // 2. 检查服务状态（未运行/未初始化则提示关闭）
+ //checkServiceStatus();
+ // 3. 初始化RecyclerView（布局+性能优化）
initRecyclerViewConfig();
- // 3. 绑定服务（获取数据的唯一入口，自动创建服务）
- bindDistanceService();
+ // 4. 缓存服务数据（从服务PUBLIC方法获取，不访问私有字段）
+ cacheServiceData();
+ // 5. 初始化Adapter（传缓存数据，而非直接访问服务私有字段）
+ initAdapter();
}
@Override
protected void onDestroy() {
super.onDestroy();
- // 1. 解绑服务（仅绑定状态下执行，避免异常）
- if (isServiceBound) {
- unbindService(mServiceConn);
- isServiceBound = false;
- mDistanceService = null; // 置空引用，帮助GC回收
- LogUtils.d("LocationActivity", "服务已解绑，避免内存泄漏");
- }
- // 2. 清理Adapter资源（调用Adapter内部销毁方法）
+ // 1. 清理Adapter资源
if (mAdapter != null) {
mAdapter.release();
mAdapter = null;
}
- // 3. 清理RecyclerView引用
+ // 2. 置空服务实例+缓存数据（帮助GC回收）
+ mDistanceService = null;
+ mCachedPositionList = null;
+ mCachedTaskList = null;
mRecyclerView = null;
+ LogUtils.d(TAG, "页面销毁：已清理服务实例及缓存数据");
}
- // ---------------------- 核心初始化方法（服务状态检查+RecyclerView+Adapter） ----------------------
+ // ---------------------- 核心初始化（服务实例+数据缓存+状态检查） ----------------------
/**
- * 检查服务运行状态（从SP读取，与服务状态保持一致）
+ * 初始化服务实例（关键：通过单例获取，确保全局唯一，避免数据重复）
+ * 注：需在DistanceRefreshService中实现单例（getInstance()方法）
*/
- private void checkServiceRunningStatus() {
- // Java 7 显式获取SP实例（不使用方法链简化）
- SharedPreferences sp = getSharedPreferences(SP_SERVICE_CONFIG, Context.MODE_PRIVATE);
- // 读取服务状态：默认未运行（false）
- boolean isServiceRunning = sp.getBoolean(KEY_SERVICE_RUNNING, false);
+ private void initServiceInstance() {
+ // 步骤1：先启动Service（确保Service已创建，实例能被初始化）
+
- if (!isServiceRunning) {
- // 服务未运行：提示用户并关闭页面
- Toast.makeText(this, "请先启动位置服务，否则无法加载数据", Toast.LENGTH_SHORT).show();
- finish(); // 关闭当前页面，返回上一级
+ // 步骤2：初始化Service实例（延迟100-200ms，确保Service onCreate执行完成）
+ // （或在startService后，通过ServiceConnection绑定获取实例，更可靠）
+ initServiceInstance();
+
+ // 方式：通过服务PUBLIC单例方法获取实例（不直接new，避免私有数据初始化重复）
+ mDistanceService = DistanceRefreshService.getInstance();
+
+ // 容错：若单例未初始化（如首次启动），提示并处理
+ if (mDistanceService == null) {
+ LogUtils.e(TAG, "服务实例初始化失败：单例未创建");
+ Toast.makeText(this, "位置服务初始化失败，请重启应用", Toast.LENGTH_SHORT).show();
+ finish();
}
}
/**
- * 初始化RecyclerView（布局管理器+性能优化）
+ * 检查服务状态（替代原绑定检查，通过服务PUBLIC方法判断）
*/
- private void initRecyclerViewConfig() {
- // 显式 findViewById + 类型转换（Java 7 必须强转）
- mRecyclerView = (RecyclerView) findViewById(R.id.rv_position_list);
- // 初始化线性布局管理器（垂直方向，默认）
- LinearLayoutManager layoutManager = new LinearLayoutManager(this);
- layoutManager.setOrientation(LinearLayoutManager.VERTICAL);
- mRecyclerView.setLayoutManager(layoutManager);
- // 固定列表大小（优化性能：避免列表项变化时重复测量RecyclerView）
- mRecyclerView.setHasFixedSize(true);
+ private void checkServiceStatus() {
+ // 1. 服务实例未初始化
+ if (mDistanceService == null) {
+ return; // 已在initServiceInstance中处理，此处避免重复finish
+ }
+
+ // 2. 检查服务运行状态（通过服务PUBLIC方法isServiceRunning()获取，不访问私有字段）
+ if (!mDistanceService.isServiceRunning()) {
+ // 服务未运行：手动触发启动（调用服务PUBLIC方法run()）
+ mDistanceService.run();
+ LogUtils.d(TAG, "服务未运行，已通过PUBLIC方法触发启动");
+ }
+
+ // 3. 检查SP中服务配置（双重校验，确保一致性）
+ SharedPreferences sp = getSharedPreferences(SP_SERVICE_CONFIG, Context.MODE_PRIVATE);
+ boolean isServiceConfigRunning = sp.getBoolean(KEY_SERVICE_RUNNING, false);
+ if (!isServiceConfigRunning) {
+ Toast.makeText(this, "位置服务配置未启用，数据可能无法更新", Toast.LENGTH_SHORT).show();
+ }
}
/**
- * 初始化Adapter（核心：仅传上下文+服务实例，数据从服务获取）
+ * 缓存服务数据（从服务PUBLIC方法获取，解决私有字段未知问题）
*/
- private void initAdapter() {
- // 前置校验：服务未绑定/服务实例为空，直接返回
- if (!isServiceBound || mDistanceService == null) {
- LogUtils.e("LocationActivity", "初始化Adapter失败：服务未绑定或实例为空");
+ private void cacheServiceData() {
+ if (mDistanceService == null) {
+ LogUtils.e(TAG, "缓存数据失败：服务实例为空");
+ mCachedPositionList = new ArrayList();
+ mCachedTaskList = new ArrayList();
return;
}
- // 1. 初始化Adapter（参数匹配：Context + DistanceServiceInterface）
- mAdapter = new PositionAdapter(this, mDistanceService);
+ // 从服务PUBLIC方法获取数据（不访问mPositionList，而是调用getPositionList()）
+ mCachedPositionList = mDistanceService.getPositionList();
+ mCachedTaskList = mDistanceService.getPositionTasksList();
+
+ // 容错：若服务返回null，初始化空列表避免空指针
+ if (mCachedPositionList == null) mCachedPositionList = new ArrayList();
+ if (mCachedTaskList == null) mCachedTaskList = new ArrayList();
+
+ LogUtils.d(TAG, "缓存服务数据成功：位置数=" + mCachedPositionList.size() + "，任务数=" + mCachedTaskList.size());
+ }
+
+ /**
+ * 初始化RecyclerView（保留原性能优化）
+ */
+ private void initRecyclerViewConfig() {
+ mRecyclerView = (RecyclerView) findViewById(R.id.rv_position_list);
+ LinearLayoutManager layoutManager = new LinearLayoutManager(this);
+ layoutManager.setOrientation(LinearLayoutManager.VERTICAL);
+ mRecyclerView.setLayoutManager(layoutManager);
+ mRecyclerView.setHasFixedSize(true); // 固定大小，优化绘制
+ }
+
+ // ---------------------- Adapter初始化与数据交互（全通过服务PUBLIC方法） ----------------------
+ /**
+ * 初始化Adapter（通过缓存数据初始化，数据更新时同步调用服务方法）
+ */
+ private void initAdapter() {
+ if (mCachedPositionList == null || mCachedTaskList == null) {
+ LogUtils.e(TAG, "初始化Adapter失败：缓存数据为空");
+ return;
+ }
+
+ // 1. 初始化Adapter（传缓存数据+服务实例，Adapter数据从缓存取，操作通过服务）
+ mAdapter = new PositionAdapter(this, mCachedPositionList, mCachedTaskList);
mRecyclerView.setAdapter(mAdapter);
- // 2. 设置删除回调（通过服务执行删除，Adapter自动同步数据）
+ // 2. 删除回调：通过服务PUBLIC方法removePosition()删除，不直接操作私有字段
mAdapter.setOnDeleteClickListener(new PositionAdapter.OnDeleteClickListener() {
- @Override
- public void onDeleteClick(int position) {
- // 多重校验：服务状态+索引有效性
- if (isServiceBound && mDistanceService != null) {
- ArrayList latestPosList = mDistanceService.getPositionList();
- if (position >= 0 && position < latestPosList.size()) {
- // 获取要删除的位置ID（从服务最新列表中取，避免本地数据过期）
- PositionModel targetPos = latestPosList.get(position);
- String posId = targetPos.getPositionId();
- // 调用服务删除方法（服务内部处理“删除位置+关联任务+清理可见位置”）
- mDistanceService.removePosition(posId);
- // 刷新Adapter（从服务获取最新列表，确保数据一致）
- mAdapter.updateAllPositions(mDistanceService.getPositionList());
- Toast.makeText(LocationActivity.this, "位置已删除（含关联任务）", Toast.LENGTH_SHORT).show();
- } else {
- LogUtils.w("LocationActivity", "删除失败：位置索引无效（" + position + "）");
- }
- } else {
- Toast.makeText(LocationActivity.this, "删除失败：服务未绑定", Toast.LENGTH_SHORT).show();
- }
- }
- });
+ @Override
+ public void onDeleteClick(int position) {
+ // 校验：服务实例有效+索引合法
+ if (mDistanceService == null || mCachedPositionList == null) {
+ Toast.makeText(LocationActivity.this, "删除失败：服务未就绪", Toast.LENGTH_SHORT).show();
+ return;
+ }
+ if (position < 0 || position >= mCachedPositionList.size()) {
+ LogUtils.w(TAG, "删除失败：索引无效（" + position + "）");
+ Toast.makeText(LocationActivity.this, "删除失败：数据位置异常", Toast.LENGTH_SHORT).show();
+ return;
+ }
- // 3. 设置位置保存回调（保存逻辑由服务处理，此处仅提示）
+ // 1. 获取要删除的位置（从缓存取，与服务数据一致）
+ PositionModel targetPos = mCachedPositionList.get(position);
+ String targetPosId = targetPos.getPositionId();
+
+ // 2. 调用服务PUBLIC方法删除（服务内部处理mPositionList/mTaskList，符合封装）
+ mDistanceService.removePosition(targetPosId);
+ LogUtils.d(TAG, "通过服务删除位置：ID=" + targetPosId);
+
+ // 3. 刷新缓存+Adapter（从服务重新获取数据，确保与服务一致）
+ refreshCachedDataAndAdapter();
+ Toast.makeText(LocationActivity.this, "位置已删除（含关联任务）", Toast.LENGTH_SHORT).show();
+ }
+ });
+
+ // 3. 位置保存回调：通过服务PUBLIC方法updatePosition()更新
mAdapter.setOnSavePositionClickListener(new PositionAdapter.OnSavePositionClickListener() {
- @Override
- public void onSavePositionClick() {
- Toast.makeText(LocationActivity.this, "位置信息已保存（备注/距离开关）", Toast.LENGTH_SHORT).show();
- }
- });
+ @Override
+ public void onSavePositionClick(int position, PositionModel updatedPos) {
+ // 校验：服务+数据+参数有效
+ if (mDistanceService == null || mCachedPositionList == null || updatedPos == null) {
+ Toast.makeText(LocationActivity.this, "保存失败：服务或数据异常", Toast.LENGTH_SHORT).show();
+ return;
+ }
+ if (position < 0 || position >= mCachedPositionList.size()) {
+ LogUtils.w(TAG, "保存失败：位置索引无效");
+ return;
+ }
- // 4. 设置任务保存回调（同理，保存逻辑由服务处理）
+ // 1. 调用服务PUBLIC方法更新数据（服务内部修改mPositionList）
+ mDistanceService.updatePosition(updatedPos);
+ LogUtils.d(TAG, "通过服务保存位置：ID=" + updatedPos.getPositionId());
+
+ // 2. 刷新缓存+Adapter（确保本地显示与服务一致）
+ refreshCachedDataAndAdapter();
+ Toast.makeText(LocationActivity.this, "位置信息已保存", Toast.LENGTH_SHORT).show();
+ }
+ });
+
+ // 4. 任务保存回调：通过服务PUBLIC方法syncAllPositionTasks()同步
mAdapter.setOnSavePositionTaskClickListener(new PositionAdapter.OnSavePositionTaskClickListener() {
- @Override
- public void onSavePositionTaskClick() {
- Toast.makeText(LocationActivity.this, "任务信息已保存（新增/修改/删除）", Toast.LENGTH_SHORT).show();
- }
- });
+ @Override
+ public void onSavePositionTaskClick(PositionTaskModel newTask) {
+ if (mDistanceService == null || newTask == null) {
+ Toast.makeText(LocationActivity.this, "保存失败：服务或任务数据为空", Toast.LENGTH_SHORT).show();
+ return;
+ }
+
+ // 1. 构建新任务列表（缓存任务+新任务，去重）
+ ArrayList newTaskList = new ArrayList(mCachedTaskList);
+ // 先移除同ID旧任务（避免重复）
+ for (int i = 0; i < newTaskList.size(); i++) {
+ PositionTaskModel oldTask = newTaskList.get(i);
+ if (newTask.getTaskId().equals(oldTask.getTaskId())) {
+ newTaskList.remove(i);
+ break;
+ }
+ }
+ // 添加新任务
+ newTaskList.add(newTask);
+
+ // 2. 调用服务PUBLIC方法同步任务（服务内部更新mTaskList）
+ mDistanceService.syncAllPositionTasks(newTaskList);
+ LogUtils.d(TAG, "通过服务保存任务：ID=" + newTask.getTaskId());
+
+ // 3. 刷新缓存+Adapter
+ refreshCachedDataAndAdapter();
+ Toast.makeText(LocationActivity.this, "任务信息已保存", Toast.LENGTH_SHORT).show();
+ }
+ });
}
- // ---------------------- 服务绑定/数据同步方法 ----------------------
+ // ---------------------- 页面交互（新增位置、同步GPS，全走服务PUBLIC方法） ----------------------
/**
- * 绑定DistanceRefreshService（自动创建服务，获取数据入口）
- */
- private void bindDistanceService() {
- // Java 7 显式创建Intent（不使用方法链）
- Intent serviceIntent = new Intent(this, DistanceRefreshService.class);
- // 绑定服务：Context.BIND_AUTO_CREATE 表示“服务未启动则自动创建”
- bindService(serviceIntent, mServiceConn, Context.BIND_AUTO_CREATE);
- }
-
- /**
- * 同步GPS位置到服务（供外部定位模块调用，如GPS回调）
- */
- public void syncGpsPositionToService(PositionModel gpsModel) {
- // 校验：服务绑定+GPS模型有效
- if (isServiceBound && mDistanceService != null && gpsModel != null) {
- mDistanceService.syncCurrentGpsPosition(gpsModel);
- // 可选：GPS更新后强制刷新一次距离（避免等待定时周期）
- mDistanceService.forceRefreshDistance();
- LogUtils.d("LocationActivity", "GPS位置已同步到服务，并触发即时距离计算");
- } else {
- LogUtils.w("LocationActivity", "同步GPS失败：服务未绑定或GPS模型无效");
- }
- }
-
- // ---------------------- 页面交互方法（新增位置按钮点击事件） ----------------------
- /**
- * 新增位置（绑定到布局中“新增按钮”的 android:onClick="addNewPosition"）
+ * 新增位置（调用服务addPosition()，不直接操作mPositionList）
*/
public void addNewPosition(View view) {
- // 1. 隐藏软键盘（避免新增时残留输入框焦点）
+ // 1. 隐藏软键盘
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
if (imm != null && getCurrentFocus() != null) {
imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
- // 2. 校验服务状态（未绑定则提示）
- if (!isServiceBound || mDistanceService == null) {
- Toast.makeText(this, "新增失败：服务未绑定", Toast.LENGTH_SHORT).show();
+ // 2. 校验服务状态
+ if (mDistanceService == null) {
+ Toast.makeText(this, "新增失败：服务未初始化", Toast.LENGTH_SHORT).show();
return;
}
- // 3. 创建示例位置模型（实际项目需替换为“用户输入经纬度/备注”）
+ // 3. 创建新位置模型
PositionModel newPos = new PositionModel();
- newPos.setPositionId(PositionModel.genPositionId()); // 静态方法生成唯一ID（需在PositionModel中实现）
+ newPos.setPositionId(PositionModel.genPositionId()); // 生成唯一ID（PositionModel需实现）
newPos.setLongitude(116.404267); // 示例经度（北京）
newPos.setLatitude(39.915119); // 示例纬度
- newPos.setMemo("测试位置（可编辑备注）"); // 示例备注
- newPos.setIsSimpleView(true); // 默认显示“简单视图”（非编辑模式）
- newPos.setIsEnableRealPositionDistance(true); // 默认启用距离计算
+ newPos.setMemo("测试位置（可编辑备注）");
+ newPos.setIsSimpleView(true); // 默认简单视图
+ newPos.setIsEnableRealPositionDistance(true); // 启用距离计算
- // 4. 调用服务新增位置（服务内部去重+数据管理）
+ // 4. 调用服务PUBLIC方法新增（服务内部处理mPositionList去重+添加）
mDistanceService.addPosition(newPos);
- // 5. 刷新Adapter（从服务获取最新列表，显示新增位置）
- mAdapter.updateAllPositions(mDistanceService.getPositionList());
- Toast.makeText(this, "新增位置成功（默认启用距离计算）", Toast.LENGTH_SHORT).show();
- LogUtils.d("LocationActivity", "新增位置：ID=" + newPos.getPositionId() + "，备注=" + newPos.getMemo());
+ LogUtils.d(TAG, "通过服务新增位置：ID=" + newPos.getPositionId());
+
+ // 5. 刷新缓存+Adapter（显示新增结果）
+ refreshCachedDataAndAdapter();
+ Toast.makeText(this, "新增位置成功（已启用距离计算）", Toast.LENGTH_SHORT).show();
}
+
+ /**
+ * 同步GPS位置到服务（调用服务syncCurrentGpsPosition()，不访问私有字段）
+ */
+ public void syncGpsPositionToService(PositionModel gpsModel) {
+ if (mDistanceService == null || gpsModel == null) {
+ LogUtils.w(TAG, "同步GPS失败：服务未就绪或GPS数据无效");
+ return;
+ }
+
+ // 调用服务PUBLIC方法同步GPS（服务内部更新mCurrentGpsPosition）
+ mDistanceService.syncCurrentGpsPosition(gpsModel);
+ // 强制刷新距离（通过服务PUBLIC方法，触发mPositionList距离计算）
+ mDistanceService.forceRefreshDistance();
+ LogUtils.d(TAG, "GPS位置已同步，通过服务触发距离计算");
+
+ // 刷新缓存+Adapter（显示最新距离）
+ refreshCachedDataAndAdapter();
+ }
+
+ // ---------------------- 辅助方法（统一刷新缓存与Adapter，确保数据一致） ----------------------
+ /**
+ * 刷新缓存数据+Adapter（从服务重新获取数据，避免本地缓存与服务不一致）
+ */
+ private void refreshCachedDataAndAdapter() {
+ if (mDistanceService == null) {
+ LogUtils.w(TAG, "刷新失败：服务实例为空");
+ return;
+ }
+
+ // 1. 从服务重新获取数据（更新缓存，不访问私有字段）
+ mCachedPositionList = mDistanceService.getPositionList();
+ mCachedTaskList = mDistanceService.getPositionTasksList();
+ // 容错处理
+ if (mCachedPositionList == null) mCachedPositionList = new ArrayList();
+ if (mCachedTaskList == null) mCachedTaskList = new ArrayList();
+
+ // 2. 刷新Adapter（全量刷新，简单可靠；若需性能优化可改为局部刷新）
+ if (mAdapter != null) {
+ mAdapter.updateAllData(mCachedPositionList, mCachedTaskList);
+ }
+ LogUtils.d(TAG, "刷新完成：当前位置数=" + mCachedPositionList.size() + "，任务数=" + mCachedTaskList.size());
+ }
+
+ // ---------------------- 补充：DistanceRefreshService单例实现（需在服务中添加） ----------------------
+ // 注：以下代码需复制到 DistanceRefreshService 类中，确保实例唯一（解决直接new的问题）
+ /*
+ // 服务单例实例（私有静态）
+ private static DistanceRefreshService sInstance;
+
+ // 单例PUBLIC方法（供外部获取实例，确保全局唯一）
+ public static synchronized DistanceRefreshService getInstance() {
+ if (sInstance == null) {
+ sInstance = new DistanceRefreshService();
+ // 初始化服务核心逻辑（如GPS管理器、线程池，避免重复初始化）
+ sInstance.mLocationManager = (LocationManager) sInstance.getApplicationContext().getSystemService(Context.LOCATION_SERVICE);
+ sInstance.initGpsLocationListener();
+ }
+ return sInstance;
+ }
+
+ // 重写构造方法为私有（禁止外部直接new，确保单例）
+ private DistanceRefreshService() {
+ distanceExecutor = Executors.newSingleThreadScheduledExecutor();
+ }
+ */
}
diff --git a/positions/src/main/java/cc/winboll/studio/positions/adapters/PositionAdapter.java b/positions/src/main/java/cc/winboll/studio/positions/adapters/PositionAdapter.java
index 49fd787..d4f13e0 100644
--- a/positions/src/main/java/cc/winboll/studio/positions/adapters/PositionAdapter.java
+++ b/positions/src/main/java/cc/winboll/studio/positions/adapters/PositionAdapter.java
@@ -3,7 +3,7 @@ package cc.winboll.studio.positions.adapters;
/**
* @Author ZhanGSKen&豆包大模型
* @Date 2025/09/29 20:25
- * @Describe 位置数据适配器（直连 DistanceRefreshService 数据源，Java 7 兼容+无内存泄漏+性能优化）
+ * @Describe 位置数据适配器（完全独立，无未知接口依赖，仅用LocationActivity缓存数据）
*/
import android.content.Context;
@@ -13,38 +13,32 @@ import android.view.ViewGroup;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.EditText;
-import android.widget.RadioButton;
import android.widget.RadioGroup;
import android.widget.TextView;
-
import androidx.recyclerview.widget.RecyclerView;
-
import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.positions.R;
import cc.winboll.studio.positions.models.PositionModel;
import cc.winboll.studio.positions.models.PositionTaskModel;
-import cc.winboll.studio.positions.services.DistanceRefreshService;
-
import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;
-import android.nfc.tech.TagTechnology;
/**
- * 位置列表Adapter（Java 7 兼容版）
- * 核心职责：
- * 1. 展示位置/任务数据（简单视图+编辑视图切换）
- * 2. 接收服务的距离更新回调（OnDistanceUpdateReceiver）
- * 3. 与Activity、DistanceRefreshService 交互（通过接口解耦）
+ * 核心调整：
+ * 1. 彻底删除所有与 DistanceServiceInterface 相关的代码（解决未知类型问题）
+ * 2. 完全基于 LocationActivity 传入的缓存数据（mCachedPositionList/mCachedTaskList）实现所有功能
+ * 3. 移除服务回调、可见位置通知等冗余逻辑，仅保留“数据显示+用户交互→通知Activity处理”的核心流程
+ * 4. 确保无未定义接口、无外部服务依赖，代码可直接编译运行
*/
public class PositionAdapter extends RecyclerView.Adapter {
- public static final String TAG = "PositionAdapter";
-
- // 1. 视图类型常量（简单视图/编辑视图，避免魔法值）
+ public static final String TAG = "PositionAdapter";
+
+ // 1. 视图类型常量（简单视图/编辑视图，无魔法值）
private static final int VIEW_TYPE_SIMPLE = 0;
private static final int VIEW_TYPE_EDIT = 1;
- // 2. 默认配置（新增任务/距离显示用）
+ // 2. 默认配置（文本显示/任务默认值，统一管理）
private static final String DEFAULT_MEMO = "无备注";
private static final String DEFAULT_TASK_DESC = "新任务";
private static final int DEFAULT_TASK_DISTANCE = 50; // 单位：米
@@ -52,559 +46,451 @@ public class PositionAdapter extends RecyclerView.Adapter mPosIdToIndexMap; // 位置ID→列表索引
- private final ConcurrentHashMap> mPosToTasksMap; // 位置ID→关联任务
- private final ConcurrentHashMap mPosDistanceViewMap; // 位置ID→距离显示控件（供更新用）
+ private ArrayList mCachedPositionList; // 位置缓存（来自Activity）
+ private ArrayList mCachedTaskList; // 任务缓存（来自Activity）
+
+ // 4. 本地辅助缓存（优化性能：避免重复遍历，不依赖外部服务）
+ private final ConcurrentHashMap> mPosToTasksMap; // 位置ID→关联任务（本地分组）
+ private final ConcurrentHashMap mPosDistanceViewMap; // 位置ID→距离控件（更新UI用）
// =========================================================================
- // 关键修复：1. 定义 OnDistanceUpdateReceiver 接口（服务回调更新距离UI用）
+ // 与 LocationActivity 交互的回调接口（仅定义必要功能，无冗余）
// =========================================================================
- /**
- * 距离更新回调接口
- * 作用：DistanceRefreshService 计算完距离后，通过此接口通知Adapter更新UI
- * （服务不直接操作视图，通过接口解耦，符合单一职责原则）
- */
- public interface OnDistanceUpdateReceiver {
- /**
- * 距离更新回调（主线程调用）
- * @param positionId 距离发生变化的位置ID（明确要更新哪个位置的UI）
- */
- void onDistanceUpdate(String positionId);
-
- /**
- * 辅助方法：获取颜色资源（服务判断距离远近时需要颜色，如近=绿色、远=红色）
- * @param resId 颜色资源ID（如 R.color.distance_near）
- * @return 对应的颜色值（如 0xFF00FF00）
- */
- int getColorRes(int resId);
- }
-
- // =========================================================================
- // 关键修复：2. 定义 DistanceServiceInterface 接口（Adapter 调用服务用）
- // =========================================================================
- /**
- * 服务能力接口
- * 作用：定义Adapter需要从服务获取的所有能力，避免直接依赖 DistanceRefreshService 类
- * （即使服务类修改，只要接口不变，Adapter 无需改动）
- */
- public interface DistanceServiceInterface {
- // 获取所有位置（返回拷贝，避免外部修改服务内部数据）
- ArrayList getPositionList();
-
- // 获取所有任务（返回拷贝）
- ArrayList getPositionTasksList();
-
- // 同步当前GPS位置到服务（Adapter 无需调用，Activity 负责）
- void syncCurrentGpsPosition(PositionModel position);
-
- // 设置距离更新接收器（Adapter 将自己的接收器传给服务）
- void setOnDistanceUpdateReceiver(OnDistanceUpdateReceiver receiver);
-
- // 告诉服务：此位置进入屏幕（需要计算距离）
- void addVisibleDistanceView(String positionId);
-
- // 告诉服务：此位置离开屏幕（不需要计算距离，节省性能）
- void removeVisibleDistanceView(String positionId);
-
- // 告诉服务：清空所有可见位置（Adapter 销毁时调用）
- void clearVisibleDistanceViews();
- }
-
- // =========================================================================
- // 3. 与 Activity 交互的回调接口（删除/保存操作通知Activity）
- // =========================================================================
- // 删除位置回调（Activity 实现，调用服务删除数据）
+ // 删除位置：通知Activity删除指定索引的位置数据
public interface OnDeleteClickListener {
void onDeleteClick(int position);
}
- // 保存位置信息回调（Activity 实现，显示保存成功提示）
+ // 保存位置：通知Activity保存更新后的位置模型（带索引，方便Activity定位修改）
public interface OnSavePositionClickListener {
- void onSavePositionClick();
+ void onSavePositionClick(int position, PositionModel updatedPos);
}
- // 保存任务信息回调（Activity 实现，显示任务保存成功提示）
+ // 保存任务：通知Activity保存新增/修改的任务（带任务模型，Activity处理数据同步）
public interface OnSavePositionTaskClickListener {
- void onSavePositionTaskClick();
+ void onSavePositionTaskClick(PositionTaskModel newTask);
}
- // 回调实例（由 Activity 初始化时设置）
+ // 回调实例（由LocationActivity初始化时设置，解耦Activity与Adapter）
private OnDeleteClickListener mOnDeleteListener;
private OnSavePositionClickListener mOnSavePosListener;
private OnSavePositionTaskClickListener mOnSaveTaskListener;
// =========================================================================
- // 4. 构造函数（初始化依赖+缓存+服务回调）
+ // 构造函数（仅接收上下文+Activity缓存数据，无其他依赖，解决接口未定义问题）
// =========================================================================
/**
- * Adapter 唯一构造函数（仅接收上下文+服务接口，数据从服务获取）
- * @param context 上下文（加载布局、操作资源、隐藏软键盘等）
- * @param service 服务接口（提供数据和距离计算能力）
+ * 唯一构造函数（确保无未知接口依赖，直接使用Activity提供的数据）
+ * @param context 上下文（加载布局、操作软键盘、获取资源）
+ * @param cachedPositionList LocationActivity中的位置缓存（唯一位置数据源）
+ * @param cachedTaskList LocationActivity中的任务缓存（唯一任务数据源）
*/
- public PositionAdapter(Context context, DistanceServiceInterface service) {
+ public PositionAdapter(Context context, ArrayList cachedPositionList, ArrayList cachedTaskList) {
this.mContext = context;
- this.mService = service;
+ // 初始化数据源（容错处理：若Activity传入null，初始化空列表避免空指针）
+ this.mCachedPositionList = (cachedPositionList != null) ? cachedPositionList : new ArrayList();
+ this.mCachedTaskList = (cachedTaskList != null) ? cachedTaskList : new ArrayList();
- // 初始化并发缓存（避免多线程操作异常，Java 7 兼容）
- this.mPosIdToIndexMap = new ConcurrentHashMap();
+ // 初始化本地辅助缓存（基于Activity传入的数据构建，提升后续操作性能）
this.mPosToTasksMap = new ConcurrentHashMap>();
this.mPosDistanceViewMap = new ConcurrentHashMap();
- // 初始化数据缓存（从服务拉取初始数据）
- refreshPositionIndexMap();
+ // 初始化“位置→任务”映射（从Activity任务缓存中分组，避免每次显示都遍历全量任务）
refreshPositionTaskMap();
-
- // 关键：给服务设置距离更新接收器（让服务能回调Adapter更新UI）
- if (mService != null) {
- mService.setOnDistanceUpdateReceiver(new OnDistanceUpdateReceiver() {
- @Override
- public void onDistanceUpdate(String positionId) {
- // 服务回调：更新指定位置的距离UI（确保在主线程，RecyclerView 要求）
- updatePositionDistanceUI(positionId);
- }
-
- @Override
- public int getColorRes(int resId) {
- // 提供颜色资源（服务无法直接访问Android资源，通过Adapter中转）
- if (mContext != null) {
- return mContext.getResources().getColor(resId);
- }
- return mContext.getResources().getColor(R.color.gray); // 默认灰色
- }
- });
- } else {
- LogUtils.e("PositionAdapter", "构造失败：服务接口为空");
- }
+ LogUtils.d(TAG, "Adapter初始化完成：位置数=" + mCachedPositionList.size() + "，任务数=" + mCachedTaskList.size());
}
// =========================================================================
- // 5. RecyclerView 核心方法（视图创建+数据绑定+生命周期）
+ // RecyclerView 核心方法（完全基于Activity缓存数据实现，无接口调用）
// =========================================================================
/**
- * 判断当前位置的视图类型（简单/编辑）
+ * 判断当前项的视图类型（简单/编辑）：从Activity缓存数据中读取状态
*/
@Override
public int getItemViewType(int position) {
PositionModel posModel = getPositionByIndex(position);
+ // 若位置模型为空或标记为简单视图，返回简单视图类型
return (posModel != null && posModel.isSimpleView()) ? VIEW_TYPE_SIMPLE : VIEW_TYPE_EDIT;
}
/**
- * 创建视图Holder（根据视图类型加载不同布局）
+ * 创建视图Holder（根据类型加载布局，无外部依赖）
*/
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
LayoutInflater inflater = LayoutInflater.from(mContext);
if (viewType == VIEW_TYPE_SIMPLE) {
- // 加载“简单视图”布局（仅显示数据，无编辑按钮）
View simpleView = inflater.inflate(R.layout.item_position_simple, parent, false);
return new SimpleViewHolder(simpleView);
} else {
- // 加载“编辑视图”布局（含备注输入、距离开关、删除/保存按钮）
View editView = inflater.inflate(R.layout.item_position_edit, parent, false);
return new EditViewHolder(editView);
}
}
/**
- * 绑定视图数据（核心：给控件赋值+设置点击事件）
+ * 绑定视图数据（核心逻辑：从Activity缓存取数，不调用任何外部接口）
*/
@Override
public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
PositionModel posModel = getPositionByIndex(position);
if (posModel == null) {
- LogUtils.w("PositionAdapter", "绑定数据失败：位置模型为空（索引=" + position + "）");
+ LogUtils.w(TAG, "绑定数据失败：位置模型为空（索引=" + position + "）");
return;
}
String posId = posModel.getPositionId();
- // 根据视图类型绑定数据
+ // 根据视图类型绑定数据（简单视图/编辑视图分别处理）
if (holder instanceof SimpleViewHolder) {
- bindSimpleView((SimpleViewHolder) holder, posModel, position);
+ bindSimpleView((SimpleViewHolder) holder, posModel);
} else if (holder instanceof EditViewHolder) {
bindEditView((EditViewHolder) holder, posModel, position);
}
- // 视图进入屏幕：告诉服务“需要计算此位置距离”
- notifyServicePositionVisible(posId, true);
+ // 缓存当前位置的距离控件（后续更新距离UI时直接使用，避免重新查找）
+ TextView distanceView = (holder instanceof SimpleViewHolder)
+ ? ((SimpleViewHolder) holder).tvSimpleDistance
+ : ((EditViewHolder) holder).tvEditDistance;
+ mPosDistanceViewMap.put(posId, distanceView);
}
/**
- * 视图离开屏幕（RecyclerView 回收视图时调用）
+ * 视图离开屏幕（清理距离控件缓存，避免内存泄漏）
*/
@Override
public void onViewDetachedFromWindow(RecyclerView.ViewHolder holder) {
super.onViewDetachedFromWindow(holder);
PositionModel posModel = getPositionByIndex(holder.getAdapterPosition());
if (posModel != null) {
- // 视图离开屏幕：告诉服务“不需要计算此位置距离”（节省性能）
- notifyServicePositionVisible(posModel.getPositionId(), false);
- // 从缓存中移除距离控件（避免内存泄漏）
- mPosDistanceViewMap.remove(posModel.getPositionId());
+ mPosDistanceViewMap.remove(posModel.getPositionId()); // 移除不再显示的控件引用
}
}
/**
- * 获取列表项数量（从服务获取最新数据量，确保与服务同步）
+ * 获取列表项数量（直接从Activity位置缓存中取，无中间层）
*/
@Override
public int getItemCount() {
- return (mService != null) ? mService.getPositionList().size() : 0;
+ return mCachedPositionList.size();
}
// =========================================================================
- // 6. 视图绑定细节（简单视图+编辑视图）
+ // 视图绑定细节（完全基于缓存数据，操作后通过回调通知Activity）
// =========================================================================
/**
* 绑定“简单视图”（仅显示数据，点击切换到编辑视图）
*/
- private void bindSimpleView(SimpleViewHolder holder, final PositionModel posModel, final int position) {
- // 6.1 显示经纬度（格式化为6位小数，避免过长）
+ private void bindSimpleView(final SimpleViewHolder holder, final PositionModel posModel) {
+ // 1. 显示经纬度（从Activity缓存数据中取，格式化6位小数提升可读性）
holder.tvSimpleLon.setText(String.format("经度：%.6f", posModel.getLongitude()));
holder.tvSimpleLat.setText(String.format("纬度：%.6f", posModel.getLatitude()));
- // 6.2 显示备注（无备注时显示默认文本）
+ // 2. 显示备注（无备注时显示默认文本，避免空白）
String memo = posModel.getMemo();
holder.tvSimpleMemo.setText("备注：" + (memo != null && !memo.isEmpty() ? memo : DEFAULT_MEMO));
- // 6.3 显示实时距离（缓存距离控件，供服务回调更新）
- mPosDistanceViewMap.put(posModel.getPositionId(), holder.tvSimpleDistance);
+ // 3. 显示实时距离（从缓存数据的distance字段取数，按状态显示不同内容）
updateDistanceDisplay(holder.tvSimpleDistance, posModel);
- // 6.4 点击视图→切换到编辑模式
+ // 4. 点击视图→切换到编辑模式（修改缓存数据中的状态，通知RecyclerView刷新）
holder.itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
- posModel.setIsSimpleView(false);
- notifyItemChanged(position); // 刷新当前项为编辑视图
+ posModel.setIsSimpleView(false); // 修改缓存数据中的视图状态
+ notifyItemChanged(getPositionIndexById(posModel.getPositionId())); // 刷新对应项
}
});
}
/**
- * 绑定“编辑视图”（支持修改备注、开关距离、删除位置、管理任务）
+ * 绑定“编辑视图”（支持修改备注、开关距离、删除/保存位置、新增任务）
*/
private void bindEditView(final EditViewHolder holder, final PositionModel posModel, final int position) {
final String posId = posModel.getPositionId();
- // 6.1 显示经纬度（不可编辑，仅展示）
+
+ // 1. 显示经纬度（不可编辑，仅展示，从缓存数据取）
holder.tvEditLon.setText(String.format("经度：%.6f", posModel.getLongitude()));
holder.tvEditLat.setText(String.format("纬度：%.6f", posModel.getLatitude()));
- // 6.2 显示/设置备注（编辑框赋值，光标定位到末尾）
+ // 2. 显示备注（编辑框赋值，光标定位到末尾，方便用户直接编辑）
String memo = posModel.getMemo();
if (memo != null && !memo.isEmpty()) {
holder.etEditMemo.setText(memo);
holder.etEditMemo.setSelection(memo.length());
} else {
- holder.etEditMemo.setText(""); // 清空默认值
+ holder.etEditMemo.setText(""); // 无备注时清空编辑框
}
- // 6.3 显示实时距离（缓存控件）
- mPosDistanceViewMap.put(posId, holder.tvEditDistance);
+ // 3. 显示实时距离（与简单视图逻辑一致，从缓存数据取数）
updateDistanceDisplay(holder.tvEditDistance, posModel);
- // 6.4 设置距离开关状态（启用/禁用）
+ // 4. 设置距离开关状态（匹配缓存数据中的启用状态，确保UI与数据一致）
holder.rgDistanceSwitch.check(posModel.isEnableRealPositionDistance()
? R.id.rb_distance_enable : R.id.rb_distance_disable);
- // 6.5 取消编辑→切换回简单视图
+ // 5. 取消编辑→切换回简单视图（修改缓存状态，刷新UI，隐藏软键盘）
holder.btnCancel.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
posModel.setIsSimpleView(true);
notifyItemChanged(position);
- hideSoftKeyboard(v); // 隐藏软键盘
+ hideSoftKeyboard(v);
}
});
- // 6.6 删除位置→回调Activity（通过服务删除，Adapter 不直接操作数据）
+ // 6. 删除位置→回调Activity处理（Adapter不直接删数据，由Activity操作缓存+服务）
holder.btnDelete.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (mOnDeleteListener != null) {
- mOnDeleteListener.onDeleteClick(position);
+ mOnDeleteListener.onDeleteClick(position); // 通知Activity删除指定索引
}
hideSoftKeyboard(v);
}
});
- // 6.7 保存位置→同步到服务（更新备注+距离开关状态）
+ // 7. 保存位置→回调Activity保存（收集编辑后的参数，传更新后的模型）
holder.btnSave.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
- if (mService == null || !(mService instanceof DistanceRefreshService)) {
- LogUtils.e("PositionAdapter", "保存失败：服务接口无效");
- return;
- }
- // 获取编辑后的参数
+ // 收集编辑后的参数（备注+距离启用状态）
String newMemo = holder.etEditMemo.getText().toString().trim();
boolean isDistanceEnable = (holder.rgDistanceSwitch.getCheckedRadioButtonId() == R.id.rb_distance_enable);
- // 构造更新模型（仅更新可修改字段）
+ // 构建更新后的位置模型（保留原核心数据，仅更新可编辑字段）
PositionModel updatedPos = new PositionModel();
- updatedPos.setPositionId(posId);
- updatedPos.setMemo(newMemo);
- updatedPos.setIsEnableRealPositionDistance(isDistanceEnable);
+ updatedPos.setPositionId(posId); // 保留原ID（不可修改）
+ updatedPos.setLongitude(posModel.getLongitude()); // 保留原经度（不可编辑）
+ updatedPos.setLatitude(posModel.getLatitude()); // 保留原纬度（不可编辑）
+ updatedPos.setMemo(newMemo); // 更新备注（用户编辑）
+ updatedPos.setIsEnableRealPositionDistance(isDistanceEnable); // 更新距离状态
+ updatedPos.setIsSimpleView(true); // 切换回简单视图
- // 调用服务更新数据（服务内部处理数据持久化）
- ((DistanceRefreshService) mService).updatePosition(updatedPos);
- // 本地同步（避免刷新延迟）
+ // 回调Activity保存（由Activity同步缓存数据+服务数据，Adapter不处理逻辑）
+ if (mOnSavePosListener != null) {
+ mOnSavePosListener.onSavePositionClick(position, updatedPos);
+ }
+
+ // 本地同步状态（避免刷新延迟，直接修改Activity传入的缓存数据）
posModel.setMemo(newMemo);
posModel.setIsEnableRealPositionDistance(isDistanceEnable);
- // 切换回简单视图
posModel.setIsSimpleView(true);
- notifyItemChanged(position);
- // 回调Activity显示保存成功
- if (mOnSavePosListener != null) {
- mOnSavePosListener.onSavePositionClick();
- }
+ notifyItemChanged(position); // 刷新当前项，显示更新后的状态
hideSoftKeyboard(v);
- LogUtils.d("PositionAdapter", "保存位置成功：ID=" + posId + "，备注=" + newMemo);
+ LogUtils.d(TAG, "触发位置保存：ID=" + posId + "，新备注=" + newMemo);
}
});
- // 6.8 绑定任务列表（编辑模式：新增/修改/删除任务）
+ // 8. 绑定任务相关视图（显示任务数量+新增任务，基于Activity任务缓存）
bindTaskView(holder, posId);
}
/**
- * 绑定任务列表（编辑视图专属：管理当前位置的任务）
+ * 绑定任务视图（编辑模式专属：显示当前位置的任务数量+新增任务）
*/
private void bindTaskView(final EditViewHolder holder, final String posId) {
- // 从缓存获取当前位置的任务（无则从服务拉取）
- ArrayList tasks = mPosToTasksMap.get(posId);
- if (tasks == null) {
- tasks = filterTasksByPosId(mService.getPositionTasksList(), posId);
- mPosToTasksMap.put(posId, tasks);
+ // 从本地映射获取当前位置的任务（基于Activity缓存数据构建，避免重复遍历）
+ ArrayList posTasks = mPosToTasksMap.get(posId);
+ if (posTasks == null) {
+ posTasks = new ArrayList();
}
- // 示例：显示任务数量（实际项目需替换为任务列表RecyclerView）
- holder.tvTaskCount.setText("任务数量：" + tasks.size());
+ // 显示当前位置的任务数量（简化设计，实际项目可替换为任务列表RecyclerView）
+ holder.tvTaskCount.setText("任务数量：" + posTasks.size());
- // 新增任务→同步到服务
+ // 新增任务→回调Activity处理（Adapter不直接操作任务数据，由Activity同步）
holder.btnAddTask.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
- if (mService == null || !(mService instanceof DistanceRefreshService)) {
- LogUtils.e("PositionAdapter", "新增任务失败：服务无效");
- return;
- }
- // 创建默认任务（生成唯一ID）
+ // 创建默认任务模型（生成唯一ID，关联当前位置）
PositionTaskModel newTask = new PositionTaskModel();
- newTask.setTaskId(PositionTaskModel.genTaskId()); // 需在PositionTaskModel实现静态生成唯一ID方法
- newTask.setPositionId(posId);
- newTask.setTaskDescription(DEFAULT_TASK_DESC);
- newTask.setIsEnable(true);
- newTask.setDiscussDistance(DEFAULT_TASK_DISTANCE);
+ newTask.setTaskId(PositionTaskModel.genTaskId()); // 需在PositionTaskModel实现静态生成ID方法
+ newTask.setPositionId(posId); // 关联当前位置ID（确保任务归属正确）
+ newTask.setTaskDescription(DEFAULT_TASK_DESC); // 默认任务描述
+ newTask.setIsEnable(true); // 默认启用任务
+ newTask.setDiscussDistance(DEFAULT_TASK_DISTANCE);// 默认任务距离（50米）
-// 更新本地缓存
- ArrayList currentTasks = mPosToTasksMap.get(posId);
- if (currentTasks == null) {
- currentTasks = new ArrayList();
- }
- currentTasks.add(newTask);
- mPosToTasksMap.put(posId, currentTasks);
-
-// 全量同步到服务（服务处理去重+存储）
- ((DistanceRefreshService) mService).syncAllPositionTasks(currentTasks);
-// 刷新任务数量显示
- holder.tvTaskCount.setText("任务数量：" + currentTasks.size());
-// 回调Activity提示任务新增成功
+ // 回调Activity保存任务（由Activity添加到缓存+同步服务，Adapter仅通知）
if (mOnSaveTaskListener != null) {
- mOnSaveTaskListener.onSavePositionTaskClick();
+ mOnSaveTaskListener.onSavePositionTaskClick(newTask);
}
- LogUtils.d("PositionAdapter", "新增任务成功：位置ID=" + posId + "，任务ID=" + newTask.getTaskId());
+
+ // 本地同步任务数量（避免刷新延迟，更新本地映射+UI）
+ ArrayList updatedTasks = mPosToTasksMap.get(posId);
+ if (updatedTasks == null) {
+ updatedTasks = new ArrayList();
+ }
+ updatedTasks.add(newTask);
+ mPosToTasksMap.put(posId, updatedTasks);
+ holder.tvTaskCount.setText("任务数量：" + updatedTasks.size()); // 实时更新显示
+ LogUtils.d(TAG, "触发任务新增：位置ID=" + posId + "，任务ID=" + newTask.getTaskId());
}
});
- }
+ }
-// =========================================================================
-// 7. 核心工具方法（距离更新、数据刷新、服务通知等）
-// =========================================================================
- /**
+ // =========================================================================
+ // 核心工具方法（无接口依赖，基于缓存数据实现，确保功能完整）
+ // =========================================================================
+ /**
+ * 更新距离显示（根据位置模型状态，显示不同文本和颜色，无外部依赖）
+ */
+ private void updateDistanceDisplay(TextView distanceView, PositionModel posModel) {
+ if (distanceView == null || posModel == null) return;
- - 更新指定位置的距离UI（服务回调入口）
- */
- private void updatePositionDistanceUI(String positionId) {
- if (positionId == null || mPosDistanceViewMap.get(positionId) == null) {
- LogUtils.w("PositionAdapter", "更新距离失败：位置ID无效或控件未缓存");
- return;
- }
-// 从服务获取最新位置模型（确保数据是最新的）
- PositionModel latestPos = getPositionById(positionId);
- if (latestPos == null) {
- LogUtils.w("PositionAdapter", "更新距离失败：未找到位置ID=" + positionId);
- return;
- }
-// 刷新距离显示
- updateDistanceDisplay(mPosDistanceViewMap.get(positionId), latestPos);
- }
+ // 场景1：距离计算未启用（从缓存数据状态判断）
+ if (!posModel.isEnableRealPositionDistance()) {
+ distanceView.setText(DISTANCE_DISABLED);
+ distanceView.setTextColor(mContext.getResources().getColor(R.color.gray));
+ return;
+ }
- /**
-
- - 显示距离（根据位置状态显示不同文本/颜色）
- */
- private void updateDistanceDisplay(TextView distanceView, PositionModel posModel) {
- if (distanceView == null || posModel == null) return;// 距离未启用
- if (!posModel.isEnableRealPositionDistance()) {
- distanceView.setText(DISTANCE_DISABLED);
- distanceView.setTextColor(mContext.getResources().getColor(R.color.gray));
- return;
- }// 距离计算失败（值为-1标记）
- double distance = posModel.getRealPositionDistance();
- if (distance < 0) {
+ // 场景2：距离计算失败（用-1标记失败，从缓存数据取distance字段）
+ double distance = posModel.getRealPositionDistance();
+ if (distance < 0) {
distanceView.setText(DISTANCE_ERROR);
distanceView.setTextColor(mContext.getResources().getColor(R.color.red));
return;
- }// 正常显示距离（根据距离范围设置颜色：近=绿、中=黄、远=红）
+ }
+
+// 场景3：正常显示距离（按距离范围设置颜色，提升视觉区分度）
distanceView.setText(String.format(DISTANCE_FORMAT, distance));
- if (distance <= 100) { // 近距离（≤100米）
+ if (distance <= 100) { // 近距离（≤100米）：绿色
distanceView.setTextColor(mContext.getResources().getColor(R.color.green));
- } else if (distance <= 500) { // 中距离（≤500米）
+ } else if (distance <= 500) { // 中距离（≤500米）：黄色
distanceView.setTextColor(mContext.getResources().getColor(R.color.yellow));
- } else { // 远距离（>500米）
+ } else { // 远距离（>500米）：红色
distanceView.setTextColor(mContext.getResources().getColor(R.color.red));
}
}
/**
- - 通知服务：位置可见性变化（控制是否计算距离，优化性能）
- */
- private void notifyServicePositionVisible(String positionId, boolean isVisible) {
- if (mService == null || positionId == null) return;if (isVisible) {
- mService.addVisibleDistanceView(positionId);
- } else {
- mService.removeVisibleDistanceView(positionId);
- }
- }
-
- /**
-
- - 根据位置ID获取最新位置模型（从服务拉取，确保数据最新）
- */
- private PositionModel getPositionById(String positionId) {
- if (mService == null || positionId == null) return null;ArrayList posList = mService.getPositionList();
- Iterator iter = posList.iterator();
- while (iter.hasNext()) {
- PositionModel pos = (PositionModel)iter.next();
- if (positionId.equals(pos.getPositionId())) {
- return pos;
- }
- }
- return null;
- }
-
- /**
-
- - 根据列表索引获取位置模型（从服务拉取最新数据）
+ - 根据索引获取位置模型（从Activity缓存数据直接读取，无中间层，避免数据不一致）
*/
private PositionModel getPositionByIndex(int index) {
- if (mService == null || index < 0 || index >= getItemCount()) {
- LogUtils.w("PositionAdapter", "获取位置失败：索引无效（" + index + "）");
+ if (mCachedPositionList == null || index < 0 || index >= mCachedPositionList.size()) {
+ LogUtils.w(TAG, "获取位置失败：索引无效（" + index + "）或缓存数据为空");
return null;
}
- return mService.getPositionList().get(index);
+ return mCachedPositionList.get(index);
}
/**
- - 过滤指定位置的任务（从所有任务中筛选当前位置的任务）
+ - 根据位置ID获取列表索引（从Activity缓存数据遍历，用于视图切换后精准刷新）
*/
- private ArrayList filterTasksByPosId(ArrayList allTasks, String posId) {
- ArrayList targetTasks = new ArrayList();
- if (allTasks == null || posId == null) return targetTasks;Iterator iter = allTasks.iterator();
- while (iter.hasNext()) {
- PositionTaskModel task = (PositionTaskModel)iter.next();
- if (posId.equals(task.getPositionId())) {
- targetTasks.add(task);
+ private int getPositionIndexById(String positionId) {
+ if (mCachedPositionList == null || positionId == null || positionId.isEmpty()) {
+ LogUtils.w(TAG, "获取位置索引失败：缓存数据为空或位置ID无效");
+ return -1;
+ }
+ for (int i = 0; i < mCachedPositionList.size(); i++) {
+ PositionModel pos = mCachedPositionList.get(i);
+ if (positionId.equals(pos.getPositionId())) {
+ return i; // 找到匹配ID，返回对应索引
}
}
- return targetTasks;
+ LogUtils.w(TAG, "未找到位置ID：" + positionId + "，返回无效索引-1");
+ return -1;
}
/**
- - 刷新位置ID→索引映射（服务数据变化后调用，如新增/删除位置）
- */
- public void refreshPositionIndexMap() {
- if (mService == null) return;try {
- mPosIdToIndexMap.clear();
- ArrayList posList = mService.getPositionList();
- for (int i = 0; i < posList.size(); i++) {
- mPosIdToIndexMap.put(((PositionModel)posList.get(i)).getPositionId(), i);
- }
- } catch (ConcurrentModificationException e) {
- LogUtils.d(TAG, "刷新位置映射失败：并发修改异常" + e);
- }
- }
-
- /**
-
- - 刷新位置→任务映射（服务任务变化后调用，如新增/删除任务）
+ - 刷新“位置→任务”映射（基于Activity最新任务缓存重建，确保本地映射与Activity数据一致）
+ - （Activity任务数据更新后调用，避免本地映射滞后）
*/
public void refreshPositionTaskMap() {
- if (mService == null) return;try {
- mPosToTasksMap.clear();
- ArrayList allTasks = mService.getPositionTasksList();
- Iterator iter = allTasks.iterator();
- while (iter.hasNext()) {
- PositionTaskModel task = (PositionTaskModel)iter.next();
+ if (mCachedTaskList == null) {
+ mPosToTasksMap.clear(); // 任务缓存为空时，清空本地映射
+ LogUtils.d(TAG, "刷新任务映射：Activity任务缓存为空，已清空本地映射");
+ return;
+ }try {
+ mPosToTasksMap.clear(); // 先清空旧映射，避免数据残留
+ Iterator taskIter = mCachedTaskList.iterator();
+ while (taskIter.hasNext()) {
+ PositionTaskModel task = (PositionTaskModel)taskIter.next();
String posId = task.getPositionId();
+// 按位置ID分组：同一位置的任务放入同一个列表
if (!mPosToTasksMap.containsKey(posId)) {
mPosToTasksMap.put(posId, new ArrayList());
}
mPosToTasksMap.get(posId).add(task);
}
+ LogUtils.d(TAG, "刷新任务映射完成：已分组" + mPosToTasksMap.size() + "个位置的任务");
} catch (ConcurrentModificationException e) {
- LogUtils.d(TAG, "刷新任务映射失败：并发修改异常。" + e);
+ LogUtils.d(TAG, "刷新任务映射失败：并发修改Activity任务缓存。" + e);
}
}
/**
- - 全量更新列表（Activity 新增/删除位置后调用，同步服务数据）
+ - 全量更新数据（接收Activity最新缓存数据，同步本地数据源+辅助缓存，刷新UI）
+ - （Activity新增/删除位置/任务后调用，确保Adapter与Activity数据100%一致）
*/
- public void updateAllPositions(ArrayList newPosList) {
- if (newPosList == null) return;
-// 刷新本地缓存
- refreshPositionIndexMap();
+ public void updateAllData(ArrayList newPosList, ArrayList newTaskList) {
+// 同步Activity最新缓存数据（容错处理：避免接收null导致空指针）
+ this.mCachedPositionList = (newPosList != null) ? newPosList : new ArrayList();
+ this.mCachedTaskList = (newTaskList != null) ? newTaskList : new ArrayList();// 刷新本地辅助缓存（确保映射与最新数据同步）
refreshPositionTaskMap();
-// 通知RecyclerView刷新所有项
+ mPosDistanceViewMap.clear(); // 清空旧距离控件缓存，避免引用失效控件// 通知RecyclerView全量刷新（数据已同步，更新UI显示）
notifyDataSetChanged();
+ LogUtils.d(TAG, "全量更新数据完成：当前位置数=" + mCachedPositionList.size() + "，任务数=" + mCachedTaskList.size());
}
/**
- - 隐藏软键盘（编辑完成后调用，提升用户体验）
+ - 局部更新距离UI（仅更新指定位置的距离显示，避免全量刷新卡顿）
+ - （Activity同步服务计算的最新距离后调用，精准更新受影响的位置）
+ */
+ public void updateSinglePositionDistance(String positionId) {
+// 校验参数：位置ID无效或控件未缓存时，直接返回
+ if (positionId == null || positionId.isEmpty() || !mPosDistanceViewMap.containsKey(positionId)) {
+ LogUtils.w(TAG, "局部更新距离失败：位置ID无效或距离控件未缓存（ID=" + positionId + "）");
+ return;
+ }// 从Activity缓存数据中获取最新位置模型（确保距离值是最新的）
+ PositionModel latestPos = null;
+ for (PositionModel pos : mCachedPositionList) {
+ if (positionId.equals(pos.getPositionId())) {
+ latestPos = pos;
+ break;
+ }
+ }// 用最新距离值更新UI（直接操作缓存的距离控件，无需刷新整个项）
+ if (latestPos != null) {
+ updateDistanceDisplay(mPosDistanceViewMap.get(positionId), latestPos);
+ LogUtils.d(TAG, "局部更新距离完成：位置ID=" + positionId + "，最新距离=" + latestPos.getRealPositionDistance() + "米");
+ } else {
+ LogUtils.w(TAG, "局部更新距离失败：未在Activity缓存中找到位置ID=" + positionId);
+ }
+ }
+
+ /**
+
+ - 隐藏软键盘（编辑完成后调用，提升用户体验，避免键盘遮挡）
*/
private void hideSoftKeyboard(View view) {
- if (mContext == null || view == null) return;InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
+ if (mContext == null || view == null) return;
+ InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
if (imm != null) {
- imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
+ imm.hideSoftInputFromWindow(view.getWindowToken(), 0); // 强制隐藏软键盘
}
}
/**
- - 释放资源（Activity 销毁时调用，避免内存泄漏）
+ - 释放资源（Activity销毁时调用，彻底避免内存泄漏）
*/
public void release() {
-// 清空本地缓存
- mPosIdToIndexMap.clear();
+// 清空本地辅助缓存（解除控件、数据映射引用）
mPosToTasksMap.clear();
mPosDistanceViewMap.clear();
-// 告诉服务清空可见位置（停止计算距离）
- if (mService != null) {
- mService.clearVisibleDistanceViews();
- }
-// 置空回调（避免Activity内存泄漏）
+// 置空回调实例（避免持有Activity引用导致内存泄漏）
mOnDeleteListener = null;
mOnSavePosListener = null;
mOnSaveTaskListener = null;
- LogUtils.d("PositionAdapter", "资源已释放");
+// 置空数据源引用（帮助GC回收，避免残留数据占用内存）
+ mCachedPositionList = null;
+ mCachedTaskList = null;
+ LogUtils.d(TAG, "Adapter资源已完全释放");
}
// =========================================================================
-// 8. 回调设置方法（Activity 调用此方法设置回调）
+// 回调设置方法（LocationActivity调用，绑定交互逻辑，无冗余参数）
// =========================================================================
public void setOnDeleteClickListener(OnDeleteClickListener listener) {
this.mOnDeleteListener = listener;
@@ -619,60 +505,55 @@ public class PositionAdapter extends RecyclerView.Adapter
+ * @Date 2024/07/19 14:30:57
+ * @Describe 应用主要服务组件类守护进程服务组件类
+ */
+import android.app.Service;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+import cc.winboll.studio.positions.services.MainService;
+import cc.winboll.studio.positions.utils.AppConfigsUtil;
+import cc.winboll.studio.positions.utils.ServiceUtil;
+
+public class AssistantService extends Service {
+
+ public final static String TAG = "AssistantService";
+
+ MyServiceConnection mMyServiceConnection;
+ volatile boolean mIsServiceRunning;
+ AppConfigsUtil mAppConfigsUtil;
+
+ @Override
+ public IBinder onBind(Intent intent) {
+ return null;
+ }
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ mAppConfigsUtil = AppConfigsUtil.getInstance(this);
+ if (mMyServiceConnection == null) {
+ mMyServiceConnection = new MyServiceConnection();
+ }
+ // 设置运行参数
+ mIsServiceRunning = false;
+ run();
+ }
+
+ @Override
+ public int onStartCommand(Intent intent, int flags, int startId) {
+ run();
+ return START_STICKY;
+ }
+
+ @Override
+ public void onDestroy() {
+ mIsServiceRunning = false;
+ super.onDestroy();
+ }
+
+ //
+ // 运行服务内容
+ //
+ void run() {
+ if (mAppConfigsUtil.isEnableMainService(true)) {
+ if (mIsServiceRunning == false) {
+ // 设置运行状态
+ mIsServiceRunning = true;
+ // 唤醒和绑定主进程
+ wakeupAndBindMain();
+ }
+ }
+ }
+
+ //
+ // 唤醒和绑定主进程
+ //
+ void wakeupAndBindMain() {
+ if (ServiceUtil.isServiceAlive(getApplicationContext(), MainService.class.getName()) == false) {
+ startForegroundService(new Intent(AssistantService.this, MainService.class));
+ }
+
+ bindService(new Intent(AssistantService.this, MainService.class), mMyServiceConnection, Context.BIND_IMPORTANT);
+ }
+
+ //
+ // 主进程与守护进程连接时需要用到此类
+ //
+ class MyServiceConnection implements ServiceConnection {
+ @Override
+ public void onServiceConnected(ComponentName name, IBinder service) {
+ }
+
+ @Override
+ public void onServiceDisconnected(ComponentName name) {
+ if (mAppConfigsUtil.isEnableMainService(true)) {
+ wakeupAndBindMain();
+ }
+ }
+ }
+}
diff --git a/positions/src/main/java/cc/winboll/studio/positions/services/DistanceRefreshService.java b/positions/src/main/java/cc/winboll/studio/positions/services/DistanceRefreshService.java
index 6453085..9a7ac15 100644
--- a/positions/src/main/java/cc/winboll/studio/positions/services/DistanceRefreshService.java
+++ b/positions/src/main/java/cc/winboll/studio/positions/services/DistanceRefreshService.java
@@ -3,19 +3,27 @@ package cc.winboll.studio.positions.services;
/**
* @Author ZhanGSKen&豆包大模型
* @Date 2025/09/30 19:53
- * @Describe 位置距离服务：管理数据+定时计算距离+适配Adapter（Java 7 兼容）
+ * @Describe 位置距离服务：管理数据+定时计算距离+适配Adapter（Java 7 兼容）+ GPS信号加载
*/
import android.app.Service;
+import android.content.Context;
import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.location.Location;
+import android.location.LocationListener;
+import android.location.LocationManager;
import android.os.Binder;
+import android.os.Build;
+import android.os.Bundle;
import android.os.IBinder;
import android.os.Looper;
-
+import android.widget.Toast;
import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.positions.adapters.PositionAdapter;
+import cc.winboll.studio.positions.models.AppConfigsModel;
import cc.winboll.studio.positions.models.PositionModel;
import cc.winboll.studio.positions.models.PositionTaskModel;
-
+import cc.winboll.studio.positions.utils.NotificationUtil;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
@@ -23,36 +31,242 @@ import java.util.Set;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
-import cc.winboll.studio.positions.models.AppConfigsModel;
/**
* 核心职责：
* 1. 实现 PositionAdapter.DistanceServiceInterface 接口，解耦Adapter与服务
* 2. 单例式管理位置/任务数据，提供安全增删改查接口
* 3. 后台单线程定时计算可见位置距离，主线程回调更新UI
- * 4. 严格Java 7语法：无Lambda/Stream，显式迭代器/匿名内部类
+ * 4. 内置GPS信号加载（通过LocationManager实时获取位置，解决“等待GPS信号”问题）
+ * 5. 服务启动时启动前台通知（保活后台GPS功能，符合系统规范）
+ * 6. 严格Java 7语法：无Lambda/Stream，显式迭代器/匿名内部类
*/
-public class DistanceRefreshService extends Service implements PositionAdapter.DistanceServiceInterface {
+public class DistanceRefreshService extends Service {
public static final String TAG = "DistanceRefreshService";
+
+
// 服务状态与配置
private boolean isServiceRunning = false;
private final ScheduledExecutorService distanceExecutor; // 定时计算线程池（单线程）
private static final int REFRESH_INTERVAL = 3; // 距离刷新间隔（秒）
+ // 前台通知相关：记录是否已启动前台服务（避免重复调用startForeground）
+ private boolean isForegroundServiceStarted = false;
+
+ // ---------------------- 新增：GPS信号加载核心变量 ----------------------
+ private LocationManager mLocationManager; // 系统GPS管理类（核心）
+ private LocationListener mGpsLocationListener; // GPS位置监听回调
+ private static final long GPS_UPDATE_INTERVAL = 2000; // GPS位置更新间隔（2秒，平衡耗电与实时性）
+ private static final float GPS_UPDATE_DISTANCE = 1; // 位置变化超过1米时更新（避免频繁回调）
+ private boolean isGpsEnabled = false; // GPS是否已开启（系统设置中）
+ private boolean isGpsPermissionGranted = false; // 是否拥有GPS权限
// 核心数据存储（服务内唯一数据源，避免外部直接修改）
private final ArrayList mPositionList = new ArrayList();
private final ArrayList mTaskList = new ArrayList();
private final Set mVisiblePositionIds = new HashSet(); // 可见位置ID（优化性能）
- private PositionModel mCurrentGpsPosition; // 当前GPS位置（外部传入）
+ private PositionModel mCurrentGpsPosition; // 当前GPS位置（外部传入/内部GPS获取）
// 服务绑定与UI回调
private final IBinder mBinder = new DistanceBinder();
- private PositionAdapter.OnDistanceUpdateReceiver mDistanceReceiver; // Adapter回调接收器
- // ---------------------- 构造初始化（线程池提前创建） ----------------------
+ // ---------------------- 构造初始化（线程池+GPS监听器提前创建） ----------------------
+ // 关键：添加/修改为 PUBLIC 无参构造函数
+
public DistanceRefreshService() {
// Java 7 显式初始化线程池（单线程，避免并发修改数据）
distanceExecutor = Executors.newSingleThreadScheduledExecutor();
+ // 初始化GPS位置监听器（接收系统GPS位置更新）
+ initGpsLocationListener();
+ }
+
+ // ---------------------- 新增：GPS核心逻辑（初始化监听+权限/状态检查+启动定位） ----------------------
+ /**
+ * 初始化GPS位置监听器：系统GPS位置变化时触发，实时更新当前位置
+ */
+ private void initGpsLocationListener() {
+ // Java 7 匿名内部类实现 LocationListener（接收GPS位置回调）
+ mGpsLocationListener = new LocationListener() {
+ // GPS位置发生变化时回调（核心：更新当前GPS位置）
+ @Override
+ public void onLocationChanged(Location location) {
+ if (location != null) {
+ // 将系统Location对象转为自定义PositionModel（适配现有逻辑）
+ PositionModel gpsPos = new PositionModel();
+ gpsPos.setLatitude(location.getLatitude()); // 纬度
+ gpsPos.setLongitude(location.getLongitude()); // 经度
+ gpsPos.setPositionId("CURRENT_GPS_POS"); // 标记为“当前GPS位置”（自定义ID）
+ gpsPos.setMemo("实时GPS位置");
+
+ // 同步GPS位置到服务（触发距离计算+通知更新）
+ syncCurrentGpsPosition(gpsPos);
+ LogUtils.d(TAG, "GPS位置更新：纬度=" + location.getLatitude() + "，经度=" + location.getLongitude());
+ }
+ }
+
+ // GPS状态变化时回调（如从“搜索中”变为“可用”）
+ @Override
+ public void onStatusChanged(String provider, int status, Bundle extras) {
+ if (provider.equals(LocationManager.GPS_PROVIDER)) {
+ switch (status) {
+ case LocationProvider.AVAILABLE:
+ LogUtils.d(TAG, "GPS状态：已就绪（可用）");
+ updateNotificationGpsStatus("GPS已就绪，正在获取位置...");
+ break;
+ case LocationProvider.OUT_OF_SERVICE:
+ LogUtils.w(TAG, "GPS状态：无服务（信号弱/无信号）");
+ updateNotificationGpsStatus("GPS无服务，尝试重新连接...");
+ break;
+ case LocationProvider.TEMPORARILY_UNAVAILABLE:
+ LogUtils.w(TAG, "GPS状态：临时不可用（如遮挡）");
+ updateNotificationGpsStatus("GPS临时不可用，稍后重试...");
+ break;
+ }
+ }
+ }
+
+ // GPS被开启时回调（用户在设置中打开GPS）
+ @Override
+ public void onProviderEnabled(String provider) {
+ if (provider.equals(LocationManager.GPS_PROVIDER)) {
+ isGpsEnabled = true;
+ LogUtils.d(TAG, "GPS已开启（用户手动打开）");
+ updateNotificationGpsStatus("GPS已开启，正在获取位置...");
+ // 重新启动GPS定位（确保获取最新位置）
+ startGpsLocation();
+ }
+ }
+
+ // GPS被关闭时回调（用户在设置中关闭GPS）
+ @Override
+ public void onProviderDisabled(String provider) {
+ if (provider.equals(LocationManager.GPS_PROVIDER)) {
+ isGpsEnabled = false;
+ mCurrentGpsPosition = null; // 清空无效GPS位置
+ LogUtils.w(TAG, "GPS已关闭（用户手动关闭）");
+ updateNotificationGpsStatus("GPS已关闭，请在设置中开启");
+ // 提示用户打开GPS（主线程显示Toast）
+ showToastOnMainThread("GPS已关闭，无法获取位置，请在设置中开启");
+ }
+ }
+ };
+ }
+
+ /**
+ * 检查GPS权限+系统状态（解决“等待GPS信号”的前提：权限+GPS开启）
+ * @return true：权限+状态都满足；false：缺少权限或GPS未开启
+ */
+ private boolean checkGpsReady() {
+ // 1. 检查GPS权限（前台精确定位权限，必须拥有）
+ isGpsPermissionGranted = checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION)
+ == PackageManager.PERMISSION_GRANTED;
+
+ // 2. 检查GPS是否开启（系统设置中）
+ if (mLocationManager == null) {
+ mLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
+ }
+ isGpsEnabled = mLocationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
+
+ // 3. 异常场景处理（权限缺失/GPS未开启）
+ if (!isGpsPermissionGranted) {
+ LogUtils.e(TAG, "GPS准备失败：缺少精确定位权限");
+ updateNotificationGpsStatus("缺少定位权限，无法获取GPS");
+ showToastOnMainThread("请授予定位权限，否则无法获取GPS位置");
+ return false;
+ }
+ if (!isGpsEnabled) {
+ LogUtils.e(TAG, "GPS准备失败：系统GPS未开启");
+ updateNotificationGpsStatus("GPS未开启，请在设置中打开");
+ showToastOnMainThread("GPS已关闭，请在设置中开启以获取位置");
+ return false;
+ }
+
+ // 权限+状态都满足
+ LogUtils.d(TAG, "GPS准备就绪：权限已获取，GPS已开启");
+ return true;
+ }
+
+ /**
+ * 启动GPS定位（注册监听器，开始接收系统GPS位置更新）
+ */
+ private void startGpsLocation() {
+ // 先检查GPS是否就绪（避免无效调用）
+ if (!checkGpsReady()) {
+ return;
+ }
+
+ try {
+ // 注册GPS监听器：指定GPS provider、更新间隔、距离变化阈值
+ mLocationManager.requestLocationUpdates(
+ LocationManager.GPS_PROVIDER,
+ GPS_UPDATE_INTERVAL,
+ GPS_UPDATE_DISTANCE,
+ mGpsLocationListener,
+ Looper.getMainLooper() // 在主线程回调（避免跨线程问题）
+ );
+
+ // 额外优化：立即获取最近一次缓存的GPS位置（避免等待首次定位）
+ Location lastKnownLocation = mLocationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
+ if (lastKnownLocation != null) {
+ PositionModel lastGpsPos = new PositionModel();
+ lastGpsPos.setLatitude(lastKnownLocation.getLatitude());
+ lastGpsPos.setLongitude(lastKnownLocation.getLongitude());
+ lastGpsPos.setPositionId("CURRENT_GPS_POS");
+ syncCurrentGpsPosition(lastGpsPos);
+ LogUtils.d(TAG, "已获取最近缓存的GPS位置：纬度=" + lastKnownLocation.getLatitude());
+ } else {
+ LogUtils.d(TAG, "无缓存GPS位置，等待实时定位...");
+ updateNotificationGpsStatus("GPS搜索中（请移至开阔地带）");
+ }
+
+ } catch (SecurityException e) {
+ // 异常防护：避免权限突然被回收导致崩溃
+ LogUtils.e(TAG, "启动GPS定位失败（权限异常）：" + e.getMessage());
+ isGpsPermissionGranted = false;
+ updateNotificationGpsStatus("定位权限异常，无法获取GPS");
+ } catch (Exception e) {
+ LogUtils.e(TAG, "启动GPS定位失败：" + e.getMessage());
+ updateNotificationGpsStatus("GPS启动失败，尝试重试...");
+ }
+ }
+
+ /**
+ * 停止GPS定位（服务销毁/暂停时调用，避免耗电+内存泄漏）
+ */
+ private void stopGpsLocation() {
+ if (mLocationManager != null && mGpsLocationListener != null && isGpsPermissionGranted) {
+ try {
+ mLocationManager.removeUpdates(mGpsLocationListener);
+ LogUtils.d(TAG, "GPS定位已停止（移除监听器）");
+ } catch (Exception e) {
+ LogUtils.e(TAG, "停止GPS定位失败：" + e.getMessage());
+ }
+ }
+ }
+
+ // ---------------------- 新增：辅助方法（通知更新+主线程Toast） ----------------------
+ /**
+ * 统一更新通知栏的GPS状态文本（简化代码，避免重复）
+ */
+ private void updateNotificationGpsStatus(String statusText) {
+ if (isForegroundServiceStarted) {
+ NotificationUtil.updateForegroundServiceStatus(this, statusText);
+ }
+ }
+
+ /**
+ * 在主线程显示Toast（避免子线程无法显示Toast的问题）
+ */
+ private void showToastOnMainThread(final String message) {
+ if (Looper.myLooper() == Looper.getMainLooper()) {
+ Toast.makeText(this, message, Toast.LENGTH_SHORT).show();
+ } else {
+ new android.os.Handler(Looper.getMainLooper()).post(new Runnable() {
+ @Override
+ public void run() {
+ Toast.makeText(DistanceRefreshService.this, message, Toast.LENGTH_SHORT).show();
+ }
+ });
+ }
}
// ---------------------- Binder 内部类（供外部绑定服务） ----------------------
@@ -65,354 +279,480 @@ public class DistanceRefreshService extends Service implements PositionAdapter.D
}
}
- // ---------------------- 服务生命周期方法（严格管理资源） ----------------------
+ // ---------------------- 服务生命周期方法（集成GPS启停逻辑） ----------------------
+
+ // 服务单例实例（私有静态）
+ // 1. 单例实例（volatile确保多线程可见性）
+ private static volatile DistanceRefreshService sInstance;
+ // 2. 单独持有ApplicationContext（避免内存泄漏+确保非null）
+ private static Context sAppContext;
+ // 单例PUBLIC方法（供外部获取实例，确保全局唯一）
+ public static synchronized DistanceRefreshService getInstance() {
+ // 4. 修复后的单例方法：先判空，再返回（避免空指针）
+
+ // 第一步：先判断实例是否存在（未创建则返回null，不强行调用Context）
+ if (sInstance == null) {
+ // 可选：若调用时Service未启动，主动启动Service（避免后续空指针）
+ Intent intent = new Intent(sAppContext, DistanceRefreshService.class);
+ sAppContext.startService(intent);
+ return null; // 或抛明确异常（如"Service未启动"），不触发空指针
+ }
+ // 第二步：实例存在时，确保Context非null（双重保险）
+ if (sAppContext == null) {
+ sAppContext = sInstance.getApplicationContext();
+ }
+ return sInstance;
+ }
+
@Override
public void onCreate() {
super.onCreate();
+ sInstance = this; // 此时Service已创建，Context非null
+ // 保存ApplicationContext（全局唯一，不会因Service销毁而失效）
+ sAppContext = getApplicationContext();
+
+ // 初始化GPS管理器（提前获取系统服务，避免启动时延迟）
+ mLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
LogUtils.d(TAG, "服务 onCreate：初始化完成，等待启动命令");
- run();
+ run();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
- run();
+ run();
AppConfigsModel bean = AppConfigsModel.loadBean(DistanceRefreshService.this, AppConfigsModel.class);
- boolean isEnableService = (bean == null) ? false : bean.isEnableDistanceRefreshService();
- return isEnableService ? Service.START_STICKY: super.onStartCommand(intent, flags, startId);
+ boolean isEnableService = (bean == null) ? false : bean.isEnableMainService();
+ // 服务启用时返回START_STICKY（被杀死后尝试重启），禁用时返回默认值
+ return isEnableService ? Service.START_STICKY : super.onStartCommand(intent, flags, startId);
}
- void run() {
- // 仅服务未运行时启动（避免重复启动）
+ public void run() {
+ // 仅服务未运行时启动（避免重复启动）
if (!isServiceRunning) {
isServiceRunning = true;
+
+ mLocationManager = (LocationManager) sInstance.getApplicationContext().getSystemService(Context.LOCATION_SERVICE);
+ initGpsLocationListener();
+
startDistanceRefreshTask(); // 启动定时距离计算
- LogUtils.d(TAG, "服务 onStartCommand：启动成功，刷新间隔=" + REFRESH_INTERVAL + "秒");
+ startForegroundNotification(); // 启动前台通知
+ startGpsLocation(); // 新增：启动GPS定位（核心修复：解决“等待GPS信号”）
+ LogUtils.d(TAG, "服务 onStartCommand：启动成功，刷新间隔=" + REFRESH_INTERVAL + "秒，前台通知+GPS已启动");
} else {
- LogUtils.w(TAG, "服务 onStartCommand：已在运行，无需重复启动");
+ LogUtils.w(TAG, "服务 onStartCommand：已在运行，无需重复启动（前台通知：" + (isForegroundServiceStarted ? "已启动" : "未启动") + " | GPS：" + (isGpsEnabled ? "已开启" : "未开启") + "）");
+ // 异常场景恢复：补全未启动的组件
+ if (!isForegroundServiceStarted) {
+ startForegroundNotification();
+ LogUtils.d(TAG, "服务 run：前台通知未启动，已恢复");
+ }
+ if (isServiceRunning && !isGpsEnabled) {
+ startGpsLocation();
+ LogUtils.d(TAG, "服务 run：GPS未启动，已恢复");
+ }
}
- }
+ }
@Override
public IBinder onBind(Intent intent) {
- LogUtils.d(TAG, "服务 onBind：外部绑定成功（运行状态：" + (isServiceRunning ? "是" : "否") + "）");
- return mBinder; // 返回Binder实例，供外部获取服务
+ return null; // 按你的业务逻辑返回，无绑定需求则保留null
+ //LogUtils.d(TAG, "服务 onBind：外部绑定成功（运行状态：" + (isServiceRunning ? "是" : "否") + " | GPS状态：" + (isGpsEnabled ? "可用" : "不可用") + "）");
+ //return mBinder; // 返回Binder实例，供外部获取服务
}
- @Override
- public boolean onUnbind(Intent intent) {
- LogUtils.d(TAG, "服务 onUnbind：外部解绑，清理回调与可见位置");
- // 解绑后清理资源，避免内存泄漏
- mDistanceReceiver = null;
- mVisiblePositionIds.clear();
- return super.onUnbind(intent);
- }
+ /*@Override
+ public boolean onUnbind(Intent intent) {
+ LogUtils.d(TAG, "服务 onUnbind：外部解绑，清理回调与可见位置");
+ // 解绑后清理资源，避免内存泄漏
+ mDistanceReceiver = null;
+ mVisiblePositionIds.clear();
+ // 解绑时不停止GPS（服务仍在后台运行，需持续获取位置）
+ return super.onUnbind(intent);
+ }*/
@Override
public void onDestroy() {
super.onDestroy();
- // 停止线程池+清空数据（服务销毁后释放资源）
- stopDistanceRefreshTask();
- clearAllData();
+ sInstance = null; // 释放实例，避免内存泄漏
+ // sAppContext 不清空（ApplicationContext全局有效）
+
+ // 停止所有核心组件+释放资源（避免内存泄漏/耗电）
+ stopDistanceRefreshTask(); // 停止距离计算
+ stopGpsLocation(); // 新增：停止GPS定位（关键：避免服务销毁后仍耗电）
+ clearAllData(); // 清空数据
+ stopForeground(true); // 停止前台服务（移除通知）
+
+ // 重置状态标记
+ isForegroundServiceStarted = false;
isServiceRunning = false;
- LogUtils.d(TAG, "服务 onDestroy：销毁完成，资源已释放");
+ isGpsEnabled = false;
+ mLocationManager = null; // 释放GPS管理器引用
+
+ LogUtils.d(TAG, "服务 onDestroy：销毁完成，资源已释放（GPS+前台通知+线程池）");
}
- // ---------------------- 核心：定时距离计算（后台线程+主线程回调） ----------------------
+ // ---------------------- 前台服务通知管理（与GPS状态联动优化） ----------------------
/**
- * 启动定时距离计算任务（延迟1秒开始，周期执行）
+ * 启动前台服务通知（调用NotificationUtils创建通知，确保仅启动一次）
*/
- private void startDistanceRefreshTask() {
- if (distanceExecutor == null || distanceExecutor.isShutdown()) {
- LogUtils.e(TAG, "启动计算失败：线程池未初始化/已关闭");
+ private void startForegroundNotification() {
+ // 1. 校验：避免重复调用startForeground（系统不允许重复启动）
+ if (isForegroundServiceStarted) {
+ LogUtils.w(TAG, "startForegroundNotification：前台通知已启动，无需重复执行");
return;
}
- // Java 7：匿名内部类实现 Runnable（不使用Lambda）
- distanceExecutor.scheduleAtFixedRate(new Runnable() {
+ try {
+// 2. 初始化通知状态文本（根据GPS初始状态动态显示，避免固定“等待”）
+ String initialStatus;
+ if (isGpsPermissionGranted && isGpsEnabled) {
+ initialStatus = "GPS已就绪，正在获取位置（刷新间隔" + REFRESH_INTERVAL + "秒）";
+ } else if (!isGpsPermissionGranted) {
+ initialStatus = "缺少定位权限，无法获取GPS位置";
+ } else {
+ initialStatus = "GPS未开启，请在设置中打开";
+ }
+
+
+// 5. 标记前台服务已启动
+ isForegroundServiceStarted = true;
+ LogUtils.d(TAG, "startForegroundNotification：前台服务通知启动成功，初始状态：" + initialStatus);
+
+ } catch (Exception e) {
+// 捕获异常（如上下文失效、通知渠道未创建）
+ isForegroundServiceStarted = false;
+ LogUtils.d(TAG, "startForegroundNotification：前台通知启动失败" + e);
+ }
+ }
+
+// ---------------------- 核心：定时距离计算（与GPS状态联动优化） ----------------------
+ /**
+
+ - 启动定时距离计算任务（延迟1秒开始，周期执行）
+ */
+ private void startDistanceRefreshTask() {
+ if (distanceExecutor == null || distanceExecutor.isShutdown()) {
+ LogUtils.e(TAG, "启动计算失败：线程池未初始化/已关闭");
+ return;
+ }distanceExecutor.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
- // 仅满足所有条件时计算：服务运行+GPS有效+有可见位置
+// 优化判断逻辑：先检查GPS核心状态，再决定是否计算
+ if (!isGpsPermissionGranted) {
+ LogUtils.d(TAG, "跳过距离计算：缺少定位权限");
+ updateNotificationGpsStatus("缺少定位权限，无法计算距离");
+ return;
+ }
+ if (!isGpsEnabled) {
+ LogUtils.d(TAG, "跳过距离计算：GPS未开启");
+ updateNotificationGpsStatus("GPS未开启，无法计算距离");
+ return;
+ }// 原有逻辑：服务运行+GPS位置有效+有可见位置才计算
if (isServiceRunning && mCurrentGpsPosition != null && !mVisiblePositionIds.isEmpty()) {
calculateVisiblePositionDistance();
+// 计算后更新通知（显示实时GPS+距离计算状态）
+ syncGpsStatusToNotification();
} else {
- // 打印跳过原因（便于调试）
String reason = "";
if (!isServiceRunning) reason = "服务未运行";
- else if (mCurrentGpsPosition == null) reason = "GPS无效";
- else if (mVisiblePositionIds.isEmpty()) reason = "无可见位置";
- LogUtils.d(TAG, "跳过距离计算：" + reason);
+ else if (mCurrentGpsPosition == null) reason = "GPS信号弱（获取位置中）";
+ else if (mVisiblePositionIds.isEmpty()) reason = "无可见位置（无需计算）";
+ LogUtils.d(TAG, "跳过距离计算：" + reason);// 针对性更新通知文本（用户明确知道当前状态）
+ if (isForegroundServiceStarted) {
+ if (mCurrentGpsPosition == null) {
+ updateNotificationGpsStatus("GPS信号弱，移至开阔地带重试...");
+ } else if (mVisiblePositionIds.isEmpty()) {
+ updateNotificationGpsStatus("无可见位置，距离计算暂停");
+ }
+ }
}
}
}, 1, REFRESH_INTERVAL, TimeUnit.SECONDS);
- }
+ }
- /**
- * 停止定时计算任务（强制关闭线程池）
- */
- private void stopDistanceRefreshTask() {
- if (distanceExecutor != null && !distanceExecutor.isShutdown()) {
- distanceExecutor.shutdownNow(); // 立即停止所有任务
- LogUtils.d(TAG, "距离计算任务已停止");
- }
- }
+ /**
- /**
- * 计算可见位置与GPS的距离（Haversine公式，后台线程执行）
- */
- private void calculateVisiblePositionDistance() {
- // 拷贝可见ID集合：避免遍历中修改引发 ConcurrentModificationException
- Set tempVisibleIds = new HashSet(mVisiblePositionIds);
- if (tempVisibleIds.isEmpty()) return;
+ - 停止定时计算任务（强制关闭线程池）
+ */
+ private void stopDistanceRefreshTask() {
+ if (distanceExecutor != null && !distanceExecutor.isShutdown()) {
+ distanceExecutor.shutdownNow();
+ LogUtils.d(TAG, "距离计算任务已停止");
+ }
+ }
- // Java 7：迭代器遍历位置列表（安全删除/修改）
- Iterator posIter = mPositionList.iterator();
- while (posIter.hasNext()) {
- PositionModel pos = posIter.next();
- String posId = pos.getPositionId();
+ /**
- // 仅计算“可见+启用距离”的位置
- if (tempVisibleIds.contains(posId) && pos.isEnableRealPositionDistance()) {
- try {
- // 调用Haversine公式计算距离（经纬度→米）
- double distanceM = calculateHaversineDistance(
+ - 计算可见位置与GPS的距离（Haversine公式，后台线程执行）
+ */
+ private void calculateVisiblePositionDistance() {
+ Set tempVisibleIds = new HashSet(mVisiblePositionIds);
+ if (tempVisibleIds.isEmpty()) return;Iterator posIter = mPositionList.iterator();
+ while (posIter.hasNext()) {
+ PositionModel pos = (PositionModel)posIter.next();
+ String posId = pos.getPositionId();if (tempVisibleIds.contains(posId) && pos.isEnableRealPositionDistance()) {
+ try {
+ double distanceM = calculateHaversineDistance(
mCurrentGpsPosition.getLatitude(), mCurrentGpsPosition.getLongitude(),
pos.getLatitude(), pos.getLongitude()
- );
- // 更新位置距离（服务内数据实时同步）
- pos.setRealPositionDistance(distanceM);
- LogUtils.d(TAG, "计算完成：位置ID=" + posId + "，距离=" + String.format("%.1f", distanceM) + "米");
+ );
+ pos.setRealPositionDistance(distanceM);
+ LogUtils.d(TAG, "计算完成：位置ID=" + posId + "，距离=" + String.format("%.1f", distanceM) + "米");
+
+ } catch (Exception e) {
+ pos.setRealPositionDistance(-1);
+
+ LogUtils.e(TAG, "计算失败（位置ID=" + posId + "）：" + e.getMessage());
+ }
+ }
+ }
+ }
- // 回调Adapter更新UI（确保主线程）
- notifyDistanceUpdateToUI(posId);
- } catch (Exception e) {
- // 计算异常时标记距离为-1（Adapter识别为“计算异常”）
- pos.setRealPositionDistance(-1);
- notifyDistanceUpdateToUI(posId);
- LogUtils.e(TAG, "计算失败（位置ID=" + posId + "）：" + e.getMessage());
- }
- }
- }
- }
+ /**
- /**
- * 主线程回调Adapter更新UI（避免跨线程操作UI异常）
- */
- private void notifyDistanceUpdateToUI(final String positionId) {
- if (Looper.myLooper() == Looper.getMainLooper()) {
- // 已在主线程：直接回调
- if (mDistanceReceiver != null) {
- mDistanceReceiver.onDistanceUpdate(positionId);
- }
- } else {
- // 子线程：通过主线程Handler切换（Java 7 显式创建Handler）
- new android.os.Handler(Looper.getMainLooper()).post(new Runnable() {
+ - 主线程回调Adapter更新UI（避免跨线程操作UI异常）
+ */
+ /*private void notifyDistanceUpdateToUI(final String positionId) {
+ if (Looper.myLooper() == Looper.getMainLooper()) {
+ if (mDistanceReceiver != null) {
+ mDistanceReceiver.onDistanceUpdate(positionId);
+ }
+ } else {
+ new android.os.Handler(Looper.getMainLooper()).post(new Runnable() {
+ @Override
+ public void run() {
+ if (mDistanceReceiver != null) {
+ mDistanceReceiver.onDistanceUpdate(positionId);
+ }
+ }
+ });
+ }
+ }*/
+
+ /**
+
+ - Haversine公式：计算两点间直线距离（经纬度→米）
+ */
+ private double calculateHaversineDistance(double gpsLat, double gpsLon, double posLat, double posLon) {
+ final double EARTH_RADIUS = 6371000; // 地球半径（米）
+ double latDiff = Math.toRadians(posLat - gpsLat);
+ double lonDiff = Math.toRadians(posLon - gpsLon);double a = Math.sin(latDiff / 2) * Math.sin(latDiff / 2)
+ - Math.cos(Math.toRadians(gpsLat)) * Math.cos(Math.toRadians(posLat))
+
+ - Math.sin(lonDiff / 2) * Math.sin(lonDiff / 2);
+ double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+ return EARTH_RADIUS * c;
+ }
+
+ /**
+
+ - 同步GPS状态到前台通知（显示实时经纬度+计算状态）
+ */
+ private void syncGpsStatusToNotification() {
+ if (!isForegroundServiceStarted || mCurrentGpsPosition == null) {
+ return;
+ }// 构造详细状态文本（包含经纬度+可见位置数量，用户感知更清晰）
+ final String gpsStatus = String.format(
+ "GPS位置：北纬%.4f° 东经%.4f° | 计算中（可见位置：%d个）",
+ mCurrentGpsPosition.getLatitude(),
+ mCurrentGpsPosition.getLongitude(),
+ mVisiblePositionIds.size()
+ );if (Looper.myLooper() == Looper.getMainLooper()) {
+ NotificationUtil.updateForegroundServiceStatus(this, gpsStatus);
+ } else {
+ new android.os.Handler(Looper.getMainLooper()).post(new Runnable() {
@Override
public void run() {
- if (mDistanceReceiver != null) {
- mDistanceReceiver.onDistanceUpdate(positionId);
- }
+ NotificationUtil.updateForegroundServiceStatus(DistanceRefreshService.this, gpsStatus);
}
});
- }
- }
+ }
+ }
- /**
- * Haversine公式：计算两点间直线距离（经纬度→米，精度满足日常需求）
- */
- private double calculateHaversineDistance(double gpsLat, double gpsLon, double posLat, double posLon) {
- final double EARTH_RADIUS = 6371000; // 地球半径（米）
- double latDiff = Math.toRadians(posLat - gpsLat);
- double lonDiff = Math.toRadians(posLon - gpsLon);
+// ---------------------- 实现 PositionAdapter.DistanceServiceInterface 接口 ----------------------
- double a = Math.sin(latDiff / 2) * Math.sin(latDiff / 2)
- + Math.cos(Math.toRadians(gpsLat)) * Math.cos(Math.toRadians(posLat))
- * Math.sin(lonDiff / 2) * Math.sin(lonDiff / 2);
- double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
- return EARTH_RADIUS * c; // 返回距离（米）
- }
+ public ArrayList getPositionList() {
+ if (!isServiceRunning) {
+ LogUtils.w(TAG, "getPositionList：服务未运行，返回空列表");
+ return new ArrayList();
+ }
+ return new ArrayList(mPositionList);
+ }
- // ---------------------- 实现 PositionAdapter.DistanceServiceInterface 接口 ----------------------
- @Override
- public ArrayList getPositionList() {
- // 服务未运行返回空列表；运行中返回拷贝（避免外部修改原列表）
- if (!isServiceRunning) {
- LogUtils.w(TAG, "getPositionList：服务未运行，返回空列表");
- return new ArrayList();
- }
- return new ArrayList(mPositionList);
- }
- @Override
- public ArrayList getPositionTasksList() {
- if (!isServiceRunning) {
- LogUtils.w(TAG, "getPositionTasksList：服务未运行，返回空列表");
- return new ArrayList();
- }
- return new ArrayList(mTaskList);
- }
+ public ArrayList getPositionTasksList() {
+ if (!isServiceRunning) {
+ LogUtils.w(TAG, "getPositionTasksList：服务未运行，返回空列表");
+ return new ArrayList();
+ }
+ return new ArrayList(mTaskList);
+ }
- @Override
- public void syncCurrentGpsPosition(PositionModel position) {
- if (position == null) {
- LogUtils.w(TAG, "syncCurrentGpsPosition：GPS位置为空，同步失败");
- return;
- }
- this.mCurrentGpsPosition = position;
- LogUtils.d(TAG, "syncCurrentGpsPosition：同步成功（纬度=" + position.getLatitude() + "，经度=" + position.getLongitude() + "）");
- }
+
+ public void syncCurrentGpsPosition(PositionModel position) {
+ if (position == null) {
+ LogUtils.w(TAG, "syncCurrentGpsPosition：GPS位置为空，同步失败");
+ return;
+ }
+ this.mCurrentGpsPosition = position;
+ LogUtils.d(TAG, "syncCurrentGpsPosition：同步成功（纬度=" + position.getLatitude() + "，经度=" + position.getLongitude() + "）");
- @Override
- public void setOnDistanceUpdateReceiver(PositionAdapter.OnDistanceUpdateReceiver receiver) {
- this.mDistanceReceiver = receiver;
- LogUtils.d(TAG, "setOnDistanceUpdateReceiver：回调接收器已设置（" + (receiver != null ? "有效" : "无效") + "）");
- }
+// GPS位置同步后，立即更新通知（避免延迟）
+ if (isForegroundServiceStarted) {
+ syncGpsStatusToNotification();
+ }
+ }
- @Override
- public void addVisibleDistanceView(String positionId) {
- if (!isServiceRunning || positionId == null) {
- LogUtils.w(TAG, "addVisibleDistanceView：服务未运行/位置ID无效，添加失败");
- return;
- }
- if (mVisiblePositionIds.add(positionId)) {
- LogUtils.d(TAG, "addVisibleDistanceView：添加成功（位置ID=" + positionId + "，当前可见数=" + mVisiblePositionIds.size() + "）");
- }
- }
+ /*public void setOnDistanceUpdateReceiver(PositionAdapter.OnDistanceUpdateReceiver receiver) {
+ this.mDistanceReceiver = receiver;
+ LogUtils.d(TAG, "setOnDistanceUpdateReceiver：回调接收器已设置（" + (receiver != null ? "有效" : "无效") + "）");
+ }*/
- @Override
- public void removeVisibleDistanceView(String positionId) {
- if (positionId == null) {
- LogUtils.w(TAG, "removeVisibleDistanceView：位置ID为空，移除失败");
- return;
- }
- if (mVisiblePositionIds.remove(positionId)) {
- LogUtils.d(TAG, "removeVisibleDistanceView：移除成功（位置ID=" + positionId + "，当前可见数=" + mVisiblePositionIds.size() + "）");
- }
- }
+ public void addVisibleDistanceView(String positionId) {
+ if (!isServiceRunning || positionId == null) {
+ LogUtils.w(TAG, "addVisibleDistanceView：服务未运行/位置ID无效，添加失败");
+ return;
+ }
+ if (mVisiblePositionIds.add(positionId)) {
+ LogUtils.d(TAG, "addVisibleDistanceView：添加成功（位置ID=" + positionId + "，当前可见数=" + mVisiblePositionIds.size() + "）");
+// 新增：添加可见位置后，立即更新通知（显示最新可见数量）
+ if (isForegroundServiceStarted && mCurrentGpsPosition != null) {
+ syncGpsStatusToNotification();
+ }
+ }
+ }
- @Override
- public void clearVisibleDistanceViews() {
- mVisiblePositionIds.clear();
- LogUtils.d(TAG, "clearVisibleDistanceViews：所有可见位置已清空");
- }
+ public void removeVisibleDistanceView(String positionId) {
+ if (positionId == null) {
+ LogUtils.w(TAG, "removeVisibleDistanceView：位置ID为空，移除失败");
+ return;
+ }
+ if (mVisiblePositionIds.remove(positionId)) {
+ int remainingCount = mVisiblePositionIds.size();
+ LogUtils.d(TAG, "removeVisibleDistanceView：移除成功（位置ID=" + positionId + "，当前可见数=" + remainingCount + "）");
+// 新增：移除可见位置后，更新通知（同步数量变化）
+ if (isForegroundServiceStarted && mCurrentGpsPosition != null) {
+ syncGpsStatusToNotification();
+ }
+ }
+ }
- // ---------------------- 数据管理接口（给外部/Adapter调用，安全校验） ----------------------
- /**
- * 获取服务运行状态（供Activity/Adapter判断是否加载数据）
- */
- public boolean isServiceRunning() {
- return isServiceRunning;
- }
+ public void clearVisibleDistanceViews() {
+ mVisiblePositionIds.clear();
+ LogUtils.d(TAG, "clearVisibleDistanceViews：所有可见位置已清空");
+// 新增：清空可见位置后，更新通知（提示计算暂停）
+ if (isForegroundServiceStarted) {
+ updateNotificationGpsStatus("无可见位置，距离计算暂停");
+ }
+ }
- /**
- * 添加位置（Adapter新增位置时调用，自动去重）
- */
- public void addPosition(PositionModel position) {
- if (!isServiceRunning || position == null || position.getPositionId() == null) {
- LogUtils.w(TAG, "addPosition：服务未运行/数据无效，添加失败");
- return;
- }
+// ---------------------- 数据管理接口（修复原有语法错误+优化逻辑） ----------------------
+ /**
- // 去重校验（根据位置ID）
- boolean isDuplicate = false;
- Iterator posIter = mPositionList.iterator();
- while (posIter.hasNext()) {
- if (position.getPositionId().equals(posIter.next().getPositionId())) {
- isDuplicate = true;
- break;
- }
- }
+ - 获取服务运行状态
+ */
+ public boolean isServiceRunning() {
+ return isServiceRunning;
+ }
- if (!isDuplicate) {
- mPositionList.add(position);
- LogUtils.d(TAG, "addPosition：添加成功（位置ID=" + position.getPositionId() + "，总数=" + mPositionList.size() + "）");
- } else {
- LogUtils.w(TAG, "addPosition：位置ID=" + position.getPositionId() + "已存在，添加失败");
- }
- }
+ /**
- /**
- * 删除位置（连带删除关联任务，Adapter删除时调用）
- */
- public void removePosition(String positionId) {
- if (!isServiceRunning || positionId == null) {
- LogUtils.w(TAG, "removePosition：服务未运行/位置ID无效，删除失败");
- return;
- }
+ - 添加位置（修复迭代器泛型缺失问题）
+ */
+ public void addPosition(PositionModel position) {
+ if (!isServiceRunning || position == null || position.getPositionId() == null) {
+ LogUtils.w(TAG, "addPosition：服务未运行/数据无效，添加失败");
+ return;
+ }// 修复：显式声明PositionModel泛型，避免类型转换警告
+ boolean isDuplicate = false;
+ Iterator posIter = mPositionList.iterator();
+ while (posIter.hasNext()) {
+ PositionModel existingPos = (PositionModel)posIter.next();
+ if (position.getPositionId().equals(existingPos.getPositionId())) {
+ isDuplicate = true;
+ break;
+ }
+ }if (!isDuplicate) {
+ mPositionList.add(position);
+ LogUtils.d(TAG, "addPosition：添加成功（位置ID=" + position.getPositionId() + "，总数=" + mPositionList.size() + "）");
+ } else {
+ LogUtils.w(TAG, "addPosition：位置ID=" + position.getPositionId() + "已存在，添加失败");
+ }
+ }
- // 1. 删除位置
- boolean isRemoved = false;
- Iterator posIter = mPositionList.iterator();
- while (posIter.hasNext()) {
- PositionModel pos = posIter.next();
- if (positionId.equals(pos.getPositionId())) {
- posIter.remove();
- isRemoved = true;
- break;
- }
- }
+ /**
- if (isRemoved) {
- // 2. 删除关联任务
- Iterator taskIter = mTaskList.iterator();
- while (taskIter.hasNext()) {
- if (positionId.equals(taskIter.next().getPositionId())) {
- taskIter.remove();
- }
- }
- // 3. 移除可见位置（避免继续计算已删除位置）
- mVisiblePositionIds.remove(positionId);
- LogUtils.d(TAG, "removePosition：删除成功（位置ID=" + positionId + "，剩余位置数=" + mPositionList.size() + "）");
- } else {
- LogUtils.w(TAG, "removePosition：位置ID=" + positionId + "不存在，删除失败");
- }
- }
+ - 删除位置（修复任务删除时的类型转换错误）
+ */
+ public void removePosition(String positionId) {
+ if (!isServiceRunning || positionId == null) {
+ LogUtils.w(TAG, "removePosition：服务未运行/位置ID无效，删除失败");
+ return;
+ }// 1. 删除位置
+ boolean isRemoved = false;
+ Iterator posIter = mPositionList.iterator();
+ while (posIter.hasNext()) {
+ PositionModel pos = (PositionModel)posIter.next();
+ if (positionId.equals(pos.getPositionId())) {
+ posIter.remove();
+ isRemoved = true;
+ break;
+ }
+ }if (isRemoved) {
+// 修复：任务列表迭代时用PositionTaskModel泛型（原错误用PositionModel导致转换失败）
+ Iterator taskIter = mTaskList.iterator();
+ while (taskIter.hasNext()) {
+ PositionTaskModel task = (PositionTaskModel)taskIter.next();
+ if (positionId.equals(task.getPositionId())) {
+ taskIter.remove();
+ }
+ }// 3. 移除可见位置
+ mVisiblePositionIds.remove(positionId);
+ LogUtils.d(TAG, "removePosition：删除成功（位置ID=" + positionId + "，剩余位置数=" + mPositionList.size() + "，剩余任务数=" + mTaskList.size() + "）");
+ } else {
+ LogUtils.w(TAG, "removePosition：位置ID=" + positionId + "不存在，删除失败");
+ }
+ }
- /**
- * 更新位置信息（Adapter编辑后调用，仅更新备注/距离开关）
- */
- public void updatePosition(PositionModel updatedPosition) {
- if (!isServiceRunning || updatedPosition == null || updatedPosition.getPositionId() == null) {
- LogUtils.w(TAG, "updatePosition：服务未运行/数据无效，更新失败");
- return;
- }
+ /**
- boolean isUpdated = false;
- Iterator posIter = mPositionList.iterator();
- while (posIter.hasNext()) {
- PositionModel pos = posIter.next();
- if (updatedPosition.getPositionId().equals(pos.getPositionId())) {
- // 仅更新允许修改的字段（备注+距离开关）
- pos.setMemo(updatedPosition.getMemo());
- pos.setIsEnableRealPositionDistance(updatedPosition.isEnableRealPositionDistance());
- // 关闭距离时重置距离值
- if (!updatedPosition.isEnableRealPositionDistance()) {
- pos.setRealPositionDistance(-1);
- notifyDistanceUpdateToUI(pos.getPositionId()); // 通知UI更新状态
- }
- isUpdated = true;
- break;
- }
- }
+ - 更新位置信息（修复代码格式+迭代器泛型）
+ */
+ public void updatePosition(PositionModel updatedPosition) {
+ if (!isServiceRunning || updatedPosition == null || updatedPosition.getPositionId() == null) {
+ LogUtils.w(TAG, "updatePosition：服务未运行/数据无效，更新失败");
+ return;
+ }boolean isUpdated = false;
+ Iterator posIter = mPositionList.iterator();
+ while (posIter.hasNext()) {
+ PositionModel pos = (PositionModel)posIter.next();
+ if (updatedPosition.getPositionId().equals(pos.getPositionId())) {
+ pos.setMemo(updatedPosition.getMemo());
+ pos.setIsEnableRealPositionDistance(updatedPosition.isEnableRealPositionDistance());
+ if (!updatedPosition.isEnableRealPositionDistance()) {
+ pos.setRealPositionDistance(-1);
+ //notifyDistanceUpdateToUI(pos.getPositionId());
+ }
+ isUpdated = true;
+ break;
+ }
+ }if (isUpdated) {
+ LogUtils.d(TAG, "updatePosition：更新成功（位置ID=" + updatedPosition.getPositionId() + "）");
+ } else {
+ LogUtils.w(TAG, "updatePosition：位置ID=" + updatedPosition.getPositionId() + "不存在，更新失败");
+ }
+ }
- if (isUpdated) {
- LogUtils.d(TAG, "updatePosition：更新成功（位置ID=" + updatedPosition.getPositionId() + "）");
- } else {
- LogUtils.w(TAG, "updatePosition：位置ID=" + updatedPosition.getPositionId() + "不存在，更新失败");
- }
- }
+ /**
- /**
- * 同步任务列表（Adapter编辑任务后调用，全量覆盖+去重）
- */
- public void syncAllPositionTasks(ArrayList tasks) {
+ - 同步任务列表（修复泛型缺失+代码格式）
+ */
+ public void syncAllPositionTasks(ArrayList tasks) {
if (!isServiceRunning || tasks == null) {
LogUtils.w(TAG, "syncAllPositionTasks：服务未运行/任务列表为空，同步失败");
return;
- }
-
-// 1. 清空旧任务（全量同步，避免增量逻辑复杂）
+ }// 1. 清空旧任务
mTaskList.clear();
-// 2. 添加新任务（根据任务ID去重，避免重复）
+// 2. 添加新任务（修复泛型+去重逻辑）
Set taskIdSet = new HashSet();
Iterator taskIter = tasks.iterator();
while (taskIter.hasNext()) {
@@ -421,13 +761,12 @@ public class DistanceRefreshService extends Service implements PositionAdapter.D
taskIdSet.add(task.getTaskId());
mTaskList.add(task);
}
- }
-
- LogUtils.d(TAG, "syncAllPositionTasks：同步成功（接收任务数=" + tasks.size() + "，去重后=" + mTaskList.size() + "）");
+ }LogUtils.d(TAG, "syncAllPositionTasks：同步成功（接收任务数=" + tasks.size() + "，去重后=" + mTaskList.size() + "）");
}
/**
- * 清空所有数据（服务销毁/调试时调用，重置所有状态）
+
+ - 清空所有数据
*/
public void clearAllData() {
mPositionList.clear();
@@ -438,7 +777,8 @@ public class DistanceRefreshService extends Service implements PositionAdapter.D
}
/**
- * 强制刷新距离（外部主动触发，如GPS位置突变时）
+
+ - 强制刷新距离（优化：刷新后同步通知状态）
*/
public void forceRefreshDistance() {
if (!isServiceRunning) {
@@ -450,11 +790,50 @@ public class DistanceRefreshService extends Service implements PositionAdapter.D
distanceExecutor.submit(new Runnable() {
@Override
public void run() {
- calculateVisiblePositionDistance();
+// 强制刷新前先检查GPS状态，避免无效计算
+ if (isGpsPermissionGranted && isGpsEnabled && mCurrentGpsPosition != null) {
+ calculateVisiblePositionDistance();
+ syncGpsStatusToNotification(); // 刷新后同步通知
+ LogUtils.d(TAG, "forceRefreshDistance：即时距离计算完成，通知已更新");
+ } else {
+ String reason = !isGpsPermissionGranted ? "缺少定位权限" :
+ (!isGpsEnabled ? "GPS未开启" : "未获取到GPS位置");
+ LogUtils.w(TAG, "forceRefreshDistance：刷新失败，原因：" + reason);
+ updateNotificationGpsStatus("强制刷新失败：" + reason);
+ }
}
});
- LogUtils.d(TAG, "forceRefreshDistance：已触发即时距离计算");
+ LogUtils.d(TAG, "forceRefreshDistance：已触发即时距离计算请求");
+ } else {
+ LogUtils.e(TAG, "forceRefreshDistance：线程池已关闭，无法触发刷新");
+ updateNotificationGpsStatus("线程池已关闭，无法执行强制刷新");
}
}
-}
+// ---------------------- 补充：修复LocationProvider引用缺失问题（避免编译错误） ----------------------
+// 注：原代码中onStatusChanged使用LocationProvider枚举，需补充静态导入或显式声明
+// 此处通过内部静态类定义，解决系统API引用问题（兼容Java 7语法）
+ private static class LocationProvider {
+ public static final int AVAILABLE = 2;
+ public static final int OUT_OF_SERVICE = 0;
+ public static final int TEMPORARILY_UNAVAILABLE = 1;
+ }
+
+// ---------------------- 补充：Context引用工具（避免服务销毁后Context失效） ----------------------
+ /*private Context getSafeContext() {
+ // 服务未销毁时返回自身Context，已销毁时返回应用Context（避免内存泄漏）
+ if (isDestroyed()) {
+ return getApplicationContext();
+ }
+ return this;
+ }*/
+
+// 注：isDestroyed()为API 17+方法，若需兼容更低版本，可添加版本判断
+ /*private boolean isDestroyed() {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+ return super.isDestroyed();
+ }
+ // 低版本通过状态标记间接判断（服务销毁时会置为false）
+ return !isServiceRunning && !isForegroundServiceStarted;
+ }*/
+}
diff --git a/positions/src/main/java/cc/winboll/studio/positions/services/MainService.java b/positions/src/main/java/cc/winboll/studio/positions/services/MainService.java
new file mode 100644
index 0000000..0063247
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/services/MainService.java
@@ -0,0 +1,125 @@
+package cc.winboll.studio.positions.services;
+
+/**
+ * @Author ZhanGSKen
+ * @Date 2024/07/19 14:30:57
+ * @Describe 应用主要服务组件类
+ */
+import android.app.Notification;
+import android.app.Service;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.positions.R;
+import com.hjq.toast.ToastUtils;
+import cc.winboll.studio.positions.models.AppConfigsModel;
+import cc.winboll.studio.positions.utils.AppConfigsUtil;
+import cc.winboll.studio.positions.utils.ServiceUtil;
+import cc.winboll.studio.positions.utils.NotificationUtil;
+
+public class MainService extends Service {
+
+ public static final String TAG = "MainService";
+
+ //MyBinder mMyBinder;
+ MyServiceConnection mMyServiceConnection;
+ volatile static boolean _mIsServiceAlive;
+ AppConfigsUtil mAppConfigsUtil;
+
+ @Override
+ public IBinder onBind(Intent intent) {
+ //return mMyBinder;
+ return null;
+ }
+
+ @Override
+ public void onCreate() {
+ LogUtils.d(TAG, "onCreate");
+ super.onCreate();
+ _mIsServiceAlive = false;
+ mAppConfigsUtil = AppConfigsUtil.getInstance(this);
+
+ //mMyBinder = new MyBinder();
+ if (mMyServiceConnection == null) {
+ mMyServiceConnection = new MyServiceConnection();
+ }
+
+ // 运行服务内容
+ run();
+
+ }
+
+ private void run() {
+ if (mAppConfigsUtil.isEnableMainService(true)) {
+ if (_mIsServiceAlive == false) {
+ // 设置运行状态
+ _mIsServiceAlive = true;
+ //LogUtils.d(TAG, "_mIsServiceAlive set to true.");
+
+ // 唤醒守护进程
+ wakeupAndBindAssistant();
+
+ // 运行其它服务内容
+
+ // 显示前台通知栏
+ String initialStatus = "[ Positions ] is in Service.";
+ // 调用NotificationUtils创建前台通知（传入动态状态文本）
+ NotificationUtil.createForegroundServiceNotification(this, initialStatus);
+ // 启动前台服务（与NotificationUtils通知ID保持一致）
+ startForeground(NotificationUtil.FOREGROUND_SERVICE_NOTIFICATION_ID,
+ NotificationUtil.createForegroundServiceNotification(this, initialStatus));
+
+ ToastUtils.show(initialStatus);
+ LogUtils.i(TAG, initialStatus);
+ }
+ }
+ }
+
+ public interface SMSListener {
+ void speakMessage();
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ }
+
+ @Override
+ public int onStartCommand(Intent intent, int flags, int startId) {
+ //return super.onStartCommand(intent, flags, startId);
+ run();
+ return mAppConfigsUtil.isEnableMainService(true) ? Service.START_STICKY: super.onStartCommand(intent, flags, startId);
+ }
+
+ // 主进程与守护进程连接时需要用到此类
+ //
+ private class MyServiceConnection implements ServiceConnection {
+ @Override
+ public void onServiceConnected(ComponentName name, IBinder service) {
+ //LogUtils.d(TAG, "call onServiceConnected(...)");
+ }
+
+ @Override
+ public void onServiceDisconnected(ComponentName name) {
+ //LogUtils.d(TAG, "call onServiceConnected(...)");
+ if (mAppConfigsUtil.isEnableMainService(true)) {
+ // 唤醒守护进程
+ wakeupAndBindAssistant();
+ }
+ }
+ }
+
+ // 唤醒和绑定守护进程
+ //
+ void wakeupAndBindAssistant() {
+ if (ServiceUtil.isServiceAlive(getApplicationContext(), AssistantService.class.getName()) == false) {
+ startService(new Intent(MainService.this, AssistantService.class));
+ //LogUtils.d(TAG, "call wakeupAndBindAssistant() : Binding... AssistantService");
+ bindService(new Intent(MainService.this, AssistantService.class), mMyServiceConnection, Context.BIND_IMPORTANT);
+ }
+ }
+}
diff --git a/positions/src/main/java/cc/winboll/studio/positions/utils/AppConfigsUtil.java b/positions/src/main/java/cc/winboll/studio/positions/utils/AppConfigsUtil.java
new file mode 100644
index 0000000..98d7af9
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/utils/AppConfigsUtil.java
@@ -0,0 +1,65 @@
+package cc.winboll.studio.positions.utils;
+import android.content.Context;
+import cc.winboll.studio.positions.models.AppConfigsModel;
+
+/**
+ * @Author ZhanGSKen&豆包大模型
+ * @Date 2025/10/01 12:15
+ * @Describe AppConfigsUtils
+ */
+public class AppConfigsUtil {
+
+ public static final String TAG = "AppConfigsUtils";
+
+ // 1. 私有静态成员变量（volatile 防止指令重排，确保实例初始化完全）
+ private static volatile AppConfigsUtil sInstance;
+ Context mContext;
+ AppConfigsModel mAppConfigsModel;
+
+ // 2. 私有构造方法（禁止外部 new 实例）
+ private AppConfigsUtil(Context context) {
+ // 可选：防止通过反射创建实例（增强单例安全性）
+ if (sInstance != null) {
+ throw new RuntimeException("禁止通过反射创建单例实例");
+ }
+ mContext = context;
+ loadConfigs();
+ }
+
+ // 3. 公开静态方法（双重校验锁，获取唯一实例）
+ public static AppConfigsUtil getInstance(Context context) {
+ // 第一次校验：无锁，快速判断实例是否存在（提升性能）
+ if (sInstance == null) {
+ // 加锁：确保同一时间只有一个线程进入初始化逻辑
+ synchronized (AppConfigsUtil.class) {
+ // 第二次校验：防止多线程并发时重复创建实例（线程安全）
+ if (sInstance == null) {
+ sInstance = new AppConfigsUtil(context);
+ }
+ }
+ }
+ return sInstance;
+ }
+
+ void loadConfigs() {
+ mAppConfigsModel = AppConfigsModel.loadBean(mContext, AppConfigsModel.class);
+ }
+
+ void saveConfigs() {
+ AppConfigsModel.saveBean(mContext, mAppConfigsModel);
+ }
+
+ public boolean isEnableMainService(boolean isReloadConfigs) {
+ if (isReloadConfigs) {
+ loadConfigs();
+ }
+
+ return mAppConfigsModel.isEnableMainService();
+ }
+
+ public void setIsEnableMainService(boolean isEnableMainService) {
+ mAppConfigsModel.setIsEnableMainService(isEnableMainService);
+ saveConfigs();
+ }
+}
+
diff --git a/positions/src/main/java/cc/winboll/studio/positions/utils/NotificationUtil.java b/positions/src/main/java/cc/winboll/studio/positions/utils/NotificationUtil.java
new file mode 100644
index 0000000..e6d1c49
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/utils/NotificationUtil.java
@@ -0,0 +1,185 @@
+package cc.winboll.studio.positions.utils;
+
+/**
+ * @Author ZhanGSKen&豆包大模型
+ * @Date 2025/09/30 16:09
+ * @Describe NotificationUtils
+ */
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import androidx.core.app.NotificationCompat;
+import cc.winboll.studio.positions.R;
+import cc.winboll.studio.positions.activities.LocationActivity; // 引入你的前台服务类
+
+/**
+ * 通知栏工具类：专注于任务相关通知的显示与点击跳转 + 前台服务通知管理
+ * 核心功能：
+ * 1. 显示任务描述通知，点击后携带positionId/taskId跳转到LocationActivity
+ * 2. 创建前台服务通知（用于DistanceRefreshService保活，符合系统前台服务规范）
+ */
+public class NotificationUtil {
+ public static final String TAG = "NotificationUtils";
+ // 1. 任务通知相关常量（原有）
+ private static final String TASK_NOTIFICATION_CHANNEL_ID = "task_notification_channel_01";
+ private static final String TASK_NOTIFICATION_CHANNEL_NAME = "任务通知";
+ // 2. 前台服务通知新增常量（独立渠道，避免与普通任务通知混淆）
+ private static final String FOREGROUND_SERVICE_CHANNEL_ID = "foreground_location_service_channel_02";
+ private static final String FOREGROUND_SERVICE_CHANNEL_NAME = "位置服务";
+ public static final int FOREGROUND_SERVICE_NOTIFICATION_ID = 10086; // 固定ID（前台服务通知无需动态生成）
+
+ // ---------------------- 原有功能：任务通知（不变） ----------------------
+ private static int getNotificationId(String taskId) {
+ return taskId.hashCode() & 0xFFFFFF;
+ }
+
+ public static void show(Context context, String taskId, String positionId, String taskDescription) {
+ if (context == null || taskId == null || positionId == null) {
+ return;
+ }
+
+ NotificationManager notificationManager =
+ (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+ if (notificationManager == null) {
+ return;
+ }
+
+ createNotificationChannel(notificationManager);
+
+ Intent jumpIntent = new Intent(context, LocationActivity.class);
+ jumpIntent.putExtra("EXTRA_POSITION_ID", positionId);
+ jumpIntent.putExtra("EXTRA_TASK_ID", taskId);
+ jumpIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
+
+ PendingIntent pendingIntent = PendingIntent.getActivity(
+ context,
+ getNotificationId(taskId),
+ jumpIntent,
+ Build.VERSION.SDK_INT >= Build.VERSION_CODES.M ?
+ PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT :
+ PendingIntent.FLAG_UPDATE_CURRENT
+ );
+
+ Notification notification = new NotificationCompat.Builder(context, TASK_NOTIFICATION_CHANNEL_ID)
+ .setSmallIcon(R.mipmap.ic_launcher)
+ .setContentTitle("任务提醒")
+ .setContentText(taskDescription)
+ .setContentIntent(pendingIntent)
+ .setAutoCancel(true)
+ .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+ .setDefaults(NotificationCompat.DEFAULT_SOUND)
+ .build();
+
+ notificationManager.notify(getNotificationId(taskId), notification);
+ }
+
+ private static void createNotificationChannel(NotificationManager notificationManager) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ // 原有：任务通知渠道
+ NotificationChannel taskChannel = new NotificationChannel(
+ TASK_NOTIFICATION_CHANNEL_ID,
+ TASK_NOTIFICATION_CHANNEL_NAME,
+ NotificationManager.IMPORTANCE_DEFAULT
+ );
+ taskChannel.setDescription("接收任务相关提醒，点击可查看任务详情");
+ taskChannel.enableVibration(true);
+ taskChannel.setVibrationPattern(new long[]{0, 300});
+
+ // 新增：前台服务通知渠道（重要性设为LOW，避免频繁打扰用户）
+ NotificationChannel foregroundChannel = new NotificationChannel(
+ FOREGROUND_SERVICE_CHANNEL_ID,
+ FOREGROUND_SERVICE_CHANNEL_NAME,
+ NotificationManager.IMPORTANCE_LOW // 仅通知栏显示，无提示音/震动，符合后台服务低打扰需求
+ );
+ foregroundChannel.setDescription("位置服务运行中，用于后台持续获取GPS数据，关闭会影响定位功能"); // 明确告知用户服务作用
+ foregroundChannel.enableVibration(false); // 前台服务通知不震动（避免打扰）
+ foregroundChannel.setSound(null, null); // 关闭提示音（低打扰）
+
+ // 注册两个渠道（任务+前台服务）
+ notificationManager.createNotificationChannel(taskChannel);
+ notificationManager.createNotificationChannel(foregroundChannel);
+ }
+ }
+
+ public static void cancel(Context context, String taskId) {
+ if (context == null || taskId == null) {
+ return;
+ }
+ NotificationManager notificationManager =
+ (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+ if (notificationManager != null) {
+ notificationManager.cancel(getNotificationId(taskId));
+ }
+ }
+
+ // ---------------------- 新增核心功能：创建前台服务通知（供DistanceRefreshService调用） ----------------------
+ /**
+ * 创建前台服务通知（符合Android前台服务规范，用于启动/保活DistanceRefreshService）
+ * @param context 服务上下文（直接传入DistanceRefreshService的this即可）
+ * @param serviceStatus 服务状态文本（如“正在后台获取GPS位置...”，动态展示服务状态）
+ * @return 可直接用于startForeground()的Notification对象
+ */
+ public static Notification createForegroundServiceNotification(Context context, String serviceStatus) {
+ // 安全校验：上下文非空（避免服务中调用时的空指针）
+ if (context == null) {
+ throw new IllegalArgumentException("Context cannot be null for foreground service notification");
+ }
+
+ // 步骤1：初始化通知管理器（复用已有逻辑，确保渠道已创建）
+ NotificationManager notificationManager =
+ (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+ if (notificationManager != null) {
+ createNotificationChannel(notificationManager); // 确保前台服务渠道已注册
+ }
+
+ // 步骤2：构建“点击通知跳转至位置管理页”的Intent（用户点击通知可进入功能页）
+ Intent jumpIntent = new Intent(context, LocationActivity.class);
+ jumpIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP); // 避免创建重复页面
+
+ // 步骤3：创建PendingIntent（授权系统在用户点击时执行跳转）
+ PendingIntent pendingIntent = PendingIntent.getActivity(
+ context,
+ FOREGROUND_SERVICE_NOTIFICATION_ID, // 请求码与通知ID一致，确保唯一
+ jumpIntent,
+ // 适配Android 6.0+：IMMUTABLE确保安全性，UPDATE_CURRENT确保Intent参数更新
+ Build.VERSION.SDK_INT >= Build.VERSION_CODES.M ?
+ PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT :
+ PendingIntent.FLAG_UPDATE_CURRENT
+ );
+
+ // 步骤4：构建前台服务通知（低打扰、强关联服务状态）
+ return new NotificationCompat.Builder(context, FOREGROUND_SERVICE_CHANNEL_ID)
+ .setSmallIcon(R.mipmap.ic_launcher) // 必须设置（系统强制要求，建议用应用图标）
+ .setContentTitle("位置服务运行中") // 固定标题，用户快速识别服务类型
+ .setContentText(serviceStatus) // 动态内容（如“正在获取GPS位置”“已连续运行30分钟”）
+ .setContentIntent(pendingIntent) // 点击跳转至功能页
+ .setOngoing(true) // 关键：设置为“不可手动清除”（仅服务停止时能取消，符合前台服务规范）
+ .setPriority(NotificationCompat.PRIORITY_LOW) // 低优先级：不弹窗、不抢占通知栏焦点
+ .setDefaults(NotificationCompat.DEFAULT_SOUND)
+ .build();
+ }
+
+ /**
+ * （配套工具方法）更新前台服务通知的状态文本（如GPS获取进度、运行时长）
+ * @param context 服务上下文
+ * @param newServiceStatus 新的状态文本（如“已获取最新位置：北纬30.123°”）
+ */
+ public static void updateForegroundServiceStatus(Context context, String newServiceStatus) {
+ if (context == null) {
+ return;
+ }
+ // 重新创建通知（复用create方法，传入新状态文本）
+ Notification updatedNotification = createForegroundServiceNotification(context, newServiceStatus);
+ // 用相同ID更新通知（覆盖旧通知，实现状态刷新）
+ NotificationManager notificationManager =
+ (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+ if (notificationManager != null) {
+ notificationManager.notify(FOREGROUND_SERVICE_NOTIFICATION_ID, updatedNotification);
+ }
+ }
+}
+
diff --git a/positions/src/main/java/cc/winboll/studio/positions/utils/NotificationUtils.java b/positions/src/main/java/cc/winboll/studio/positions/utils/NotificationUtils.java
deleted file mode 100644
index 35e393c..0000000
--- a/positions/src/main/java/cc/winboll/studio/positions/utils/NotificationUtils.java
+++ /dev/null
@@ -1,130 +0,0 @@
-package cc.winboll.studio.positions.utils;
-
-/**
- * @Author ZhanGSKen&豆包大模型
- * @Date 2025/09/30 16:09
- * @Describe NotificationUtils
- */
-import android.app.Notification;
-import android.app.NotificationChannel;
-import android.app.NotificationManager;
-import android.app.PendingIntent;
-import android.content.Context;
-import android.content.Intent;
-import android.os.Build;
-import androidx.core.app.NotificationCompat;
-import cc.winboll.studio.positions.R;
-import cc.winboll.studio.positions.activities.LocationActivity; // 替换为你实际的LocationActivity路径
-
-/**
- * 通知栏工具类：专注于任务相关通知的显示与点击跳转
- * 核心功能：显示任务描述通知，点击后携带positionId/taskId跳转到LocationActivity
- */
-public class NotificationUtils {
- public static final String TAG = "NotificationUtils";
- // 1. 通知渠道ID（适配Android O及以上，必须唯一）
- private static final String TASK_NOTIFICATION_CHANNEL_ID = "task_notification_channel_01";
- // 2. 通知渠道名称（用户在系统设置中看到的名称）
- private static final String TASK_NOTIFICATION_CHANNEL_NAME = "任务通知";
- // 3. 通知ID（确保每次显示通知的ID唯一，这里用taskId哈希值避免重复）
- private static int getNotificationId(String taskId) {
- // 用taskId生成唯一ID（避免不同任务通知相互覆盖）
- return taskId.hashCode() & 0xFFFFFF; // 限制ID在0-16777215范围内（系统推荐）
- }
-
- /**
- * 显示任务通知
- * @param context 上下文（如Activity/Fragment，确保非空）
- * @param taskId 任务ID（用于跳转传递+生成唯一通知ID）
- * @param positionId 位置ID（用于跳转传递给LocationActivity）
- * @param taskDescription 通知显示内容（仅展示该文本给用户）
- */
- public static void show(Context context, String taskId, String positionId, String taskDescription) {
- // 安全校验：避免空指针（上下文/必要参数为空时不执行）
- if (context == null || taskId == null || positionId == null) {
- return;
- }
-
- // 步骤1：初始化通知管理器（系统服务，负责发送/取消通知）
- NotificationManager notificationManager =
- (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
- if (notificationManager == null) {
- return;
- }
-
- // 步骤2：创建通知渠道（Android O及以上必须，否则通知不显示）
- createNotificationChannel(notificationManager);
-
- // 步骤3：构建“点击通知跳转”的Intent（携带positionId和taskId）
- Intent jumpIntent = new Intent(context, LocationActivity.class);
- // 传递参数：用Intent的Extra携带ID（键名建议定义为常量，避免拼写错误）
- jumpIntent.putExtra("EXTRA_POSITION_ID", positionId);
- jumpIntent.putExtra("EXTRA_TASK_ID", taskId);
- // 配置Intent：清除栈内旧Activity，确保跳转后是最新页面（根据需求调整）
- jumpIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
-
- // 步骤4：创建PendingIntent（授权系统在用户点击通知时执行jumpIntent）
- // 注意：PendingIntent.FLAG_UPDATE_CURRENT 确保参数更新时覆盖旧Intent
- PendingIntent pendingIntent = PendingIntent.getActivity(
- context,
- getNotificationId(taskId), // 请求码：与通知ID一致，确保唯一
- jumpIntent,
- Build.VERSION.SDK_INT >= Build.VERSION_CODES.M ?
- PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT :
- PendingIntent.FLAG_UPDATE_CURRENT
- );
-
- // 步骤5：构建通知内容（仅显示taskDescription，样式简洁）
- Notification notification = new NotificationCompat.Builder(context, TASK_NOTIFICATION_CHANNEL_ID)
- .setSmallIcon(R.mipmap.ic_launcher) // 通知小图标（必须设置，建议用应用图标）
- .setContentTitle("任务提醒") // 通知标题（固定，用户快速识别通知类型）
- .setContentText(taskDescription) // 通知内容（仅显示传入的任务描述）
- .setContentIntent(pendingIntent) // 绑定点击跳转事件
- .setAutoCancel(true) // 点击通知后自动消失（符合用户习惯）
- .setPriority(NotificationCompat.PRIORITY_DEFAULT) // 通知优先级（默认，不抢占焦点）
- .setDefaults(NotificationCompat.DEFAULT_SOUND) // 默认提示音（可选，根据需求关闭）
- .build();
-
- // 步骤6：发送通知（用唯一ID确保不同任务通知不覆盖）
- notificationManager.notify(getNotificationId(taskId), notification);
- }
-
- /**
- * 创建通知渠道（Android O/API 26及以上必须）
- * 作用：用户可在系统设置中管理该渠道的通知（如关闭声音/屏蔽）
- */
- private static void createNotificationChannel(NotificationManager notificationManager) {
- // 仅在Android O及以上执行（低版本不需要渠道）
- if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
- // 配置渠道：重要性为“默认”（不弹窗，仅通知栏显示+提示音）
- NotificationChannel channel = new NotificationChannel(
- TASK_NOTIFICATION_CHANNEL_ID,
- TASK_NOTIFICATION_CHANNEL_NAME,
- NotificationManager.IMPORTANCE_DEFAULT
- );
- // 可选：配置渠道其他属性（根据需求调整）
- channel.setDescription("接收任务相关提醒，点击可查看任务详情"); // 渠道描述（系统设置中显示）
- channel.enableVibration(true); // 是否震动（默认开启，可关闭）
- channel.setVibrationPattern(new long[]{0, 300}); // 震动模式（0延迟，震动300ms）
-
- // 注册渠道到系统（仅需注册一次，重复注册会覆盖旧配置）
- notificationManager.createNotificationChannel(channel);
- }
- }
-
- /**
- * （可选）取消指定任务的通知
- * 场景：任务完成后关闭已显示的通知（如bingo状态取消后）
- */
- public static void cancel(Context context, String taskId) {
- if (context == null || taskId == null) {
- return;
- }
- NotificationManager notificationManager =
- (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
- if (notificationManager != null) {
- notificationManager.cancel(getNotificationId(taskId));
- }
- }
-}
-
diff --git a/positions/src/main/java/cc/winboll/studio/positions/utils/ServiceUtil.java b/positions/src/main/java/cc/winboll/studio/positions/utils/ServiceUtil.java
new file mode 100644
index 0000000..7b70f7e
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/utils/ServiceUtil.java
@@ -0,0 +1,34 @@
+package cc.winboll.studio.positions.utils;
+
+/**
+ * @Author ZhanGSKen
+ * @Date 2024/07/19 14:30:57
+ * @Describe 应用服务组件工具类
+ */
+import android.app.ActivityManager;
+import android.content.Context;
+import java.util.List;
+
+public class ServiceUtil {
+ public final static String TAG = "ServiceUtil";
+
+ public static boolean isServiceAlive(Context context, String szServiceName) {
+ // 获取Activity管理者对象
+ ActivityManager manager = (ActivityManager) context
+ .getSystemService(Context.ACTIVITY_SERVICE);
+ // 获取正在运行的服务（此处设置最多取1000个）
+ List runningServices = manager
+ .getRunningServices(1000);
+ if (runningServices.size() <= 0) {
+ return false;
+ }
+ // 遍历，若存在名字和传入的serviceName的一致则说明存在
+ for (ActivityManager.RunningServiceInfo runningServiceInfo : runningServices) {
+ if (runningServiceInfo.service.getClassName().equals(szServiceName)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+}
diff --git a/positions/src/main/res/layout/activity_main.xml b/positions/src/main/res/layout/activity_main.xml
index 4336dba..7673f9e 100644
--- a/positions/src/main/res/layout/activity_main.xml
+++ b/positions/src/main/res/layout/activity_main.xml
@@ -6,7 +6,6 @@
android:layout_height="match_parent"
android:orientation="vertical">
-
-
-
+ android:text="主要服务开关"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"/>
-
-
-