<positions>APK 15.0.6 release Publish.

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:libaes:15.10.2'
-    api 'cc.winboll.studio:libapputils:15.8.5'
+    api 'cc.winboll.studio:libapputils:15.10.2'
-    api 'cc.winboll.studio:libappbase:15.9.5'
+    api 'cc.winboll.studio:libappbase:15.10.9'
 }

positions/build.properties

@@ -1,8 +1,8 @@
 #Created by .winboll/winboll_app_build.gradle
-#Mon Sep 29 18:01:50 HKT 2025
+#Wed Oct 01 21:30:08 HKT 2025
-stageCount=1
+stageCount=7
 libraryProject=
 baseVersion=15.0
-publishVersion=15.0.0
+publishVersion=15.0.6
 buildCount=0
-baseBetaVersion=15.0.1
+baseBetaVersion=15.0.7

positions/src/beta/res/values-zh/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">@笨笨龙@</string>
+</resources>

positions/src/main/AndroidManifest.xml

@@ -3,6 +3,25 @@
     xmlns:android="http://schemas.android.com/apk/res/android"
     package="cc.winboll.studio.positions">
 
+    <!-- 前台服务权限（可选，提升后台定位稳定性，避免服务被回收） -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+
+    <!-- 只能在前台获取精确的位置信息 -->
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
+
+    <!-- 只有在前台运行时才能获取大致位置信息 -->
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
+
+    <!-- 拥有完全的网络访问权限 -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+
+    <!-- 在后台使用位置信息 -->
+    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION"/>
+
+    <uses-feature
+        android:name="android.hardware.location.gps"
+        android:required="false"/>
+
     <application
         android:allowBackup="true"
         android:icon="@drawable/ic_launcher"
@@ -31,6 +50,17 @@
 
         <activity android:name=".GlobalApplication$CrashActivity"/>
 
+        <activity android:name="cc.winboll.studio.positions.activities.LocationActivity"/>
+
+        <meta-data
+            android:name="com.google.android.gms.version"
+            android:value="@integer/google_play_services_version"/>
+
+        <service android:name=".services.MainService"/>
+
+        <service android:name=".services.AssistantService"/>
+
+        <service android:name=".services.DistanceRefreshService"/>
     </application>
 
 </manifest>

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 布局样式

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 androidx.core.content.ContextCompat;
-import com.hjq.toast.ToastUtils;
+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);
+        // 1. 初始化顶部 Toolbar（保留原逻辑，设置页面标题）
-		setSupportActionBar(toolbar);
+        initToolbar();
-
+        // 2. 初始化其他控件
-        mLogView = findViewById(R.id.logview);
+        initViews();
-        
+        // 3. 检查并申请位置权限（含后台GPS权限，确保服务启动前权限就绪）
-        ToastUtils.show("onCreate");
+        if (!checkLocationPermissions()) {
+            requestLocationPermissions();
+        }
+        // 4. 绑定服务（仅用于获取服务实时状态，不影响服务独立运行）
+        //bindDistanceService();
     }
 
     @Override
-    protected void onResume() {
+    protected void onDestroy() {
-        super.onResume();
+        super.onDestroy();
-        mLogView.start();
+        // 页面销毁时解绑服务，避免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("位置管理");
+        }
+    }
+
+    /**
+     * 初始化服务控制开关：读取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();
+			}
+		}
+	}
+
 }
+

positions/src/main/java/cc/winboll/studio/positions/activities/LocationActivity.java

@@ -0,0 +1,374 @@
+package cc.winboll.studio.positions.activities;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @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;
+
+/**
+ * 核心调整说明：
+ * 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<PositionModel> mCachedPositionList; 
+    private ArrayList<PositionTaskModel> 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);
+
+        // 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() {
+        // 1. 服务实例未初始化
+        if (mMainService == null) {
+            return; // 已在initServiceInstance中处理，此处避免重复finish
+        }
+
+        // 2. 检查服务运行状态（通过服务PUBLIC方法isServiceRunning()获取，不访问私有字段）
+//        if (!mMainService.isServiceRunning()) {
+//            // 服务未运行：手动触发启动（调用服务PUBLIC方法run()）
+//            mMainService.run();
+//            LogUtils.d(TAG, "服务未运行，已通过PUBLIC方法触发启动");
+//        }
+
+        // 3. 检查SP中服务配置（双重校验，确保一致性）
+        SharedPreferences sp = getSharedPreferences(SP_SERVICE_CONFIG, Context.MODE_PRIVATE);
+        boolean isServiceConfigRunning = sp.getBoolean(KEY_SERVICE_RUNNING, false);
+        if (!isServiceConfigRunning) {
+            Toast.makeText(this, "位置服务配置未启用，数据可能无法更新", Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    /**
+     * 缓存服务数据（从服务PUBLIC方法获取，解决私有字段未知问题）
+     */
+    private void cacheServiceData() {
+        if (mMainService == null) {
+            LogUtils.e(TAG, "缓存数据失败：服务实例为空");
+            mCachedPositionList = new ArrayList<PositionModel>();
+            mCachedTaskList = new ArrayList<PositionTaskModel>();
+            return;
+        }
+
+        // 从服务PUBLIC方法获取数据（不访问mPositionList，而是调用getPositionList()）
+        mCachedPositionList = mMainService.getPositionList();
+        mCachedTaskList = mMainService.getPositionTasksList();
+        
+        // 容错：若服务返回null，初始化空列表避免空指针
+        if (mCachedPositionList == null) mCachedPositionList = new ArrayList<PositionModel>();
+        if (mCachedTaskList == null) mCachedTaskList = new ArrayList<PositionTaskModel>();
+        
+        LogUtils.d(TAG, "缓存服务数据成功：位置数=" + mCachedPositionList.size() + "，任务数=" + mCachedTaskList.size());
+    }
+
+    /**
+     * 初始化RecyclerView（保留原性能优化）
+     */
+    private void initRecyclerViewConfig() {
+        mRecyclerView = (RecyclerView) findViewById(R.id.rv_position_list);
+        LinearLayoutManager layoutManager = new LinearLayoutManager(this);
+        layoutManager.setOrientation(LinearLayoutManager.VERTICAL);
+        mRecyclerView.setLayoutManager(layoutManager);
+        mRecyclerView.setHasFixedSize(true); // 固定大小，优化绘制
+    }
+
+    // ---------------------- Adapter初始化与数据交互（全通过服务PUBLIC方法） ----------------------
+    /**
+     * 初始化Adapter（通过缓存数据初始化，数据更新时同步调用服务方法）
+     */
+    private void initAdapter() {
+        if (mCachedPositionList == null || mCachedTaskList == null) {
+            LogUtils.e(TAG, "初始化Adapter失败：缓存数据为空");
+            return;
+        }
+
+        // 1. 初始化Adapter（传缓存数据+服务实例，Adapter数据从缓存取，操作通过服务）
+        mAdapter = new PositionAdapter(this, mCachedPositionList, mCachedTaskList);
+        mRecyclerView.setAdapter(mAdapter);
+
+        // 2. 删除回调：通过服务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<PositionTaskModel> newTaskList = new ArrayList<PositionTaskModel>(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<PositionModel>();
+        if (mCachedTaskList == null) mCachedTaskList = new ArrayList<PositionTaskModel>();
+
+        // 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();
+    }
+    */
+}
+

