diff --git a/positions/build.gradle b/positions/build.gradle
index b8401af2..356a27ae 100644
--- a/positions/build.gradle
+++ b/positions/build.gradle
@@ -45,6 +45,9 @@ android {
dependencies {
api fileTree(dir: 'libs', include: ['*.jar'])
+
+ // 谷歌定位服务核心依赖（FusedLocationProviderClient所在库）
+ api 'com.google.android.gms:play-services-location:21.0.1'
// SSH
api 'com.jcraft:jsch:0.1.55'
@@ -67,7 +70,7 @@ dependencies {
//api 'androidx.vectordrawable:vectordrawable-animated:1.1.0'
//api 'androidx.fragment:fragment:1.1.0'
- api 'cc.winboll.studio:libaes:15.9.3'
- api 'cc.winboll.studio:libapputils:15.8.5'
- api 'cc.winboll.studio:libappbase:15.9.5'
+ api 'cc.winboll.studio:libaes:15.10.2'
+ api 'cc.winboll.studio:libapputils:15.10.2'
+ api 'cc.winboll.studio:libappbase:15.10.9'
}
diff --git a/positions/build.properties b/positions/build.properties
index 7d34a4a1..53e18264 100644
--- a/positions/build.properties
+++ b/positions/build.properties
@@ -1,8 +1,8 @@
#Created by .winboll/winboll_app_build.gradle
-#Mon Sep 29 09:07:13 GMT 2025
-stageCount=0
+#Thu Oct 02 02:36:00 GMT 2025
+stageCount=8
libraryProject=
baseVersion=15.0
-publishVersion=15.0.0
-buildCount=1
-baseBetaVersion=15.0.1
+publishVersion=15.0.7
+buildCount=9
+baseBetaVersion=15.0.8
diff --git a/positions/src/beta/AndroidManifest.xml b/positions/src/beta/AndroidManifest.xml
index ee78d9fa..d783f522 100644
--- a/positions/src/beta/AndroidManifest.xml
+++ b/positions/src/beta/AndroidManifest.xml
@@ -2,7 +2,9 @@
-
+
diff --git a/positions/src/beta/res/values-zh/strings.xml b/positions/src/beta/res/values-zh/strings.xml
new file mode 100644
index 00000000..7732c38a
--- /dev/null
+++ b/positions/src/beta/res/values-zh/strings.xml
@@ -0,0 +1,4 @@
+
+
+ 寻龙记#
+
diff --git a/positions/src/main/AndroidManifest.xml b/positions/src/main/AndroidManifest.xml
index ac871265..d3022109 100644
--- a/positions/src/main/AndroidManifest.xml
+++ b/positions/src/main/AndroidManifest.xml
@@ -3,10 +3,28 @@
xmlns:android="http://schemas.android.com/apk/res/android"
package="cc.winboll.studio.positions">
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
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 08ae159c..9ca6fd7e 100644
--- a/positions/src/main/java/cc/winboll/studio/positions/App.java
+++ b/positions/src/main/java/cc/winboll/studio/positions/App.java
@@ -41,15 +41,19 @@ import java.util.Arrays;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
+import cc.winboll.studio.libaes.utils.WinBoLLActivityManager;
public class App extends GlobalApplication {
private static Handler MAIN_HANDLER = new Handler(Looper.getMainLooper());
-
+
@Override
public void onCreate() {
super.onCreate();
-
+ setIsDebuging(BuildConfig.DEBUG);
+
+ WinBoLLActivityManager.init(this);
+
// 初始化 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 f824af53..654f31e7 100644
--- a/positions/src/main/java/cc/winboll/studio/positions/MainActivity.java
+++ b/positions/src/main/java/cc/winboll/studio/positions/MainActivity.java
@@ -1,31 +1,266 @@
package cc.winboll.studio.positions;
+import android.Manifest;
+import android.app.Activity;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Build;
import android.os.Bundle;
-import androidx.appcompat.app.AppCompatActivity;
+import android.view.View;
+import android.widget.Button;
+import android.widget.CompoundButton;
+import android.widget.Switch;
+import android.widget.Toast;
+import androidx.annotation.NonNull;
import androidx.appcompat.widget.Toolbar;
-import cc.winboll.studio.libappbase.LogView;
-import com.hjq.toast.ToastUtils;
+import androidx.core.content.ContextCompat;
+import cc.winboll.studio.libaes.interfaces.IWinBoLLActivity;
+import cc.winboll.studio.libaes.utils.WinBoLLActivityManager;
+import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.positions.activities.LocationActivity;
+import cc.winboll.studio.positions.activities.WinBoLLActivity;
+import cc.winboll.studio.positions.services.MainService;
+import cc.winboll.studio.positions.utils.AppConfigsUtil;
-public class MainActivity extends AppCompatActivity {
+/**
+ * 主页面：仅负责
+ * 1. 位置服务启动/停止（通过 Switch 开关控制）
+ * 2. 跳转至“位置管理页（LocationActivity）”和“日志页（LogActivity）”
+ * 3. Java 7 语法适配：无 Lambda、显式接口实现、兼容低版本
+ */
+public class MainActivity extends WinBoLLActivity implements IWinBoLLActivity {
+ public static final String TAG = "MainActivity";
+ // 权限请求码（建议定义为类常量，避免魔法值）
+ private static final int REQUEST_LOCATION_PERMISSIONS = 1001;
+ private static final int REQUEST_BACKGROUND_LOCATION_PERMISSION = 1002;
+
+ // UI 控件：服务控制开关、顶部工具栏
+ private Switch mServiceSwitch;
+ private Button mManagePositionsButton;
+ private Toolbar mToolbar;
+ // 服务相关：服务实例、绑定状态标记
+ //private DistanceRefreshService mDistanceService;
+ private boolean isServiceBound = false;
- LogView mLogView;
+ @Override
+ public Activity getActivity() {
+ return this;
+ }
+
+ @Override
+ public String getTag() {
+ return TAG;
+ }
+
+ // ---------------------- 服务连接回调（仅用于获取服务状态，不依赖服务执行核心逻辑） ----------------------
+// private final ServiceConnection mServiceConn = new ServiceConnection() {
+// /**
+// * 服务绑定成功：获取服务实例，同步开关状态（以服务实际状态为准）
+// */
+// @Override
+// public void onServiceConnected(ComponentName name, IBinder service) {
+// // Java 7 显式强转 Binder 实例（确保类型匹配，避免ClassCastException）
+// DistanceRefreshService.DistanceBinder binder = (DistanceRefreshService.DistanceBinder) service;
+// mDistanceService = binder.getService();
+// isServiceBound = true;
+// }
+//
+// /**
+// * 服务意外断开（如服务崩溃）：重置服务实例和绑定状态
+// */
+// @Override
+// public void onServiceDisconnected(ComponentName name) {
+// mDistanceService = null;
+// isServiceBound = false;
+// }
+// };
+
+ // ---------------------- Activity 生命周期（核心：初始化UI、申请权限、绑定服务、释放资源） ----------------------
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
- setContentView(R.layout.activity_main);
+ setContentView(R.layout.activity_main); // 关联主页面布局
- Toolbar toolbar=(Toolbar)findViewById(R.id.toolbar);
- setSupportActionBar(toolbar);
-
- mLogView = findViewById(R.id.logview);
-
- ToastUtils.show("onCreate");
+ // 1. 初始化顶部 Toolbar（保留原逻辑，设置页面标题）
+ initToolbar();
+ // 2. 初始化其他控件
+ initViews();
+ // 3. 检查并申请位置权限（含后台GPS权限，确保服务启动前权限就绪）
+ if (!checkLocationPermissions()) {
+ requestLocationPermissions();
+ }
+ // 4. 绑定服务（仅用于获取服务实时状态，不影响服务独立运行）
+ //bindDistanceService();
}
@Override
- protected void onResume() {
- super.onResume();
- mLogView.start();
+ protected void onDestroy() {
+ super.onDestroy();
+ // 页面销毁时解绑服务，避免Activity与服务相互引用导致内存泄漏
+// if (isServiceBound) {
+// unbindService(mServiceConn);
+// isServiceBound = false;
+// mDistanceService = null;
+// }
}
+
+ // ---------------------- 核心功能1：初始化UI组件（Toolbar + 服务开关） ----------------------
+ /**
+ * 初始化顶部 Toolbar，设置页面标题
+ */
+ private void initToolbar() {
+ mToolbar = (Toolbar) findViewById(R.id.toolbar); // Java 7 显式 findViewById + 强转
+ setSupportActionBar(mToolbar);
+ // 给ActionBar设置标题（先判断非空，避免空指针异常）
+ if (getSupportActionBar() != null) {
+ getSupportActionBar().setTitle(getString(R.string.app_name));
+ }
+ }
+
+ /**
+ * 初始化服务控制开关：读取SP状态、绑定点击事件（含权限检查）
+ */
+ private void initViews() {
+ mServiceSwitch = (Switch) findViewById(R.id.switch_service_control); // 显式强转
+ mServiceSwitch.setChecked(AppConfigsUtil.getInstance(this).isEnableMainService(true));
+
+ mManagePositionsButton = (Button) findViewById(R.id.btn_manage_positions);
+ mManagePositionsButton.setEnabled(mServiceSwitch.isChecked());
+
+ // Java 7 用匿名内部类实现 CompoundButton.OnCheckedChangeListener
+ mServiceSwitch.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
+ @Override
+ public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+ // 开关打开前先检查权限：无权限则终止操作、重置开关、引导申请
+ 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 {
+ LogUtils.d(TAG, "设置关闭服务");
+ AppConfigsUtil.getInstance(MainActivity.this).setIsEnableMainService(false);
+ // 停止服务前先解绑，避免服务被Activity持有
+// if (isServiceBound) {
+// unbindService(mServiceConn);
+// isServiceBound = false;
+// }
+ stopService(new Intent(MainActivity.this, MainService.class));
+ }
+
+ mManagePositionsButton.setEnabled(isChecked);
+ }
+ });
+ }
+
+
+ /**
+ * 绑定服务（仅用于获取服务状态，不启动服务）
+ */
+// private void bindDistanceService() {
+// Intent serviceIntent = new Intent(this, MainService.class);
+// // BIND_AUTO_CREATE：服务未启动则创建（仅为获取状态，启停由开关控制）
+// bindService(serviceIntent, mServiceConn, Context.BIND_AUTO_CREATE);
+// }
+
+ // ---------------------- 核心功能3：页面跳转（位置管理页+日志页） ----------------------
+ /**
+ * 跳转至“位置管理页（LocationActivity）”（按钮点击触发，需在布局中设置 android:onClick="onPositions"）
+ * 服务未启动时提示，不允许跳转（避免LocationActivity无数据）
+ */
+ public void onPositions(View view) {
+ //ToastUtils.show("onPositions");
+ // 服务已启动：跳转到位置管理页
+ startActivity(new Intent(MainActivity.this, LocationActivity.class));
+ }
+
+ /**
+ * 跳转至“日志页（LogActivity）”（按钮点击触发，需在布局中设置 android:onClick="onLog"）
+ * 无服务状态限制，直接跳转
+ */
+ public void onLog(View view) {
+ WinBoLLActivityManager.getInstance().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() {
+ // 1. 先判断前台定位权限（ACCESS_FINE_LOCATION）是否已授予
+ if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
+ != PackageManager.PERMISSION_GRANTED) {
+ // 1.1 未授予前台权限：先申请前台权限（API 30+ 后台权限依赖前台权限）
+ String[] foregroundPermissions = new String[]{Manifest.permission.ACCESS_FINE_LOCATION};
+ // 对API 23+（Android 6.0）动态申请，低版本会直接授予（清单已声明前提下）
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ requestPermissions(foregroundPermissions, REQUEST_LOCATION_PERMISSIONS);
+ }
+ } else {
+ // 2. 已授予前台权限：判断是否需要申请后台权限（仅API 29+需要）
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+ // 2.1 检查后台权限是否未授予
+ if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+ != PackageManager.PERMISSION_GRANTED) {
+ // 2.2 API 30+ 必须单独申请后台权限（不能和前台权限一起弹框）
+ requestPermissions(
+ new String[]{Manifest.permission.ACCESS_BACKGROUND_LOCATION},
+ REQUEST_BACKGROUND_LOCATION_PERMISSION
+ );
+ }
+ }
+ // 3. 前台权限已授予（+ 后台权限按需授予）：此处可执行定位相关逻辑
+ // doLocationRelatedLogic();
+ }
+ }
+
+// 【必须补充】权限申请结果回调（处理用户同意/拒绝逻辑）
+ @Override
+ public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+ super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+ // 处理前台权限申请结果
+ if (requestCode == REQUEST_LOCATION_PERMISSIONS) {
+ if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+ // 前台权限同意：自动尝试申请后台权限（如果是API 29+）
+ requestLocationPermissions();
+ } else {
+ // 前台权限拒绝：提示用户（可选：引导跳转到应用设置页）
+ Toast.makeText(this, "需要前台定位权限才能使用该功能", Toast.LENGTH_SHORT).show();
+ }
+ } else if (requestCode == REQUEST_BACKGROUND_LOCATION_PERMISSION) {
+ if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+ // 后台权限同意：可执行后台定位逻辑
+ Toast.makeText(this, "已获得后台定位权限", Toast.LENGTH_SHORT).show();
+ } else {
+ // 后台权限拒绝：提示用户（可选：说明后台定位的用途，引导手动开启）
+ Toast.makeText(this, "拒绝后台权限将无法在后台持续定位", Toast.LENGTH_SHORT).show();
+ }
+ }
+ }
+
}
+
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
new file mode 100644
index 00000000..d10b831c
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/activities/LocationActivity.java
@@ -0,0 +1,381 @@
+package cc.winboll.studio.positions.activities;
+
+/**
+ * @Author ZhanGSKen&豆包大模型
+ * @Date 2025/09/29 18:22
+ * @Describe 位置列表页面（直连服务数据+移除绑定，兼容服务私有字段）
+ */
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.view.View;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.Toast;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+import cc.winboll.studio.libaes.interfaces.IWinBoLLActivity;
+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.MainService;
+import java.util.ArrayList;
+import cc.winboll.studio.libappbase.ToastUtils;
+import cc.winboll.studio.positions.utils.AppConfigsUtil;
+
+/**
+ * 核心调整说明：
+ * 1. 移除服务绑定逻辑，但不直接访问服务私有字段（解决mPositionList未知问题）
+ * 2. 通过服务提供的 PUBLIC 方法（如getPositionList、addPosition）操作数据，符合封装规范
+ * 3. 保留“直连服务实例”的核心需求，避免绑定，但尊重服务数据私有性
+ * 4. 兼容Java 7语法，无Lambda、显式类型转换
+ */
+public class LocationActivity extends WinBoLLActivity implements IWinBoLLActivity {
+ public static final String TAG = "LocationActivity";
+
+ // 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 MainService mMainService;
+ // 缓存服务数据（从服务PUBLIC方法获取，避免重复调用）
+ private ArrayList mCachedPositionList;
+ private ArrayList mCachedTaskList;
+
+
+ @Override
+ public Activity getActivity() {
+ return this;
+ }
+
+ @Override
+ public String getTag() {
+ return TAG;
+ }
+
+ // ---------------------- 页面生命周期（简化资源管理，无服务绑定） ----------------------
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_location);
+
+ LogUtils.d(TAG, "onCreate");
+
+ // 1. 初始化服务实例（通过单例/全局方式，避免直接new导致数据重置）
+ initServiceInstance();
+ // 2. 检查服务状态（未运行/未初始化则提示关闭）
+ checkServiceStatus();
+ // 3. 初始化RecyclerView（布局+性能优化）
+ initRecyclerViewConfig();
+ // 4. 缓存服务数据（从服务PUBLIC方法获取，不访问私有字段）
+ cacheServiceData();
+ // 5. 初始化Adapter（传缓存数据，而非直接访问服务私有字段）
+ initAdapter();
+ }
+
+ @Override
+ protected void onDestroy() {
+ super.onDestroy();
+ // 1. 清理Adapter资源
+ if (mAdapter != null) {
+ mAdapter.release();
+ mAdapter = null;
+ }
+ // 2. 置空服务实例+缓存数据（帮助GC回收）
+ mMainService = null;
+ mCachedPositionList = null;
+ mCachedTaskList = null;
+ mRecyclerView = null;
+ LogUtils.d(TAG, "页面销毁：已清理服务实例及缓存数据");
+ }
+
+ // ---------------------- 核心初始化（服务实例+数据缓存+状态检查） ----------------------
+ /**
+ * 初始化服务实例（关键：通过单例获取，确保全局唯一，避免数据重复）
+ * 注：需在DistanceRefreshService中实现单例（getInstance()方法）
+ */
+ private void initServiceInstance() {
+ // 步骤1：先启动Service（确保Service已创建，实例能被初始化）
+
+ // 步骤2：初始化Service实例（延迟100-200ms，确保Service onCreate执行完成）
+ // （或在startService后，通过ServiceConnection绑定获取实例，更可靠）
+ //initServiceInstance();
+
+ // 方式：通过服务PUBLIC单例方法获取实例（不直接new，避免私有数据初始化重复）
+ mMainService = MainService.getInstance();
+
+ // 容错：若单例未初始化（如首次启动），提示并处理
+ if (mMainService == null) {
+ LogUtils.e(TAG, "服务实例初始化失败：单例未创建");
+ Toast.makeText(this, "位置服务初始化失败，请重启应用", Toast.LENGTH_SHORT).show();
+ finish();
+ }
+ }
+
+
+ /**
+ * 检查服务状态（替代原绑定检查，通过服务PUBLIC方法判断）
+ */
+ private void checkServiceStatus() {
+ LogUtils.d(TAG, "checkServiceStatus");
+ // 1. 服务实例未初始化
+ if (mMainService == null) {
+ return; // 已在initServiceInstance中处理，此处避免重复finish
+ }
+
+ // 2. 检查服务运行状态（通过服务PUBLIC方法isServiceRunning()获取，不访问私有字段）
+ if (!mMainService.isServiceRunning()) {
+ // 服务未运行：手动触发启动（调用服务PUBLIC方法run()）
+ mMainService.run();
+ LogUtils.d(TAG, "服务未运行，已通过PUBLIC方法触发启动");
+ }
+
+ // 3. 检查SP中服务配置（双重校验，确保一致性）
+ if (!AppConfigsUtil.getInstance(LocationActivity.this).isEnableMainService(true)) {
+ Toast.makeText(this, "位置服务配置未启用，数据可能无法更新", Toast.LENGTH_SHORT).show();
+ }
+ }
+
+ /**
+ * 缓存服务数据（从服务PUBLIC方法获取，解决私有字段未知问题）
+ */
+ private void cacheServiceData() {
+ if (mMainService == null) {
+ ToastUtils.show("缓存数据失败：服务实例为空");
+ LogUtils.e(TAG, "缓存数据失败：服务实例为空");
+ mCachedPositionList = new ArrayList();
+ mCachedTaskList = new ArrayList();
+ return;
+ }
+
+ // 从服务PUBLIC方法获取数据（不访问mPositionList，而是调用getPositionList()）
+ mCachedPositionList = mMainService.getPositionList();
+ mCachedTaskList = mMainService.getPositionTasksList();
+
+ // 容错：若服务返回null，初始化空列表避免空指针
+ if (mCachedPositionList == null) mCachedPositionList = new ArrayList();
+ if (mCachedTaskList == null) mCachedTaskList = new ArrayList();
+
+ ToastUtils.show("缓存服务数据成功：位置数=" + mCachedPositionList.size() + "，任务数=" + mCachedTaskList.size());
+ 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() {
+ LogUtils.d(TAG, "initAdapter");
+ if (mCachedPositionList == null || mCachedTaskList == null) {
+ LogUtils.e(TAG, "初始化Adapter失败：缓存数据为空");
+ return;
+ }
+
+ // 1. 初始化Adapter（传缓存数据+服务实例，Adapter数据从缓存取，操作通过服务）
+ mAdapter = new PositionAdapter(this, mCachedPositionList, mCachedTaskList);
+ mRecyclerView.setAdapter(mAdapter);
+
+ // 2. 删除回调：通过服务PUBLIC方法removePosition()删除，不直接操作私有字段
+ mAdapter.setOnDeleteClickListener(new PositionAdapter.OnDeleteClickListener() {
+ @Override
+ public void onDeleteClick(int position) {
+ // 校验：服务实例有效+索引合法
+ if (mMainService == 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;
+ }
+
+ // 1. 获取要删除的位置（从缓存取，与服务数据一致）
+ PositionModel targetPos = mCachedPositionList.get(position);
+ String targetPosId = targetPos.getPositionId();
+
+ // 2. 调用服务PUBLIC方法删除（服务内部处理mPositionList/mTaskList，符合封装）
+ mMainService.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(int position, PositionModel updatedPos) {
+ // 校验：服务+数据+参数有效
+ if (mMainService == null || mCachedPositionList == null || updatedPos == null) {
+ Toast.makeText(LocationActivity.this, "保存失败：服务或数据异常", Toast.LENGTH_SHORT).show();
+ return;
+ }
+ if (position < 0 || position >= mCachedPositionList.size()) {
+ LogUtils.w(TAG, "保存失败：位置索引无效");
+ return;
+ }
+
+ // 1. 调用服务PUBLIC方法更新数据（服务内部修改mPositionList）
+ mMainService.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(PositionTaskModel newTask) {
+ if (mMainService == 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）
+ mMainService.syncAllPositionTasks(newTaskList);
+ LogUtils.d(TAG, "通过服务保存任务：ID=" + newTask.getTaskId());
+
+ // 3. 刷新缓存+Adapter
+ refreshCachedDataAndAdapter();
+ Toast.makeText(LocationActivity.this, "任务信息已保存", Toast.LENGTH_SHORT).show();
+ }
+ });
+ }
+
+ // ---------------------- 页面交互（新增位置、同步GPS，全走服务PUBLIC方法） ----------------------
+ /**
+ * 新增位置（调用服务addPosition()，不直接操作mPositionList）
+ */
+ public void addNewPosition(View view) {
+ // 1. 隐藏软键盘
+ InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+ if (imm != null && getCurrentFocus() != null) {
+ imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
+ }
+
+ // 2. 校验服务状态
+ if (mMainService == null) {
+ Toast.makeText(this, "新增失败：服务未初始化", Toast.LENGTH_SHORT).show();
+ return;
+ }
+
+ // 3. 创建新位置模型
+ PositionModel newPos = new PositionModel();
+ newPos.setPositionId(PositionModel.genPositionId()); // 生成唯一ID（PositionModel需实现）
+ newPos.setLongitude(116.404267); // 示例经度（北京）
+ newPos.setLatitude(39.915119); // 示例纬度
+ newPos.setMemo("测试位置（可编辑备注）");
+ newPos.setIsSimpleView(true); // 默认简单视图
+ newPos.setIsEnableRealPositionDistance(true); // 启用距离计算
+
+ // 4. 调用服务PUBLIC方法新增（服务内部处理mPositionList去重+添加）
+ mMainService.addPosition(newPos);
+ LogUtils.d(TAG, "通过服务新增位置：ID=" + newPos.getPositionId());
+
+ // 5. 刷新缓存+Adapter（显示新增结果）
+ refreshCachedDataAndAdapter();
+ Toast.makeText(this, "新增位置成功（已启用距离计算）", Toast.LENGTH_SHORT).show();
+ }
+
+ /**
+ * 同步GPS位置到服务（调用服务syncCurrentGpsPosition()，不访问私有字段）
+ */
+ public void syncGpsPositionToService(PositionModel gpsModel) {
+ if (mMainService == null || gpsModel == null) {
+ LogUtils.w(TAG, "同步GPS失败：服务未就绪或GPS数据无效");
+ return;
+ }
+
+ // 调用服务PUBLIC方法同步GPS（服务内部更新mCurrentGpsPosition）
+ mMainService.syncCurrentGpsPosition(gpsModel);
+ // 强制刷新距离（通过服务PUBLIC方法，触发mPositionList距离计算）
+ mMainService.forceRefreshDistance();
+ LogUtils.d(TAG, "GPS位置已同步，通过服务触发距离计算");
+
+ // 刷新缓存+Adapter（显示最新距离）
+ refreshCachedDataAndAdapter();
+ }
+
+ // ---------------------- 辅助方法（统一刷新缓存与Adapter，确保数据一致） ----------------------
+ /**
+ * 刷新缓存数据+Adapter（从服务重新获取数据，避免本地缓存与服务不一致）
+ */
+ private void refreshCachedDataAndAdapter() {
+ if (mMainService == null) {
+ LogUtils.w(TAG, "刷新失败：服务实例为空");
+ return;
+ }
+
+ // 1. 从服务重新获取数据（更新缓存，不访问私有字段）
+ mCachedPositionList = mMainService.getPositionList();
+ mCachedTaskList = mMainService.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/activities/WinBoLLActivity.java b/positions/src/main/java/cc/winboll/studio/positions/activities/WinBoLLActivity.java
new file mode 100644
index 00000000..3cf13b76
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/activities/WinBoLLActivity.java
@@ -0,0 +1,60 @@
+package cc.winboll.studio.positions.activities;
+
+/**
+ * @Author ZhanGSKen&豆包大模型
+ * @Date 2025/09/29 00:11
+ * @Describe WinBoLL 窗口基础类
+ */
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.MenuItem;
+import androidx.appcompat.app.AppCompatActivity;
+import cc.winboll.studio.libaes.interfaces.IWinBoLLActivity;
+import cc.winboll.studio.libaes.utils.WinBoLLActivityManager;
+import cc.winboll.studio.libappbase.LogUtils;
+
+public class WinBoLLActivity extends AppCompatActivity implements IWinBoLLActivity {
+
+ public static final String TAG = "WinBoLLActivity";
+
+ @Override
+ public Activity getActivity() {
+ return this;
+ }
+
+ @Override
+ public String getTag() {
+ return TAG;
+ }
+
+ @Override
+ protected void onResume() {
+ super.onResume();
+ LogUtils.d(TAG, String.format("onResume %s", getTag()));
+ }
+
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ /*if (item.getItemId() == R.id.item_log) {
+ WinBoLLActivityManager.getInstance().startLogActivity(this);
+ return true;
+ } else if (item.getItemId() == R.id.item_home) {
+ startActivity(new Intent(this, MainActivity.class));
+ return true;
+ }*/
+ // 在switch语句中处理每个ID，并在处理完后返回true，未处理的情况返回false。
+ return super.onOptionsItemSelected(item);
+ }
+
+ @Override
+ protected void onPostCreate(Bundle savedInstanceState) {
+ super.onPostCreate(savedInstanceState);
+ WinBoLLActivityManager.getInstance().add(this);
+ }
+
+ @Override
+ protected void onDestroy() {
+ super.onDestroy();
+ WinBoLLActivityManager.getInstance().registeRemove(this);
+ }
+}
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
new file mode 100644
index 00000000..d4f13e07
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/adapters/PositionAdapter.java
@@ -0,0 +1,559 @@
+package cc.winboll.studio.positions.adapters;
+
+/**
+ * @Author ZhanGSKen&豆包大模型
+ * @Date 2025/09/29 20:25
+ * @Describe 位置数据适配器（完全独立，无未知接口依赖，仅用LocationActivity缓存数据）
+ */
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.Button;
+import android.widget.EditText;
+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 java.util.ArrayList;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 核心调整：
+ * 1. 彻底删除所有与 DistanceServiceInterface 相关的代码（解决未知类型问题）
+ * 2. 完全基于 LocationActivity 传入的缓存数据（mCachedPositionList/mCachedTaskList）实现所有功能
+ * 3. 移除服务回调、可见位置通知等冗余逻辑，仅保留“数据显示+用户交互→通知Activity处理”的核心流程
+ * 4. 确保无未定义接口、无外部服务依赖，代码可直接编译运行
+ */
+public class PositionAdapter extends RecyclerView.Adapter {
+ public static final String TAG = "PositionAdapter";
+
+ // 1. 视图类型常量（简单视图/编辑视图，无魔法值）
+ private static final int VIEW_TYPE_SIMPLE = 0;
+ private static final int VIEW_TYPE_EDIT = 1;
+ // 2. 默认配置（文本显示/任务默认值，统一管理）
+ private static final String DEFAULT_MEMO = "无备注";
+ private static final String DEFAULT_TASK_DESC = "新任务";
+ private static final int DEFAULT_TASK_DISTANCE = 50; // 单位：米
+ private static final String DISTANCE_FORMAT = "实时距离：%.1f 米";
+ private static final String DISTANCE_DISABLED = "实时距离：未启用";
+ private static final String DISTANCE_ERROR = "实时距离：计算失败";
+
+ // 3. 唯一数据源（完全依赖 LocationActivity 传入的缓存数据，无其他来源）
+ private final Context mContext;
+ private ArrayList mCachedPositionList; // 位置缓存（来自Activity）
+ private ArrayList mCachedTaskList; // 任务缓存（来自Activity）
+
+ // 4. 本地辅助缓存（优化性能：避免重复遍历，不依赖外部服务）
+ private final ConcurrentHashMap> mPosToTasksMap; // 位置ID→关联任务（本地分组）
+ private final ConcurrentHashMap mPosDistanceViewMap; // 位置ID→距离控件（更新UI用）
+
+ // =========================================================================
+ // 与 LocationActivity 交互的回调接口（仅定义必要功能，无冗余）
+ // =========================================================================
+ // 删除位置：通知Activity删除指定索引的位置数据
+ public interface OnDeleteClickListener {
+ void onDeleteClick(int position);
+ }
+
+ // 保存位置：通知Activity保存更新后的位置模型（带索引，方便Activity定位修改）
+ public interface OnSavePositionClickListener {
+ void onSavePositionClick(int position, PositionModel updatedPos);
+ }
+
+ // 保存任务：通知Activity保存新增/修改的任务（带任务模型，Activity处理数据同步）
+ public interface OnSavePositionTaskClickListener {
+ void onSavePositionTaskClick(PositionTaskModel newTask);
+ }
+
+ // 回调实例（由LocationActivity初始化时设置，解耦Activity与Adapter）
+ private OnDeleteClickListener mOnDeleteListener;
+ private OnSavePositionClickListener mOnSavePosListener;
+ private OnSavePositionTaskClickListener mOnSaveTaskListener;
+
+ // =========================================================================
+ // 构造函数（仅接收上下文+Activity缓存数据，无其他依赖，解决接口未定义问题）
+ // =========================================================================
+ /**
+ * 唯一构造函数（确保无未知接口依赖，直接使用Activity提供的数据）
+ * @param context 上下文（加载布局、操作软键盘、获取资源）
+ * @param cachedPositionList LocationActivity中的位置缓存（唯一位置数据源）
+ * @param cachedTaskList LocationActivity中的任务缓存（唯一任务数据源）
+ */
+ public PositionAdapter(Context context, ArrayList cachedPositionList, ArrayList cachedTaskList) {
+ this.mContext = context;
+ // 初始化数据源（容错处理：若Activity传入null，初始化空列表避免空指针）
+ this.mCachedPositionList = (cachedPositionList != null) ? cachedPositionList : new ArrayList();
+ this.mCachedTaskList = (cachedTaskList != null) ? cachedTaskList : new ArrayList();
+
+ // 初始化本地辅助缓存（基于Activity传入的数据构建，提升后续操作性能）
+ this.mPosToTasksMap = new ConcurrentHashMap>();
+ this.mPosDistanceViewMap = new ConcurrentHashMap();
+
+ // 初始化“位置→任务”映射（从Activity任务缓存中分组，避免每次显示都遍历全量任务）
+ refreshPositionTaskMap();
+ LogUtils.d(TAG, "Adapter初始化完成：位置数=" + mCachedPositionList.size() + "，任务数=" + mCachedTaskList.size());
+ }
+
+ // =========================================================================
+ // 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（根据类型加载布局，无外部依赖）
+ */
+ @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(TAG, "绑定数据失败：位置模型为空（索引=" + position + "）");
+ return;
+ }
+ String posId = posModel.getPositionId();
+
+ // 根据视图类型绑定数据（简单视图/编辑视图分别处理）
+ if (holder instanceof SimpleViewHolder) {
+ bindSimpleView((SimpleViewHolder) holder, posModel);
+ } else if (holder instanceof EditViewHolder) {
+ bindEditView((EditViewHolder) holder, posModel, position);
+ }
+
+ // 缓存当前位置的距离控件（后续更新距离UI时直接使用，避免重新查找）
+ TextView distanceView = (holder instanceof SimpleViewHolder)
+ ? ((SimpleViewHolder) holder).tvSimpleDistance
+ : ((EditViewHolder) holder).tvEditDistance;
+ mPosDistanceViewMap.put(posId, distanceView);
+ }
+
+ /**
+ * 视图离开屏幕（清理距离控件缓存，避免内存泄漏）
+ */
+ @Override
+ public void onViewDetachedFromWindow(RecyclerView.ViewHolder holder) {
+ super.onViewDetachedFromWindow(holder);
+ PositionModel posModel = getPositionByIndex(holder.getAdapterPosition());
+ if (posModel != null) {
+ mPosDistanceViewMap.remove(posModel.getPositionId()); // 移除不再显示的控件引用
+ }
+ }
+
+ /**
+ * 获取列表项数量（直接从Activity位置缓存中取，无中间层）
+ */
+ @Override
+ public int getItemCount() {
+ return mCachedPositionList.size();
+ }
+
+ // =========================================================================
+ // 视图绑定细节（完全基于缓存数据，操作后通过回调通知Activity）
+ // =========================================================================
+ /**
+ * 绑定“简单视图”（仅显示数据，点击切换到编辑视图）
+ */
+ 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()));
+ // 2. 显示备注（无备注时显示默认文本，避免空白）
+ String memo = posModel.getMemo();
+ holder.tvSimpleMemo.setText("备注：" + (memo != null && !memo.isEmpty() ? memo : DEFAULT_MEMO));
+ // 3. 显示实时距离（从缓存数据的distance字段取数，按状态显示不同内容）
+ updateDistanceDisplay(holder.tvSimpleDistance, posModel);
+ // 4. 点击视图→切换到编辑模式（修改缓存数据中的状态，通知RecyclerView刷新）
+ holder.itemView.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ posModel.setIsSimpleView(false); // 修改缓存数据中的视图状态
+ notifyItemChanged(getPositionIndexById(posModel.getPositionId())); // 刷新对应项
+ }
+ });
+ }
+
+ /**
+ * 绑定“编辑视图”（支持修改备注、开关距离、删除/保存位置、新增任务）
+ */
+ private void bindEditView(final EditViewHolder holder, final PositionModel posModel, final int position) {
+ final String posId = posModel.getPositionId();
+
+ // 1. 显示经纬度（不可编辑，仅展示，从缓存数据取）
+ holder.tvEditLon.setText(String.format("经度：%.6f", posModel.getLongitude()));
+ holder.tvEditLat.setText(String.format("纬度：%.6f", posModel.getLatitude()));
+ // 2. 显示备注（编辑框赋值，光标定位到末尾，方便用户直接编辑）
+ String memo = posModel.getMemo();
+ if (memo != null && !memo.isEmpty()) {
+ holder.etEditMemo.setText(memo);
+ holder.etEditMemo.setSelection(memo.length());
+ } else {
+ holder.etEditMemo.setText(""); // 无备注时清空编辑框
+ }
+ // 3. 显示实时距离（与简单视图逻辑一致，从缓存数据取数）
+ updateDistanceDisplay(holder.tvEditDistance, posModel);
+ // 4. 设置距离开关状态（匹配缓存数据中的启用状态，确保UI与数据一致）
+ holder.rgDistanceSwitch.check(posModel.isEnableRealPositionDistance()
+ ? R.id.rb_distance_enable : R.id.rb_distance_disable);
+
+ // 5. 取消编辑→切换回简单视图（修改缓存状态，刷新UI，隐藏软键盘）
+ holder.btnCancel.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ posModel.setIsSimpleView(true);
+ notifyItemChanged(position);
+ hideSoftKeyboard(v);
+ }
+ });
+
+ // 6. 删除位置→回调Activity处理（Adapter不直接删数据，由Activity操作缓存+服务）
+ holder.btnDelete.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ if (mOnDeleteListener != null) {
+ mOnDeleteListener.onDeleteClick(position); // 通知Activity删除指定索引
+ }
+ hideSoftKeyboard(v);
+ }
+ });
+
+ // 7. 保存位置→回调Activity保存（收集编辑后的参数，传更新后的模型）
+ holder.btnSave.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ // 收集编辑后的参数（备注+距离启用状态）
+ String newMemo = holder.etEditMemo.getText().toString().trim();
+ boolean isDistanceEnable = (holder.rgDistanceSwitch.getCheckedRadioButtonId() == R.id.rb_distance_enable);
+
+ // 构建更新后的位置模型（保留原核心数据，仅更新可编辑字段）
+ PositionModel updatedPos = new PositionModel();
+ updatedPos.setPositionId(posId); // 保留原ID（不可修改）
+ updatedPos.setLongitude(posModel.getLongitude()); // 保留原经度（不可编辑）
+ updatedPos.setLatitude(posModel.getLatitude()); // 保留原纬度（不可编辑）
+ updatedPos.setMemo(newMemo); // 更新备注（用户编辑）
+ updatedPos.setIsEnableRealPositionDistance(isDistanceEnable); // 更新距离状态
+ updatedPos.setIsSimpleView(true); // 切换回简单视图
+
+ // 回调Activity保存（由Activity同步缓存数据+服务数据，Adapter不处理逻辑）
+ if (mOnSavePosListener != null) {
+ mOnSavePosListener.onSavePositionClick(position, updatedPos);
+ }
+
+ // 本地同步状态（避免刷新延迟，直接修改Activity传入的缓存数据）
+ posModel.setMemo(newMemo);
+ posModel.setIsEnableRealPositionDistance(isDistanceEnable);
+ posModel.setIsSimpleView(true);
+ notifyItemChanged(position); // 刷新当前项，显示更新后的状态
+ hideSoftKeyboard(v);
+ LogUtils.d(TAG, "触发位置保存：ID=" + posId + "，新备注=" + newMemo);
+ }
+ });
+
+ // 8. 绑定任务相关视图（显示任务数量+新增任务，基于Activity任务缓存）
+ bindTaskView(holder, posId);
+ }
+
+ /**
+ * 绑定任务视图（编辑模式专属：显示当前位置的任务数量+新增任务）
+ */
+ private void bindTaskView(final EditViewHolder holder, final String posId) {
+ // 从本地映射获取当前位置的任务（基于Activity缓存数据构建，避免重复遍历）
+ ArrayList posTasks = mPosToTasksMap.get(posId);
+ if (posTasks == null) {
+ posTasks = new ArrayList();
+ }
+
+ // 显示当前位置的任务数量（简化设计，实际项目可替换为任务列表RecyclerView）
+ holder.tvTaskCount.setText("任务数量：" + posTasks.size());
+
+ // 新增任务→回调Activity处理（Adapter不直接操作任务数据，由Activity同步）
+ holder.btnAddTask.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ // 创建默认任务模型（生成唯一ID，关联当前位置）
+ PositionTaskModel newTask = new PositionTaskModel();
+ newTask.setTaskId(PositionTaskModel.genTaskId()); // 需在PositionTaskModel实现静态生成ID方法
+ newTask.setPositionId(posId); // 关联当前位置ID（确保任务归属正确）
+ newTask.setTaskDescription(DEFAULT_TASK_DESC); // 默认任务描述
+ newTask.setIsEnable(true); // 默认启用任务
+ newTask.setDiscussDistance(DEFAULT_TASK_DISTANCE);// 默认任务距离（50米）
+
+ // 回调Activity保存任务（由Activity添加到缓存+同步服务，Adapter仅通知）
+ if (mOnSaveTaskListener != null) {
+ mOnSaveTaskListener.onSavePositionTaskClick(newTask);
+ }
+
+ // 本地同步任务数量（避免刷新延迟，更新本地映射+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());
+ }
+ });
+ }
+
+ // =========================================================================
+ // 核心工具方法（无接口依赖，基于缓存数据实现，确保功能完整）
+ // =========================================================================
+ /**
+ * 更新距离显示（根据位置模型状态，显示不同文本和颜色，无外部依赖）
+ */
+ private void updateDistanceDisplay(TextView distanceView, PositionModel posModel) {
+ if (distanceView == null || posModel == null) return;
+
+ // 场景1：距离计算未启用（从缓存数据状态判断）
+ if (!posModel.isEnableRealPositionDistance()) {
+ distanceView.setText(DISTANCE_DISABLED);
+ distanceView.setTextColor(mContext.getResources().getColor(R.color.gray));
+ return;
+ }
+
+ // 场景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米）：绿色
+ distanceView.setTextColor(mContext.getResources().getColor(R.color.green));
+ } else if (distance <= 500) { // 中距离（≤500米）：黄色
+ distanceView.setTextColor(mContext.getResources().getColor(R.color.yellow));
+ } else { // 远距离（>500米）：红色
+ distanceView.setTextColor(mContext.getResources().getColor(R.color.red));
+ }
+ }
+
+ /**
+
+ - 根据索引获取位置模型（从Activity缓存数据直接读取，无中间层，避免数据不一致）
+ */
+ private PositionModel getPositionByIndex(int index) {
+ if (mCachedPositionList == null || index < 0 || index >= mCachedPositionList.size()) {
+ LogUtils.w(TAG, "获取位置失败：索引无效（" + index + "）或缓存数据为空");
+ return null;
+ }
+ return mCachedPositionList.get(index);
+ }
+
+ /**
+
+ - 根据位置ID获取列表索引（从Activity缓存数据遍历，用于视图切换后精准刷新）
+ */
+ 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，返回对应索引
+ }
+ }
+ LogUtils.w(TAG, "未找到位置ID：" + positionId + "，返回无效索引-1");
+ return -1;
+ }
+
+ /**
+
+ - 刷新“位置→任务”映射（基于Activity最新任务缓存重建，确保本地映射与Activity数据一致）
+ - （Activity任务数据更新后调用，避免本地映射滞后）
+ */
+ public void refreshPositionTaskMap() {
+ 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, "刷新任务映射失败：并发修改Activity任务缓存。" + e);
+ }
+ }
+
+ /**
+
+ - 全量更新数据（接收Activity最新缓存数据，同步本地数据源+辅助缓存，刷新UI）
+ - （Activity新增/删除位置/任务后调用，确保Adapter与Activity数据100%一致）
+ */
+ public void updateAllData(ArrayList newPosList, ArrayList newTaskList) {
+// 同步Activity最新缓存数据（容错处理：避免接收null导致空指针）
+ this.mCachedPositionList = (newPosList != null) ? newPosList : new ArrayList();
+ this.mCachedTaskList = (newTaskList != null) ? newTaskList : new ArrayList();// 刷新本地辅助缓存（确保映射与最新数据同步）
+ refreshPositionTaskMap();
+ 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 (imm != null) {
+ imm.hideSoftInputFromWindow(view.getWindowToken(), 0); // 强制隐藏软键盘
+ }
+ }
+
+ /**
+
+ - 释放资源（Activity销毁时调用，彻底避免内存泄漏）
+ */
+ public void release() {
+// 清空本地辅助缓存（解除控件、数据映射引用）
+ mPosToTasksMap.clear();
+ mPosDistanceViewMap.clear();
+// 置空回调实例（避免持有Activity引用导致内存泄漏）
+ mOnDeleteListener = null;
+ mOnSavePosListener = null;
+ mOnSaveTaskListener = null;
+// 置空数据源引用（帮助GC回收，避免残留数据占用内存）
+ mCachedPositionList = null;
+ mCachedTaskList = null;
+ LogUtils.d(TAG, "Adapter资源已完全释放");
+ }
+
+// =========================================================================
+// 回调设置方法（LocationActivity调用，绑定交互逻辑，无冗余参数）
+// =========================================================================
+ public void setOnDeleteClickListener(OnDeleteClickListener listener) {
+ this.mOnDeleteListener = listener;
+ }
+
+ public void setOnSavePositionClickListener(OnSavePositionClickListener listener) {
+ this.mOnSavePosListener = listener;
+ }
+
+ public void setOnSavePositionTaskClickListener(OnSavePositionTaskClickListener listener) {
+ this.mOnSaveTaskListener = listener;
+ }
+
+// =========================================================================
+// 视图Holder类（静态内部类，不持有外部引用，彻底避免内存泄漏）
+// =========================================================================
+ /**
+
+ - 简单视图Holder（仅显示数据，对应布局：item_position_simple.xml）
+ */
+ public static class SimpleViewHolder extends RecyclerView.ViewHolder {
+ TextView tvSimpleLon; // 经度显示控件
+ TextView tvSimpleLat; // 纬度显示控件
+ TextView tvSimpleMemo; // 备注显示控件
+ TextView tvSimpleDistance;// 实时距离显示控件
+ public SimpleViewHolder(View itemView) {
+ super(itemView);
+// 绑定布局控件（与XML中ID严格对应，避免运行时空指针）
+ tvSimpleLon = (TextView) itemView.findViewById(R.id.tv_simple_longitude);
+ tvSimpleLat = (TextView) itemView.findViewById(R.id.tv_simple_latitude);
+ tvSimpleMemo = (TextView) itemView.findViewById(R.id.tv_simple_memo);
+ tvSimpleDistance = (TextView) itemView.findViewById(R.id.tv_simple_distance);
+ }
+ }
+
+ /**
+
+ - 编辑视图Holder（含编辑控件+功能按钮，对应布局：item_position_edit.xml）
+ */
+ public static class EditViewHolder extends RecyclerView.ViewHolder {
+ TextView tvEditLon; // 经度显示控件（不可编辑）
+ TextView tvEditLat; // 纬度显示控件（不可编辑）
+ EditText etEditMemo; // 备注编辑控件
+ TextView tvEditDistance; // 实时距离显示控件
+ RadioGroup rgDistanceSwitch; // 距离启用/禁用开关组
+ Button btnCancel; // 取消编辑按钮
+ Button btnDelete; // 删除位置按钮
+ Button btnSave; // 保存位置按钮
+ Button btnAddTask; // 新增任务按钮
+ TextView tvTaskCount; // 任务数量显示控件（简化设计）
+ public EditViewHolder(View itemView) {
+ super(itemView);
+// 绑定布局控件（与XML中ID严格对应，避免运行时空指针）
+ tvEditLon = (TextView) itemView.findViewById(R.id.tv_edit_longitude);
+ tvEditLat = (TextView) itemView.findViewById(R.id.tv_edit_latitude);
+ etEditMemo = (EditText) itemView.findViewById(R.id.et_edit_memo);
+ tvEditDistance = (TextView) itemView.findViewById(R.id.tv_edit_distance);
+ rgDistanceSwitch = (RadioGroup) itemView.findViewById(R.id.rg_distance_switch);
+ btnCancel = (Button) itemView.findViewById(R.id.btn_edit_cancel);
+ btnDelete = (Button) itemView.findViewById(R.id.btn_edit_delete);
+ btnSave = (Button) itemView.findViewById(R.id.btn_edit_save);
+ btnAddTask = (Button) itemView.findViewById(R.id.btn_add_task);
+ tvTaskCount = (TextView) itemView.findViewById(R.id.tv_task_count);
+ }
+ }
+}
diff --git a/positions/src/main/java/cc/winboll/studio/positions/models/AppConfigsModel.java b/positions/src/main/java/cc/winboll/studio/positions/models/AppConfigsModel.java
new file mode 100644
index 00000000..feb0aa06
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/models/AppConfigsModel.java
@@ -0,0 +1,75 @@
+package cc.winboll.studio.positions.models;
+
+/**
+ * @Author ZhanGSKen&豆包大模型
+ * @Date 2025/10/01 04:50
+ * @Describe AppConfigsModel
+ */
+ import cc.winboll.studio.libappbase.BaseBean;
+import android.util.JsonWriter;
+import android.util.JsonReader;
+import java.io.IOException;
+
+public class AppConfigsModel extends BaseBean {
+
+ public static final String TAG = "AppConfigsModel";
+
+ boolean isEnableMainService;
+
+ public AppConfigsModel(boolean isEnableMainService) {
+ this.isEnableMainService = isEnableMainService;
+ }
+
+ public AppConfigsModel() {
+ this.isEnableMainService = false;
+ }
+
+ public void setIsEnableMainService(boolean isEnableMainService) {
+ this.isEnableMainService = isEnableMainService;
+ }
+
+ public boolean isEnableMainService() {
+ return isEnableMainService;
+ }
+
+ @Override
+ public String getName() {
+ return AppConfigsModel.class.getName();
+ }
+
+ // JSON序列化（保存位置数据）
+ @Override
+ public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
+ super.writeThisToJsonWriter(jsonWriter);
+ jsonWriter.name("isEnableDistanceRefreshService").value(isEnableMainService());
+ }
+
+ // JSON反序列化（加载位置数据，校验字段）
+ @Override
+ public boolean initObjectsFromJsonReader(JsonReader jsonReader, String name) throws IOException {
+ if (super.initObjectsFromJsonReader(jsonReader, name)) {
+ return true;
+ } else {
+ if (name.equals("isEnableDistanceRefreshService")) {
+ setIsEnableMainService(jsonReader.nextBoolean());
+ } else {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ // 从JSON读取位置数据
+ @Override
+ public BaseBean readBeanFromJsonReader(JsonReader jsonReader) throws IOException {
+ jsonReader.beginObject();
+ while (jsonReader.hasNext()) {
+ String name = jsonReader.nextName();
+ if (!initObjectsFromJsonReader(jsonReader, name)) {
+ jsonReader.skipValue(); // 跳过未知字段
+ }
+ }
+ jsonReader.endObject();
+ return this;
+ }
+}
diff --git a/positions/src/main/java/cc/winboll/studio/positions/models/PositionModel.java b/positions/src/main/java/cc/winboll/studio/positions/models/PositionModel.java
new file mode 100644
index 00000000..7c7c9ca2
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/models/PositionModel.java
@@ -0,0 +1,219 @@
+package cc.winboll.studio.positions.models;
+
+/**
+ * @Author ZhanGSKen&豆包大模型
+ * @Date 2025/09/29 18:57
+ * @Describe 位置数据模型
+ */
+import android.util.JsonReader;
+import android.util.JsonWriter;
+import cc.winboll.studio.libappbase.BaseBean;
+import java.io.IOException;
+import java.util.UUID;
+
+public class PositionModel extends BaseBean {
+
+ public static final String TAG = "PositionModel";
+ // 位置唯一标识符（与任务的positionId绑定）
+ String positionId;
+ // 经度（范围：-180~180）
+ double longitude;
+ // 纬度（范围：-90~90）
+ double latitude;
+ // 位置备注（空值时显示“无备注”）
+ String memo;
+ // 定位点与指定点实时距离长度
+ double realPositionDistance;
+ // 是否启用实时距离计算
+ boolean isEnableRealPositionDistance;
+ // 是否显示简单视图（true=简单视图，false=编辑视图）
+ boolean isSimpleView = true;
+
+ // 带参构造（强制初始化位置ID和经纬度）
+ public PositionModel(String positionId, double longitude, double latitude, String memo, boolean isEnableRealPositionDistance) {
+ this.positionId = (positionId == null || positionId.trim().isEmpty()) ? genPositionId() : positionId;
+ this.longitude = Math.max(-180, Math.min(180, longitude)); // 经度范围限制
+ this.latitude = Math.max(-90, Math.min(90, latitude)); // 纬度范围限制
+ this.memo = (memo == null || memo.trim().isEmpty()) ? "无备注" : memo;
+ this.isEnableRealPositionDistance = isEnableRealPositionDistance;
+ }
+
+ // 无参构造（默认值初始化，避免空指针）
+ public PositionModel() {
+ this.positionId = genPositionId();
+ this.longitude = 0.0;
+ this.latitude = 0.0;
+ this.memo = "无备注";
+ this.isEnableRealPositionDistance = false;
+ }
+
+ public void setRealPositionDistance(double realPositionDistance) {
+ this.realPositionDistance = realPositionDistance;
+ }
+
+ public double getRealPositionDistance() {
+ return realPositionDistance;
+ }
+
+ // ---------------------- Getter/Setter（确保字段有效性） ----------------------
+ public void setPositionId(String positionId) {
+ this.positionId = (positionId == null || positionId.trim().isEmpty()) ? genPositionId() : positionId;
+ }
+
+ public String getPositionId() {
+ return positionId;
+ }
+
+ public void setIsEnableRealPositionDistance(boolean isEnableRealPositionDistance) {
+ this.isEnableRealPositionDistance = isEnableRealPositionDistance;
+ }
+
+ public boolean isEnableRealPositionDistance() {
+ return isEnableRealPositionDistance;
+ }
+
+ public void setIsSimpleView(boolean isSimpleView) {
+ this.isSimpleView = isSimpleView;
+ }
+
+ public boolean isSimpleView() {
+ return isSimpleView;
+ }
+
+ public void setMemo(String memo) {
+ this.memo = (memo == null || memo.trim().isEmpty()) ? "无备注" : memo;
+ }
+
+ public String getMemo() {
+ return memo;
+ }
+
+ public void setLongitude(double longitude) {
+ this.longitude = Math.max(-180, Math.min(180, longitude)); // 限制经度范围
+ }
+
+ public double getLongitude() {
+ return longitude;
+ }
+
+ public void setLatitude(double latitude) {
+ this.latitude = Math.max(-90, Math.min(90, latitude)); // 限制纬度范围
+ }
+
+ public double getLatitude() {
+ return latitude;
+ }
+
+ // ---------------------- 父类方法重写 ----------------------
+ @Override
+ public String getName() {
+ return PositionModel.class.getName();
+ }
+
+ // 生成唯一位置ID（与任务ID格式一致，确保关联匹配）
+ public static String genPositionId() {
+ UUID uniqueUuid = UUID.randomUUID();
+ return uniqueUuid.toString(); // 36位标准UUID（含横杠，确保与任务ID格式统一）
+ }
+
+ // JSON序列化（保存位置数据）
+ @Override
+ public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
+ super.writeThisToJsonWriter(jsonWriter);
+ jsonWriter.name("positionId").value(getPositionId());
+ jsonWriter.name("longitude").value(getLongitude());
+ jsonWriter.name("latitude").value(getLatitude());
+ jsonWriter.name("memo").value(getMemo());
+ jsonWriter.name("isEnableRealPositionDistance").value(isEnableRealPositionDistance());
+ }
+
+ // JSON反序列化（加载位置数据，校验字段）
+ @Override
+ public boolean initObjectsFromJsonReader(JsonReader jsonReader, String name) throws IOException {
+ if (super.initObjectsFromJsonReader(jsonReader, name)) {
+ return true;
+ } else {
+ if (name.equals("positionId")) {
+ setPositionId(jsonReader.nextString());
+ } else if (name.equals("longitude")) {
+ setLongitude(jsonReader.nextDouble());
+ } else if (name.equals("latitude")) {
+ setLatitude(jsonReader.nextDouble());
+ } else if (name.equals("memo")) {
+ setMemo(jsonReader.nextString());
+ } else if (name.equals("isEnableRealPositionDistance")) {
+ setIsEnableRealPositionDistance(jsonReader.nextBoolean());
+ } else {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ // 从JSON读取位置数据
+ @Override
+ public BaseBean readBeanFromJsonReader(JsonReader jsonReader) throws IOException {
+ jsonReader.beginObject();
+ while (jsonReader.hasNext()) {
+ String name = jsonReader.nextName();
+ if (!initObjectsFromJsonReader(jsonReader, name)) {
+ jsonReader.skipValue(); // 跳过未知字段
+ }
+ }
+ jsonReader.endObject();
+ return this;
+ }
+
+ // ---------------------- 核心工具方法：计算两点距离（Haversine公式，确保精度） ----------------------
+ /**
+ * 计算两个位置之间的直线距离（地球表面最短距离）
+ * @param position1 第一个位置（非null）
+ * @param position2 第二个位置（非null）
+ * @param isKilometer 是否返回千米单位：true→千米，false→米
+ * @return 距离（保留1位小数，符合显示需求）
+ * @throws IllegalArgumentException 位置为null或经纬度无效时抛出
+ */
+ public static double calculatePositionDistance(PositionModel position1, PositionModel position2, boolean isKilometer) {
+ // 1. 校验参数有效性（避免计算异常）
+ if (position1 == null || position2 == null) {
+ throw new IllegalArgumentException("位置对象不能为null");
+ }
+ double lon1 = position1.getLongitude();
+ double lat1 = position1.getLatitude();
+ double lon2 = position2.getLongitude();
+ double lat2 = position2.getLatitude();
+ // 经纬度范围二次校验（确保有效）
+ if (lat1 < -90 || lat1 > 90 || lat2 < -90 || lat2 > 90
+ || lon1 < -180 || lon1 > 180 || lon2 < -180 || lon2 > 180) {
+ throw new IllegalArgumentException("经纬度值无效（纬度：-90~90，经度：-180~180）");
+ }
+
+ // 2. Haversine公式计算（地球半径取6371km，行业标准）
+ final double EARTH_RADIUS_KM = 6371;
+ double radLat1 = Math.toRadians(lat1); // 角度转弧度
+ double radLat2 = Math.toRadians(lat2);
+ double radLon1 = Math.toRadians(lon1);
+ double radLon2 = Math.toRadians(lon2);
+
+ double deltaLat = radLat2 - radLat1; // 纬度差
+ double deltaLon = radLon2 - radLon1; // 经度差
+
+ // 核心公式
+ double a = Math.pow(Math.sin(deltaLat / 2), 2)
+ + Math.cos(radLat1) * Math.cos(radLat2)
+ * Math.pow(Math.sin(deltaLon / 2), 2);
+ double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+ double distanceKm = EARTH_RADIUS_KM * c; // 距离（千米）
+
+ // 3. 单位转换+精度处理（保留1位小数，符合显示需求）
+ double distance;
+ if (isKilometer) {
+ distance = Math.round(distanceKm * 10.0) / 10.0; // 千米→1位小数
+ } else {
+ distance = Math.round(distanceKm * 1000 * 10.0) / 10.0; // 米→1位小数
+ }
+
+ return distance;
+ }
+}
+
diff --git a/positions/src/main/java/cc/winboll/studio/positions/models/PositionTaskModel.java b/positions/src/main/java/cc/winboll/studio/positions/models/PositionTaskModel.java
new file mode 100644
index 00000000..722c33da
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/models/PositionTaskModel.java
@@ -0,0 +1,192 @@
+package cc.winboll.studio.positions.models;
+
+/**
+ * @Author ZhanGSKen&豆包大模型
+ * @Date 2025/09/30 02:48
+ * @Describe 位置任务数据模型
+ */
+import android.util.JsonReader;
+import android.util.JsonWriter;
+import cc.winboll.studio.libappbase.BaseBean;
+import java.io.IOException;
+import java.util.UUID;
+
+public class PositionTaskModel extends BaseBean {
+
+ public static final String TAG = "PositionTaskModel";
+ // 任务标识符（唯一）
+ String taskId;
+ // 绑定的位置标识符（与PositionModel的positionId一一对应）
+ String positionId;
+ // 任务描述
+ String taskDescription;
+ // 任务距离条件：是否大于设定距离
+ boolean isGreaterThan;
+ // 任务距离条件：是否小于设定距离（与isGreaterThan互斥）
+ boolean isLessThan;
+ // 任务条件距离（单位：米）
+ int discussDistance;
+ // 任务是否已触发
+ boolean isBingo = false;
+ // 是否启用任务
+ boolean isEnable;
+
+ // 带参构造（强制传入positionId，确保任务与位置绑定）
+ public PositionTaskModel(String taskId, String positionId, String taskDescription, boolean isGreaterThan, int discussDistance, boolean isEnable) {
+ this.taskId = (taskId == null || taskId.trim().isEmpty()) ? genTaskId() : taskId; // 空ID自动生成
+ this.positionId = positionId; // 强制绑定位置ID
+ this.taskDescription = (taskDescription == null || taskDescription.trim().isEmpty()) ? "新任务" : taskDescription;
+ this.isGreaterThan = isGreaterThan;
+ this.isLessThan = !isGreaterThan; // 确保互斥
+ this.discussDistance = Math.max(discussDistance, 1); // 距离最小1米，避免无效值
+ this.isEnable = isEnable;
+ }
+
+ // 无参构造（初始化默认值，positionId需后续设置）
+ public PositionTaskModel() {
+ this.taskId = genTaskId();
+ this.positionId = "";
+ this.taskDescription = "新任务";
+ this.isGreaterThan = true;
+ this.isLessThan = false; // 初始互斥
+ this.discussDistance = 100; // 默认100米
+ this.isEnable = true;
+ }
+
+ public void setIsBingo(boolean isBingo) {
+ this.isBingo = isBingo;
+ }
+
+ public boolean isBingo() {
+ return isBingo;
+ }
+
+ // ---------------------- Getter/Setter（确保positionId不为空，距离有效） ----------------------
+ public void setTaskId(String taskId) {
+ this.taskId = (taskId == null || taskId.trim().isEmpty()) ? genTaskId() : taskId;
+ }
+
+ public String getTaskId() {
+ return taskId;
+ }
+
+ public void setPositionId(String positionId) {
+ this.positionId = (positionId == null || positionId.trim().isEmpty()) ? "" : positionId; // 空值防护
+ }
+
+ public String getPositionId() {
+ return positionId;
+ }
+
+ public void setTaskDescription(String taskDescription) {
+ this.taskDescription = (taskDescription == null || taskDescription.trim().isEmpty()) ? "新任务" : taskDescription;
+ }
+
+ public String getTaskDescription() {
+ return taskDescription;
+ }
+
+ // 修复：确保isGreaterThan和isLessThan互斥
+ public void setIsGreaterThan(boolean isGreaterThan) {
+ this.isGreaterThan = isGreaterThan;
+ this.isLessThan = !isGreaterThan; // 关键：小于 = 非大于
+ }
+
+ public boolean isGreaterThan() {
+ return isGreaterThan;
+ }
+
+ // 修复：确保isLessThan和isGreaterThan互斥
+ public void setIsLessThan(boolean isLessThan) {
+ this.isLessThan = isLessThan;
+ this.isGreaterThan = !isLessThan; // 关键：大于 = 非小于
+ }
+
+ public boolean isLessThan() {
+ return isLessThan;
+ }
+
+ public void setDiscussDistance(int discussDistance) {
+ this.discussDistance = Math.max(discussDistance, 1); // 距离最小1米，避免0或负数
+ }
+
+ public int getDiscussDistance() {
+ return discussDistance;
+ }
+
+ public void setIsEnable(boolean isEnable) {
+ this.isEnable = isEnable;
+ }
+
+ public boolean isEnable() {
+ return isEnable;
+ }
+
+ // ---------------------- 父类方法重写 ----------------------
+ @Override
+ public String getName() {
+ return PositionTaskModel.class.getName();
+ }
+
+ // 生成唯一任务ID（与PositionModel保持一致格式）
+ public static String genTaskId() {
+ UUID uniqueUuid = UUID.randomUUID();
+ return uniqueUuid.toString(); // 36位标准UUID（含横杠，确保唯一）
+ }
+
+ // JSON序列化（保存任务数据，包含所有字段）
+ @Override
+ public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
+ super.writeThisToJsonWriter(jsonWriter);
+ jsonWriter.name("taskId").value(getTaskId());
+ jsonWriter.name("positionId").value(getPositionId());
+ jsonWriter.name("taskDescription").value(getTaskDescription());
+ jsonWriter.name("isGreaterThan").value(isGreaterThan());
+ jsonWriter.name("isLessThan").value(isLessThan());
+ jsonWriter.name("discussDistance").value(getDiscussDistance());
+ jsonWriter.name("isEnable").value(isEnable());
+ }
+
+ // JSON反序列化（加载任务数据，校验字段有效性）
+ @Override
+ public boolean initObjectsFromJsonReader(JsonReader jsonReader, String name) throws IOException {
+ if (super.initObjectsFromJsonReader(jsonReader, name)) {
+ return true;
+ } else {
+ if (name.equals("taskId")) {
+ setTaskId(jsonReader.nextString());
+ } else if (name.equals("positionId")) {
+ setPositionId(jsonReader.nextString());
+ } else if (name.equals("taskDescription")) {
+ setTaskDescription(jsonReader.nextString());
+ } else if (name.equals("isGreaterThan")) {
+ setIsGreaterThan(jsonReader.nextBoolean());
+ } else if (name.equals("isLessThan")) {
+ setIsLessThan(jsonReader.nextBoolean());
+ } else if (name.equals("discussDistance")) {
+ setDiscussDistance(jsonReader.nextInt());
+ } else if (name.equals("isEnable")) {
+ setIsEnable(jsonReader.nextBoolean());
+ } else {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ // 从JSON读取任务数据（确保反序列化完整）
+ @Override
+ public BaseBean readBeanFromJsonReader(JsonReader jsonReader) throws IOException {
+ jsonReader.beginObject();
+ while (jsonReader.hasNext()) {
+ String name = jsonReader.nextName();
+ if (!initObjectsFromJsonReader(jsonReader, name)) {
+ jsonReader.skipValue(); // 跳过未知字段，避免崩溃
+ }
+ }
+ jsonReader.endObject();
+ return this;
+ }
+
+}
+
diff --git a/positions/src/main/java/cc/winboll/studio/positions/services/AssistantService.java b/positions/src/main/java/cc/winboll/studio/positions/services/AssistantService.java
new file mode 100644
index 00000000..93c18f4b
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/services/AssistantService.java
@@ -0,0 +1,95 @@
+package cc.winboll.studio.positions.services;
+
+/**
+ * @Author ZhanGSKen
+ * @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
new file mode 100644
index 00000000..0e48a342
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/services/DistanceRefreshService.java
@@ -0,0 +1,433 @@
+//package cc.winboll.studio.positions.services;
+//
+///**
+// * @Author ZhanGSKen&豆包大模型
+// * @Date 2025/09/30 19:53
+// * @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;
+//import java.util.Set;
+//import java.util.concurrent.Executors;
+//import java.util.concurrent.ScheduledExecutorService;
+//import java.util.concurrent.TimeUnit;
+//
+///**
+// * 核心职责：
+// * 1. 实现 PositionAdapter.DistanceServiceInterface 接口，解耦Adapter与服务
+// * 2. 单例式管理位置/任务数据，提供安全增删改查接口
+// * 3. 后台单线程定时计算可见位置距离，主线程回调更新UI
+// * 4. 内置GPS信号加载（通过LocationManager实时获取位置，解决“等待GPS信号”问题）
+// * 5. 服务启动时启动前台通知（保活后台GPS功能，符合系统规范）
+// * 6. 严格Java 7语法：无Lambda/Stream，显式迭代器/匿名内部类
+// */
+//public class DistanceRefreshService extends Service {
+// public static final String TAG = "DistanceRefreshService";
+//
+//
+// // 服务状态与配置
+// private boolean isServiceRunning = false;
+//
+// private static final int REFRESH_INTERVAL = 3; // 距离刷新间隔（秒）
+// // 前台通知相关：记录是否已启动前台服务（避免重复调用startForeground）
+// private boolean isForegroundServiceStarted = false;
+//
+//
+//
+// // 服务绑定与UI回调
+// private final IBinder mBinder = new DistanceBinder();
+//
+//
+//
+//
+// /**
+// * 在主线程显示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 内部类（供外部绑定服务） ----------------------
+// public class DistanceBinder extends Binder {
+// /**
+// * 外部绑定后获取服务实例（安全暴露服务引用）
+// */
+// public DistanceRefreshService getService() {
+// return DistanceRefreshService.this;
+// }
+// }
+//
+//
+//
+// @Override
+// public void onCreate() {
+// super.onCreate();
+//
+// // 初始化GPS管理器（提前获取系统服务，避免启动时延迟）
+// mLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
+// LogUtils.d(TAG, "服务 onCreate：初始化完成，等待启动命令");
+// run();
+// }
+//
+// @Override
+// public int onStartCommand(Intent intent, int flags, int startId) {
+// run();
+// AppConfigsModel bean = AppConfigsModel.loadBean(DistanceRefreshService.this, AppConfigsModel.class);
+// boolean isEnableService = (bean == null) ? false : bean.isEnableMainService();
+// // 服务启用时返回START_STICKY（被杀死后尝试重启），禁用时返回默认值
+// return isEnableService ? Service.START_STICKY : super.onStartCommand(intent, flags, startId);
+// }
+//
+// public void run() {
+// // 仅服务未运行时启动（避免重复启动）
+// if (!isServiceRunning) {
+// isServiceRunning = true;
+//
+//
+//
+// startDistanceRefreshTask(); // 启动定时距离计算
+// startForegroundNotification(); // 启动前台通知
+//
+// LogUtils.d(TAG, "服务 onStartCommand：启动成功，刷新间隔=" + REFRESH_INTERVAL + "秒，前台通知+GPS已启动");
+// } else {
+// 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) {
+// 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();
+// // 解绑时不停止GPS（服务仍在后台运行，需持续获取位置）
+// return super.onUnbind(intent);
+// }*/
+//
+// @Override
+// public void onDestroy() {
+// super.onDestroy();
+//
+// LogUtils.d(TAG, "服务 onDestroy：销毁完成，资源已释放（GPS+前台通知+线程池）");
+// }
+//
+// // ---------------------- 前台服务通知管理（与GPS状态联动优化） ----------------------
+// /**
+// * 启动前台服务通知（调用NotificationUtils创建通知，确保仅启动一次）
+// */
+// private void startForegroundNotification() {
+// // 1. 校验：避免重复调用startForeground（系统不允许重复启动）
+// if (isForegroundServiceStarted) {
+// LogUtils.w(TAG, "startForegroundNotification：前台通知已启动，无需重复执行");
+// return;
+// }
+//
+// 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);
+// }
+// }
+//
+//
+//
+// /**
+//
+// - 主线程回调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);
+// }
+// }
+// });
+// }
+// }*/
+//
+//
+//
+//
+//
+//// ---------------------- 实现 PositionAdapter.DistanceServiceInterface 接口 ----------------------
+//
+// public ArrayList getPositionList() {
+// if (!isServiceRunning) {
+// LogUtils.w(TAG, "getPositionList：服务未运行，返回空列表");
+// return new ArrayList();
+// }
+// return new ArrayList(mPositionList);
+// }
+//
+//
+// public ArrayList getPositionTasksList() {
+// if (!isServiceRunning) {
+// LogUtils.w(TAG, "getPositionTasksList：服务未运行，返回空列表");
+// return new ArrayList();
+// }
+// return new ArrayList(mTaskList);
+// }
+//
+//
+//
+//
+// /*public void setOnDistanceUpdateReceiver(PositionAdapter.OnDistanceUpdateReceiver receiver) {
+// this.mDistanceReceiver = receiver;
+// LogUtils.d(TAG, "setOnDistanceUpdateReceiver：回调接收器已设置（" + (receiver != null ? "有效" : "无效") + "）");
+// }*/
+//
+// 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();
+// }
+// }
+// }
+//
+// 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();
+// }
+// }
+// }
+//
+// public void clearVisibleDistanceViews() {
+// mVisiblePositionIds.clear();
+// LogUtils.d(TAG, "clearVisibleDistanceViews：所有可见位置已清空");
+//// 新增：清空可见位置后，更新通知（提示计算暂停）
+// if (isForegroundServiceStarted) {
+// updateNotificationGpsStatus("无可见位置，距离计算暂停");
+// }
+// }
+//
+//// ---------------------- 数据管理接口（修复原有语法错误+优化逻辑） ----------------------
+// /**
+//
+// - 获取服务运行状态
+// */
+// public boolean isServiceRunning() {
+// return isServiceRunning;
+// }
+//
+// /**
+//
+// - 添加位置（修复迭代器泛型缺失问题）
+// */
+// 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() + "已存在，添加失败");
+// }
+// }
+//
+// /**
+//
+// - 删除位置（修复任务删除时的类型转换错误）
+// */
+// 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 + "不存在，删除失败");
+// }
+// }
+//
+// /**
+//
+// - 更新位置信息（修复代码格式+迭代器泛型）
+// */
+// 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() + "不存在，更新失败");
+// }
+// }
+//
+// /**
+//
+// - 同步任务列表（修复泛型缺失+代码格式）
+// */
+// public void syncAllPositionTasks(ArrayList tasks) {
+// if (!isServiceRunning || tasks == null) {
+// LogUtils.w(TAG, "syncAllPositionTasks：服务未运行/任务列表为空，同步失败");
+// return;
+// }// 1. 清空旧任务
+// mTaskList.clear();
+//// 2. 添加新任务（修复泛型+去重逻辑）
+// Set taskIdSet = new HashSet();
+// Iterator taskIter = tasks.iterator();
+// while (taskIter.hasNext()) {
+// PositionTaskModel task = (PositionTaskModel)taskIter.next();
+// if (task != null && task.getTaskId() != null && !taskIdSet.contains(task.getTaskId())) {
+// taskIdSet.add(task.getTaskId());
+// mTaskList.add(task);
+// }
+// }LogUtils.d(TAG, "syncAllPositionTasks：同步成功（接收任务数=" + tasks.size() + "，去重后=" + mTaskList.size() + "）");
+// }
+//
+//
+//
+//
+//// ---------------------- 补充：修复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 00000000..caa13987
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/services/MainService.java
@@ -0,0 +1,589 @@
+package cc.winboll.studio.positions.services;
+
+/**
+ * @Author ZhanGSKen
+ * @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.content.pm.PackageManager;
+import android.location.Location;
+import android.location.LocationListener;
+import android.location.LocationManager;
+import android.location.LocationProvider;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.Looper;
+import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.positions.models.PositionModel;
+import cc.winboll.studio.positions.models.PositionTaskModel;
+import cc.winboll.studio.positions.utils.AppConfigsUtil;
+import cc.winboll.studio.positions.utils.NotificationUtil;
+import cc.winboll.studio.positions.utils.ServiceUtil;
+import com.hjq.toast.ToastUtils;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+public class MainService extends Service {
+
+ public static final String TAG = "MainService";
+
+ // ---------------------- 新增：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 PositionModel mCurrentGpsPosition; // 当前GPS位置（外部传入/内部GPS获取）
+
+ MyServiceConnection mMyServiceConnection;
+ volatile static boolean _mIsServiceRunning;
+ AppConfigsUtil mAppConfigsUtil;
+ private final ScheduledExecutorService distanceExecutor; // 定时计算线程池（单线程）
+ private final Set mVisiblePositionIds = new HashSet(); // 可见位置ID（优化性能）
+
+ // ---------------------- 服务生命周期方法（集成GPS启停逻辑） ----------------------
+
+ // 服务单例实例（私有静态）
+ // 1. 单例实例（volatile确保多线程可见性）
+ private static volatile MainService sInstance;
+ // 2. 单独持有ApplicationContext（避免内存泄漏+确保非null）
+ private static Context sAppContext;
+ // 单例PUBLIC方法（供外部获取实例，确保全局唯一）
+ public static synchronized MainService getInstance() {
+ // 4. 修复后的单例方法：先判空，再返回（避免空指针）
+
+ // 第一步：先判断实例是否存在（未创建则返回null，不强行调用Context）
+ if (sInstance == null) {
+ // 可选：若调用时Service未启动，主动启动Service（避免后续空指针）
+ Intent intent = new Intent(sAppContext, MainService.class);
+ sAppContext.startService(intent);
+ return null; // 或抛明确异常（如"Service未启动"），不触发空指针
+ }
+ // 第二步：实例存在时，确保Context非null（双重保险）
+ if (sAppContext == null) {
+ sAppContext = sInstance.getApplicationContext();
+ }
+ return sInstance;
+ }
+
+ @Override
+ public IBinder onBind(Intent intent) {
+ //return mMyBinder;
+ return null;
+ }
+
+ @Override
+ public void onCreate() {
+ LogUtils.d(TAG, "onCreate");
+ super.onCreate();
+ sInstance = this; // 此时Service已创建，Context非null
+ // 保存ApplicationContext（全局唯一，不会因Service销毁而失效）
+ sAppContext = getApplicationContext();
+
+ _mIsServiceRunning = false;
+ mAppConfigsUtil = AppConfigsUtil.getInstance(this);
+
+ //mMyBinder = new MyBinder();
+ if (mMyServiceConnection == null) {
+ mMyServiceConnection = new MyServiceConnection();
+ }
+
+ // 运行服务内容
+ run();
+
+ }
+
+ public void run() {
+ if (mAppConfigsUtil.isEnableMainService(true)) {
+ if (_mIsServiceRunning == false) {
+ // 设置运行状态
+ _mIsServiceRunning = 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));
+
+ // 运行其它服务内容
+ mLocationManager = (LocationManager) sInstance.getApplicationContext().getSystemService(Context.LOCATION_SERVICE);
+ initGpsLocationListener();
+ startGpsLocation(); // 新增：启动GPS定位（核心修复：解决“等待GPS信号”）
+
+ ToastUtils.show(initialStatus);
+ LogUtils.i(TAG, initialStatus);
+ }
+ }
+ }
+
+ public boolean isServiceRunning() {
+ return _mIsServiceRunning;
+ }
+
+ public interface SMSListener {
+ void speakMessage();
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ sInstance = null; // 释放实例，避免内存泄漏
+ // sAppContext 不清空（ApplicationContext全局有效）
+
+ // 停止所有核心组件+释放资源（避免内存泄漏/耗电）
+ //stopDistanceRefreshTask(); // 停止距离计算
+ stopGpsLocation(); // 新增：停止GPS定位（关键：避免服务销毁后仍耗电）
+ clearAllData(); // 清空数据
+ stopForeground(true); // 停止前台服务（移除通知）
+
+ // 重置状态标记
+ _mIsServiceRunning = false;
+ isGpsEnabled = false;
+ mLocationManager = null; // 释放GPS管理器引用
+
+ }
+
+ public ArrayList getPositionList() {
+ return mPositionList;
+ }
+
+ public ArrayList getPositionTasksList() {
+ return mTaskList;
+ }
+
+ public void removePosition(String targetPosId) {
+ LogUtils.d(TAG, "removePosition 未实现");
+ }
+
+ public void updatePosition(PositionModel updatedPos) {
+ LogUtils.d(TAG, "updatePosition 未实现");
+ }
+
+ public void syncAllPositionTasks(ArrayList newTaskList) {
+ LogUtils.d(TAG, "syncAllPositionTasks 未实现");
+ }
+
+ public void addPosition(PositionModel newPos) {
+ LogUtils.d(TAG, "addPosition 未实现");
+ }
+
+ /**
+ * 清空所有数据
+ */
+ public void clearAllData() {
+ mPositionList.clear();
+ mTaskList.clear();
+ //mVisiblePositionIds.clear();
+ mCurrentGpsPosition = null;
+ LogUtils.d(TAG, "clearAllData：所有数据已清空（位置/任务/GPS/可见位置）");
+ }
+
+ 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() + "）");
+
+// GPS位置同步后，立即更新通知（避免延迟）
+ if (_mIsServiceRunning) {
+ syncGpsStatusToNotification();
+ }
+
+ }
+
+ /**
+ - 同步GPS状态到前台通知（显示实时经纬度+计算状态）
+ */
+ private void syncGpsStatusToNotification() {
+ if (!_mIsServiceRunning || mCurrentGpsPosition == null) {
+ return;
+ }// 构造详细状态文本（包含经纬度+可见位置数量，用户感知更清晰）
+ final String gpsStatus = String.format(
+ "GPS位置：北纬%.4f° 东经%.4f° | 计算中（可见位置：%d个）",
+ mCurrentGpsPosition.getLatitude(),
+ mCurrentGpsPosition.getLongitude(),
+ 666//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() {
+ NotificationUtil.updateForegroundServiceStatus(MainService.this, gpsStatus);
+ }
+ });
+ }
+ }
+
+ // ---------------------- 核心：定时距离计算（与GPS状态联动优化） ----------------------
+ /**
+ - 启动定时距离计算任务（延迟1秒开始，周期执行）
+ */
+// private void startDistanceRefreshTask() {
+// if (distanceExecutor == null || distanceExecutor.isShutdown()) {
+// LogUtils.e(TAG, "启动计算失败：线程池未初始化/已关闭");
+// return;
+// }distanceExecutor.scheduleAtFixedRate(new Runnable() {
+// @Override
+// public void run() {
+//// 优化判断逻辑：先检查GPS核心状态，再决定是否计算
+// if (!isGpsPermissionGranted) {
+// LogUtils.d(TAG, "跳过距离计算：缺少定位权限");
+// updateNotificationGpsStatus("缺少定位权限，无法计算距离");
+// return;
+// }
+// if (!isGpsEnabled) {
+// LogUtils.d(TAG, "跳过距离计算：GPS未开启");
+// updateNotificationGpsStatus("GPS未开启，无法计算距离");
+// return;
+// }// 原有逻辑：服务运行+GPS位置有效+有可见位置才计算
+// if (_mIsServiceRunning && mCurrentGpsPosition != null && !mVisiblePositionIds.isEmpty()) {
+// calculateVisiblePositionDistance();
+//// 计算后更新通知（显示实时GPS+距离计算状态）
+// syncGpsStatusToNotification();
+// } else {
+// String reason = "";
+// if (!_mIsServiceRunning) 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() {
+ 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) + "米");
+
+ } catch (Exception e) {
+ pos.setRealPositionDistance(-1);
+
+ LogUtils.e(TAG, "计算失败（位置ID=" + posId + "）：" + e.getMessage());
+ }
+ }
+ }
+ }
+
+ /**
+ - 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;
+ }
+
+ /**
+ * 强制刷新距离（优化：刷新后同步通知状态）
+ */
+ public void forceRefreshDistance() {
+ if (!_mIsServiceRunning) {
+ LogUtils.w(TAG, "forceRefreshDistance：服务未运行，刷新失败");
+ return;
+ }
+ if (distanceExecutor != null && !distanceExecutor.isShutdown()) {
+// 提交即时任务（不等待定时周期）
+ distanceExecutor.submit(new Runnable() {
+ @Override
+ public void run() {
+// 强制刷新前先检查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：已触发即时距离计算请求");
+ } else {
+ LogUtils.e(TAG, "forceRefreshDistance：线程池已关闭，无法触发刷新");
+ updateNotificationGpsStatus("线程池已关闭，无法执行强制刷新");
+ }
+ }
+
+ @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);
+ }
+ }
+
+ // ---------------------- 构造初始化（线程池+GPS监听器提前创建） ----------------------
+ // 关键：添加/修改为 PUBLIC 无参构造函数
+
+ public MainService() {
+ // Java 7 显式初始化线程池（单线程，避免并发修改数据）
+ distanceExecutor = Executors.newSingleThreadScheduledExecutor();
+ // 初始化GPS位置监听器（接收系统GPS位置更新）
+ initGpsLocationListener();
+ }
+
+ // ---------------------- 新增：GPS核心逻辑（初始化监听+权限/状态检查+启动定位） ----------------------
+ /**
+ * 初始化GPS位置监听器：系统GPS位置变化时触发，实时更新当前位置
+ */
+ private void initGpsLocationListener() {
+ LogUtils.d(TAG, "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");
+ ToastUtils.show("请授予定位权限，否则无法获取GPS位置");
+ //showToastOnMainThread("请授予定位权限，否则无法获取GPS位置");
+ return false;
+ }
+ if (!isGpsEnabled) {
+ LogUtils.e(TAG, "GPS准备失败：系统GPS未开启");
+ ToastUtils.show("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 (_mIsServiceRunning) {
+ NotificationUtil.updateForegroundServiceStatus(this, statusText);
+ }
+ }
+}
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 00000000..17d3c39b
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/utils/AppConfigsUtil.java
@@ -0,0 +1,68 @@
+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 == null) ?false: mAppConfigsModel.isEnableMainService();
+ }
+
+ public void setIsEnableMainService(boolean isEnableMainService) {
+ if(mAppConfigsModel == null) {
+ mAppConfigsModel = new AppConfigsModel();
+ }
+ 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 00000000..e6d1c494
--- /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/ServiceUtil.java b/positions/src/main/java/cc/winboll/studio/positions/utils/ServiceUtil.java
new file mode 100644
index 00000000..7b70f7e4
--- /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/java/cc/winboll/studio/positions/views/PositionTaskListView.java b/positions/src/main/java/cc/winboll/studio/positions/views/PositionTaskListView.java
new file mode 100644
index 00000000..c9046dc1
--- /dev/null
+++ b/positions/src/main/java/cc/winboll/studio/positions/views/PositionTaskListView.java
@@ -0,0 +1,416 @@
+package cc.winboll.studio.positions.views;
+
+/**
+ * @Author ZhanGSKen&豆包大模型
+ * @Date 2025/09/30 08:09
+ * @Describe 位置任务列表视图（支持简单/编辑模式，含 isBingo 红点标识）
+ */
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.CompoundButton;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.RadioButton;
+import android.widget.RadioGroup;
+import android.widget.TextView;
+import android.widget.Toast;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+import cc.winboll.studio.positions.R;
+import cc.winboll.studio.positions.models.PositionTaskModel;
+import java.util.ArrayList;
+import java.util.List;
+
+public class PositionTaskListView extends LinearLayout {
+ // 视图模式常量
+ public static final int VIEW_MODE_SIMPLE = 1;
+ public static final int VIEW_MODE_EDIT = 2;
+
+ // 核心成员变量
+ private String mBindPositionId;
+ private ArrayList mTaskList;
+ private int mCurrentViewMode;
+ private TaskListAdapter mTaskAdapter;
+ private RecyclerView mRvTasks;
+
+ // 任务修改回调接口
+ public interface OnTaskUpdatedListener {
+ void onTaskUpdated(String positionId, ArrayList updatedTasks);
+ }
+
+ private OnTaskUpdatedListener mOnTaskUpdatedListener;
+
+ // ---------------------- 构造函数 ----------------------
+ public PositionTaskListView(Context context) {
+ super(context);
+ initView(context);
+ }
+
+ public PositionTaskListView(Context context, @Nullable AttributeSet attrs) {
+ super(context, attrs);
+ initView(context);
+ }
+
+ public PositionTaskListView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
+ super(context, attrs, defStyleAttr);
+ initView(context);
+ }
+
+ // 初始化视图（绑定控件+设置布局）
+ private void initView(Context context) {
+ setOrientation(VERTICAL);
+ LayoutInflater.from(context).inflate(R.layout.view_position_task_list, this, true);
+
+ mRvTasks = (RecyclerView) findViewById(R.id.rv_position_tasks);
+ mRvTasks.setLayoutManager(new LinearLayoutManager(context));
+
+ mTaskList = new ArrayList();
+ mTaskAdapter = new TaskListAdapter(mTaskList);
+ mRvTasks.setAdapter(mTaskAdapter);
+
+ mCurrentViewMode = VIEW_MODE_SIMPLE;
+ }
+
+ // ---------------------- 对外API ----------------------
+ public void init(ArrayList taskList, String positionId) {
+ this.mBindPositionId = positionId;
+ if (this.mTaskList.isEmpty()) {
+ ArrayList matchedTasks = new ArrayList();
+ if (taskList != null && !taskList.isEmpty()) {
+ for (PositionTaskModel task : taskList) {
+ if (task != null && positionId.equals(task.getPositionId())) {
+ matchedTasks.add(task);
+ }
+ }
+ }
+ mTaskList.clear();
+ mTaskList.addAll(matchedTasks);
+ }
+ mTaskAdapter.notifyDataSetChanged();
+ }
+
+ public void setViewStatus(int viewMode) {
+ if (viewMode != VIEW_MODE_SIMPLE && viewMode != VIEW_MODE_EDIT) {
+ return;
+ }
+ mCurrentViewMode = viewMode;
+ mTaskAdapter.notifyDataSetChanged();
+ }
+
+ public void setOnTaskUpdatedListener(OnTaskUpdatedListener listener) {
+ this.mOnTaskUpdatedListener = listener;
+ }
+
+ public ArrayList getAllTasks() {
+ return new ArrayList(mTaskList);
+ }
+
+ public void clearData() {
+ mTaskList.clear();
+ if (mTaskAdapter != null && mTaskAdapter.mData != null) {
+ mTaskAdapter.mData.clear();
+ }
+ mTaskAdapter.notifyDataSetChanged();
+ mBindPositionId = null;
+ }
+
+ public void triggerTaskSync() {
+ if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
+ mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList(mTaskList));
+ }
+ }
+
+ // ---------------------- 内部工具方法 ----------------------
+ private boolean isTaskMatchedWithPosition(PositionTaskModel task) {
+ if (task == null || mBindPositionId == null || mBindPositionId.trim().isEmpty()) {
+ return false;
+ }
+ return mBindPositionId.equals(task.getPositionId());
+ }
+
+ // ---------------------- 内部Adapter：适配 isBingo 红点（核心调整） ----------------------
+ private class TaskListAdapter extends RecyclerView.Adapter {
+ private final List mData;
+
+ public TaskListAdapter(List data) {
+ this.mData = data;
+ }
+
+ @Override
+ public int getItemCount() {
+ return mData.isEmpty() ? 1 : mData.size();
+ }
+
+ // 调整：根据“是否空列表”+“视图模式”区分视图类型（确保简单/编辑模式加载对应布局）
+ @Override
+ public int getItemViewType(int position) {
+ if (mData.isEmpty()) {
+ return 0; // 0=空提示
+ } else {
+ return mCurrentViewMode; // 1=简单模式，2=编辑模式（复用视图模式常量）
+ }
+ }
+
+ // 调整：按视图类型加载布局（简单模式加载带红点的布局，编辑模式加载原有布局）
+ @NonNull
+ @Override
+ public TaskViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+ Context context = parent.getContext();
+ LayoutInflater inflater = LayoutInflater.from(context);
+
+ if (viewType == 0) {
+ // 空提示布局
+ View emptyView = inflater.inflate(R.layout.item_task_empty, parent, false);
+ return new EmptyViewHolder(emptyView);
+ } else if (viewType == VIEW_MODE_SIMPLE) {
+ // 简单模式布局（带 isBingo 红点）
+ View simpleTaskView = inflater.inflate(R.layout.item_position_task_simple, parent, false);
+ return new SimpleTaskViewHolder(simpleTaskView);
+ } else {
+ // 编辑模式布局（原有布局不变）
+ View editTaskView = inflater.inflate(R.layout.item_task_content, parent, false);
+ return new TaskContentViewHolder(editTaskView);
+ }
+ }
+
+ // 调整：按视图类型绑定数据（简单模式绑定红点+文本，编辑模式绑定原有逻辑）
+ @Override
+ public void onBindViewHolder(@NonNull TaskViewHolder holder, int position) {
+ // 空提示处理（不变）
+ if (holder instanceof EmptyViewHolder) {
+ EmptyViewHolder emptyHolder = (EmptyViewHolder) holder;
+ TextView tvEmptyTip = (TextView) emptyHolder.itemView.findViewById(R.id.tv_task_empty_tip);
+ tvEmptyTip.setText(mCurrentViewMode == VIEW_MODE_EDIT ? "暂无任务，点击\"添加新任务\"创建" : "暂无启用的任务");
+ return;
+ }
+
+ // 任务项有效性校验（不变）
+ if (position >= mData.size()) {
+ return;
+ }
+ final PositionTaskModel task = mData.get(position);
+ if (task == null) {
+ return;
+ }
+
+ // 简单模式：绑定红点（isBingo）和文本数据
+ if (holder instanceof SimpleTaskViewHolder) {
+ SimpleTaskViewHolder simpleHolder = (SimpleTaskViewHolder) holder;
+ // 绑定任务描述
+ simpleHolder.tvSimpleTaskDesc.setText(String.format("任务：%s", task.getTaskDescription()));
+ // 绑定距离条件
+ String distanceCond = task.isGreaterThan() ? "大于" : "小于";
+ simpleHolder.tvSimpleDistanceCond.setText(String.format("条件：距离 %s %d 米", distanceCond, task.getDiscussDistance()));
+ // 绑定启用状态
+ simpleHolder.tvSimpleIsEnable.setText(task.isEnable() ? "状态：已启用" : "状态：已禁用");
+ // 核心：根据 isBingo 控制红点显示（true=显示，false=隐藏）
+ simpleHolder.vBingoDot.setVisibility(task.isBingo() ? View.VISIBLE : View.GONE);
+ }
+ // 编辑模式：沿用原有绑定逻辑（核心修复在此处）
+ else if (holder instanceof TaskContentViewHolder) {
+ TaskContentViewHolder contentHolder = (TaskContentViewHolder) holder;
+ bindTaskData(contentHolder, task, position);
+ }
+ }
+
+ // ---------------------- 核心修复：编辑模式绑定逻辑（解决布局中通知异常） ----------------------
+ private void bindTaskData(final TaskContentViewHolder holder, final PositionTaskModel task, final int position) {
+ String taskDesc = (task.getTaskDescription() == null) ? "未设置描述" : task.getTaskDescription();
+ holder.tvTaskDesc.setText(String.format("任务：%s", taskDesc));
+
+ String distanceCondition = task.isGreaterThan() ? "大于" : "小于";
+ holder.tvTaskDistance.setText(String.format("条件：%s %d 米", distanceCondition, task.getDiscussDistance()));
+
+ // 修复点1：先移除开关监听，再设置状态（避免设值时触发回调导致异常）
+ holder.cbTaskEnable.setOnCheckedChangeListener(null);
+ holder.cbTaskEnable.setChecked(task.isEnable());
+ holder.cbTaskEnable.setEnabled(mCurrentViewMode == VIEW_MODE_EDIT);
+
+ if (mCurrentViewMode == VIEW_MODE_EDIT) {
+ holder.btnEditTask.setVisibility(View.VISIBLE);
+ holder.btnDeleteTask.setVisibility(View.VISIBLE);
+
+ // 删除按钮逻辑（不变，本身在点击时执行，不涉及布局中通知）
+ holder.btnDeleteTask.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ mData.remove(position);
+ notifyItemRemoved(position);
+ notifyItemRangeChanged(position, mData.size());
+ if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
+ mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList(mData));
+ }
+ Toast.makeText(getContext(), "任务已删除", Toast.LENGTH_SHORT).show();
+ }
+ });
+
+ // 编辑按钮逻辑（不变，弹窗保存时修复通知时机）
+ holder.btnEditTask.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ showTaskEditDialog(task, position);
+ }
+ });
+
+ // 修复点2：开关监听-用 RecyclerView.post 延迟执行 notify（避免布局中调用）
+ holder.cbTaskEnable.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
+ @Override
+ public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+ task.setIsEnable(isChecked); // 先更新数据源（必须执行）
+ // 关键：通过 mRvTasks.post 延迟通知，确保在布局计算/滚动结束后执行
+ mRvTasks.post(new Runnable() {
+ @Override
+ public void run() {
+ notifyItemChanged(position);
+ if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
+ mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList(mData));
+ }
+ }
+ });
+ }
+ });
+ } else {
+ holder.btnEditTask.setVisibility(View.GONE);
+ holder.btnDeleteTask.setVisibility(View.GONE);
+ holder.cbTaskEnable.setOnCheckedChangeListener(null);
+ }
+ }
+
+ // ---------------------- 修复：编辑弹窗保存逻辑（延迟通知，避免极端场景异常） ----------------------
+ private void showTaskEditDialog(final PositionTaskModel task, final int position) {
+ final Context context = getContext();
+ View dialogView = LayoutInflater.from(context).inflate(R.layout.dialog_edit_task, null);
+
+ final EditText etEditDesc = (EditText) dialogView.findViewById(R.id.et_edit_task_desc);
+ final RadioGroup rgDistanceCondition = (RadioGroup) dialogView.findViewById(R.id.rg_distance_condition);
+ final EditText etEditDistance = (EditText) dialogView.findViewById(R.id.et_edit_distance);
+ Button btnCancel = (Button) dialogView.findViewById(R.id.btn_dialog_cancel);
+ Button btnSave = (Button) dialogView.findViewById(R.id.btn_dialog_save);
+
+ etEditDesc.setText(task.getTaskDescription());
+ etEditDesc.setSelection(etEditDesc.getText().length());
+
+ if (task.isGreaterThan()) {
+ rgDistanceCondition.check(R.id.rb_greater_than);
+ } else {
+ rgDistanceCondition.check(R.id.rb_less_than);
+ }
+
+ etEditDistance.setText(String.valueOf(task.getDiscussDistance()));
+
+ final android.app.AlertDialog dialog = new android.app.AlertDialog.Builder(context)
+ .setView(dialogView)
+ .create();
+ dialog.show();
+
+ btnCancel.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ dialog.dismiss();
+ }
+ });
+
+ btnSave.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ String newDesc = etEditDesc.getText().toString().trim();
+ String distanceStr = etEditDistance.getText().toString().trim();
+
+ if (distanceStr.isEmpty()) {
+ Toast.makeText(context, "请输入有效距离", Toast.LENGTH_SHORT).show();
+ return;
+ }
+
+ int newDistance;
+ try {
+ newDistance = Integer.parseInt(distanceStr);
+ if (newDistance < 1) {
+ Toast.makeText(context, "距离不能小于1米", Toast.LENGTH_SHORT).show();
+ return;
+ }
+ } catch (NumberFormatException e) {
+ Toast.makeText(context, "距离请输入数字", Toast.LENGTH_SHORT).show();
+ return;
+ }
+
+ task.setTaskDescription(newDesc);
+ task.setDiscussDistance(newDistance);
+ boolean isGreater = rgDistanceCondition.getCheckedRadioButtonId() == R.id.rb_greater_than;
+ task.setIsGreaterThan(isGreater);
+ task.setPositionId(mBindPositionId);
+
+ // 修复点3：弹窗保存后延迟通知（同开关逻辑，避免列表滚动时异常）
+ mRvTasks.post(new Runnable() {
+ @Override
+ public void run() {
+ notifyItemChanged(position);
+ if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
+ mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList(mData));
+ }
+ }
+ });
+
+ dialog.dismiss();
+ Toast.makeText(context, "任务已更新", Toast.LENGTH_SHORT).show();
+ }
+ });
+ }
+
+ // ---------------------- ViewHolder 定义（完全不变） ----------------------
+ // 基础抽象 ViewHolder（不变）
+ public abstract class TaskViewHolder extends RecyclerView.ViewHolder {
+ public TaskViewHolder(@NonNull View itemView) {
+ super(itemView);
+ }
+ }
+
+ // 空提示 Holder（不变）
+ public class EmptyViewHolder extends TaskViewHolder {
+ public EmptyViewHolder(@NonNull View itemView) {
+ super(itemView);
+ }
+ }
+
+ // 新增：简单模式 Holder（绑定带红点的布局控件）
+ public class SimpleTaskViewHolder extends TaskViewHolder {
+ TextView tvSimpleTaskDesc; // 任务描述
+ TextView tvSimpleDistanceCond;// 距离条件
+ TextView tvSimpleIsEnable; // 启用状态
+ View vBingoDot; // isBingo 红点控件
+
+ public SimpleTaskViewHolder(@NonNull View itemView) {
+ super(itemView);
+ // 绑定简单模式布局中的控件（与 item_task_simple.xml 完全对应）
+ tvSimpleTaskDesc = itemView.findViewById(R.id.tv_simple_task_desc);
+ tvSimpleDistanceCond = itemView.findViewById(R.id.tv_simple_distance_cond);
+ tvSimpleIsEnable = itemView.findViewById(R.id.tv_simple_is_enable);
+ vBingoDot = itemView.findViewById(R.id.v_bingo_dot);
+ }
+ }
+
+ // 编辑模式 Holder（原有逻辑，完全不变）
+ public class TaskContentViewHolder extends TaskViewHolder {
+ TextView tvTaskDesc;
+ TextView tvTaskDistance;
+ CompoundButton cbTaskEnable;
+ Button btnEditTask;
+ Button btnDeleteTask;
+
+ public TaskContentViewHolder(@NonNull View itemView) {
+ super(itemView);
+ tvTaskDesc = (TextView) itemView.findViewById(R.id.tv_task_desc);
+ tvTaskDistance = (TextView) itemView.findViewById(R.id.tv_task_distance);
+ cbTaskEnable = (CompoundButton) itemView.findViewById(R.id.cb_task_enable);
+ btnEditTask = (Button) itemView.findViewById(R.id.btn_edit_task);
+ btnDeleteTask = (Button) itemView.findViewById(R.id.btn_delete_task);
+ }
+ }
+ }
+}
+
diff --git a/positions/src/main/res/drawable/bg_bingo_dot.xml b/positions/src/main/res/drawable/bg_bingo_dot.xml
new file mode 100644
index 00000000..248bd1b7
--- /dev/null
+++ b/positions/src/main/res/drawable/bg_bingo_dot.xml
@@ -0,0 +1,8 @@
+
+
+
+
+
diff --git a/positions/src/main/res/drawable/bg_task_item.xml b/positions/src/main/res/drawable/bg_task_item.xml
new file mode 100644
index 00000000..d8a68b89
--- /dev/null
+++ b/positions/src/main/res/drawable/bg_task_item.xml
@@ -0,0 +1,20 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/positions/src/main/res/drawable/btn_cancel_bg.xml b/positions/src/main/res/drawable/btn_cancel_bg.xml
new file mode 100644
index 00000000..74ca496b
--- /dev/null
+++ b/positions/src/main/res/drawable/btn_cancel_bg.xml
@@ -0,0 +1,18 @@
+
+
+
+ -
+
+
+
+
+
+
+ -
+
+
+
+
+
+
+
diff --git a/positions/src/main/res/drawable/btn_confirm_bg.xml b/positions/src/main/res/drawable/btn_confirm_bg.xml
new file mode 100644
index 00000000..9524b333
--- /dev/null
+++ b/positions/src/main/res/drawable/btn_confirm_bg.xml
@@ -0,0 +1,18 @@
+
+
+
+ -
+
+
+
+
+
+
+ -
+
+
+
+
+
+
+
diff --git a/positions/src/main/res/drawable/btn_delete_bg.xml b/positions/src/main/res/drawable/btn_delete_bg.xml
new file mode 100644
index 00000000..c7f86237
--- /dev/null
+++ b/positions/src/main/res/drawable/btn_delete_bg.xml
@@ -0,0 +1,16 @@
+
+
+ -
+
+
+
+
+
+ -
+
+
+
+
+
+
+
diff --git a/positions/src/main/res/drawable/circle_button_bg.xml b/positions/src/main/res/drawable/circle_button_bg.xml
new file mode 100644
index 00000000..5ed6038a
--- /dev/null
+++ b/positions/src/main/res/drawable/circle_button_bg.xml
@@ -0,0 +1,21 @@
+
+
+
+
+
+ -
+
+
+
+
+
+
+
+ -
+
+
+
+
+
+
+
diff --git a/positions/src/main/res/drawable/edittext_bg.xml b/positions/src/main/res/drawable/edittext_bg.xml
new file mode 100644
index 00000000..85b3d284
--- /dev/null
+++ b/positions/src/main/res/drawable/edittext_bg.xml
@@ -0,0 +1,18 @@
+
+
+ -
+
+
+
+
+
+
+ -
+
+
+
+
+
+
+
+
diff --git a/positions/src/main/res/drawable/ic_launcher.xml b/positions/src/main/res/drawable/ic_launcher.xml
new file mode 100644
index 00000000..1fd5efd2
--- /dev/null
+++ b/positions/src/main/res/drawable/ic_launcher.xml
@@ -0,0 +1,10 @@
+
+
+ -
+
+
+
+
+
+
+
+
+ -
+
+
+
+
+
+
+
+
diff --git a/positions/src/main/res/drawable/item_bg_simple.xml b/positions/src/main/res/drawable/item_bg_simple.xml
new file mode 100644
index 00000000..16170548
--- /dev/null
+++ b/positions/src/main/res/drawable/item_bg_simple.xml
@@ -0,0 +1,26 @@
+
+
+
+
+ -
+
+
+
+
+
+
+
+
+ -
+
+
+
+
+
+
+
+
diff --git a/positions/src/main/res/drawable/item_position_bg.xml b/positions/src/main/res/drawable/item_position_bg.xml
new file mode 100644
index 00000000..a6dba446
--- /dev/null
+++ b/positions/src/main/res/drawable/item_position_bg.xml
@@ -0,0 +1,18 @@
+
+
+ -
+
+
+
+
+
+
+ -
+
+
+
+
+
+
+
+
diff --git a/positions/src/main/res/layout/activity_location.xml b/positions/src/main/res/layout/activity_location.xml
new file mode 100644
index 00000000..af9064c8
--- /dev/null
+++ b/positions/src/main/res/layout/activity_location.xml
@@ -0,0 +1,71 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/positions/src/main/res/layout/activity_main.xml b/positions/src/main/res/layout/activity_main.xml
index 8000fb42..67f7f967 100644
--- a/positions/src/main/res/layout/activity_main.xml
+++ b/positions/src/main/res/layout/activity_main.xml
@@ -6,46 +6,34 @@
android:layout_height="match_parent"
android:orientation="vertical">
-
+
+
+
+