positions/src/main/java/cc/winboll/studio/positions/activities/WinBoLLActivity.java

@@ -0,0 +1,60 @@
+package cc.winboll.studio.positions.activities;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @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);
+    }
+}

positions/src/main/java/cc/winboll/studio/positions/adapters/PositionAdapter.java

@@ -0,0 +1,559 @@
+package cc.winboll.studio.positions.adapters;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @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<RecyclerView.ViewHolder> {
+    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<PositionModel> mCachedPositionList; // 位置缓存（来自Activity）
+    private ArrayList<PositionTaskModel> mCachedTaskList;  // 任务缓存（来自Activity）
+
+    // 4. 本地辅助缓存（优化性能：避免重复遍历，不依赖外部服务）
+    private final ConcurrentHashMap<String, ArrayList<PositionTaskModel>> mPosToTasksMap; // 位置ID→关联任务（本地分组）
+    private final ConcurrentHashMap<String, TextView> 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<PositionModel> cachedPositionList, ArrayList<PositionTaskModel> cachedTaskList) {
+        this.mContext = context;
+        // 初始化数据源（容错处理：若Activity传入null，初始化空列表避免空指针）
+        this.mCachedPositionList = (cachedPositionList != null) ? cachedPositionList : new ArrayList<PositionModel>();
+        this.mCachedTaskList = (cachedTaskList != null) ? cachedTaskList : new ArrayList<PositionTaskModel>();
+
+        // 初始化本地辅助缓存（基于Activity传入的数据构建，提升后续操作性能）
+        this.mPosToTasksMap = new ConcurrentHashMap<String, ArrayList<PositionTaskModel>>();
+        this.mPosDistanceViewMap = new ConcurrentHashMap<String, TextView>();
+
+        // 初始化“位置→任务”映射（从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<PositionTaskModel> posTasks = mPosToTasksMap.get(posId);
+        if (posTasks == null) {
+            posTasks = new ArrayList<PositionTaskModel>();
+        }
+
+        // 显示当前位置的任务数量（简化设计，实际项目可替换为任务列表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<PositionTaskModel> updatedTasks = mPosToTasksMap.get(posId);
+					if (updatedTasks == null) {
+						updatedTasks = new ArrayList<PositionTaskModel>();
+					}
+					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);
+	}
+	}
+}

positions/src/main/java/cc/winboll/studio/positions/models/AppConfigsModel.java

@@ -0,0 +1,75 @@
+package cc.winboll.studio.positions.models;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @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;
+	}
+}

positions/src/main/java/cc/winboll/studio/positions/models/PositionModel.java

@@ -0,0 +1,219 @@
+package cc.winboll.studio.positions.models;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @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;
+	}
+}
+

positions/src/main/java/cc/winboll/studio/positions/models/PositionTaskModel.java

@@ -0,0 +1,192 @@
+package cc.winboll.studio.positions.models;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @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;
+	}
+    
+}
+

positions/src/main/java/cc/winboll/studio/positions/services/AssistantService.java

@@ -0,0 +1,95 @@
+package cc.winboll.studio.positions.services;
+
+/**
+ * @Author ZhanGSKen<zhangsken@qq.com>
+ * @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();
+            }
+        }
+    }
+}

positions/src/main/java/cc/winboll/studio/positions/services/DistanceRefreshService.java

@@ -0,0 +1,433 @@
+//package cc.winboll.studio.positions.services;
+//
+///**
+// * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+// * @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;
+//	 }*/
+//}

positions/src/main/java/cc/winboll/studio/positions/services/MainService.java

@@ -0,0 +1,585 @@
+package cc.winboll.studio.positions.services;
+
+/**
+ * @Author ZhanGSKen<zhangsken@qq.com>
+ * @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<PositionModel> mPositionList = new ArrayList<PositionModel>();
+    private final ArrayList<PositionTaskModel> mTaskList = new ArrayList<PositionTaskModel>();
+	private PositionModel mCurrentGpsPosition; // 当前GPS位置（外部传入/内部GPS获取）
+
+    MyServiceConnection mMyServiceConnection;
+    volatile static boolean _mIsServiceRunning;
+    AppConfigsUtil mAppConfigsUtil;
+	private final ScheduledExecutorService distanceExecutor; // 定时计算线程池（单线程）
+	private final Set<String> mVisiblePositionIds = new HashSet<String>(); // 可见位置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();
+
+    }
+
+    private 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 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<PositionModel> getPositionList() {
+		return mPositionList;
+	}
+
+	public ArrayList<PositionTaskModel> 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<PositionTaskModel> 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);
+        }
+    }
+}

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&豆包大模型<zhangsken@qq.com>
+ * @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();
+	}
+}
+

positions/src/main/java/cc/winboll/studio/positions/utils/NotificationUtil.java

@@ -0,0 +1,185 @@
+package cc.winboll.studio.positions.utils;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @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);
+		}
+	}
+}
+

positions/src/main/java/cc/winboll/studio/positions/utils/ServiceUtil.java

@@ -0,0 +1,34 @@
+package cc.winboll.studio.positions.utils;
+
+/**
+ * @Author ZhanGSKen<zhangsken@qq.com>
+ * @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<ActivityManager.RunningServiceInfo> 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;
+    }
+}

positions/src/main/java/cc/winboll/studio/positions/views/PositionTaskListView.java

@@ -0,0 +1,416 @@
+package cc.winboll.studio.positions.views;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @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<PositionTaskModel> mTaskList;
+    private int mCurrentViewMode;
+    private TaskListAdapter mTaskAdapter;
+    private RecyclerView mRvTasks;
+
+    // 任务修改回调接口
+    public interface OnTaskUpdatedListener {
+        void onTaskUpdated(String positionId, ArrayList<PositionTaskModel> 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<PositionTaskModel>();
+        mTaskAdapter = new TaskListAdapter(mTaskList);
+        mRvTasks.setAdapter(mTaskAdapter);
+
+        mCurrentViewMode = VIEW_MODE_SIMPLE;
+    }
+
+    // ---------------------- 对外API ----------------------
+    public void init(ArrayList<PositionTaskModel> taskList, String positionId) {
+        this.mBindPositionId = positionId;
+        if (this.mTaskList.isEmpty()) {
+            ArrayList<PositionTaskModel> matchedTasks = new ArrayList<PositionTaskModel>();
+            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<PositionTaskModel> getAllTasks() {
+        return new ArrayList<PositionTaskModel>(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<PositionTaskModel>(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<TaskListAdapter.TaskViewHolder> {
+        private final List<PositionTaskModel> mData;
+
+        public TaskListAdapter(List<PositionTaskModel> 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<PositionTaskModel>(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<PositionTaskModel>(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<PositionTaskModel>(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);
+            }
+        }
+    }
+}
+

positions/src/main/res/drawable/bg_bingo_dot.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="oval">  <!-- 形状：圆形 -->
+    <solid android:color="#FF4444"/>  <!-- 填充色：亮红色（可调整色值） -->
+    <stroke
+        android:width="1dp"
+        android:color="#FFFFFF"/>
+</shape>

positions/src/main/res/drawable/bg_task_item.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+
+    <solid android:color="@color/white" />
+
+    <corners android:radius="4dp" />
+
+    <stroke
+        android:width="1dp"
+        android:color="@color/gray" />
+
+    <padding
+        android:left="8dp"
+        android:top="8dp"
+        android:right="8dp"
+        android:bottom="8dp" />
+
+</shape>
+

positions/src/main/res/drawable/btn_cancel_bg.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- 按压状态（加深灰色） -->
+    <item android:state_pressed="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#666666"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+    <!-- 默认状态（浅灰色） -->
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#999999"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+</selector>
+

positions/src/main/res/drawable/btn_confirm_bg.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- 按压状态（加深蓝色） -->
+    <item android:state_pressed="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#303F9F"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+    <!-- 默认状态（标准蓝色） -->
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#3F51B5"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+</selector>
+

positions/src/main/res/drawable/btn_delete_bg.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:state_pressed="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#D32F2F"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#F44336"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+</selector>
+

positions/src/main/res/drawable/circle_button_bg.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 圆形按钮背景：默认青色，按压时深色 -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- 按钮按压状态（深色，增强交互反馈） -->
+    <item android:state_pressed="true">
+        <shape android:shape="oval"> <!-- oval=圆形 -->
+            <solid android:color="#0F9D58"/> <!-- 按压时颜色：深青色（接近Google绿，美观且醒目） -->
+            <stroke android:width="1dp" android:color="#0F9D58"/> <!-- 边框颜色与背景一致，避免白边 -->
+        </shape>
+    </item>
+
+    <!-- 按钮默认状态（青色） -->
+    <item>
+        <shape android:shape="oval">
+            <solid android:color="#14C38E"/> <!-- 默认颜色：亮青色（视觉舒适，符合悬浮按钮风格） -->
+            <stroke android:width="1dp" android:color="#14C38E"/>
+        </shape>
+    </item>
+
+</selector>

positions/src/main/res/drawable/edittext_bg.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:state_focused="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#FFFFFF"/>
+            <stroke android:width="1.5dp" android:color="#4A90E2"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#FFFFFF"/>
+            <stroke android:width="1dp" android:color="#DDDDDD"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+</selector>
+

positions/src/main/res/drawable/item_bg_edit.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- res/drawable/item_bg_edit.xml -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- 状态1：按压时（编辑项被点击，反馈明确） -->
+    <item android:state_pressed="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#E0E6ED" /> <!-- 按压底色：比默认深一点的灰蓝色，反馈清晰 -->
+            <corners android:radius="8dp" />  <!-- 保持圆角统一 -->
+            <stroke
+                android:width="1.5dp"
+                android:color="#A0B4C8" />    <!-- 按压时边框加深，增强视觉焦点 -->
+        </shape>
+    </item>
+
+    <!-- 状态2：默认状态（未按压，区分简单视图） -->
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#EEEEEE" /> <!-- 默认底色：比简单视图深，明确编辑模式 -->
+            <corners android:radius="8dp" />  <!-- 与简单视图一致的圆角，UI不割裂 -->
+            <stroke
+                android:width="1.5dp"
+                android:color="#D0D8E0" />    <!-- 淡蓝色边框，暗示“可编辑” -->
+        </shape>
+    </item>
+</selector>
+

positions/src/main/res/drawable/item_bg_simple.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- res/drawable/item_bg_simple.xml -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- 状态1：按压时的背景（深一点的灰色，明确反馈点击动作） -->
+    <item android:state_pressed="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#E8E8E8" /> <!-- 按压底色（比默认深一点） -->
+            <corners android:radius="8dp" />  <!-- 保持和默认状态一致的圆角 -->
+            <stroke
+                android:width="1dp"
+                android:color="#E0E0E0" />
+        </shape>
+    </item>
+
+    <!-- 状态2：默认状态（未按压时的背景，和基础版一致） -->
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#F5F5F5" /> <!-- 默认浅灰底色 -->
+            <corners android:radius="8dp" />  <!-- 8dp圆角 -->
+            <stroke
+                android:width="1dp"
+                android:color="#E0E0E0" />    <!-- 细灰边框 -->
+        </shape>
+    </item>
+</selector>
+

positions/src/main/res/drawable/item_position_bg.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:state_pressed="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#F5F5F5"/>
+            <stroke android:width="1dp" android:color="#DDDDDD"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#FFFFFF"/>
+            <stroke android:width="1dp" android:color="#DDDDDD"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+</selector>
+

positions/src/main/res/layout/activity_location.xml

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:padding="20dp">
+
+    <!-- 1. 经纬度显示区域（保持居中，上方） -->
+    <LinearLayout
+        android:id="@+id/layout_location_info"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_centerHorizontal="true"
+        android:layout_marginTop="30dp"
+        android:orientation="vertical"
+        android:gravity="center_horizontal">
+
+        <!-- 标题 -->
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="实时位置信息"
+            android:textSize="22sp"
+            android:textStyle="bold"/>
+
+        <!-- 经度显示 -->
+        <TextView
+            android:id="@+id/tv_longitude"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="当前经度：等待更新..."
+            android:textSize="18sp"
+            android:layout_marginTop="15dp"/>
+
+        <!-- 纬度显示 -->
+        <TextView
+            android:id="@+id/tv_latitude"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="当前纬度：等待更新..."
+            android:textSize="18sp"
+            android:layout_marginTop="10dp"/>
+
+    </LinearLayout>
+
+    <!-- 2. 新增：位置列表（RecyclerView）- 位于经纬度下方，悬浮按钮上方 -->
+    <androidx.recyclerview.widget.RecyclerView
+        android:id="@+id/rv_position_list"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:layout_below="@id/layout_location_info"
+        android:layout_above="@id/fab_p_button"
+        android:layout_marginTop="20dp"
+        android:paddingBottom="10dp"/>
+
+    <!-- 3. 右下角圆形悬浮按钮（不变） -->
+    <Button
+        android:id="@+id/fab_p_button"
+        android:layout_width="60dp"
+        android:layout_height="60dp"
+        android:layout_alignParentBottom="true"
+        android:layout_alignParentRight="true"
+        android:layout_margin="20dp"
+        android:background="@drawable/circle_button_bg"
+        android:text="P"
+        android:textColor="@android:color/white"
+        android:textSize="24sp"
+        android:elevation="6dp"
+        android:padding="0dp"/>
+
+</RelativeLayout>
+

positions/src/main/res/layout/activity_main.xml

@@ -6,46 +6,34 @@
 	android:layout_height="match_parent"
 	android:orientation="vertical">
 
-	<com.google.android.material.appbar.AppBarLayout
+	<androidx.appcompat.widget.Toolbar
+		android:id="@+id/toolbar"
+		android:layout_width="match_parent"
+		android:layout_height="?attr/actionBarSize"
+		android:background="?attr/colorPrimary"
+		android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar"/>
+
+	<Switch
+		android:id="@+id/switch_service_control"
+		android:layout_margin="16dp"
+		android:text="主要服务开关"
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"/>
+
+	<Button
 		android:layout_width="match_parent"
 		android:layout_height="wrap_content"
-		android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar">
+		android:layout_margin="16dp"
+		android:onClick="onPositions"
+		android:text="进入位置管理"
+		android:id="@+id/btn_manage_positions"/>
 
-		<androidx.appcompat.widget.Toolbar
+	<Button
-			android:id="@+id/toolbar"
-			android:layout_width="match_parent"
-			android:layout_height="?attr/actionBarSize"
-			app:popupTheme="@style/ThemeOverlay.AppCompat.Light"/>
-
-	</com.google.android.material.appbar.AppBarLayout>
-
-	<LinearLayout
-		android:orientation="vertical"
 		android:layout_width="match_parent"
-		android:layout_height="0dp"
+		android:layout_height="wrap_content"
-		android:layout_weight="1.0"
+		android:layout_margin="16dp"
-		android:gravity="center_vertical|center_horizontal">
+		android:onClick="onLog"
-
+		android:text="查看操作日志"/>
-		<TextView
-			android:layout_width="wrap_content"
-			android:layout_height="wrap_content"
-			android:text="Positions"
-			android:textAppearance="?android:attr/textAppearanceLarge"/>
-
-	</LinearLayout>
-
-	<LinearLayout
-		android:orientation="vertical"
-		android:layout_width="match_parent"
-		android:layout_height="0dp"
-		android:layout_weight="1.0">
-
-		<cc.winboll.studio.libappbase.LogView
-			android:layout_width="match_parent"
-			android:layout_height="match_parent"
-			android:id="@+id/logview"/>
-
-	</LinearLayout>
 
 </LinearLayout>
 

positions/src/main/res/layout/dialog_edit_position.xml

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 编辑视图布局：垂直排列（经纬度显示+备注输入框），带内边距确保美观 -->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="16dp">
+
+    <!-- 1. 经度显示（灰色小字体，不可编辑） -->
+    <TextView
+        android:id="@+id/tv_edit_longitude"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#666666"
+        android:layout_marginBottom="8dp"/>
+
+    <!-- 2. 纬度显示（灰色小字体，不可编辑） -->
+    <TextView
+        android:id="@+id/tv_edit_latitude"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#666666"
+        android:layout_marginBottom="16dp"/>
+
+    <!-- 3. 备注输入框（可编辑，带提示文字，适配多行输入） -->
+    <EditText
+        android:id="@+id/et_edit_memo"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:hint="请输入位置备注（如：公司/家/学校）"
+        android:textSize="16sp"
+        android:inputType="textMultiLine"
+        android:minLines="3"
+        android:maxLines="5"
+        android:padding="10dp"
+        android:background="@drawable/edittext_bg"/> <!-- 输入框背景（带边框，区分普通文本） -->
+
+</LinearLayout>
+

positions/src/main/res/layout/dialog_edit_task.xml

@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="16dp"
+    android:background="@color/white">
+
+    <EditText
+        android:id="@+id/et_edit_task_desc"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:hint="输入任务描述"
+        android:maxLines="1"
+        android:textSize="14sp" />
+
+    <RadioGroup
+        android:id="@+id/rg_distance_condition"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:layout_marginTop="12dp">
+
+        <RadioButton
+            android:id="@+id/rb_greater_than"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="大于"
+            android:textColor="@color/black"
+            android:textSize="14sp" />
+
+        <RadioButton
+            android:id="@+id/rb_less_than"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="小于"
+            android:textColor="@color/black"
+            android:textSize="14sp"
+            android:layout_marginLeft="24dp" />
+
+    </RadioGroup>
+
+    <EditText
+        android:id="@+id/et_edit_distance"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:hint="输入距离（米）"
+        android:inputType="number"
+        android:maxLines="1"
+        android:textSize="14sp"
+        android:layout_marginTop="8dp" />
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="end"
+        android:layout_marginTop="16dp">
+
+        <Button
+            android:id="@+id/btn_dialog_cancel"
+            android:layout_width="wrap_content"
+            android:layout_height="40dp"
+            android:text="取消"
+            android:textColor="@color/black"
+            android:textSize="14sp"
+            android:layout_marginRight="8dp"
+            android:background="@color/gray" />
+
+        <Button
+            android:id="@+id/btn_dialog_save"
+            android:layout_width="wrap_content"
+            android:layout_height="40dp"
+            android:text="保存"
+            android:textSize="14sp"
+            android:background="@color/blue"
+            android:textColor="@color/white" />
+
+    </LinearLayout>
+
+</LinearLayout>
+

positions/src/main/res/layout/item_position_edit.xml

@@ -0,0 +1,178 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+	xmlns:android="http://schemas.android.com/apk/res/android"
+	android:layout_width="match_parent"
+	android:layout_height="wrap_content"
+	android:orientation="vertical"
+	android:padding="12dp"
+	android:background="@drawable/item_bg_edit">
+
+	<TextView
+		android:id="@+id/tv_edit_longitude"
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:textSize="14sp"
+		android:textColor="#999999"/>
+
+	<TextView
+		android:id="@+id/tv_edit_latitude"
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:textSize="14sp"
+		android:textColor="#999999"
+		android:layout_marginTop="4dp"/>
+
+	<EditText
+		android:id="@+id/et_edit_memo"
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:hint="请输入位置备注"
+		android:textSize="14sp"
+		android:padding="8dp"
+		android:layout_marginTop="8dp"
+		android:background="@drawable/edittext_bg"/>
+
+	<LinearLayout
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:orientation="vertical"
+		android:layout_marginTop="10dp">
+
+		<TextView
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:textSize="14sp"
+			android:textColor="#333333"
+			android:id="@+id/tv_edit_distance"/>
+
+		<RadioGroup
+			android:id="@+id/rg_distance_switch"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:orientation="horizontal"
+			android:layout_marginLeft="8dp">
+
+			<RadioButton
+				android:id="@+id/rb_distance_disable"
+				android:layout_width="wrap_content"
+				android:layout_height="wrap_content"
+				android:text="禁用"
+				android:textSize="14sp"
+				android:checked="true"/>
+
+			<RadioButton
+				android:id="@+id/rb_distance_enable"
+				android:layout_width="wrap_content"
+				android:layout_height="wrap_content"
+				android:text="启用"
+				android:textSize="14sp"
+				android:layout_marginLeft="15dp"/>
+
+		</RadioGroup>
+
+	</LinearLayout>
+
+	<LinearLayout
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:orientation="horizontal"
+		android:layout_marginTop="12dp">
+
+		<Button
+			android:id="@+id/btn_edit_delete"
+			android:layout_width="wrap_content"
+			android:layout_height="32dp"
+			android:background="@drawable/btn_delete_bg"
+			android:text="删除位置"
+			android:textColor="@android:color/white"
+			android:textSize="13sp"
+			android:paddingStart="15dp"
+			android:paddingEnd="15dp"/>
+
+		<View
+			android:layout_width="10dp"
+			android:layout_height="match_parent"/>
+
+		<Button
+			android:id="@+id/btn_edit_cancel"
+			android:layout_width="wrap_content"
+			android:layout_height="32dp"
+			android:background="@drawable/btn_cancel_bg"
+			android:text="取消"
+			android:textColor="@android:color/white"
+			android:textSize="13sp"
+			android:paddingStart="15dp"
+			android:paddingEnd="15dp"/>
+
+		<View
+			android:layout_width="10dp"
+			android:layout_height="match_parent"/>
+
+		<Button
+			android:id="@+id/btn_edit_save"
+			android:layout_width="wrap_content"
+			android:layout_height="32dp"
+			android:background="@drawable/btn_confirm_bg"
+			android:text="确定"
+			android:textColor="@android:color/white"
+			android:textSize="13sp"
+			android:paddingStart="15dp"
+			android:paddingEnd="15dp"/>
+
+	</LinearLayout>
+
+	<LinearLayout
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:orientation="vertical"
+		android:layout_marginTop="16dp">
+
+		<LinearLayout
+			android:layout_width="match_parent"
+			android:layout_height="30dp"
+			android:orientation="horizontal">
+
+			<TextView
+				android:layout_width="wrap_content"
+				android:layout_height="match_parent"
+				android:gravity="center_vertical"
+				android:text="关联任务（可编辑）："
+				android:textSize="14sp"
+				android:textColor="#333333"/>
+
+			<TextView
+				android:id="@+id/tv_task_count"
+				android:layout_width="wrap_content"
+				android:layout_height="match_parent"
+				android:gravity="center_vertical"
+				android:textSize="14sp"
+				android:textColor="#333333"/>
+			
+			<View
+				android:layout_width="0dp"
+				android:layout_height="match_parent"
+				android:layout_weight="1"/>
+
+			<Button
+				android:id="@+id/btn_add_task"
+				android:layout_width="wrap_content"
+				android:layout_height="match_parent"
+				android:background="@drawable/btn_confirm_bg"
+				android:text="添加新任务"
+				android:textColor="@android:color/white"
+				android:textSize="12sp"
+				android:paddingStart="12dp"
+				android:paddingEnd="12dp"/>
+
+		</LinearLayout>
+
+		<cc.winboll.studio.positions.views.PositionTaskListView
+			android:id="@+id/ptlv_edit_tasks"
+			android:layout_width="match_parent"
+			android:layout_height="wrap_content"
+			android:layout_marginTop="6dp"/>
+
+	</LinearLayout>
+
+</LinearLayout>
+

positions/src/main/res/layout/item_position_empty.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="100dp"
+    android:gravity="center"
+    android:orientation="vertical">
+
+    <TextView
+        android:id="@+id/tv_empty_tip"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textColor="@color/colorGrayText"
+        android:textSize="16sp" />
+
+</LinearLayout>
+

positions/src/main/res/layout/item_position_simple.xml

@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="12dp"
+    android:background="@drawable/item_bg_simple">
+    <TextView
+        android:id="@+id/tv_simple_longitude"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#333333"/>
+
+    <TextView
+        android:id="@+id/tv_simple_latitude"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#333333"
+        android:layout_marginTop="4dp"/>
+
+    <TextView
+        android:id="@+id/tv_simple_memo"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#666666"
+        android:layout_marginTop="4dp"/>
+
+    <TextView
+        android:id="@+id/tv_simple_distance"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#2E8B57"
+        android:layout_marginTop="6dp"/>
+
+    <TextView
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="关联任务（已启用）："
+        android:textSize="14sp"
+        android:textColor="#333333"
+        android:layout_marginTop="8dp"
+        android:layout_marginBottom="4dp"/>
+
+    <cc.winboll.studio.positions.views.PositionTaskListView
+        android:id="@+id/ptlv_simple_tasks"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="4dp"/>
+
+</LinearLayout>
+

positions/src/main/res/layout/item_position_task_edit.xml

@@ -0,0 +1,184 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="12dp"
+    android:background="@drawable/item_bg_edit"
+    android:layout_marginBottom="8dp">
+
+    <!-- 1. 不可编辑字段（仅显示，灰色文字） -->
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        android:layout_marginBottom="10dp">
+
+        <TextView
+            android:id="@+id/tv_edit_task_id"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:textSize="12sp"
+            android:textColor="#999999"
+            android:text="任务ID："/>
+
+        <TextView
+            android:id="@+id/tv_edit_position_id"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:textSize="12sp"
+            android:textColor="#999999"
+            android:layout_marginTop="2dp"
+            android:text="位置ID："/>
+    </LinearLayout>
+
+    <!-- 2. 任务描述（可编辑） -->
+    <EditText
+        android:id="@+id/et_edit_task_desc"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:hint="请输入任务描述（如：到达后提醒打卡）"
+        android:textSize="14sp"
+        android:padding="8dp"
+        android:background="@drawable/edittext_bg"
+        android:layout_marginBottom="10dp"/>
+
+    <!-- 3. 距离条件（单选组：大于/小于） -->
+    <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:layout_marginBottom="10dp">
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="距离条件："
+            android:textSize="14sp"
+            android:textColor="#333333"
+            android:layout_marginRight="10dp"/>
+
+        <RadioGroup
+            android:id="@+id/rg_edit_distance_cond"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal">
+
+            <RadioButton
+                android:id="@+id/rb_edit_greater"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="大于"
+                android:textSize="14sp"
+                android:layout_marginRight="15dp"/>
+
+            <RadioButton
+                android:id="@+id/rb_edit_less"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="小于"
+                android:textSize="14sp"/>
+        </RadioGroup>
+    </LinearLayout>
+
+    <!-- 4. 商议距离（可编辑，仅整数） -->
+    <EditText
+        android:id="@+id/et_edit_discuss_dist"
+        android:layout_width="120dp"
+        android:layout_height="wrap_content"
+        android:hint="请输入距离（米）"
+        android:textSize="14sp"
+        android:inputType="number"
+        android:padding="8dp"
+        android:background="@drawable/edittext_bg"
+        android:layout_marginBottom="10dp"/>
+
+    <!-- 5. 启用状态（单选组：是/否） -->
+    <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:layout_marginBottom="12dp">
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="启用任务："
+            android:textSize="14sp"
+            android:textColor="#333333"
+            android:layout_marginRight="10dp"/>
+
+        <RadioGroup
+            android:id="@+id/rg_edit_is_enable"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal">
+
+            <RadioButton
+                android:id="@+id/rb_edit_enable_yes"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="是"
+                android:textSize="14sp"
+                android:layout_marginRight="15dp"/>
+
+            <RadioButton
+                android:id="@+id/rb_edit_enable_no"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="否"
+                android:textSize="14sp"/>
+        </RadioGroup>
+    </LinearLayout>
+
+    <!-- 6. 功能按钮（删除-红 / 取消-灰 / 确定-蓝） -->
+    <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="center_vertical">
+
+        <Button
+            android:id="@+id/btn_edit_delete"
+            android:layout_width="wrap_content"
+            android:layout_height="32dp"
+            android:background="@drawable/btn_delete_bg"
+            android:text="删除"
+            android:textColor="@android:color/white"
+            android:textSize="13sp"
+            android:paddingStart="15dp"
+            android:paddingEnd="15dp"/>
+
+        <View
+            android:layout_width="10dp"
+            android:layout_height="match_parent"/>
+
+        <Button
+            android:id="@+id/btn_edit_cancel"
+            android:layout_width="wrap_content"
+            android:layout_height="32dp"
+            android:background="@drawable/btn_cancel_bg"
+            android:text="取消"
+            android:textColor="@android:color/white"
+            android:textSize="13sp"
+            android:paddingStart="15dp"
+            android:paddingEnd="15dp"/>
+
+        <View
+            android:layout_width="10dp"
+            android:layout_height="match_parent"/>
+
+        <Button
+            android:id="@+id/btn_edit_confirm"
+            android:layout_width="wrap_content"
+            android:layout_height="32dp"
+            android:background="@drawable/btn_confirm_bg"
+            android:text="确定"
+            android:textColor="@android:color/white"
+            android:textSize="13sp"
+            android:paddingStart="15dp"
+            android:paddingEnd="15dp"/>
+    </LinearLayout>
+
+</LinearLayout>
+

positions/src/main/res/layout/item_position_task_simple.xml

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 根布局改为 RelativeLayout，支持红点右上角定位（原 LinearLayout 无法便捷实现绝对位置） -->
+<RelativeLayout 
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="12dp"
+    android:background="@drawable/item_bg_simple"
+    android:layout_marginBottom="8dp">
+
+    <!-- 1. 右上角小红点（仅 isBingo=true 时显示，绑定 isBingo 属性） -->
+    <View
+        android:id="@+id/v_bingo_dot"
+        android:layout_width="12dp"
+        android:layout_height="12dp"
+        android:layout_alignParentRight="true"
+        android:layout_alignParentTop="true"
+        android:layout_marginRight="2dp"
+        android:layout_marginTop="2dp"
+        android:background="@drawable/bg_bingo_dot"
+        android:visibility="gone"/>  <!-- 默认隐藏，仅任务触发（isBingo=true）时显示 -->
+
+    <!-- 2. 任务描述（原控件不变，位置受红点不影响） -->
+    <TextView
+        android:id="@+id/tv_simple_task_desc"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="16sp"
+        android:textColor="#333333"
+        android:text="任务：无描述"/>
+
+    <!-- 3. 距离条件（原控件不变） -->
+    <TextView
+        android:id="@+id/tv_simple_distance_cond"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#666666"
+        android:layout_marginTop="6dp"
+        android:layout_below="@id/tv_simple_task_desc"
+        android:text="条件：距离 > 0 米"/>
+
+    <!-- 4. 启用状态（原控件不变） -->
+    <TextView
+        android:id="@+id/tv_simple_is_enable"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#2E8B57"
+        android:layout_marginTop="4dp"
+        android:layout_below="@id/tv_simple_distance_cond"
+        android:text="状态：已启用"/>
+
+</RelativeLayout>
+

positions/src/main/res/layout/item_task_content.xml

@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="horizontal"
+    android:gravity="center_vertical"
+    android:padding="8dp"
+    android:background="@drawable/bg_task_item"
+    android:layout_marginVertical="4dp">
+
+    <CheckBox
+        android:id="@+id/cb_task_enable"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginRight="12dp" />
+
+    <LinearLayout
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:orientation="vertical">
+
+        <TextView
+            android:id="@+id/tv_task_desc"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="任务描述"
+            android:textSize="16sp"
+            android:textColor="@color/black" />
+
+        <TextView
+            android:id="@+id/tv_task_distance"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="条件：大于 100 米"
+            android:textSize="12sp"
+            android:textColor="@color/gray_dark"
+            android:layout_marginTop="2dp" />
+
+    </LinearLayout>
+
+    <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:layout_marginLeft="8dp">
+
+        <Button
+            android:id="@+id/btn_edit_task"
+            android:layout_width="wrap_content"
+            android:layout_height="30dp"
+            android:text="修改"
+            android:textSize="12sp"
+            android:layout_marginRight="4dp"
+            android:background="@color/blue"
+            android:textColor="@color/white" />
+
+        <Button
+            android:id="@+id/btn_delete_task"
+            android:layout_width="wrap_content"
+            android:layout_height="30dp"
+            android:text="删除"
+            android:textSize="12sp"
+            android:background="@color/red"
+            android:textColor="@color/white" />
+
+    </LinearLayout>
+
+</LinearLayout>
+

positions/src/main/res/layout/item_task_empty.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="80dp"
+    android:gravity="center"
+    android:orientation="vertical"
+    android:background="@color/background_light">
+
+    <TextView
+        android:id="@+id/tv_task_empty_tip"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="暂无任务"
+        android:textColor="@color/gray"
+        android:textSize="14sp" />
+
+</LinearLayout>
+

positions/src/main/res/layout/view_position_task_list.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="8dp">
+
+    <androidx.recyclerview.widget.RecyclerView
+        android:id="@+id/rv_position_tasks"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:background="@color/white"
+        android:paddingVertical="4dp" />
+
+</LinearLayout>
+

positions/src/main/res/menu/menu_item_edit.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- 编辑菜单：点击后切换到编辑视图 -->
+    <item
+        android:id="@+id/menu_edit"
+        android:title="编辑"
+        android:orderInCategory="100"
+        android:showAsAction="never"/> <!-- 仅在菜单中显示，不显示在按钮栏 -->
+</menu>

positions/src/main/res/values-zh/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">~笨笨龙~</string>
+</resources>

positions/src/main/res/values/colors.xml

@@ -3,4 +3,31 @@
     <color name="colorPrimary">#009688</color>
     <color name="colorPrimaryDark">#00796B</color>
     <color name="colorAccent">#FF9800</color>
-</resources>
+	<!-- 1. colorEnableGreen：简单视图“已启用”状态文字颜色（柔和绿色，不刺眼） -->
+    <color name="colorEnableGreen">#2E8B57</color> <!-- 海绿色：比纯绿柔和，适合文字提示 -->
+
+    <!-- 2. colorGrayText：编辑视图“不可编辑字段”文字颜色（浅灰色，暗示“不可修改”） -->
+    <color name="colorGrayText">#999999</color> <!-- 中浅灰：既不模糊，又能和可编辑文字区分开 -->
+
+    <!-- （可选补充）适配之前的背景资源颜色（避免后续新增资源报错，提前定义） -->
+    <color name="colorItemSimpleBg">#F5F5F5</color> <!-- item_bg_simple 底色 -->
+    <color name="colorItemEditBg">#EEEEEE</color>   <!-- item_bg_edit 底色 -->
+    <color name="colorItemBorder">#E0E0E0</color>   <!-- 列表项边框颜色 -->
+	<color name="colorRed">#F44336</color> <!-- 标准 Material 红色，可自定义RGB值 -->
+
+	<!-- 基础颜色：解决@color/gray未定义问题 -->
+	<color name="gray">#9E9E9E</color> <!-- 浅灰色（用于提示文本、次要信息） -->
+	<color name="gray_dark">#616161</color> <!-- 深灰色（备用，避免后续扩展缺失） -->
+
+	<!-- 其他已用颜色：确保布局中所有颜色引用都有定义 -->
+	<color name="white">#FFFFFF</color> <!-- 白色（任务列表背景、弹窗背景） -->
+	<color name="black">#000000</color> <!-- 黑色（任务描述文本） -->
+	<color name="blue">#2196F3</color> <!-- 蓝色（编辑/保存按钮背景） -->
+	<color name="red">#F44336</color> <!-- 红色（删除按钮背景） -->
+	<color name="background_light">#F5F5F5</color> <!-- 浅灰背景（备用，提升页面质感） -->
+
+	<!-- 扩展颜色（避免后续新增功能时再次缺失） -->
+	<color name="green">#4CAF50</color> <!-- 绿色（备用：如“启用”状态标识） -->
+	<color name="yellow">#FFC107</color> <!-- 黄色（备用：如“提醒”标识） -->
+
+</resources>

positions/src/main/res/values/strings.xml

@@ -1,4 +1,3 @@
 <resources>
     <string name="app_name">Positions</string>
-    
 </resources>