<positions>APK 15.0.17 release Publish.

positions/README.md

@@ -2,6 +2,7 @@
 
 #### 介绍
 安卓位置应用，有关于地理位置的相关应用。
+PS:使用感言~~~『記低用唔到』。
 
 #### 软件架构
 适配安卓应用 [AIDE Pro] 的 Gradle 编译结构。

positions/build.gradle

@@ -46,6 +46,9 @@ android {
 dependencies {
     api fileTree(dir: 'libs', include: ['*.jar'])
 	
+	// https://mvnrepository.com/artifact/com.jzxiang.pickerview/TimePickerDialog
+	api 'com.jzxiang.pickerview:TimePickerDialog:1.0.1'
+	
 	// 谷歌定位服务核心依赖（FusedLocationProviderClient所在库）
     api 'com.google.android.gms:play-services-location:21.0.1'
     
@@ -59,7 +62,7 @@ dependencies {
     // 应用介绍页类库
     api 'io.github.medyo:android-about-page:2.0.0'
     // 吐司类库
-    api 'com.github.getActivity:ToastUtils:10.5'
+    //api 'com.github.getActivity:ToastUtils:10.5'
     // 网络连接类库
     api 'com.squareup.okhttp3:okhttp:4.4.1'
     // AndroidX 类库

positions/build.properties

@@ -1,8 +1,8 @@
 #Created by .winboll/winboll_app_build.gradle
-#Thu Oct 02 13:16:14 GMT 2025
-stageCount=8
+#Tue Oct 28 20:03:59 HKT 2025
+stageCount=18
 libraryProject=
 baseVersion=15.0
-publishVersion=15.0.7
-buildCount=29
-baseBetaVersion=15.0.8
+publishVersion=15.0.17
+buildCount=0
+baseBetaVersion=15.0.18

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

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <string name="app_name">寻龙记#</string>
+    <string name="app_name">悟空笔记#</string>
 </resources>

positions/src/main/AndroidManifest.xml

@@ -3,6 +3,9 @@
     xmlns:android="http://schemas.android.com/apk/res/android"
     package="cc.winboll.studio.positions">
 
+	<!-- 1. 声明GPS权限 -->
+	<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+
     <!-- 前台服务权限（可选，提升后台定位稳定性，避免服务被回收） -->
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
 
@@ -61,6 +64,17 @@
         <service android:name=".services.AssistantService"/>
 
         <service android:name=".services.DistanceRefreshService"/>
+
+
+		<!-- 2. 注册运动状态Receiver -->
+		<receiver
+			android:name="cc.winboll.studio.positions.receivers.MotionStatusReceiver"
+			android:enabled="true"
+			android:exported="true">
+			<intent-filter>
+				<action android:name="cc.winboll.studio.positions.ACTION_MOTION_STATUS" />
+			</intent-filter>
+		</receiver>
     </application>
 
 </manifest>

positions/src/main/java/cc/winboll/studio/positions/App.java

@@ -22,9 +22,9 @@ import android.widget.HorizontalScrollView;
 import android.widget.ScrollView;
 import android.widget.TextView;
 import android.widget.Toast;
+import cc.winboll.studio.libaes.utils.WinBoLLActivityManager;
 import cc.winboll.studio.libappbase.GlobalApplication;
-import com.hjq.toast.ToastUtils;
-import com.hjq.toast.style.WhiteToastStyle;
+import cc.winboll.studio.libappbase.ToastUtils;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.Closeable;
@@ -41,7 +41,6 @@ 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 {
 
@@ -58,8 +57,8 @@ public class App extends GlobalApplication {
         ToastUtils.init(this);
         // 设置 Toast 布局样式
         //ToastUtils.setView(R.layout.view_toast);
-        ToastUtils.setStyle(new WhiteToastStyle());
-        ToastUtils.setGravity(Gravity.BOTTOM, 0, 200);
+        //ToastUtils.setStyle(new WhiteToastStyle());
+        //ToastUtils.setGravity(Gravity.BOTTOM, 0, 200);
         
         //CrashHandler.getInstance().registerGlobal(this);
         //CrashHandler.getInstance().registerPart(this);

positions/src/main/java/cc/winboll/studio/positions/MainActivity.java

@@ -21,6 +21,7 @@ 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;
+import cc.winboll.studio.positions.utils.ServiceUtil;
 
 /**
  * 主页面：仅负责
@@ -141,18 +142,11 @@ public class MainActivity extends WinBoLLActivity implements IWinBoLLActivity {
 					// 权限就绪：执行服务启停逻辑
 					if (isChecked) {
 						LogUtils.d(TAG, "设置启动服务");
-						AppConfigsUtil.getInstance(MainActivity.this).setIsEnableMainService(true);
-						// 启动服务（startService确保服务独立运行，不受Activity绑定影响）
-						startService(new Intent(MainActivity.this, MainService.class));
+						ServiceUtil.startAutoService(MainActivity.this);
 					} else {
 						LogUtils.d(TAG, "设置关闭服务");
-						AppConfigsUtil.getInstance(MainActivity.this).setIsEnableMainService(false);
-						// 停止服务前先解绑，避免服务被Activity持有
-//						if (isServiceBound) {
-//							unbindService(mServiceConn);
-//							isServiceBound = false;
-//						}
-						stopService(new Intent(MainActivity.this, MainService.class));
+
+						ServiceUtil.stopAutoService(MainActivity.this);
 					}
 
 					mManagePositionsButton.setEnabled(isChecked);

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

@@ -5,23 +5,27 @@ package cc.winboll.studio.positions.activities;
  * @Date 2025/09/29 18:22
  * @Describe 位置列表页面（适配MainService GPS接口+规范服务交互+完善生命周期）
  */
-import android.os.Bundle;
-import android.os.IBinder;
 import android.app.Activity;
 import android.content.ComponentName;
+import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.view.View;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.TextView;
 import android.widget.Toast;
 import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
-
 import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.libappbase.ToastUtils;
+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 cc.winboll.studio.positions.R;
 import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
  * Java 7 语法适配：
@@ -30,37 +34,65 @@ import java.util.ArrayList;
  * 3. 所有位置/任务操作通过 MainService 接口执行
  */
 public class LocationActivity extends Activity {
-    private static final String TAG = "LocationActivity";
+    public static final String TAG = "LocationActivity";
 
     private RecyclerView mRvPosition;
     private PositionAdapter mPositionAdapter;
-    private ArrayList<PositionModel> mLocalPosCache; // 本地位置缓存（与MainService同步）
     
-    // MainService 引用+绑定状态
+    // MainService 引用+绑定状态（AtomicBoolean 确保多线程状态可见性）
     private MainService mMainService;
-    private boolean isServiceBound = false;
+    private final AtomicBoolean isServiceBound = new AtomicBoolean(false);
+    // 标记 Adapter 是否已初始化（避免重复初始化/销毁后初始化）
+    private final AtomicBoolean isAdapterInited = new AtomicBoolean(false);
 
-    // 服务连接（Java 7 匿名内部类实现）
+	// ---------------------- 新增：GPS监听核心变量 ----------------------
+    private MainService.GpsUpdateListener mGpsUpdateListener; // GPS监听实例
+    private PositionModel mCurrentGpsPos; // 缓存当前GPS位置（供页面使用）
+    // 本地位置缓存（解决服务数据未同步时Adapter空数据问题）
+    private final ArrayList<PositionModel> mLocalPosCache = new ArrayList<PositionModel>();
+
+
+    // 服务连接（Java 7 匿名内部类实现，强化状态同步+数据预加载）
     private ServiceConnection mServiceConnection = new ServiceConnection() {
         @Override
         public void onServiceConnected(ComponentName name, IBinder service) {
-            // 假设 MainService 用 LocalBinder 暴露实例（Java 7 强转）
+            // 1. 安全获取服务实例（避免强转失败+服务未就绪）
+            if (!(service instanceof MainService.LocalBinder)) {
+                LogUtils.e(TAG, "服务绑定失败：Binder类型不匹配（非MainService.LocalBinder）");
+                isServiceBound.set(false);
+                return;
+            }
+
+            try {
                 MainService.LocalBinder binder = (MainService.LocalBinder) service;
                 mMainService = binder.getService();
-            isServiceBound = true;
+                // 2. 标记服务绑定成功（原子操作，确保多线程可见）
+                isServiceBound.set(true);
+                LogUtils.d(TAG, "MainService绑定成功，开始同步数据+初始化Adapter");
 
-            LogUtils.d(TAG, "MainService绑定成功，开始同步数据");
-            // 从MainService同步初始数据（位置+任务）
+                // 3. 同步服务数据到本地缓存（核心：先同步数据，再初始化Adapter）
                 syncDataFromMainService();
-            // 初始化Adapter（传入MainService实例，确保任务数据从服务获取）
+                // 4. 注册GPS监听（确保监听在Adapter前初始化，数据不丢失）
+                registerGpsListener();
+                // 5. 初始化Adapter（传入本地缓存+服务实例，数据非空）
                 initPositionAdapter();
+
+            } catch (Exception e) {
+                LogUtils.d(TAG, "服务绑定后初始化失败：" + e.getMessage());
+                isServiceBound.set(false);
+                mMainService = null;
+                showToast("服务初始化失败，无法加载数据");
+            }
         }
 
         @Override
         public void onServiceDisconnected(ComponentName name) {
-            LogUtils.w(TAG, "MainService断开连接，清空引用");
+            LogUtils.w(TAG, "MainService断开连接，清空引用+标记状态");
+            // 1. 清空服务引用+标记绑定状态
             mMainService = null;
-            isServiceBound = false;
+            isServiceBound.set(false);
+            // 2. 标记Adapter未初始化（下次绑定需重新初始化）
+            isAdapterInited.set(false);
         }
     };
 
@@ -69,159 +101,361 @@ public class LocationActivity extends Activity {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_location);
 
-        // 初始化视图+本地缓存
+        // 1. 初始化视图（优先执行，避免Adapter初始化时视图为空）
         initView();
-        mLocalPosCache = new ArrayList<PositionModel>();
-
-        // 绑定MainService（确保Activity启动时就拿到服务实例）
+        // 2. 初始化GPS监听（提前创建，避免绑定服务后空指针）
+        initGpsUpdateListener();
+        // 3. 绑定MainService（最后执行，确保视图/监听已就绪）
         bindMainService();
     }
 
     /**
-     * 初始化视图（RecyclerView）
+     * 初始化视图（RecyclerView）- 确保视图先于Adapter初始化
      */
     private void initView() {
         mRvPosition = (RecyclerView) findViewById(R.id.rv_position_list);
-        // Java 7 显式设置布局管理器（LinearLayoutManager）
+        // 1. 显式设置布局管理器（避免Adapter设置时无布局管理器崩溃）
         LinearLayoutManager layoutManager = new LinearLayoutManager(this);
         layoutManager.setOrientation(LinearLayoutManager.VERTICAL);
         mRvPosition.setLayoutManager(layoutManager);
+        // 2. 初始化本地缓存（避免首次加载时缓存为空）
+        mLocalPosCache.clear();
+        LogUtils.d(TAG, "视图初始化完成（布局管理器+本地缓存已就绪）");
     }
 
     /**
-     * 绑定MainService（Java 7 显式Intent）
+     * 绑定MainService（Java 7 显式Intent，强化绑定安全性）
      */
     private void bindMainService() {
+        // 1. 避免重复绑定（快速重建Activity时防止多绑定）
+        if (isServiceBound.get()) {
+            LogUtils.w(TAG, "无需重复绑定：MainService已绑定");
+            return;
+        }
+
         Intent serviceIntent = new Intent(this, MainService.class);
-        // 绑定服务（BIND_AUTO_CREATE：服务不存在时自动创建）
-        bindService(serviceIntent, mServiceConnection, BIND_AUTO_CREATE);
-        LogUtils.d(TAG, "发起MainService绑定请求");
+        // 2. 绑定服务（BIND_AUTO_CREATE：服务不存在时自动创建，增加绑定成功率）
+        boolean bindSuccess = bindService(serviceIntent, mServiceConnection, BIND_AUTO_CREATE);
+        if (!bindSuccess) {
+            LogUtils.e(TAG, "发起MainService绑定请求失败（服务未找到/系统限制）");
+            showToast("服务绑定失败，无法加载位置数据");
+        } else {
+            LogUtils.d(TAG, "MainService绑定请求已发起");
+        }
     }
 
     /**
-     * 从MainService同步数据（位置+任务）
+     * 从MainService同步数据到本地缓存（核心解决Adapter空数据问题）
+     * 作用：1. 服务数据优先同步到本地，Adapter基于本地缓存初始化
+     *      2. 避免服务数据更新时直接操作Adapter，通过缓存中转
      */
     private void syncDataFromMainService() {
-        if (!isServiceBound || mMainService == null) {
-            LogUtils.w(TAG, "同步数据失败：MainService未绑定");
-            showToast("服务未就绪，无法加载数据");
+        // 1. 安全校验（服务未绑定/服务空，用本地缓存兜底）
+        if (!isServiceBound.get() || mMainService == null) {
+            LogUtils.w(TAG, "同步数据：服务未就绪，使用本地缓存（当前缓存量=" + mLocalPosCache.size() + "）");
             return;
         }
 
-        // 同步位置数据（从服务获取最新列表）
+        try {
+            // 2. 从服务获取最新位置数据（同步操作，确保数据拿到后再返回）
             ArrayList<PositionModel> servicePosList = mMainService.getPositionList();
-        if (servicePosList != null && !servicePosList.isEmpty()) {
+            // 3. 同步到本地缓存（清空旧数据+添加新数据，避免重复）
+            synchronized (mLocalPosCache) { // 加锁避免多线程操作缓存冲突
                 mLocalPosCache.clear();
+                if (servicePosList != null && !servicePosList.isEmpty()) {
                     mLocalPosCache.addAll(servicePosList);
-            LogUtils.d(TAG, "从MainService同步位置数据完成：数量=" + mLocalPosCache.size());
                 }
+            }
+            LogUtils.d(TAG, "数据同步完成：服务位置数=" + (servicePosList == null ? 0 : servicePosList.size()) 
+                      + "，本地缓存数=" + mLocalPosCache.size());
 
-        // 同步任务数据（无需本地缓存，Adapter直接从服务获取）
-        ArrayList<PositionTaskModel> serviceTaskList = mMainService.getAllTasks();
-        LogUtils.d(TAG, "从MainService同步任务数据完成：数量=" + serviceTaskList.size());
+        } catch (Exception e) {
+            LogUtils.d(TAG, "同步服务数据失败：" + e.getMessage());
+            // 异常时保留本地缓存，避免Adapter无数据
+            LogUtils.w(TAG, "同步失败，使用本地缓存兜底（缓存量=" + mLocalPosCache.size() + "）");
+        }
     }
 
     /**
-     * 初始化PositionAdapter（核心：传入MainService实例）
+     * 初始化PositionAdapter（核心优化：基于本地缓存初始化，避免空数据）
      */
     private void initPositionAdapter() {
-        if (mMainService == null) {
-            LogUtils.e(TAG, "初始化Adapter失败：MainService为空");
+        // 1. 多重安全校验（避免销毁后初始化/重复初始化/依赖未就绪）
+        if (isAdapterInited.get() || !isServiceBound.get() || mMainService == null || mRvPosition == null) {
+            LogUtils.w(TAG, "Adapter初始化跳过：" 
+                      + "已初始化=" + isAdapterInited.get() 
+                      + "，服务绑定=" + isServiceBound.get() 
+                      + "，视图就绪=" + (mRvPosition != null));
             return;
         }
 
-        // Java 7 显式初始化Adapter，传入上下文+本地位置缓存+MainService实例
+        try {
+            // 2. 基于本地缓存初始化Adapter（缓存已同步服务数据，非空）
             mPositionAdapter = new PositionAdapter(this, mLocalPosCache, mMainService);
 
-        // 设置Adapter回调（处理位置删除/保存，最终同步到MainService）
+            // 3. 设置删除回调（删除时同步服务+本地缓存+Adapter）
             mPositionAdapter.setOnDeleteClickListener(new PositionAdapter.OnDeleteClickListener() {
                 @Override
                 public void onDeleteClick(int position) {
-					// 删除逻辑：先删本地缓存，再调用MainService接口删服务数据
-					if (position < 0 || position >= mLocalPosCache.size()) {
-						LogUtils.w(TAG, "删除位置失败：无效索引=" + position);
+                    // 安全校验（索引有效+服务绑定+缓存非空）
+                    if (position < 0 || position >= mLocalPosCache.size() || !isServiceBound.get() || mMainService == null) {
+                        LogUtils.w(TAG, "删除位置失败：索引无效/服务未就绪（索引=" + position + "，缓存量=" + mLocalPosCache.size() + "）");
                         return;
                     }
+
                     PositionModel deletePos = mLocalPosCache.get(position);
                     if (deletePos != null && !deletePos.getPositionId().isEmpty()) {
-						// 1. 调用MainService接口删除服务端数据
+                        // 步骤1：调用服务删除（确保服务数据一致性）
                         mMainService.removePosition(deletePos.getPositionId());
-						// 2. 删除本地缓存数据
+                        // 步骤2：删除本地缓存（确保缓存与服务同步）
+                        synchronized (mLocalPosCache) {
                             mLocalPosCache.remove(position);
-						// 3. 通知Adapter刷新
+                        }
+                        // 步骤3：通知Adapter刷新（基于缓存操作，避免空数据）
                         mPositionAdapter.notifyItemRemoved(position);
                         showToast("删除位置成功：" + deletePos.getMemo());
-						LogUtils.d(TAG, "删除位置完成：ID=" + deletePos.getPositionId() + "（已同步MainService）");
+                        LogUtils.d(TAG, "删除位置完成：ID=" + deletePos.getPositionId() + "（服务+缓存已同步）");
                     }
                 }
             });
 
+            // 4. 设置保存回调（保存时同步服务+本地缓存+Adapter）
             mPositionAdapter.setOnSavePositionClickListener(new PositionAdapter.OnSavePositionClickListener() {
                 @Override
                 public void onSavePositionClick(int position, PositionModel updatedPos) {
-					// 保存逻辑：先更本地缓存，再调用MainService接口更新服务数据
-					if (!isServiceBound || mMainService == null) {
-						LogUtils.w(TAG, "保存位置失败：MainService未绑定");
+                    // 安全校验（索引有效+服务绑定+数据非空）
+                    if (!isServiceBound.get() || mMainService == null 
+                        || position < 0 || position >= mLocalPosCache.size() || updatedPos == null) {
+                        LogUtils.w(TAG, "保存位置失败：服务未就绪/索引无效/数据空");
                         showToast("服务未就绪，保存失败");
                         return;
                     }
-					if (position < 0 || position >= mLocalPosCache.size()) {
-						LogUtils.w(TAG, "保存位置失败：无效索引=" + position);
-						return;
-					}
 
-					// 1. 调用MainService接口更新服务端数据
+                    // 步骤1：调用服务更新（确保服务数据一致性）
                     mMainService.updatePosition(updatedPos);
-					// 2. 更新本地缓存数据
+                    // 步骤2：更新本地缓存（确保缓存与服务同步）
+                    synchronized (mLocalPosCache) {
                         mLocalPosCache.set(position, updatedPos);
-					// 3. 通知Adapter刷新（可选，Adapter已本地同步）
+                    }
+                    // 步骤3：通知Adapter刷新（基于缓存操作，避免空数据）
                     mPositionAdapter.notifyItemChanged(position);
                     showToast("保存位置成功：" + updatedPos.getMemo());
-					LogUtils.d(TAG, "保存位置完成：ID=" + updatedPos.getPositionId() + "（已同步MainService）");
+                    LogUtils.d(TAG, "保存位置完成：ID=" + updatedPos.getPositionId() + "（服务+缓存已同步）");
                 }
             });
 
-        // 设置Adapter到RecyclerView
+            // 5. 设置Adapter到RecyclerView（最后一步，确保Adapter已配置完成）
             mRvPosition.setAdapter(mPositionAdapter);
-        LogUtils.d(TAG, "PositionAdapter初始化完成（已绑定MainService）");
+            // 6. 标记Adapter已初始化（避免重复初始化）
+            isAdapterInited.set(true);
+            LogUtils.d(TAG, "PositionAdapter初始化完成（基于本地缓存，数据量=" + mLocalPosCache.size() + "）");
+
+        } catch (Exception e) {
+            LogUtils.d(TAG, "Adapter初始化失败：" + e.getMessage());
+            isAdapterInited.set(false);
+            mPositionAdapter = null;
+            showToast("位置列表初始化失败，请重试");
+        }
     }
 
     /**
-     * 显示Toast（Java 7 显式Toast.makeText）
+     * 显示Toast（Java 7 显式Toast.makeText，避免空Context）
      */
     private void showToast(String content) {
+        if (isFinishing() || isDestroyed()) { // 避免Activity销毁后弹Toast崩溃
+            LogUtils.w(TAG, "Activity已销毁，跳过Toast：" + content);
+            return;
+        }
         Toast.makeText(this, content, Toast.LENGTH_SHORT).show();
     }
 	
+	// ---------------------- 页面交互（新增位置逻辑保留，适配GPS数据） ----------------------
+    /**
+     * 新增位置（调用服务addPosition()，可选：用当前GPS位置初始化新位置）
+     */
+    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 (!isServiceBound.get() || mMainService == null) {
+            LogUtils.w(TAG, "新增位置失败：MainService未绑定");
+            showToast("服务未就绪，无法新增位置");
+            return;
+        }
+
+        // 3. 创建新位置模型（优化：优先用当前GPS位置初始化，无则用默认值）
+        PositionModel newPos = new PositionModel();
+        newPos.setPositionId(PositionModel.genPositionId()); // 生成唯一ID（需PositionModel实现）
+        if (mCurrentGpsPos != null) {
+            newPos.setLongitude(mCurrentGpsPos.getLongitude());
+            newPos.setLatitude(mCurrentGpsPos.getLatitude());
+            newPos.setMemo("当前GPS位置（可编辑）");
+        } else {
+            newPos.setLongitude(116.404267); // 北京经度（默认值）
+            newPos.setLatitude(39.915119);  // 北京纬度（默认值）
+            newPos.setMemo("默认位置（可编辑备注）");
+        }
+        newPos.setIsSimpleView(true);   // 默认简单视图
+        newPos.setIsEnableRealPositionDistance(true); // 启用距离计算（依赖GPS）
+
+        // 4. 调用服务新增+同步本地缓存（确保缓存与服务一致）
+        mMainService.addPosition(newPos);
+        synchronized (mLocalPosCache) {
+            mLocalPosCache.add(newPos);
+        }
+        LogUtils.d(TAG, "通过服务新增位置：ID=" + newPos.getPositionId() + "，纬度=" + newPos.getLatitude() + "（缓存已同步）");
+
+        // 5. 刷新Adapter（基于缓存操作，确保数据立即显示）
+        if (isAdapterInited.get() && mPositionAdapter != null) {
+            mPositionAdapter.notifyItemInserted(mLocalPosCache.size() - 1);
+        }
+        showToast("新增位置成功（已启用GPS距离计算）");
+    }
+
+	// ---------------------- 新增：GPS监听初始化+注册/反注册（核心适配逻辑） ----------------------
+    /**
+     * 初始化GPS监听：实现MainService.GpsUpdateListener，接收实时GPS数据
+     */
+    private void initGpsUpdateListener() {
+        LogUtils.d(TAG, "initGpsUpdateListener()");
+        mGpsUpdateListener = new MainService.GpsUpdateListener() {
+            @Override
+            public void onGpsPositionUpdated(PositionModel currentGpsPos) {
+                if (currentGpsPos == null || isFinishing() || isDestroyed()) {
+                    LogUtils.w(TAG, "GPS位置更新：数据为空或Activity已销毁");
+                    return;
+                }
+                // 缓存当前GPS位置（供页面其他逻辑使用）
+                mCurrentGpsPos = currentGpsPos;
+                LogUtils.d(TAG, String.format("收到GPS更新：纬度=%.4f，经度=%.4f"
+                                              , currentGpsPos.getLatitude(), currentGpsPos.getLongitude()));
+                // 安全更新UI（避免Activity销毁后操作视图崩溃）
+                ((TextView)findViewById(R.id.tv_latitude)).setText(String.format("当前纬度：%f", currentGpsPos.getLatitude()));
+                ((TextView)findViewById(R.id.tv_longitude)).setText(String.format("当前经度：%f", currentGpsPos.getLongitude()));
+            }
+
+            @Override
+            public void onGpsStatusChanged(String status) {
+                if (status == null || isFinishing() || isDestroyed()) return;
+                LogUtils.d(TAG, "GPS状态变化：" + status);
+                if (status.contains("未开启") || status.contains("权限") || status.contains("失败")) {
+                    ToastUtils.show("GPS提示：" + status);
+                }
+            }
+        };
+    }
+
+	/**
+     * 注册GPS监听：调用MainService的PUBLIC方法，绑定监听
+     */
+    private void registerGpsListener() {
+        // 安全校验（避免Activity销毁/服务未绑定/监听为空时注册）
+        if (isFinishing() || isDestroyed() || !isServiceBound.get() || mMainService == null || mGpsUpdateListener == null) {
+            LogUtils.w(TAG, "GPS监听注册跳过：Activity状态异常/依赖未就绪");
+            return;
+        }
+        try {
+            mMainService.registerGpsUpdateListener(mGpsUpdateListener);
+            LogUtils.d(TAG, "GPS监听已注册");
+        } catch (Exception e) {
+            LogUtils.d(TAG, "GPS监听注册失败：" + e.getMessage());
+        }
+    }
+
+    /**
+     * 反注册GPS监听：调用MainService的PUBLIC方法，解绑监听（核心防内存泄漏+数据异常）
+     */
+    private void unregisterGpsListener() {
+        // 避免Activity销毁后调用服务方法（防止空指针/服务已解绑）
+        if (mMainService == null || mGpsUpdateListener == null) {
+            LogUtils.w(TAG, "GPS监听反注册跳过：服务/监听未初始化");
+            return;
+        }
+        try {
+            mMainService.unregisterGpsUpdateListener(mGpsUpdateListener);
+            LogUtils.d(TAG, "GPS监听已反注册");
+        } catch (Exception e) {
+            LogUtils.d(TAG, "GPS监听反注册失败：" + e.getMessage());
+        }
+    }
+
+    /**
+     * 页面可见时同步数据（解决快速切回时数据未更新问题）
+     * 场景：快速关闭再打开Activity，服务已绑定但数据未重新同步
+     */
+    @Override
+    protected void onResume() {
+        super.onResume();
+        // 1. 服务已绑定但Adapter未初始化：重新同步数据+初始化Adapter
+        if (isServiceBound.get() && mMainService != null && !isAdapterInited.get()) {
+            LogUtils.d(TAG, "onResume：服务已绑定但Adapter未初始化，重新同步数据");
+            syncDataFromMainService();
+            initPositionAdapter();
+        }
+        // 2. 服务已绑定且Adapter已初始化：刷新数据（确保与服务同步）
+        else if (isServiceBound.get() && mMainService != null && isAdapterInited.get() && mPositionAdapter != null) {
+            syncDataFromMainService();
+            mPositionAdapter.notifyDataSetChanged();
+            LogUtils.d(TAG, "onResume：刷新位置数据（与服务同步）");
+        }
+    }
+
+    /**
+     * 页面不可见时暂停操作（避免后台操作导致数据异常）
+     */
+    @Override
+    protected void onPause() {
+        super.onPause();
+        // 避免后台时仍执行UI刷新（如GPS更新触发的视图操作）
+        LogUtils.d(TAG, "onPause：页面不可见，暂停UI相关操作");
+    }
+
     @Override
     protected void onDestroy() {
         super.onDestroy();
+        LogUtils.d(TAG, "onDestroy：开始释放资源");
 
-        // 1. 释放Adapter资源（反注册服务监听，避免内存泄漏）
+        // 1. 反注册GPS监听（优先执行，避免服务持有Activity引用导致内存泄漏）
+        unregisterGpsListener();
+
+        // 2. 释放Adapter资源（反注册可能的监听，避免内存泄漏）
         if (mPositionAdapter != null) {
             mPositionAdapter.release();
+            mPositionAdapter = null; // 清空引用，帮助GC回收
+            LogUtils.d(TAG, "Adapter资源已释放");
         }
 
-        // 2. 解绑MainService（避免Activity销毁后服务仍被持有）
-        if (isServiceBound) {
+        // 3. 解绑MainService（最后执行，确保其他资源已释放）
+        if (isServiceBound.get()) {
+            try {
                 unbindService(mServiceConnection);
                 LogUtils.d(TAG, "MainService解绑完成");
+            } catch (IllegalArgumentException e) {
+                // 捕获“服务未绑定”异常（快速开关时可能出现，避免崩溃）
+                LogUtils.d(TAG, "解绑MainService失败：服务未绑定（可能已提前解绑）");
             }
+            // 重置绑定状态+服务引用
+            isServiceBound.set(false);
+            mMainService = null;
         }
 
-	public static class LocalBinder extends android.os.Binder {
-        // 持有 MainService 实例引用
-        private MainService mService;
-
-        // 构造时传入服务实例
-        public LocalBinder(MainService service) {
-            this.mService = service;
+        // 4. 清空本地缓存+GPS引用（帮助GC回收）
+        synchronized (mLocalPosCache) {
+            mLocalPosCache.clear();
+        }
+        mCurrentGpsPos = null;
+        mGpsUpdateListener = null;
+        isAdapterInited.set(false);
+        LogUtils.d(TAG, "所有资源释放完成（onDestroy执行结束）");
     }
 
-        // 对外提供获取服务实例的方法（供Activity调用）
-        public MainService getService() {
-            return mService;
-        }
-    }
+    // ---------------------- 移除重复定义：LocalBinder 统一在 MainService 中定义 ----------------------
+    // 说明：原LocationActivity中的LocalBinder是重复定义（MainService已实现），会导致类型强转失败
+    // 此处删除该类，确保Activity绑定服务时强转的是MainService中的LocalBinder
 }
 
+

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

@@ -3,9 +3,19 @@ package cc.winboll.studio.positions.adapters;
 /**
  * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
  * @Date 2025/09/29 20:25
- * @Describe 位置数据适配器（完全独立，无未知接口依赖，仅用LocationActivity缓存数据）
+ * @Describe 位置数据适配器（修复视图复用资源加载，支持滚动后重新绑定数据，Java 7语法适配）
+ */
+
+
+/**
+ * Java 7 语法严格适配 + 视图复用资源加载修复：
+ * 1. 保留无Lambda/弱引用/线程安全集合等原有适配
+ * 2. 修复核心问题：移除 onViewDetachedFromWindow 中关键资源释放，改为 onBind 时重新绑定
+ * 3. 强化资源复用：任务视图/距离控件在复用后自动从服务同步最新数据，确保滚动后数据不丢失
+ * 4. 优化缓存逻辑：仅清理脱离屏幕且无效的控件缓存，有效控件保留引用供局部更新（如距离）
  */
 import android.content.Context;
+import android.text.TextUtils;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
@@ -14,36 +24,26 @@ import android.widget.Button;
 import android.widget.EditText;
 import android.widget.RadioGroup;
 import android.widget.TextView;
-import android.text.TextUtils;
 import androidx.recyclerview.widget.RecyclerView;
-
 import cc.winboll.studio.libappbase.LogUtils;
 import cc.winboll.studio.positions.R;
 import cc.winboll.studio.positions.models.PositionModel;
 import cc.winboll.studio.positions.models.PositionTaskModel;
 import cc.winboll.studio.positions.services.MainService;
-
+import cc.winboll.studio.positions.views.PositionTaskListView;
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
-import java.util.ConcurrentModificationException;
 import java.util.Iterator;
 import java.util.concurrent.ConcurrentHashMap;
 
-/**
- * Java 7 语法适配：
- * 1. 移除 Lambda/方法引用，用匿名内部类替代
- * 2. 集合操作使用迭代器（避免 ConcurrentModificationException）
- * 3. 弱引用管理 MainService，避免内存泄漏
- * 4. 所有任务数据从 MainService 获取，更新通过 MainService 接口
- */
 public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> implements MainService.TaskUpdateListener {
     public static final String TAG = "PositionAdapter";
 
-    // 视图类型常量（Java 7 静态常量定义）
+    // 视图类型常量（静态常量统一管理）
     private static final int VIEW_TYPE_SIMPLE = 0;
     private static final int VIEW_TYPE_EDIT = 1;
 
-    // 默认配置常量（统一管理，避免魔法值）
+    // 默认配置常量（避免魔法值）
     private static final String DEFAULT_MEMO = "无备注";
     private static final String DEFAULT_TASK_DESC = "新任务";
     private static final int DEFAULT_TASK_DISTANCE = 50; // 单位：米
@@ -51,13 +51,17 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
     private static final String DISTANCE_DISABLED = "实时距离：未启用";
     private static final String DISTANCE_ERROR = "实时距离：计算失败";
 
-    // 核心依赖（Java 7 弱引用+集合定义）
+    // 核心依赖（弱引用+线程安全集合，适配Java 7）
     private final Context mContext;
-    private final ArrayList<PositionModel> mCachedPositionList; // 位置缓存（从Activity传入，最终需与MainService同步）
-    private final WeakReference<MainService> mMainServiceRef;   // 弱引用MainService，避免内存泄漏
-    private final ConcurrentHashMap<String, TextView> mPosDistanceViewMap; // 距离控件缓存（优化UI更新）
+    private final ArrayList<PositionModel> mCachedPositionList; // 位置缓存（与MainService同步）
+    private final WeakReference<MainService> mMainServiceRef;   // 弱引用MainService，防内存泄漏
+    // 控件缓存：位置ID → 对应任务列表视图（分别缓存简单/编辑模式，支持复用后快速同步）
+    private final ConcurrentHashMap<String, PositionTaskListView> mSimpleTaskViewMap;
+    private final ConcurrentHashMap<String, PositionTaskListView> mEditTaskViewMap;
+    // 距离控件缓存（用于局部更新距离UI，保留有效引用避免复用后更新失效）
+    private final ConcurrentHashMap<String, TextView> mPosDistanceViewMap;
 
-    // 回调接口（与Activity交互，仅处理位置逻辑，任务逻辑直接调用MainService）
+    // 回调接口（仅处理位置逻辑，任务逻辑通过PositionTaskListView+MainService完成）
     public interface OnDeleteClickListener {
         void onDeleteClick(int position);
     }
@@ -70,34 +74,35 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
     private OnSavePositionClickListener mOnSavePosListener;
 
     // =========================================================================
-    // 构造函数（Java 7 风格：初始化依赖+注册任务监听）
+    // 构造函数（初始化依赖+注册服务监听+初始化控件缓存）
     // =========================================================================
     public PositionAdapter(Context context, ArrayList<PositionModel> cachedPositionList, MainService mainService) {
         this.mContext = context;
         // 容错处理：避免传入null导致空指针
         this.mCachedPositionList = (cachedPositionList != null) ? cachedPositionList : new ArrayList<PositionModel>();
-        // 弱引用MainService：防止Adapter持有Service导致内存泄漏（Java 7 弱引用语法）
+        // 弱引用MainService：防止Adapter持有服务导致内存泄漏（Java 7 弱引用语法）
         this.mMainServiceRef = new WeakReference<MainService>(mainService);
-        // 初始化距离控件缓存（线程安全集合，适配多线程更新场景）
+        // 初始化控件缓存（线程安全集合，适配多线程更新场景）
+        this.mSimpleTaskViewMap = new ConcurrentHashMap<String, PositionTaskListView>();
+        this.mEditTaskViewMap = new ConcurrentHashMap<String, PositionTaskListView>();
         this.mPosDistanceViewMap = new ConcurrentHashMap<String, TextView>();
 
-        // 注册MainService任务监听：服务任务变化时自动刷新Adapter（Java 7 接口实现）
+        // 注册MainService任务监听：服务任务变化时同步刷新任务列表视图
         if (mainService != null) {
             mainService.registerTaskUpdateListener(this);
             LogUtils.d(TAG, "已注册MainService任务监听，确保任务数据与服务同步");
         } else {
-            LogUtils.w(TAG, "构造函数：MainService为空，任务数据无法同步");
+            LogUtils.w(TAG, "构造函数：MainService为空，PositionTaskListView无法初始化");
         }
 
         LogUtils.d(TAG, "Adapter初始化完成：位置数量=" + mCachedPositionList.size());
     }
 
     // =========================================================================
-    // RecyclerView 核心方法（Java 7 语法适配）
+    // RecyclerView 核心方法（强化视图复用逻辑，复用后自动重新绑定资源）
     // =========================================================================
     @Override
     public int getItemViewType(int position) {
-        // 从位置缓存获取状态，判断视图类型（简单/编辑）
         PositionModel posModel = getPositionByIndex(position);
         return (posModel != null && posModel.isSimpleView()) ? VIEW_TYPE_SIMPLE : VIEW_TYPE_EDIT;
     }
@@ -105,7 +110,6 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
     @Override
     public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
         LayoutInflater inflater = LayoutInflater.from(mContext);
-        // 根据视图类型加载对应布局（Java 7 条件判断）
         if (viewType == VIEW_TYPE_SIMPLE) {
             View simpleView = inflater.inflate(R.layout.item_position_simple, parent, false);
             return new SimpleViewHolder(simpleView);
@@ -122,65 +126,101 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
             LogUtils.w(TAG, "onBindViewHolder：位置模型为空（索引=" + position + "），跳过绑定");
             return;
         }
-        String posId = posModel.getPositionId();
+        final String posId = posModel.getPositionId();
+        MainService mainService = mMainServiceRef.get();
 
-        // 按视图类型绑定数据（Java 7 类型判断）
+        // 按视图类型绑定数据（简单模式/编辑模式）—— 核心修复：复用后重新绑定所有资源
         if (holder instanceof SimpleViewHolder) {
-            bindSimpleView((SimpleViewHolder) holder, posModel);
-        } else if (holder instanceof EditViewHolder) {
-            bindEditView((EditViewHolder) holder, posModel, position);
-        }
+            LogUtils.d(TAG, "instanceof SimpleViewHolder（复用/新创建）：位置ID=" + posId);
+            SimpleViewHolder simpleHolder = (SimpleViewHolder) holder;
+            // 1. 重新绑定位置基础数据（经纬度/备注/距离，确保复用后显示最新数据）
+            bindSimplePositionData(simpleHolder, posModel);
+            // 2. 重新初始化+绑定简单模式任务视图（复用后从服务同步最新任务，避免数据丢失）
+            initAndBindSimpleTaskView(simpleHolder.ptlvSimpleTasks, posId, mainService);
+            // 3. 缓存/更新简单模式任务视图+距离控件（覆盖旧缓存，确保引用最新控件）
+            mSimpleTaskViewMap.put(posId, simpleHolder.ptlvSimpleTasks);
+            mPosDistanceViewMap.put(posId, simpleHolder.tvSimpleDistance);
 
-        // 缓存当前位置的距离控件（后续局部更新距离时直接使用）
-        TextView distanceView = (holder instanceof SimpleViewHolder)
-			? ((SimpleViewHolder) holder).tvSimpleDistance
-			: ((EditViewHolder) holder).tvEditDistance;
-        if (distanceView != null && !TextUtils.isEmpty(posId)) {
-            mPosDistanceViewMap.put(posId, distanceView);
+        } else if (holder instanceof EditViewHolder) {
+            LogUtils.d(TAG, "instanceof EditViewHolder（复用/新创建）：位置ID=" + posId);
+            EditViewHolder editHolder = (EditViewHolder) holder;
+            // 1. 重新绑定位置基础数据（经纬度/备注/距离/距离开关，复用后显示最新状态）
+            bindEditPositionData(editHolder, posModel, position);
+            // 2. 重新初始化+绑定编辑模式任务视图（复用后同步服务最新任务，支持增删改）
+            initAndBindEditTaskView(editHolder.ptlvEditTasks, posId, mainService, editHolder.btnAddTask);
+            // 3. 缓存/更新编辑模式任务视图+距离控件（覆盖旧缓存，确保引用最新控件）
+            mEditTaskViewMap.put(posId, editHolder.ptlvEditTasks);
+            mPosDistanceViewMap.put(posId, editHolder.tvEditDistance);
         }
     }
 
     @Override
     public void onViewDetachedFromWindow(RecyclerView.ViewHolder holder) {
         super.onViewDetachedFromWindow(holder);
-        // 视图离开屏幕时，移除距离控件缓存（避免内存泄漏+引用失效控件）
+        // 核心修改：仅清理「无效/已回收」的控件缓存，不释放关键资源（支持复用后重新绑定）
         PositionModel posModel = getPositionByIndex(holder.getAdapterPosition());
-        if (posModel != null && !TextUtils.isEmpty(posModel.getPositionId())) {
-            mPosDistanceViewMap.remove(posModel.getPositionId());
-            LogUtils.d(TAG, "视图脱离屏幕：移除位置ID=" + posModel.getPositionId() + "的距离控件缓存");
+        if (posModel == null || TextUtils.isEmpty(posModel.getPositionId())) {
+            return;
+        }
+        String posId = posModel.getPositionId();
+
+        // 1. 清理「已脱离视图树/无效」的距离控件缓存（保留有效控件供局部更新）
+        if (mPosDistanceViewMap.containsKey(posId)) {
+            TextView distanceView = mPosDistanceViewMap.get(posId);
+            if (distanceView == null || !distanceView.isAttachedToWindow()) {
+                mPosDistanceViewMap.remove(posId);
+                LogUtils.d(TAG, "视图脱离屏幕：移除无效距离控件缓存（位置ID=" + posId + "）");
+            }
+        }
+
+        // 2. 清理「已脱离视图树/无效」的简单模式任务视图缓存（不解绑监听/不清空数据，复用后重新同步）
+        if (holder instanceof SimpleViewHolder && mSimpleTaskViewMap.containsKey(posId)) {
+            PositionTaskListView taskView = mSimpleTaskViewMap.get(posId);
+            if (taskView == null || !taskView.isAttachedToWindow()) {
+                mSimpleTaskViewMap.remove(posId);
+                LogUtils.d(TAG, "简单模式视图脱离屏幕：移除无效任务视图缓存（位置ID=" + posId + "）");
+            }
+        }
+
+        // 3. 清理「已脱离视图树/无效」的编辑模式任务视图缓存（同上，保留数据供复用）
+        if (holder instanceof EditViewHolder && mEditTaskViewMap.containsKey(posId)) {
+            PositionTaskListView taskView = mEditTaskViewMap.get(posId);
+            if (taskView == null || !taskView.isAttachedToWindow()) {
+                mEditTaskViewMap.remove(posId);
+                LogUtils.d(TAG, "编辑模式视图脱离屏幕：移除无效任务视图缓存（位置ID=" + posId + "）");
+            }
         }
     }
 
     @Override
     public int getItemCount() {
-        // 直接从位置缓存获取数量（数据源唯一）
         return mCachedPositionList.size();
     }
 
     // =========================================================================
-    // 视图绑定逻辑（Java 7 风格：任务数据从MainService获取）
+    // 位置数据绑定（保留原有逻辑，确保复用后数据最新）
     // =========================================================================
     /**
-     * 绑定简单视图（仅显示数据，点击切换到编辑视图）
+     * 绑定简单模式位置数据（仅显示，无编辑操作）—— 复用后重新执行，显示最新数据
      */
-    private void bindSimpleView(final SimpleViewHolder holder, final PositionModel posModel) {
-        // 1. 显示经纬度（Java 7 String.format格式化）
+    private void bindSimplePositionData(SimpleViewHolder holder, final PositionModel posModel) {
+        // 1. 经纬度显示（保留6位小数，格式统一）
         holder.tvSimpleLon.setText(String.format("经度：%.6f", posModel.getLongitude()));
         holder.tvSimpleLat.setText(String.format("纬度：%.6f", posModel.getLatitude()));
 
-        // 2. 显示备注（无备注时显示默认文本）
+        // 2. 备注显示（无备注时显示默认文本）
         String memo = posModel.getMemo();
         holder.tvSimpleMemo.setText("备注：" + (TextUtils.isEmpty(memo) ? DEFAULT_MEMO : memo));
 
-        // 3. 显示实时距离（从位置模型取数，调用工具方法更新显示）
+        // 3. 实时距离显示（按状态区分文本+颜色——复用后重新计算显示最新距离）
         updateDistanceDisplay(holder.tvSimpleDistance, posModel);
 
-        // 4. 点击切换到编辑视图（Java 7 匿名内部类实现点击事件）
+        // 4. 点击切换到编辑模式
         holder.itemView.setOnClickListener(new View.OnClickListener() {
 				@Override
 				public void onClick(View v) {
-					posModel.setIsSimpleView(false); // 修改位置缓存状态
-					// 通知RecyclerView刷新当前项（精准更新，避免全量刷新）
+					posModel.setIsSimpleView(false);
+					// 精准刷新当前项（避免全量刷新）
 					notifyItemChanged(getPositionIndexById(posModel.getPositionId()));
 					LogUtils.d(TAG, "简单视图点击：位置ID=" + posModel.getPositionId() + "，切换到编辑视图");
 				}
@@ -188,159 +228,181 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
     }
 
     /**
-     * 绑定编辑视图（支持修改备注、开关距离、删除/保存位置、新增任务）
+     * 绑定编辑模式位置数据（支持备注修改/距离开关/删除/保存）—— 复用后重新执行，恢复编辑状态
      */
-    private void bindEditView(final EditViewHolder holder, final PositionModel posModel, final int position) {
+    private void bindEditPositionData(final EditViewHolder holder, final PositionModel posModel, final int position) {
         final String posId = posModel.getPositionId();
 
-        // 1. 显示经纬度（不可编辑，仅展示）
+        // 1. 经纬度显示（不可编辑，仅展示）
         holder.tvEditLon.setText(String.format("经度：%.6f", posModel.getLongitude()));
         holder.tvEditLat.setText(String.format("纬度：%.6f", posModel.getLatitude()));
 
-        // 2. 显示备注（编辑框赋值，光标定位到末尾）
+        // 2. 备注编辑（填充现有备注，光标定位到末尾——复用后恢复输入状态）
         String memo = posModel.getMemo();
         if (!TextUtils.isEmpty(memo)) {
             holder.etEditMemo.setText(memo);
-            holder.etEditMemo.setSelection(memo.length()); // 光标定位到文本末尾
+            holder.etEditMemo.setSelection(memo.length());
         } else {
-            holder.etEditMemo.setText(""); // 无备注时清空编辑框
+            holder.etEditMemo.setText("");
         }
 
-        // 3. 显示实时距离（与简单视图逻辑一致）
+        // 3. 实时距离显示（与简单模式逻辑一致——复用后显示最新距离）
         updateDistanceDisplay(holder.tvEditDistance, posModel);
 
-        // 4. 设置距离开关状态（匹配位置缓存中的启用状态）
+        // 4. 距离开关状态（匹配位置模型中的启用状态——复用后恢复开关状态）
         holder.rgDistanceSwitch.check(posModel.isEnableRealPositionDistance()
 									  ? R.id.rb_distance_enable
 									  : R.id.rb_distance_disable);
 
-        // 5. 取消编辑：切换回简单视图（Java 7 匿名内部类）
+        // 5. 取消编辑：切换回简单模式+隐藏软键盘
         holder.btnCancel.setOnClickListener(new View.OnClickListener() {
 				@Override
 				public void onClick(View v) {
 					posModel.setIsSimpleView(true);
 					notifyItemChanged(position);
-					hideSoftKeyboard(v); // 隐藏软键盘（提升用户体验）
+					hideSoftKeyboard(v);
 					LogUtils.d(TAG, "取消编辑：位置ID=" + posId + "，切换回简单视图");
 				}
 			});
 
-        // 6. 删除位置：回调Activity处理（Adapter不直接删数据，由Activity同步MainService）
+        // 6. 删除位置：回调Activity处理（Adapter不直接操作数据）
         holder.btnDelete.setOnClickListener(new View.OnClickListener() {
 				@Override
 				public void onClick(View v) {
 					if (mOnDeleteListener != null) {
-						mOnDeleteListener.onDeleteClick(position); // 通知Activity删除指定索引
+						mOnDeleteListener.onDeleteClick(position);
 					}
 					hideSoftKeyboard(v);
 					LogUtils.d(TAG, "触发删除：通知Activity处理位置ID=" + posId + "的删除逻辑");
 				}
 			});
 
-        // 7. 保存位置：回调Activity保存（收集参数→构建更新模型→通知Activity）
+        // 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);                 // 切换回简单视图
+					updatedPos.setPositionId(posId);
+					updatedPos.setLongitude(posModel.getLongitude());
+					updatedPos.setLatitude(posModel.getLatitude());
+					updatedPos.setMemo(newMemo);
+					updatedPos.setIsEnableRealPositionDistance(isDistanceEnable);
+					updatedPos.setIsSimpleView(true);
 
-					// 回调Activity保存（由Activity同步MainService+位置缓存，Adapter不处理逻辑）
+					// 回调Activity保存（由Activity同步MainService）
 					if (mOnSavePosListener != null) {
 						mOnSavePosListener.onSavePositionClick(position, updatedPos);
 					}
 
-					// 本地同步状态（避免刷新延迟，直接修改位置缓存）
+					// 本地同步状态（避免刷新延迟）
 					posModel.setMemo(newMemo);
 					posModel.setIsEnableRealPositionDistance(isDistanceEnable);
 					posModel.setIsSimpleView(true);
-					notifyItemChanged(position); // 刷新当前项，显示更新后的状态
+					notifyItemChanged(position);
 					hideSoftKeyboard(v);
-					LogUtils.d(TAG, "触发保存：位置ID=" + posId + "，新备注=" + newMemo + "，距离启用=" + isDistanceEnable);
+					LogUtils.d(TAG, "保存位置：ID=" + posId + "，新备注=" + newMemo + "，距离启用=" + isDistanceEnable);
 				}
 			});
-
-        // 8. 绑定任务视图（显示任务数量+新增任务，数据从MainService获取）
-        bindTaskView(holder, posId);
     }
 
+    // =========================================================================
+    // PositionTaskListView 集成（强化复用逻辑：复用后重新同步服务数据，确保数据不丢失）
+    // =========================================================================
     /**
-     * 绑定任务视图（编辑模式专属：从MainService获取任务数据，新增任务调用服务接口）
+     * 初始化+绑定简单模式任务列表视图——复用后重新执行，从服务同步最新任务
      */
-    private void bindTaskView(final EditViewHolder holder, final String posId) {
-        // 1. 从MainService获取当前位置的任务数量（Java 7 迭代器遍历服务数据）
-        int taskCount = 0;
-        MainService mainService = mMainServiceRef.get();
-        if (mainService != null) {
-            ArrayList<PositionTaskModel> posTasks = mainService.getTasksByPositionId(posId);
-            taskCount = (posTasks != null) ? posTasks.size() : 0;
-        }
-        // 显示任务数量（简化设计，实际可扩展为任务列表）
-        holder.tvTaskCount.setText("任务数量：" + taskCount);
-
-        // 2. 新增任务：调用MainService接口（不操作本地缓存，数据直接写入服务）
-        holder.btnAddTask.setOnClickListener(new View.OnClickListener() {
-				@Override
-				public void onClick(View v) {
-					MainService mainService = mMainServiceRef.get();
-					if (mainService == null) {
-						LogUtils.e(TAG, "新增任务失败：MainService已回收（弱引用失效）");
+    private void initAndBindSimpleTaskView(PositionTaskListView taskView, final String posId, MainService mainService) {
+        if (taskView == null || TextUtils.isEmpty(posId) || mainService == null) {
+            LogUtils.w(TAG, "初始化简单模式任务视图失败：参数无效（posId=" + posId + "，service=" + mainService + "）");
             return;
         }
 
-					// 构建默认任务模型（Java 7 显式初始化）
-					PositionTaskModel newTask = new PositionTaskModel();
-					newTask.setTaskId(PositionTaskModel.genTaskId()); // 生成唯一任务ID（需在PositionTaskModel实现静态方法）
-					newTask.setPositionId(posId);                     // 绑定当前位置ID
-					newTask.setTaskDescription(DEFAULT_TASK_DESC);    // 默认任务描述
-					newTask.setIsEnable(true);                        // 默认启用任务
-					newTask.setDiscussDistance(DEFAULT_TASK_DISTANCE);// 默认任务距离（50米）
+        // 1. 初始化任务视图（绑定MainService+当前位置ID——复用后重新绑定，确保服务引用有效）
+        taskView.init(mainService, posId);
+        // 2. 设置为简单模式（仅展示，隐藏编辑按钮——复用后恢复视图模式）
+        taskView.setViewStatus(PositionTaskListView.VIEW_MODE_SIMPLE);
+		// 3. 关键：复用后强制从服务同步最新任务（避免显示旧数据，核心修复点）
+		taskView.syncTasksFromMainService();
 
-					// 调用MainService接口新增任务（数据写入服务，由服务处理持久化+通知刷新）
-					mainService.addPositionTask(newTask);
-					hideSoftKeyboard(v);
-					LogUtils.d(TAG, "触发新增任务：调用MainService接口，位置ID=" + posId + "，任务ID=" + newTask.getTaskId());
+		// 4. 任务更新回调（服务任务变化时重新同步——复用后重新绑定回调，避免监听失效）
+		taskView.setOnTaskUpdatedListener(new PositionTaskListView.OnTaskUpdatedListener() {
+				@Override
+				public void onTaskUpdated(String positionId, ArrayList updatedTasks) {
+					LogUtils.d(TAG, "简单模式任务更新：位置ID=" + positionId + "，已启用任务数=" + updatedTasks.size());
 				}
 			});
+
+		LogUtils.d(TAG, "初始化/复用简单模式任务视图完成：位置ID=" + posId);
+	}
+
+	/**
+	 - 初始化+绑定编辑模式任务列表视图——复用后重新执行，从服务同步最新任务+恢复编辑功能
+	 */
+	private void initAndBindEditTaskView(final PositionTaskListView taskView, final String posId,
+										 MainService mainService, Button btnAddTask) {
+		if (taskView == null || TextUtils.isEmpty(posId) || mainService == null || btnAddTask == null) {
+			LogUtils.w(TAG, "初始化编辑模式任务视图失败：参数无效（posId=" + posId + "，btnAddTask=" + btnAddTask + "）");
+			return;
+		}
+		// 1. 初始化任务视图（绑定MainService+当前位置ID——复用后重新绑定，确保服务引用有效）
+		taskView.init(mainService, posId);
+		// 2. 设置为编辑模式（显示编辑/删除按钮——复用后恢复视图模式）
+		taskView.setViewStatus(PositionTaskListView.VIEW_MODE_EDIT);
+		// 3. 关键：复用后强制从服务同步最新任务（避免显示旧数据，核心修复点）
+		taskView.syncTasksFromMainService();// 4. 绑定“新增任务”按钮逻辑（复用后重新绑定点击事件，避免按钮点击失效）
+		btnAddTask.setOnClickListener(new View.OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					// 构建默认任务模型（关联当前位置ID，使用默认配置）
+					PositionTaskModel newTask = new PositionTaskModel();
+					newTask.setTaskId(PositionTaskModel.genTaskId()); // 生成唯一任务ID（需模型类实现）
+					newTask.setPositionId(posId);                     // 绑定当前位置
+					newTask.setTaskDescription(DEFAULT_TASK_DESC);    // 默认描述
+					newTask.setDiscussDistance(DEFAULT_TASK_DISTANCE); // 默认触发距离（50米）
+					newTask.setIsEnable(true);                        // 默认启用
+					newTask.setIsBingo(false);                        // 初始未触发// 调用任务视图的新增方法（假设视图已实现addNewTask，内部同步MainService）
+					taskView.addNewTask(newTask);
+					hideSoftKeyboard(v); // 隐藏软键盘，提升体验
+					LogUtils.d(TAG, "编辑模式新增任务：位置ID=" + posId + "，任务ID=" + newTask.getTaskId());
+				}
+			});// 5. 任务更新回调（通知外部任务变化——复用后重新绑定回调，确保交互正常）
+		taskView.setOnTaskUpdatedListener(new PositionTaskListView.OnTaskUpdatedListener() {
+				@Override
+				public void onTaskUpdated(String positionId, ArrayList updatedTasks) {
+					LogUtils.d(TAG, "编辑模式任务更新：位置ID=" + positionId + "，当前任务数=" + updatedTasks.size());
+				}
+			});
+			LogUtils.d(TAG, "初始化/复用编辑模式任务视图完成：位置ID=" + posId);
 	}
 
 	// =========================================================================
-    // 工具方法（Java 7 风格：无Lambda，纯匿名内部类+迭代器）
+	// 工具方法（保留原有逻辑，适配资源复用场景）
 	// =========================================================================
 	/**
-     * 更新距离显示（根据位置模型状态，显示不同文本+颜色）
+
+	 - 更新距离显示（复用后重新执行，确保显示最新距离+颜色——适配资源复用）
 	 */
 	private void updateDistanceDisplay(TextView distanceView, PositionModel posModel) {
 		if (distanceView == null || posModel == null) {
-            LogUtils.w(TAG, "updateDistanceDisplay：参数为空（控件/位置模型）");
+			LogUtils.w(TAG, "更新距离显示失败：参数为空（控件/位置模型）");
 			return;
-        }
-
-        // 场景1：距离未启用
+		}// 场景1：距离未启用（灰色文本）
 		if (!posModel.isEnableRealPositionDistance()) {
 			distanceView.setText(DISTANCE_DISABLED);
 			distanceView.setTextColor(mContext.getResources().getColor(R.color.gray));
 			return;
-        }
-
-        // 场景2：距离计算失败（用-1标记失败状态）
+		}// 场景2：距离计算失败（红色文本，用-1标记失败状态）
 		double distance = posModel.getRealPositionDistance();
 		if (distance < 0) {
 			distanceView.setText(DISTANCE_ERROR);
 			distanceView.setTextColor(mContext.getResources().getColor(R.color.red));
 			return;
-        }
-
-        // 场景3：正常显示距离（按距离范围设置颜色，提升视觉区分度）
+		}// 场景3：正常显示距离（按距离范围设置颜色——复用后重新计算颜色）
 		distanceView.setText(String.format(DISTANCE_FORMAT, distance));
 		if (distance <= 100) {
 			distanceView.setTextColor(mContext.getResources().getColor(R.color.green)); // 近距离（≤100米）
@@ -352,121 +414,201 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
 	}
 
 	/**
-     * 根据索引获取位置模型（从位置缓存取数，容错处理）
+
+	 - 根据索引获取位置模型（容错处理，避免越界/空指针——适配复用后索引变化场景）
 	 */
 	private PositionModel getPositionByIndex(int index) {
 		if (mCachedPositionList == null || index < 0 || index >= mCachedPositionList.size()) {
-            LogUtils.w(TAG, "getPositionByIndex：无效索引（" + index + "）或位置缓存为空");
+			LogUtils.w(TAG, "获取位置模型失败：无效索引（" + index + "）或缓存为空");
 			return null;
 		}
 		return mCachedPositionList.get(index);
 	}
 
 	/**
-     * 根据位置ID获取列表索引（用于精准刷新视图）
+
+	 - 根据位置ID获取列表索引（用于精准刷新视图——适配复用后视图位置变化）
 	 */
 	private int getPositionIndexById(String positionId) {
 		if (TextUtils.isEmpty(positionId) || mCachedPositionList == null || mCachedPositionList.isEmpty()) {
-            LogUtils.w(TAG, "getPositionIndexById：参数无效（位置ID/缓存为空）");
+			LogUtils.w(TAG, "获取位置索引失败：参数无效（ID/缓存为空）");
 			return -1;
-        }
-
-        // Java 7 增强for循环遍历（替代Lambda，适配Java 7语法）
+		}// Java 7 增强for循环遍历（替代Lambda，适配语法）
 		for (int i = 0; i < mCachedPositionList.size(); i++) {
 			PositionModel pos = mCachedPositionList.get(i);
 			if (positionId.equals(pos.getPositionId())) {
-                return i; // 找到匹配ID，返回索引
+				return i;
 			}
 		}
-        LogUtils.w(TAG, "getPositionIndexById：未找到位置ID=" + positionId);
+		LogUtils.w(TAG, "获取位置索引失败：未找到ID=" + positionId);
 		return -1;
 	}
 
 	/**
-     * 局部更新距离UI（仅更新指定位置的距离，避免全量刷新卡顿）
+
+	 - 局部更新距离UI（仅更新指定位置的距离，避免全量刷新卡顿——适配复用后控件缓存有效场景）
 	 */
 	public void updateSinglePositionDistance(String positionId) {
-        // 校验参数：位置ID无效或控件未缓存，直接返回
-        if (TextUtils.isEmpty(positionId) || !mPosDistanceViewMap.containsKey(positionId)) {
-            LogUtils.w(TAG, "updateSinglePositionDistance：位置ID无效或控件未缓存（ID=" + positionId + "）");
+		if (TextUtils.isEmpty(positionId) || mPosDistanceViewMap.isEmpty()) {
+			LogUtils.w(TAG, "局部更新距离失败：ID无效或无控件缓存（ID=" + positionId + "）");
+			return;
+		}
+		// 1. 获取服务端最新位置数据（带重试，避免服务临时回收）
+		MainService mainService = getMainServiceWithRetry(2);
+		if (mainService == null) {
+			LogUtils.e(TAG, "局部更新距离失败：无法获取MainService");
 			return;
 		}
-
-        // 从MainService获取最新位置模型（确保距离值是服务端最新）
 		PositionModel latestPos = null;
-        MainService mainService = mMainServiceRef.get();
-        if (mainService != null) {
-            ArrayList<PositionModel> servicePosList = mainService.getPositionList();
+		try {
+			ArrayList servicePosList = mainService.getPositionList();
 			if (servicePosList != null && !servicePosList.isEmpty()) {
-                // Java 7 迭代器遍历服务端位置列表，找到目标位置
-                Iterator<PositionModel> posIter = servicePosList.iterator();
-                while (posIter.hasNext()) {
-                    PositionModel pos = posIter.next();
+				// Java 7 迭代器遍历，避免ConcurrentModificationException
+				Iterator iter = servicePosList.iterator();
+				while (iter.hasNext()) {
+					PositionModel pos = (PositionModel)iter.next();
 					if (positionId.equals(pos.getPositionId())) {
 						latestPos = pos;
 						break;
 					}
 				}
 			}
+		} catch (Exception e) {
+			LogUtils.d(TAG, "获取最新位置数据失败（ID=" + positionId + "）" + e);
+			return;
+		}if (latestPos == null) {
+			LogUtils.w(TAG, "局部更新距离失败：未找到位置ID=" + positionId);
+			return;
 		}
-
-        // 用服务端最新距离更新UI（直接操作缓存的距离控件，无需刷新整个项）
-        if (latestPos != null) {
-            TextView distanceView = mPosDistanceViewMap.get(positionId);
-            updateDistanceDisplay(distanceView, latestPos);
-            LogUtils.d(TAG, "局部更新距离完成：位置ID=" + positionId + "，最新距离=" + latestPos.getRealPositionDistance() + "米");
+		// 2. 更新距离控件（确保主线程操作，避免跨线程异常——适配复用后控件已重新绑定）
+		final TextView distanceView = mPosDistanceViewMap.get(positionId);
+		if (distanceView != null && distanceView.isAttachedToWindow()) {
+			final PositionModel finalLatestPos = latestPos;
+			distanceView.post(new Runnable() {
+					@Override
+					public void run() {
+						updateDistanceDisplay(distanceView, finalLatestPos);
+					}
+				});
+			LogUtils.d(TAG, "局部更新距离完成：位置ID=" + positionId + "，距离=" + latestPos.getRealPositionDistance() + "米");
 		} else {
-            LogUtils.w(TAG, "局部更新距离失败：未在MainService找到位置ID=" + positionId);
+			mPosDistanceViewMap.remove(positionId); // 移除无效控件缓存（如视图已被销毁）
+			LogUtils.w(TAG, "局部更新距离失败：控件已回收/脱离视图树（ID=" + positionId + "）");
 		}
 	}
 
 	/**
-     * 全量更新位置数据（从MainService同步最新位置列表，刷新UI）
+	 - 全量更新位置数据（从服务同步最新数据，过滤无效/重复项——适配复用后全量刷新场景）
 	 */
 	public void updateAllPositionData(ArrayList<PositionModel> newPosList) {
 		if (newPosList == null) {
-            LogUtils.w(TAG, "updateAllPositionData：新位置列表为空，跳过更新");
+			LogUtils.w(TAG, "全量更新位置数据失败：新列表为空");
 			return;
 		}
-
-        // 同步服务端最新位置数据到本地缓存
+		// 1. 过滤无效位置（校验核心字段：ID/经纬度合法）
+		ArrayList<PositionModel> validPosList = new ArrayList<PositionModel>();
+		for (PositionModel pos : newPosList) {
+			if (TextUtils.isEmpty(pos.getPositionId())
+				|| pos.getLongitude() < -180 || pos.getLongitude() > 180
+				|| pos.getLatitude() < -90 || pos.getLatitude() > 90) {
+				LogUtils.w(TAG, "过滤无效位置：ID=" + pos.getPositionId() + "（经纬度/ID非法）");
+				continue;
+			}
+			validPosList.add(pos);
+		}
+		// 2. 去重（按位置ID去重，保留服务端最新数据）
+		ConcurrentHashMap<String, PositionModel> uniquePosMap = new ConcurrentHashMap<String, PositionModel>();
+		for (PositionModel pos : validPosList) {
+			uniquePosMap.put(pos.getPositionId(), pos); // 相同ID覆盖，保留最新
+		}
+		ArrayList uniquePosList = new ArrayList(uniquePosMap.values());// 3. 同步到本地缓存+刷新UI（刷新后触发onBind，自动重新绑定资源）
 		this.mCachedPositionList.clear();
-        this.mCachedPositionList.addAll(newPosList);
-        // 清空旧距离控件缓存（避免引用失效控件）
+		this.mCachedPositionList.addAll(uniquePosList);
+		// 清空旧控件缓存（避免引用失效数据，刷新后重新缓存新控件）
 		mPosDistanceViewMap.clear();
-        // 通知RecyclerView全量刷新UI
+		mSimpleTaskViewMap.clear();
+		mEditTaskViewMap.clear();
 		notifyDataSetChanged();
-        LogUtils.d(TAG, "全量更新位置数据完成：当前位置数量=" + mCachedPositionList.size() + "（数据来源：MainService）");
+		LogUtils.d(TAG, "全量更新位置数据完成：原数量=" + newPosList.size() + "，过滤后=" + uniquePosList.size());
 	}
 
 	/**
-     * 隐藏软键盘（编辑完成后调用，提升用户体验）
+	 - 隐藏软键盘（编辑完成后调用，提升用户体验——适配复用后软键盘残留问题）
 	 */
 	private void hideSoftKeyboard(View view) {
 		if (mContext == null || view == null) {
-            LogUtils.w(TAG, "hideSoftKeyboard：参数为空（上下文/视图），无法隐藏键盘");
+			LogUtils.w(TAG, "隐藏软键盘失败：参数为空（上下文/视图）");
 			return;
+		}InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
+		if (imm != null) {
+			imm.hideSoftInputFromWindow(view.getWindowToken(), 0); // 强制隐藏
+		}
 	}
 
-        // Java 7 显式获取输入法服务，避免Lambda
-        InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
-        if (imm != null) {
-            imm.hideSoftInputFromWindow(view.getWindowToken(), 0); // 强制隐藏软键盘
+	/**
+	 - 带重试的服务获取（解决弱引用临时回收问题，最多重试2次——适配复用后服务引用失效场景）
+	 */
+	private MainService getMainServiceWithRetry(int retryCount) {
+		MainService mainService = mMainServiceRef.get();
+		if (mainService != null) {
+			return mainService;
 		}
+		// 重试逻辑：每次间隔100ms，避免频繁重试
+		for (int i = 0; i < retryCount; i++) {
+			try {
+				Thread.sleep(100);
+				mainService = mMainServiceRef.get();
+				if (mainService != null) {
+					LogUtils.d(TAG, "重试获取MainService成功（第" + (i + 1) + "次）");
+					return mainService;
+				}
+			} catch (InterruptedException e) {
+				LogUtils.d(TAG, "重试获取服务时线程被中断" + e);
+				Thread.currentThread().interrupt(); // 恢复中断状态
+				break;
+			}
+		}LogUtils.e(TAG, "重试" + retryCount + "次后仍未获取到MainService");
+		return null;
 	}
 
 	// =========================================================================
-    // 实现 MainService.TaskUpdateListener 接口（服务任务变化时回调）
+	// 实现 MainService.TaskUpdateListener 接口（服务任务变化时回调——适配复用后任务同步）
 	// =========================================================================
 	@Override
 	public void onTaskUpdated() {
-        LogUtils.d(TAG, "收到MainService任务更新通知（任务新增/删除/状态变化），刷新UI");
-        // 任务数据变化时，全量刷新Adapter（确保任务数量等显示同步）
-        notifyDataSetChanged();
+		LogUtils.d(TAG, "收到MainService任务更新通知，同步所有任务列表视图（含复用视图）");
+
+		// 1. 同步简单模式任务视图（仅显示已启用任务——适配复用后视图已重新缓存）
+		if (!mSimpleTaskViewMap.isEmpty()) {
+			Iterator<ConcurrentHashMap.Entry<String, PositionTaskListView>> iter = mSimpleTaskViewMap.entrySet().iterator();
+			while (iter.hasNext()) {
+				ConcurrentHashMap.Entry<String, PositionTaskListView> entry = iter.next();
+				PositionTaskListView taskView = entry.getValue();
+				if (taskView != null && taskView.isAttachedToWindow()) {
+					taskView.syncTasksFromMainService(); // 从服务同步最新任务（复用后也能更新）
+				} else {
+					iter.remove(); // 移除无效视图缓存（如视图已脱离屏幕且未复用）
+				}
+			}
+		}
+
+		// 2. 同步编辑模式任务视图（支持编辑的全量任务——适配复用后视图已重新缓存）
+		if (!mEditTaskViewMap.isEmpty()) {
+			Iterator<ConcurrentHashMap.Entry<String, PositionTaskListView>> iter = mEditTaskViewMap.entrySet().iterator();
+			while (iter.hasNext()) {
+				ConcurrentHashMap.Entry<String, PositionTaskListView> entry = iter.next();
+				PositionTaskListView taskView = entry.getValue();
+				if (taskView != null && taskView.isAttachedToWindow()) {
+					taskView.syncTasksFromMainService(); // 从服务同步最新任务（复用后也能更新）
+				} else {
+					iter.remove(); // 移除无效视图缓存
+				}
+			}
+		}
 	}
 
 	// =========================================================================
-    // 回调设置方法（供LocationActivity调用，绑定交互逻辑）
+	// 回调设置方法（供Activity绑定交互逻辑——适配复用后回调不失效）
 	// =========================================================================
 	public void setOnDeleteClickListener(OnDeleteClickListener listener) {
 		this.mOnDeleteListener = listener;
@@ -477,69 +619,94 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
 	}
 
 	// =========================================================================
-    // 资源释放（Activity销毁时调用，避免内存泄漏）
+	// 资源释放（Activity销毁时调用，彻底释放引用，避免内存泄漏——保留原有安全逻辑）
 	// =========================================================================
 	public void release() {
-        // 1. 反注册MainService任务监听（解除与服务的绑定，避免内存泄漏）
+		// 1. 反注册MainService任务监听（解除服务绑定）
 		MainService mainService = mMainServiceRef.get();
 		if (mainService != null) {
 			mainService.unregisterTaskUpdateListener(this);
-            LogUtils.d(TAG, "已反注册MainService任务监听，避免内存泄漏");
+			LogUtils.d(TAG, "已反注册MainService任务监听");
 		}
 
-        // 2. 清空本地缓存（解除控件/数据引用，帮助GC回收）
+		// 2. 释放简单模式任务视图资源（清空数据+解绑监听——仅在Activity销毁时执行，不复用场景）
+		if (!mSimpleTaskViewMap.isEmpty()) {
+			Iterator<ConcurrentHashMap.Entry<String, PositionTaskListView>> iter = mSimpleTaskViewMap.entrySet().iterator();
+			while (iter.hasNext()) {
+				PositionTaskListView taskView = iter.next().getValue();
+				if (taskView != null) {
+					taskView.clearData();
+					taskView.setOnTaskUpdatedListener(null);
+				}
+				iter.remove();
+			}
+		}
+
+		// 3. 释放编辑模式任务视图资源（清空数据+解绑监听——仅在Activity销毁时执行）
+		if (!mEditTaskViewMap.isEmpty()) {
+			Iterator<ConcurrentHashMap.Entry<String, PositionTaskListView>> iter = mEditTaskViewMap.entrySet().iterator();
+			while (iter.hasNext()) {
+				PositionTaskListView taskView = iter.next().getValue();
+				if (taskView != null) {
+					taskView.clearData();
+					taskView.setOnTaskUpdatedListener(null);
+				}
+				iter.remove();
+			}
+		}
+
+		// 4. 清空其他缓存+置空引用（彻底释放，避免内存泄漏）
 		mPosDistanceViewMap.clear();
 		if (mCachedPositionList != null) {
 			mCachedPositionList.clear();
 		}
-
-        // 3. 置空回调实例（避免持有Activity引用导致内存泄漏）
 		mOnDeleteListener = null;
 		mOnSavePosListener = null;
 
-        LogUtils.d(TAG, "Adapter资源已完全释放（缓存清空+监听反注册）");
+		LogUtils.d(TAG, "Adapter资源已完全释放（任务视图资源释放+缓存清空+引用置空）");
 	}
 
 	// =========================================================================
-    // 静态内部类：视图Holder（Java 7 静态内部类，不持有外部引用，避免内存泄漏）
+	// 静态内部类：ViewHolder（与布局严格对应，避免外部引用导致内存泄漏）
 	// =========================================================================
 	/**
-     * 简单视图Holder（仅显示数据，对应布局：item_position_simple.xml）
+	 - 简单模式ViewHolder（对应 item_position_simple.xml，含简单模式任务列表视图）
 	 */
 	public static class SimpleViewHolder extends RecyclerView.ViewHolder {
-        TextView tvSimpleLon;     // 经度显示控件
-        TextView tvSimpleLat;     // 纬度显示控件
-        TextView tvSimpleMemo;    // 备注显示控件
-        TextView tvSimpleDistance;// 实时距离显示控件
-
+		TextView tvSimpleLon;         // 经度显示
+		TextView tvSimpleLat;         // 纬度显示
+		TextView tvSimpleMemo;        // 备注显示
+		TextView tvSimpleDistance;    // 距离显示
+		PositionTaskListView ptlvSimpleTasks; // 简单模式任务列表视图
 		public SimpleViewHolder(View itemView) {
 			super(itemView);
-            // 绑定布局控件（与XML中ID严格对应，避免运行时空指针）
+			// 绑定布局控件（与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);
+			ptlvSimpleTasks = (PositionTaskListView) itemView.findViewById(R.id.ptlv_simple_tasks);
 		}
 	}
 
 	/**
-     * 编辑视图Holder（含编辑控件+功能按钮，对应布局：item_position_edit.xml）
+	 - 编辑模式ViewHolder（对应 item_position_edit.xml，含编辑模式任务列表视图）
 	 */
 	public static class EditViewHolder extends RecyclerView.ViewHolder {
-        TextView tvEditLon;       // 经度显示控件（不可编辑）
-        TextView tvEditLat;       // 纬度显示控件（不可编辑）
-        EditText etEditMemo;      // 备注编辑控件
-        TextView tvEditDistance;  // 实时距离显示控件
-        RadioGroup rgDistanceSwitch; // 距离启用/禁用开关组
+		TextView tvEditLon;           // 经度显示（不可编辑）
+		TextView tvEditLat;           // 纬度显示（不可编辑）
+		EditText etEditMemo;          // 备注编辑
+		TextView tvEditDistance;      // 距离显示
+		RadioGroup rgDistanceSwitch;  // 距离启用/禁用开关
 		Button btnCancel;             // 取消编辑按钮
 		Button btnDelete;             // 删除位置按钮
 		Button btnSave;               // 保存位置按钮
 		Button btnAddTask;            // 新增任务按钮
-        TextView tvTaskCount;     // 任务数量显示控件
-
+		TextView tvTaskCount;         // 任务数量显示（兼容旧布局，可隐藏）
+		PositionTaskListView ptlvEditTasks; // 编辑模式任务列表视图
 		public EditViewHolder(View itemView) {
 			super(itemView);
-            // 绑定布局控件（与XML中ID严格对应，避免运行时空指针）
+			// 绑定布局控件（与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);
@@ -550,7 +717,93 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
 			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);
-        }
+			ptlvEditTasks = (PositionTaskListView) itemView.findViewById(R.id.ptlv_edit_tasks);
 		}
 	}
 
+	// =========================================================================
+	// 补充：PositionTaskListView 必要方法适配（确保视图类已实现以下基础方法）
+	// （若视图类未实现，需在 PositionTaskListView 中添加对应逻辑，否则复用后功能异常）
+	// =========================================================================
+	public static class PositionTaskListViewRequiredMethods {
+		/**
+		 1. - init 方法：初始化任务视图（绑定服务+位置ID——复用后重新绑定，确保服务引用有效）
+		 - 需在 PositionTaskListView 中添加：
+		 - public void init(MainService mainService, String positionId) {
+		 - this.mMainServiceRef = new WeakReference(mainService); // 弱引用服务，防泄漏
+		 - this.mPositionId = positionId; // 绑定当前位置ID（复用后更新为当前位置ID）
+		 - }
+		 */
+
+		/**
+		 2. - setViewStatus 方法：设置视图模式（简单/编辑——复用后恢复对应模式UI）
+		 - 需在 PositionTaskListView 中添加：
+		 - public static final int VIEW_MODE_SIMPLE = 0; // 仅显示（隐藏编辑/删除按钮）
+		 - public static final int VIEW_MODE_EDIT = 1;   // 可编辑（显示编辑/删除按钮）
+		 - private int mViewMode;
+		 - public void setViewStatus(int viewMode) {
+		 - this.mViewMode = viewMode;
+		 - // 根据模式控制按钮显示：简单模式隐藏编辑按钮，编辑模式显示
+		 - if (mEditBtn != null) mEditBtn.setVisibility(viewMode == VIEW_MODE_EDIT ? View.VISIBLE : View.GONE);
+		 - if (mDeleteBtn != null) mDeleteBtn.setVisibility(viewMode == VIEW_MODE_EDIT ? View.VISIBLE : View.GONE);
+		 - }
+		 */
+
+		/**
+		 3. - syncTasksFromMainService 方法：从服务同步任务数据（复用后核心方法，避免旧数据）
+		 - 需在 PositionTaskListView 中添加：
+		 - public void syncTasksFromMainService() {
+		 - MainService mainService = mMainServiceRef.get();
+		 - if (mainService == null || TextUtils.isEmpty(mPositionId)) return;
+		 - // 根据视图模式拉取对应任务：简单模式仅拉已启用，编辑模式拉全部
+		 - ArrayList tasks = (mViewMode == VIEW_MODE_SIMPLE)
+		 - ? mainService.getEnabledTasksByPositionId(mPositionId)
+		 - : mainService.getTasksByPositionId(mPositionId);
+		 - // 更新列表数据（刷新UI，确保复用后显示最新任务）
+		 - if (mTaskAdapter != null) {
+		 - mTaskAdapter.setTaskList(tasks);
+		 - mTaskAdapter.notifyDataSetChanged();
+		 - }
+		 - // 通知外部任务更新（如Adapter需要联动）
+		 - if (mTaskUpdateListener != null) mTaskUpdateListener.onTaskUpdated(mPositionId, tasks);
+		 - }
+		 */
+
+		/**
+		 4. - addNewTask 方法：新增任务（同步服务+刷新列表——复用后功能正常）
+		 - 需在 PositionTaskListView 中添加：
+		 - public void addNewTask(PositionTaskModel newTask) {
+		 - if (newTask == null || TextUtils.isEmpty(newTask.getPositionId())) return;
+		 - MainService mainService = mMainServiceRef.get();
+		 - if (mainService != null) {
+		 - mainService.addTask(newTask); // 同步到服务（确保数据持久化）
+		 - syncTasksFromMainService();   // 新增后立即同步，刷新列表
+		 - Toast.makeText(getContext(), "任务新增成功", Toast.LENGTH_SHORT).show();
+		 - } else {
+		 - Toast.makeText(getContext(), "服务未就绪，新增失败", Toast.LENGTH_SHORT).show();
+		 - }
+		 - }
+		 */
+
+		/**
+		 5. - clearData 方法：清空任务数据（仅在Activity销毁时调用，不复用场景）
+		 - 需在 PositionTaskListView 中添加：
+		 - public void clearData() {
+		 - if (mTaskList != null) mTaskList.clear(); // 清空本地任务列表
+		 - if (mTaskAdapter != null) mTaskAdapter.notifyDataSetChanged(); // 刷新空UI
+		 - }
+		 */
+
+		/**
+		 6. - setOnTaskUpdatedListener 方法：设置任务更新回调（复用后重新绑定，避免回调失效）
+		 - 需在 PositionTaskListView 中添加：
+		 - public interface OnTaskUpdatedListener {
+		 - void onTaskUpdated(String positionId, ArrayList updatedTasks);
+		 - }
+		 - private OnTaskUpdatedListener mTaskUpdateListener;
+		 - public void setOnTaskUpdatedListener(OnTaskUpdatedListener listener) {
+		 - this.mTaskUpdateListener = listener;
+		 - }
+		 */
+	}
+}

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

@@ -26,19 +26,22 @@ public class PositionTaskModel extends BaseBean {
 	boolean isLessThan;
 	// 任务条件距离（单位：米）
 	int discussDistance;
+	// 任务开始启用时间
+	long startTime;
 	// 任务是否已触发
 	boolean isBingo = false;
 	// 是否启用任务
 	boolean isEnable;
 
 	// 带参构造（强制传入positionId，确保任务与位置绑定）
-	public PositionTaskModel(String taskId, String positionId, String taskDescription, boolean isGreaterThan, int discussDistance, boolean isEnable) {
+	public PositionTaskModel(String taskId, String positionId, String taskDescription, boolean isGreaterThan, int discussDistance, long startTime, 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.startTime = startTime;
 		this.isEnable = isEnable;
 	}
 	
@@ -50,9 +53,18 @@ public class PositionTaskModel extends BaseBean {
 		this.isGreaterThan = true;
 		this.isLessThan = false; // 初始互斥
 		this.discussDistance = 100; // 默认100米
+		this.startTime = System.currentTimeMillis();
 		this.isEnable = true;
 	}
 
+	public void setStartTime(long startTime) {
+		this.startTime = startTime;
+	}
+
+	public long getStartTime() {
+		return startTime;
+	}
+
 	public void setIsBingo(boolean isBingo) {
 		this.isBingo = isBingo;
 	}
@@ -144,6 +156,7 @@ public class PositionTaskModel extends BaseBean {
 		jsonWriter.name("isGreaterThan").value(isGreaterThan());
 		jsonWriter.name("isLessThan").value(isLessThan());
 		jsonWriter.name("discussDistance").value(getDiscussDistance());
+		jsonWriter.name("startTime").value(getStartTime());
 		jsonWriter.name("isEnable").value(isEnable());
 	}
 
@@ -165,6 +178,8 @@ public class PositionTaskModel extends BaseBean {
 				setIsLessThan(jsonReader.nextBoolean());
 			} else if (name.equals("discussDistance")) {
 				setDiscussDistance(jsonReader.nextInt());
+			} else if (name.equals("startTime")) {
+				setStartTime(jsonReader.nextLong());
 			} else if (name.equals("isEnable")) {
 				setIsEnable(jsonReader.nextBoolean());
 			} else {

positions/src/main/java/cc/winboll/studio/positions/receivers/MotionStatusReceiver.java

@@ -0,0 +1,124 @@
+package cc.winboll.studio.positions.receivers;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/10/28 19:07
+ * @Describe MotionStatusReceiver
+ */
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.text.TextUtils;
+import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.positions.services.MainService;
+import cc.winboll.studio.positions.utils.ServiceUtil;
+
+/**
+ * 运动状态监听Receiver
+ * 功能：接收运动状态广播，控制GPS权限申请与GPS监听开关
+ */
+public class MotionStatusReceiver extends BroadcastReceiver {
+	public static final String TAG = "MotionStatusReceiver";
+
+	// 运动状态广播Action（需与运动状态发送方保持一致，如传感器服务）
+	public static final String ACTION_MOTION_STATUS = "cc.winboll.studio.positions.ACTION_MOTION_STATUS";
+	// 运动状态Extra键：0=静止/低运动，1=行走/高运动
+	public static final String EXTRA_MOTION_STATUS = "EXTRA_MOTION_STATUS";
+	// 静止时GPS定时获取间隔（单位：分钟，可配置）
+	public static final long GPS_STATIC_INTERVAL = 1;
+
+	@Override
+	public void onReceive(Context context, Intent intent) {
+		if (context == null || intent == null || !TextUtils.equals(intent.getAction(), ACTION_MOTION_STATUS)) {
+			LogUtils.w(TAG, "无效广播：Action不匹配或上下文为空");
+			return;
+		}
+
+		// 1. 获取运动状态（0=静止/低运动，1=行走/高运动）
+		int motionStatus = intent.getIntExtra(EXTRA_MOTION_STATUS, 0);
+		LogUtils.d(TAG, "接收运动状态：" + (motionStatus == 1 ? "行走中" : "静止/低运动"));
+
+		// 2. 绑定并获取MainService实例（确保服务已启动）
+		MainService mainService = getMainService(context);
+		if (mainService == null) {
+			LogUtils.e(TAG, "MainService未启动，无法控制GPS状态");
+			return;
+		}
+
+		// 3. 根据运动状态处理GPS逻辑
+		if (motionStatus == 1) {
+			// 3.1 行走中：申请GPS权限（若未授予）+ 开启持续GPS监听
+			handleWalkingStatus(mainService, context);
+		} else {
+			// 3.2 静止/低运动：关闭持续GPS监听 + 启动定时GPS获取
+			handleStaticStatus(mainService);
+		}
+	}
+
+	/**
+	 * 处理行走状态：申请GPS权限+开启持续GPS监听
+	 */
+	private void handleWalkingStatus(MainService mainService, Context context) {
+		// 检查GPS权限（Android 6.0+动态权限）
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && 
+			context.checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) 
+			!= PackageManager.PERMISSION_GRANTED) {
+			// 发送权限申请广播（由Activity接收并发起申请，Receiver无法直接申请权限）
+			Intent permissionIntent = new Intent("cc.winboll.studio.positions.ACTION_REQUEST_GPS_PERMISSION");
+			permissionIntent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
+			context.sendBroadcast(permissionIntent);
+			LogUtils.d(TAG, "行走中：GPS权限未授予，已发送权限申请广播");
+			return;
+		}
+
+		// 权限已授予：开启持续GPS监听（调用MainService原有方法）
+		if (!mainService.isGpsListening()) { // 需在MainService中新增isGpsListening()方法
+			mainService.startGpsLocation();
+			LogUtils.d(TAG, "行走中：已开启持续GPS监听");
+		}
+
+		// 停止静止时的GPS定时任务（避免重复获取）
+		mainService.stopGpsStaticTimer();
+	}
+
+	/**
+	 * 处理静止状态：关闭持续GPS监听+启动定时GPS获取
+	 */
+	private void handleStaticStatus(MainService mainService) {
+		// 关闭持续GPS监听（避免耗电）
+		if (mainService.isGpsListening()) {
+			mainService.stopGpsLocation();
+			LogUtils.d(TAG, "静止中：已关闭持续GPS监听");
+		}
+
+		// 启动定时GPS获取（获取一次后关闭，间隔GPS_STATIC_INTERVAL分钟）
+		mainService.startGpsStaticTimer(GPS_STATIC_INTERVAL);
+	}
+
+	/**
+	 * 获取MainService实例（通过绑定服务或单例，确保线程安全）
+	 */
+	private MainService getMainService(Context context) {
+		// 方式1：若MainService单例有效，直接获取（推荐）
+		MainService singleton = MainService.getInstance(context);
+		if (singleton != null && singleton.isServiceRunning()) {
+			return singleton;
+		}
+
+		// 方式2：若单例无效，尝试绑定服务（备用，需处理绑定回调）
+		if (!ServiceUtil.isServiceAlive(context, MainService.class.getName())) {
+			// 启动服务（若未运行）
+			context.startService(new Intent(context, MainService.class));
+			// 等待服务启动（短延时，实际项目建议用ServiceConnection异步绑定）
+			try {
+				Thread.sleep(500);
+			} catch (InterruptedException e) {
+				Thread.currentThread().interrupt();
+			}
+		}
+		return MainService.getInstance(context);
+	}
+}
+

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

@@ -18,6 +18,7 @@ import cc.winboll.studio.positions.utils.ServiceUtil;
 public class AssistantService extends Service {
 
     public final static String TAG = "AssistantService";
+	public static final String EXTRA_IS_SETTING_TO_ENABLE = "EXTRA_IS_SETTING_TO_ENABLE";
 	
     MyServiceConnection mMyServiceConnection;
     volatile boolean mIsServiceRunning;
@@ -37,13 +38,18 @@ public class AssistantService extends Service {
         }
         // 设置运行参数
         mIsServiceRunning = false;
+        if (mAppConfigsUtil.isEnableMainService(true)) {
 			run();
 		}
+    }
 
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
+		if (mAppConfigsUtil.isEnableMainService(true)) {
 			run();
-        return START_STICKY;
+		}
+
+        return  mAppConfigsUtil.isEnableMainService(true) ? Service.START_STICKY : super.onStartCommand(intent, flags, startId);
     }
 
     @Override

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

@@ -41,11 +41,11 @@ public class AppConfigsUtil {
         return sInstance;
     }
 
-	void loadConfigs() {
+	public void loadConfigs() {
 		mAppConfigsModel = AppConfigsModel.loadBean(mContext, AppConfigsModel.class);
 	}
 
-	void saveConfigs() {
+	public void saveConfigs() {
 		AppConfigsModel.saveBean(mContext, mAppConfigsModel);
 	}
 

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

@@ -0,0 +1,45 @@
+package cc.winboll.studio.positions.utils;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/10/22 01:16
+ * @Describe DensityUtils
+ */
+
+import android.content.Context;
+import android.util.DisplayMetrics;
+import android.view.WindowManager;
+
+/**
+ * 屏幕密度工具类（dp/sp 转 px、获取屏幕尺寸）
+ */
+public class DensityUtils {
+	public static final String TAG = "DensityUtils";
+
+	/**
+	 * dp 转 px（根据屏幕密度）
+	 */
+	public static int dp2px(Context context, float dpValue) {
+		final float scale = context.getResources().getDisplayMetrics().density;
+		return (int) (dpValue * scale + 0.5f);
+	}
+
+	/**
+	 * sp 转 px（根据文字缩放比例）
+	 */
+	public static int sp2px(Context context, float spValue) {
+		final float scale = context.getResources().getDisplayMetrics().scaledDensity;
+		return (int) (spValue * scale + 0.5f);
+	}
+
+	/**
+	 * 获取屏幕宽度（像素）
+	 */
+	public static int getScreenWidth(Context context) {
+		WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
+		DisplayMetrics dm = new DisplayMetrics();
+		wm.getDefaultDisplay().getMetrics(dm);
+		return dm.widthPixels;
+	}
+}
+

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

@@ -0,0 +1,246 @@
+package cc.winboll.studio.positions.utils;
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.text.TextUtils;
+import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.libappbase.ToastUtils;
+import cc.winboll.studio.positions.models.PositionModel;
+import cc.winboll.studio.positions.models.PositionTaskModel;
+import cc.winboll.studio.positions.services.MainService;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/10/27 18:40
+ * @Describe 距离计算工具集（单例模式）
+ */
+public class DistanceCalculatorUtil {
+
+    public static final String TAG = "DistanceCalculatorUtil";
+
+    // 1. 私有静态 volatile 实例：保证多线程下实例可见性，避免指令重排序导致的空指针
+    private static volatile DistanceCalculatorUtil sInstance;
+	Context mContext;
+	ArrayList<PositionModel> mPositionList;   // 位置数据列表
+    ArrayList<PositionTaskModel> mAllTasks;// 任务数据列表
+	PositionModel mGpsPositionCalculated;
+	long mLastCalculatedTime = 0;
+	long mMinCalculatedTimeBettween = 30000; // GPS数据更新时，两次计算之间的最小时间间隔
+	double mMinjumpDistance = 10.0f; // GPS数据更新时，能跳跃距离最小有效值，达到有效值时，两次计算之间的最小时间间隔阀值将被忽略。
+
+    // 2. 私有构造器：禁止外部通过 new 关键字创建实例，确保单例唯一性
+    private DistanceCalculatorUtil(Context context) {
+        // 可选：初始化工具类依赖的资源（如配置参数、缓存等）
+		mContext = context;
+
+        LogUtils.d(TAG, "DistanceCalculatorUtil 单例实例初始化");
+    }
+
+    // 3. 公开静态方法：双重校验锁获取单例，兼顾线程安全与性能
+    public static DistanceCalculatorUtil getInstance(Context context) {
+        // 第一重校验：避免已创建实例时的频繁加锁，提升性能
+        if (sInstance == null) {
+            // 加锁：确保多线程下仅一个线程进入实例创建逻辑
+            synchronized (DistanceCalculatorUtil.class) {
+                // 第二重校验：防止多线程并发时重复创建实例
+                if (sInstance == null) {
+                    sInstance = new DistanceCalculatorUtil(context);
+                }
+            }
+        }
+        return sInstance;
+    }
+
+    // ---------------------- 以下可补充距离计算相关工具方法 ----------------------
+    /**
+     * 示例：Haversine 公式计算两点间距离（单位：米）
+     * @param lat1 第一点纬度
+     * @param lon1 第一点经度
+     * @param lat2 第二点纬度
+     * @param lon2 第二点经度
+     * @return 两点间直线距离（米），计算失败返回 -1
+     */
+    public static double calculateHaversineDistance(double lat1, double lon1, double lat2, double lon2) {
+        try {
+            final double EARTH_RADIUS = 6371000; // 地球半径（米）
+            // 角度转弧度
+            double latDiff = Math.toRadians(lat2 - lat1);
+            double lonDiff = Math.toRadians(lon2 - lon1);
+
+            // Haversine 核心公式
+            double a = Math.sin(latDiff / 2) * Math.sin(latDiff / 2)
+				+ Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2))
+				* Math.sin(lonDiff / 2) * Math.sin(lonDiff / 2);
+            double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+            return EARTH_RADIUS * c; // 返回距离（米）
+        } catch (Exception e) {
+            LogUtils.d(TAG, "Haversine 距离计算失败：" + e.getMessage());
+            return -1; // 标记计算失败
+        }
+    }
+
+
+    /**
+     * 计算两点间距离（Haversine公式，纯Java 7 基础API，无数学工具类依赖）
+     * @param gpsLat GPS纬度
+     * @param gpsLon GPS经度
+     * @param posLat 目标位置纬度
+     * @param posLon 目标位置经度
+     * @return 两点间距离（单位：米）
+     */
+    /*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);
+	 // Haversine公式核心计算（Java 7 基础数学方法）
+	 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 checkAllTaskTriggerCondition(PositionModel currentGpsPosition) {
+		if (currentGpsPosition == null) {
+			LogUtils.d(TAG, "传入坐标参数为空，退出函数。");
+			return;
+		}
+
+		// 计算频率控制模块
+		//
+		// 计算与最近一次GPS计算的时间间隔
+		long nCalculatedTimeBettween = System.currentTimeMillis() - mLastCalculatedTime;
+		// 计算跳跃距离
+		double gpsPositionCalculatedLatitude = mGpsPositionCalculated == null ?0.0f: mGpsPositionCalculated.getLatitude();
+		double gpsPositionCalculatedLongitude = mGpsPositionCalculated == null ?0.0f: mGpsPositionCalculated.getLongitude();
+		double jumpDistance = calculateHaversineDistance(gpsPositionCalculatedLatitude, gpsPositionCalculatedLongitude, currentGpsPosition.getLatitude(), currentGpsPosition.getLongitude());
+		if (jumpDistance < mMinjumpDistance) {
+			LogUtils.d(TAG, String.format("checkAllTaskTriggerCondition：跳跃距离%f，小于50米。", jumpDistance));
+			// 跳跃距离小于最小有效跳跃值
+			if (nCalculatedTimeBettween < mMinCalculatedTimeBettween) {
+				//间隔小于最小时间间隔设定
+				LogUtils.d(TAG, String.format("checkAllTaskTriggerCondition：与最近一次计算间隔时间%d，坐标变化忽略。", nCalculatedTimeBettween));
+				return;
+			}
+		}
+
+		if (mGpsPositionCalculated == null) {
+			mGpsPositionCalculated = currentGpsPosition;
+			LogUtils.d(TAG, "最后计算位置记录为空，现在使用新坐标为初始化。");
+		}
+
+		LogUtils.d(TAG, String.format("checkAllTaskTriggerCondition：跳跃距离%f，与上次计算间隔%d，现在启动任务数据计算。", jumpDistance, nCalculatedTimeBettween));
+
+		// 获取位置任务基础数据
+		MainService mainService = MainService.getInstance(mContext);
+		mPositionList = mainService.getPositionList();
+		mAllTasks = mainService.getAllTasks();
+
+		// 位置数据为空，跳过校验。
+        if (mPositionList.isEmpty()) {
+            LogUtils.d(TAG, "checkAllTaskTriggerCondition：位置数据为空，跳过距离计算。");
+            return;
+        }
+
+		// 更新所有位置点的位置距离数据
+		refreshRealPositionDistance(currentGpsPosition);
+
+		// 任务数据为空，跳过校验。
+        if (mAllTasks.isEmpty()) {
+            LogUtils.d(TAG, "checkAllTaskTriggerCondition：任务数据为空，跳过任务提醒检查计算。");
+            return;
+        }
+
+        // 迭代器遍历任务（Java 7 安全遍历，避免并发修改异常）
+        Iterator<PositionTaskModel> taskIter = mAllTasks.iterator();
+        while (taskIter.hasNext()) {
+            PositionTaskModel task = taskIter.next();
+            // 仅校验“已启用”且“绑定有效位置”的任务
+            if (!task.isEnable() || TextUtils.isEmpty(task.getPositionId())) {
+                continue;
+            }
+
+            // 查找任务绑定的位置（Java 7 迭代器遍历位置列表）
+            PositionModel bindPos = null;
+            Iterator<PositionModel> posIter = mPositionList.iterator();
+            while (posIter.hasNext()) {
+                PositionModel pos = posIter.next();
+                if (task.getPositionId().equals(pos.getPositionId())) {
+                    bindPos = pos;
+                    break;
+                }
+            }
+            if (bindPos == null) {
+                LogUtils.w(TAG, "任务ID=" + task.getTaskId() + "：绑定位置不存在，跳过");
+                task.setIsBingo(false);
+                continue;
+            }
+
+			// 校验任务开始时间
+			if (task.getStartTime() > System.currentTimeMillis()) {
+				continue;
+			}
+
+            // 校验距离条件（判断是否满足任务触发阈值）
+            double currentDistance = bindPos.getRealPositionDistance();
+            if (currentDistance < 0) {
+                LogUtils.w(TAG, "任务ID=" + task.getTaskId() + "：距离计算失败，跳过");
+                task.setIsBingo(false);
+                continue;
+            }
+
+            boolean isTriggered = false;
+            int taskDistance = task.getDiscussDistance();
+            // 任务触发条件：大于/小于指定距离（Java 7 基础判断，无三元运算符嵌套）
+            if (task.isGreaterThan()) {
+                isTriggered = currentDistance > taskDistance;
+            } else if (task.isLessThan()) {
+                isTriggered = currentDistance < taskDistance;
+            }
+
+            // 更新任务触发状态+发送通知（状态变化时才处理）
+            if (task.isBingo() != isTriggered) {
+                task.setIsBingo(isTriggered);
+                if (isTriggered) {
+                    MainService.getInstance(mContext).sendTaskTriggerNotification(task, bindPos, currentDistance);
+                }
+            }
+        }
+
+        MainService.getInstance(mContext).saveAllTasks(); // 持久化更新后的任务状态
+		// 记录最后坐标更新点
+		mGpsPositionCalculated = currentGpsPosition;
+		// 记录数据计算时间
+		mLastCalculatedTime = System.currentTimeMillis();
+    }
+
+
+    /**
+     * 强制刷新所有位置距离（GPS更新后调用，计算距离+校验任务触发条件）
+     */
+    public void refreshRealPositionDistance(PositionModel currentGpsPosition) {
+        // 遍历所有位置计算距离（Java 7 增强for循环，无Stream）
+        for (PositionModel pos : mPositionList) {
+            if (pos.isEnableRealPositionDistance()) {
+				double distance = DistanceCalculatorUtil.calculateHaversineDistance(
+					currentGpsPosition.getLatitude(),
+					currentGpsPosition.getLongitude(),
+					pos.getLatitude(),
+					pos.getLongitude()
+				);
+				pos.setRealPositionDistance(distance);
+            } else {
+                pos.setRealPositionDistance(-1); // 未启用距离计算，标记为无效
+            }
+        }
+
+        // 距离刷新后通知GPS监听者
+        MainService.getInstance(mContext).notifyAllGpsListeners(currentGpsPosition);
+    }
+}

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

@@ -3,7 +3,7 @@ package cc.winboll.studio.positions.utils;
 /**
  * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
  * @Date 2025/09/30 16:09
- * @Describe NotificationUtils
+ * @Describe NotificationUtils（适配API 30，修复系统默认铃声获取，任务通知循环响铃）
  */
 import android.app.Notification;
 import android.app.NotificationChannel;
@@ -11,30 +11,31 @@ import android.app.NotificationManager;
 import android.app.PendingIntent;
 import android.content.Context;
 import android.content.Intent;
+import android.media.RingtoneManager; // 导入RingtoneManager（关键：用于获取系统默认铃声）
+import android.net.Uri; // 导入Uri（存储铃声路径）
 import android.os.Build;
 import androidx.core.app.NotificationCompat;
 import cc.winboll.studio.positions.R;
-import cc.winboll.studio.positions.activities.LocationActivity; // 引入你的前台服务类
+import cc.winboll.studio.positions.activities.LocationActivity;
 
 /**
- * 通知栏工具类：专注于任务相关通知的显示与点击跳转 + 前台服务通知管理
- * 核心功能：
- * 1. 显示任务描述通知，点击后携带positionId/taskId跳转到LocationActivity
- * 2. 创建前台服务通知（用于DistanceRefreshService保活，符合系统前台服务规范）
+ * 通知栏工具类：
+ * 1. 任务通知：铃声循环播放（适配API 30），修复系统默认铃声获取方式
+ * 2. 前台服务通知：低打扰（无声无震动），符合API 30规范
  */
 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 TASK_NOTIFICATION_CHANNEL_NAME = "任务通知（循环铃声）";
+    // 前台服务通知常量（独立渠道，低打扰）
     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（前台服务通知无需动态生成）
+    public static final int FOREGROUND_SERVICE_NOTIFICATION_ID = 10086; // 固定前台服务通知ID
 
-	// ---------------------- 原有功能：任务通知（不变） ----------------------
+    // ---------------------- 核心：任务通知（循环响铃+修复系统默认铃声） ----------------------
     private static int getNotificationId(String taskId) {
-		return taskId.hashCode() & 0xFFFFFF;
+        return taskId.hashCode() & 0xFFFFFF; // 确保通知ID唯一且非负
     }
 
     public static void show(Context context, String taskId, String positionId, String taskDescription) {
@@ -48,63 +49,86 @@ public class NotificationUtil {
             return;
         }
 
+        // 1. 初始化通知渠道（配置循环铃声参数，使用修复后的铃声获取方式）
         createNotificationChannel(notificationManager);
 
+        // 2. 点击跳转Intent（携带任务/位置参数，适配API 30页面栈）
         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);
 
+        // 3. PendingIntent（API 30强制加IMMUTABLE，避免安全异常）
         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
+            PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT
         );
 
-		Notification notification = new NotificationCompat.Builder(context, TASK_NOTIFICATION_CHANNEL_ID)
-			.setSmallIcon(R.mipmap.ic_launcher)
+        // 4. 构建通知（核心：循环响铃+修复的系统默认铃声）
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, TASK_NOTIFICATION_CHANNEL_ID)
+            .setSmallIcon(R.mipmap.ic_launcher) // API 30强制要求，否则通知不显示
             .setContentTitle("任务提醒")
             .setContentText(taskDescription)
             .setContentIntent(pendingIntent)
-			.setAutoCancel(true)
-			.setPriority(NotificationCompat.PRIORITY_DEFAULT)
-			.setDefaults(NotificationCompat.DEFAULT_SOUND)
-			.build();
+            .setAutoCancel(true) // 点击后取消通知，停止循环响铃
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT) // 确保铃声能正常播放（API 30规则）
+            //.setVibrationPattern(new long[]{0, 300, 200, 300}) // 震动与铃声同步循环
+            .setOnlyAlertOnce(false); // 重复通知也触发循环提醒
 
+        // 关键修复：用RingtoneManager获取系统默认通知铃声（替代废弃的NotificationManager.getDefaultUri）
+        Uri defaultNotificationRingtone = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
+        if (defaultNotificationRingtone != null) {
+            builder.setSound(defaultNotificationRingtone); // 设置系统默认铃声
+        } else {
+            builder.setDefaults(NotificationCompat.DEFAULT_SOUND); // 极端情况：铃声Uri为空时，用默认提醒音兜底
+        }
+
+        // 5. 循环响铃核心：设置FLAG_INSISTENT（通知未取消则持续循环）
+        Notification notification = builder.build();
+        notification.flags |= Notification.FLAG_INSISTENT;
+
+        // 6. 显示通知（触发循环响铃）
         notificationManager.notify(getNotificationId(taskId), notification);
     }
 
+    // ---------------------- 核心：创建通知渠道（修复铃声配置，适配API 30） ----------------------
     private static void createNotificationChannel(NotificationManager notificationManager) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-			// 原有：任务通知渠道
+            // 1. 任务通知渠道（用修复后的方式配置系统默认铃声）
             NotificationChannel taskChannel = new NotificationChannel(
                 TASK_NOTIFICATION_CHANNEL_ID,
                 TASK_NOTIFICATION_CHANNEL_NAME,
-				NotificationManager.IMPORTANCE_DEFAULT
+                NotificationManager.IMPORTANCE_DEFAULT // 重要性≥DEFAULT，否则铃声不响（API 30规则）
             );
-			taskChannel.setDescription("接收任务相关提醒，点击可查看任务详情");
+            taskChannel.setDescription("任务提醒通知，铃声循环播放至点击取消");
             taskChannel.enableVibration(true);
-			taskChannel.setVibrationPattern(new long[]{0, 300});
+            taskChannel.setVibrationPattern(new long[]{0, 300, 200, 300});
+            taskChannel.setAllowBubbles(false); // 避免气泡打断循环铃声
 
-			// 新增：前台服务通知渠道（重要性设为LOW，避免频繁打扰用户）
+            // 关键修复：渠道铃声也用RingtoneManager获取（与通知Builder保持一致，确保铃声统一）
+            Uri channelDefaultRingtone = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
+            taskChannel.setSound(channelDefaultRingtone, null); // 绑定系统默认铃声到渠道
+
+            // 2. 前台服务渠道（低打扰，无声无震动）
             NotificationChannel foregroundChannel = new NotificationChannel(
                 FOREGROUND_SERVICE_CHANNEL_ID,
                 FOREGROUND_SERVICE_CHANNEL_NAME,
-				NotificationManager.IMPORTANCE_LOW // 仅通知栏显示，无提示音/震动，符合后台服务低打扰需求
+                NotificationManager.IMPORTANCE_LOW
             );
-			foregroundChannel.setDescription("位置服务运行中，用于后台持续获取GPS数据，关闭会影响定位功能"); // 明确告知用户服务作用
-			foregroundChannel.enableVibration(false); // 前台服务通知不震动（避免打扰）
-			foregroundChannel.setSound(null, null); // 关闭提示音（低打扰）
+            foregroundChannel.setDescription("位置服务运行中，无声音/震动提醒");
+            foregroundChannel.enableVibration(false);
+            foregroundChannel.setSound(null, null); // 明确关闭铃声
+            foregroundChannel.setShowBadge(false);
 
-			// 注册两个渠道（任务+前台服务）
+            // 注册渠道（API 30覆盖旧配置，确保修复后的铃声生效）
             notificationManager.createNotificationChannel(taskChannel);
             notificationManager.createNotificationChannel(foregroundChannel);
         }
     }
 
+    // ---------------------- 原有功能：取消任务通知（停止循环响铃） ----------------------
     public static void cancel(Context context, String taskId) {
         if (context == null || taskId == null) {
             return;
@@ -112,69 +136,53 @@ public class NotificationUtil {
         NotificationManager notificationManager = 
             (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
         if (notificationManager != null) {
-			notificationManager.cancel(getNotificationId(taskId));
+            notificationManager.cancel(getNotificationId(taskId)); // 取消后循环铃声自动停止
         }
     }
 
-	// ---------------------- 新增核心功能：创建前台服务通知（供DistanceRefreshService调用） ----------------------
-	/**
-	 * 创建前台服务通知（符合Android前台服务规范，用于启动/保活DistanceRefreshService）
-	 * @param context 服务上下文（直接传入DistanceRefreshService的this即可）
-	 * @param serviceStatus 服务状态文本（如“正在后台获取GPS位置...”，动态展示服务状态）
-	 * @return 可直接用于startForeground()的Notification对象
-	 */
+    // ---------------------- 前台服务通知（适配API 30，无声无震动） ----------------------
     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); // 确保前台服务渠道已注册
+            createNotificationChannel(notificationManager);
         }
 
-		// 步骤2：构建“点击通知跳转至位置管理页”的Intent（用户点击通知可进入功能页）
+        // 点击跳转Intent
         Intent jumpIntent = new Intent(context, LocationActivity.class);
-		jumpIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP); // 避免创建重复页面
+        jumpIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
 
-		// 步骤3：创建PendingIntent（授权系统在用户点击时执行跳转）
+        // PendingIntent（API 30必加IMMUTABLE）
         PendingIntent pendingIntent = PendingIntent.getActivity(
             context,
-			FOREGROUND_SERVICE_NOTIFICATION_ID, // 请求码与通知ID一致，确保唯一
+            FOREGROUND_SERVICE_NOTIFICATION_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
+            PendingIntent.FLAG_IMMUTABLE | 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)
+            .setSmallIcon(R.mipmap.ic_launcher)
+            .setContentTitle("位置服务运行中")
+            .setContentText(serviceStatus)
+            .setContentIntent(pendingIntent)
+            .setOngoing(true) // 不可手动清除（前台服务规范）
+            .setPriority(NotificationCompat.PRIORITY_LOW)
+            .setDefaults(0) // 禁用所有默认提醒（无声无震动）
             .build();
     }
 
-	/**
-	 * （配套工具方法）更新前台服务通知的状态文本（如GPS获取进度、运行时长）
-	 * @param context 服务上下文
-	 * @param newServiceStatus 新的状态文本（如“已获取最新位置：北纬30.123°”）
-	 */
+    // ---------------------- 前台服务通知状态更新（适配API 30） ----------------------
     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) {

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

@@ -7,6 +7,10 @@ package cc.winboll.studio.positions.utils;
  */
 import android.app.ActivityManager;
 import android.content.Context;
+import android.content.Intent;
+import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.positions.services.AssistantService;
+import cc.winboll.studio.positions.services.MainService;
 import java.util.List;
 
 public class ServiceUtil {
@@ -31,4 +35,35 @@ public class ServiceUtil {
 
         return false;
     }
+
+	public static void stopAutoService(Context context) {
+		AppConfigsUtil appConfigsUtil = AppConfigsUtil.getInstance(context);
+		appConfigsUtil.setIsEnableMainService(false);
+		appConfigsUtil.saveConfigs();
+		// 关闭并设置主服务
+		Intent intent1 = new Intent(context, MainService.class);
+		intent1.putExtra(MainService.EXTRA_IS_SETTING_TO_ENABLE, false);
+		context.stopService(intent1); // 先停止旧服务
+		context.startService(intent1); // 传入新的启动标志位，返回给系统
+		// 关闭并设置主服务守护进程
+		Intent intent2 = new Intent(context, AssistantService.class);
+		intent2.putExtra(AssistantService.EXTRA_IS_SETTING_TO_ENABLE, false);
+		context.stopService(intent2); // 先停止旧服务
+		context.startService(intent2); // 传入新的启动标志位，返回给系统
+		// 再次关闭所有服务
+		context.stopService(intent1);
+		context.stopService(intent2);
+
+		LogUtils.d(TAG, "stopAutoService");
+	}
+
+	public static void startAutoService(Context context) {
+		AppConfigsUtil appConfigsUtil = AppConfigsUtil.getInstance(context);
+		appConfigsUtil.setIsEnableMainService(true);
+		appConfigsUtil.saveConfigs();
+		Intent intent = new Intent(context, MainService.class);
+		intent.putExtra(MainService.EXTRA_IS_SETTING_TO_ENABLE, true);
+		context.startService(intent);
+		LogUtils.d(TAG, "startAutoService");
+	}
 }

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

@@ -0,0 +1,254 @@
+package cc.winboll.studio.positions.views;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/10/22 02:15
+ * @Describe DateTimePickerPopup
+ */
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.NumberPicker;
+import android.widget.PopupWindow;
+import java.util.Calendar;
+import cc.winboll.studio.positions.R;
+import cc.winboll.studio.positions.utils.DensityUtils;
+
+/**
+ * 日期时间选择弹窗（竖直滚动行：年、月、日、时、分）
+ */
+public class DateTimePickerPopup extends PopupWindow {
+	public static final String TAG = "DateTimePickerPopup";
+
+    private Context mContext;
+    private NumberPicker mPickerYear;
+    private NumberPicker mPickerMonth;
+    private NumberPicker mPickerDay;
+    private NumberPicker mPickerHour;
+    private NumberPicker mPickerMinute;
+    private Button mBtnCancel;
+    private Button mBtnConfirm;
+    private OnDateTimeSelectedListener mListener;
+
+    // 时间范围默认值
+    private int mMinYear = 2000;
+    private int mMaxYear = Calendar.getInstance().get(Calendar.YEAR) + 10;
+    private int mMinMonth = 1;
+    private int mMaxMonth = 12;
+    private int mMinDay = 1;
+    private int mMaxDay = 31;
+    private int mMinHour = 0;
+    private int mMaxHour = 23;
+    private int mMinMinute = 0;
+    private int mMaxMinute = 59;
+
+    // 默认选中时间
+    private int mDefaultYear;
+    private int mDefaultMonth;
+    private int mDefaultDay;
+    private int mDefaultHour;
+    private int mDefaultMinute;
+
+    /**
+     * 日期时间选择回调
+     */
+    public interface OnDateTimeSelectedListener {
+        void onDateTimeSelected(int year, int month, int day, int hour, int minute);
+        void onCancel();
+    }
+
+    /**
+     * Builder 模式
+     */
+    public static class Builder {
+        private Context mContext;
+        private DateTimePickerPopup mPopup;
+
+        public Builder(Context context) {
+            this.mContext = context;
+            mPopup = new DateTimePickerPopup(context);
+            Calendar calendar = Calendar.getInstance();
+            mPopup.mDefaultYear = calendar.get(Calendar.YEAR);
+            mPopup.mDefaultMonth = calendar.get(Calendar.MONTH) + 1;
+            mPopup.mDefaultDay = calendar.get(Calendar.DAY_OF_MONTH);
+            mPopup.mDefaultHour = calendar.get(Calendar.HOUR_OF_DAY);
+            mPopup.mDefaultMinute = calendar.get(Calendar.MINUTE);
+        }
+
+        public Builder setDateTimeRange(int minYear, int maxYear, int minMonth, int maxMonth,
+                                       int minDay, int maxDay, int minHour, int maxHour,
+                                       int minMinute, int maxMinute) {
+            mPopup.mMinYear = minYear;
+            mPopup.mMaxYear = maxYear;
+            mPopup.mMinMonth = minMonth;
+            mPopup.mMaxMonth = maxMonth;
+            mPopup.mMinDay = minDay;
+            mPopup.mMaxDay = maxDay;
+            mPopup.mMinHour = minHour;
+            mPopup.mMaxHour = maxHour;
+            mPopup.mMinMinute = minMinute;
+            mPopup.mMaxMinute = maxMinute;
+            return this;
+        }
+
+        public Builder setDefaultDateTime(int year, int month, int day, int hour, int minute) {
+            mPopup.mDefaultYear = year;
+            mPopup.mDefaultMonth = month;
+            mPopup.mDefaultDay = day;
+            mPopup.mDefaultHour = hour;
+            mPopup.mDefaultMinute = minute;
+            return this;
+        }
+
+        public Builder setOnDateTimeSelectedListener(OnDateTimeSelectedListener listener) {
+            mPopup.mListener = listener;
+            return this;
+        }
+
+        public DateTimePickerPopup build() {
+            mPopup.initView();
+            mPopup.initPickers();
+            mPopup.bindButtonClick();
+            mPopup.setPopupStyle();
+            return mPopup;
+        }
+    }
+
+    private DateTimePickerPopup(Context context) {
+        super(context);
+        this.mContext = context;
+    }
+
+    private void initView() {
+        LayoutInflater inflater = LayoutInflater.from(mContext);
+        View rootView = inflater.inflate(R.layout.dialog_date_time_picker, null, false);
+        setContentView(rootView);
+
+        mPickerYear = (NumberPicker) rootView.findViewById(R.id.picker_year);
+        mPickerMonth = (NumberPicker) rootView.findViewById(R.id.picker_month);
+        mPickerDay = (NumberPicker) rootView.findViewById(R.id.picker_day);
+        mPickerHour = (NumberPicker) rootView.findViewById(R.id.picker_hour);
+        mPickerMinute = (NumberPicker) rootView.findViewById(R.id.picker_minute);
+        mBtnCancel = (Button) rootView.findViewById(R.id.btn_cancel);
+        mBtnConfirm = (Button) rootView.findViewById(R.id.btn_confirm);
+    }
+
+    private void initPickers() {
+        // 初始化年选择器
+        mPickerYear.setMinValue(mMinYear);
+        mPickerYear.setMaxValue(mMaxYear);
+        mPickerYear.setValue(mDefaultYear);
+        mPickerYear.setWrapSelectorWheel(false);
+
+        // 初始化月选择器
+        mPickerMonth.setMinValue(mMinMonth);
+        mPickerMonth.setMaxValue(mMaxMonth);
+        mPickerMonth.setValue(mDefaultMonth);
+        mPickerMonth.setWrapSelectorWheel(false);
+
+        // 初始化日选择器（根据年月动态调整范围）
+        updateDayRange(mDefaultYear, mDefaultMonth);
+        mPickerDay.setValue(mDefaultDay);
+        mPickerDay.setWrapSelectorWheel(false);
+
+        // 初始化时选择器
+        mPickerHour.setMinValue(mMinHour);
+        mPickerHour.setMaxValue(mMaxHour);
+        mPickerHour.setValue(mDefaultHour);
+        mPickerHour.setWrapSelectorWheel(false);
+
+        // 初始化分选择器
+        mPickerMinute.setMinValue(mMinMinute);
+        mPickerMinute.setMaxValue(mMaxMinute);
+        mPickerMinute.setValue(mDefaultMinute);
+        mPickerMinute.setWrapSelectorWheel(false);
+
+        // 年月变化时更新日范围（Java 7 匿名内部类）
+        mPickerYear.setOnValueChangedListener(new NumberPicker.OnValueChangeListener() {
+            @Override
+            public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+                updateDayRange(newVal, mPickerMonth.getValue());
+            }
+        });
+
+        mPickerMonth.setOnValueChangedListener(new NumberPicker.OnValueChangeListener() {
+            @Override
+            public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+                updateDayRange(mPickerYear.getValue(), newVal);
+            }
+        });
+    }
+
+    private void updateDayRange(int year, int month) {
+        int maxDay;
+        switch (month) {
+            case 2:
+                if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
+                    maxDay = 29;
+                } else {
+                    maxDay = 28;
+                }
+                break;
+            case 4:
+            case 6:
+            case 9:
+            case 11:
+                maxDay = 30;
+                break;
+            default:
+                maxDay = 31;
+        }
+        mPickerDay.setMaxValue(maxDay);
+        if (mPickerDay.getValue() > maxDay) {
+            mPickerDay.setValue(maxDay);
+        }
+    }
+
+    private void bindButtonClick() {
+        // 取消按钮（Java 7 匿名内部类）
+        mBtnCancel.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                dismiss();
+                if (mListener != null) {
+                    mListener.onCancel();
+                }
+            }
+        });
+
+        // 确认按钮（Java 7 匿名内部类）
+        mBtnConfirm.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                int year = mPickerYear.getValue();
+                int month = mPickerMonth.getValue();
+                int day = mPickerDay.getValue();
+                int hour = mPickerHour.getValue();
+                int minute = mPickerMinute.getValue();
+
+                if (mListener != null) {
+                    mListener.onDateTimeSelected(year, month, day, hour, minute);
+                }
+                dismiss();
+            }
+        });
+    }
+
+    private void setPopupStyle() {
+        int width = (int) (DensityUtils.getScreenWidth(mContext) * 0.85f);
+        int height = ViewGroup.LayoutParams.WRAP_CONTENT;
+
+        setWidth(width);
+        setHeight(height);
+        setFocusable(true);
+        setOutsideTouchable(true);
+        setBackgroundDrawable(mContext.getResources().getDrawable(R.drawable.bg_dialog_round));
+        setAnimationStyle(R.style.PopupDateTimePickerAnim);
+    }
+
+    public void showAsDropDown(View anchorView) {
+        super.showAsDropDown(anchorView, 0, DensityUtils.dp2px(mContext, 10));
+    }
+}

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

@@ -3,7 +3,7 @@ package cc.winboll.studio.positions.views;
 /**
  * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
  * @Date 2025/09/30 08:09
- * @Describe 位置任务列表视图（支持简单/编辑模式，含 isBingo 红点标识）
+ * @Describe 位置任务列表视图（适配MainService唯一数据源+同步任务状态+支持简单/编辑模式）
  */
 import android.content.Context;
 import android.util.AttributeSet;
@@ -14,7 +14,6 @@ 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;
@@ -22,31 +21,39 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
+import cc.winboll.studio.libappbase.LogUtils;
 import cc.winboll.studio.positions.R;
 import cc.winboll.studio.positions.models.PositionTaskModel;
+import cc.winboll.studio.positions.services.MainService;
+import com.jzxiang.pickerview.TimePickerDialog;
+import com.jzxiang.pickerview.listener.OnDateSetListener;
+import java.text.SimpleDateFormat;
 import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
 import java.util.List;
+import java.util.Locale;
 
 public class PositionTaskListView extends LinearLayout {
     // 视图模式常量
     public static final int VIEW_MODE_SIMPLE = 1;
     public static final int VIEW_MODE_EDIT = 2;
 
-    // 核心成员变量
+    // 核心成员变量（新增MainService引用，作为唯一数据源）
     private String mBindPositionId;
-    private ArrayList<PositionTaskModel> mTaskList;
+    private MainService mMainService; // 持有MainService实例，所有任务数据从服务获取
     private int mCurrentViewMode;
     private TaskListAdapter mTaskAdapter;
     private RecyclerView mRvTasks;
 
-    // 任务修改回调接口
+    // 任务修改回调接口（保留，用于通知外部同步UI）
     public interface OnTaskUpdatedListener {
         void onTaskUpdated(String positionId, ArrayList<PositionTaskModel> updatedTasks);
     }
 
     private OnTaskUpdatedListener mOnTaskUpdatedListener;
 
-    // ---------------------- 构造函数 ----------------------
+    // ---------------------- 构造函数（不变，新增MainService空校验） ----------------------
     public PositionTaskListView(Context context) {
         super(context);
         initView(context);
@@ -62,7 +69,7 @@ public class PositionTaskListView extends LinearLayout {
         initView(context);
     }
 
-    // 初始化视图（绑定控件+设置布局）
+    // 初始化视图（绑定控件+设置布局，Adapter初始化为空数据）
     private void initView(Context context) {
         setOrientation(VERTICAL);
         LayoutInflater.from(context).inflate(R.layout.view_position_task_list, this, true);
@@ -70,94 +77,204 @@ public class PositionTaskListView extends LinearLayout {
         mRvTasks = (RecyclerView) findViewById(R.id.rv_position_tasks);
         mRvTasks.setLayoutManager(new LinearLayoutManager(context));
 
-        mTaskList = new ArrayList<PositionTaskModel>();
-        mTaskAdapter = new TaskListAdapter(mTaskList);
+        // 初始化为空列表（数据后续从MainService同步）
+        mTaskAdapter = new TaskListAdapter(new ArrayList<PositionTaskModel>());
         mRvTasks.setAdapter(mTaskAdapter);
 
         mCurrentViewMode = VIEW_MODE_SIMPLE;
+        LogUtils.d(TAG, "视图初始化完成（等待绑定MainService和位置ID）");
     }
 
-    // ---------------------- 对外API ----------------------
-    public void init(ArrayList<PositionTaskModel> taskList, String positionId) {
+    // ---------------------- 对外API（核心调整：绑定MainService+从服务同步数据） ----------------------
+    /**
+     * 初始化：绑定MainService+关联位置ID（必须先调用此方法，否则无数据）
+     * @param mainService MainService实例（从Activity传入，确保唯一数据源）
+     * @param positionId 关联的位置ID（只加载该位置下的任务）
+     */
+    public void init(MainService mainService, String positionId) {
+        if (mainService == null) {
+            LogUtils.e(TAG, "init失败：MainService实例为空（需从Activity传入有效服务实例）");
+            showToast("任务列表初始化失败：服务未就绪");
+            return;
+        }
+        if (positionId == null || positionId.trim().isEmpty()) {
+            LogUtils.e(TAG, "init失败：位置ID为空（需关联有效位置）");
+            showToast("任务列表初始化失败：未关联位置");
+            return;
+        }
+
+        // 绑定服务实例+位置ID
+        this.mMainService = mainService;
         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();
+        LogUtils.d(TAG, "已绑定MainService和位置ID：" + positionId);
+
+        // 从MainService同步当前位置的任务（核心：数据来源改为服务）
+        syncTasksFromMainService();
     }
 
+    /**
+     * 从MainService同步当前位置的任务（核心方法，所有数据加载入口）
+     * 作用：1. 清空本地缓存→2. 从服务获取全量任务→3. 筛选当前位置任务→4. 刷新Adapter
+     */
+    public void syncTasksFromMainService() {
+        // 安全校验（服务未绑定/位置ID为空，不执行同步）
+        if (mMainService == null || mBindPositionId == null || mBindPositionId.trim().isEmpty()) {
+            LogUtils.w(TAG, "同步任务失败：MainService未绑定或位置ID无效");
+            return;
+        }
+
+        try {
+            // 1. 从MainService获取全量任务（服务是唯一数据源，避免本地缓存不一致）
+            ArrayList<PositionTaskModel> allServiceTasks = mMainService.getAllTasks();
+            LogUtils.d(TAG, "从MainService获取全量任务数：" + (allServiceTasks == null ? 0 : allServiceTasks.size()));
+
+            // 2. 筛选当前位置关联的任务（只保留与mBindPositionId匹配的任务）
+            ArrayList<PositionTaskModel> currentPosTasks = new ArrayList<PositionTaskModel>();
+            if (allServiceTasks != null && !allServiceTasks.isEmpty()) {
+                for (PositionTaskModel task : allServiceTasks) {
+                    if (isTaskMatchedWithPosition(task)) {
+                        currentPosTasks.add(task);
+                    }
+                }
+            }
+            LogUtils.d(TAG, "筛选后当前位置任务数：" + currentPosTasks.size());
+
+            // 3. 更新Adapter数据（直接替换数据源，避免本地缓存）
+            mTaskAdapter.updateData(currentPosTasks);
+            LogUtils.d(TAG, "从MainService同步任务完成（Adapter已刷新）");
+
+        } catch (Exception e) {
+            LogUtils.d(TAG, "同步任务失败（MainService调用异常）：" + e.getMessage());
+            showToast("任务同步失败，请重试");
+        }
+    }
+
+    // 视图模式切换（不变，刷新Adapter触发视图类型变更）
     public void setViewStatus(int viewMode) {
         if (viewMode != VIEW_MODE_SIMPLE && viewMode != VIEW_MODE_EDIT) {
+            LogUtils.w(TAG, "设置视图模式失败：无效模式（仅支持简单/编辑模式）");
             return;
         }
         mCurrentViewMode = viewMode;
         mTaskAdapter.notifyDataSetChanged();
+        LogUtils.d(TAG, "已切换视图模式：" + (viewMode == VIEW_MODE_SIMPLE ? "简单模式" : "编辑模式"));
     }
 
+    // 保留回调接口（用于通知外部UI刷新，如Activity更新列表）
     public void setOnTaskUpdatedListener(OnTaskUpdatedListener listener) {
         this.mOnTaskUpdatedListener = listener;
+        LogUtils.d(TAG, "已设置任务更新回调监听");
     }
 
-    public ArrayList<PositionTaskModel> getAllTasks() {
-        return new ArrayList<PositionTaskModel>(mTaskList);
+    /**
+     * 获取当前位置的任务（从Adapter数据源获取，而非本地缓存）
+     * @return 当前位置任务列表（新集合，避免外部修改数据源）
+     */
+    public ArrayList<PositionTaskModel> getCurrentPosTasks() {
+        return new ArrayList<PositionTaskModel>(mTaskAdapter.getAdapterData());
     }
 
+    /**
+     * 清空数据（解绑服务+清空位置ID+重置Adapter）
+     * 场景：视图销毁/切换位置时调用，避免数据残留
+     */
     public void clearData() {
-        mTaskList.clear();
-        if (mTaskAdapter != null && mTaskAdapter.mData != null) {
-            mTaskAdapter.mData.clear();
-        }
-        mTaskAdapter.notifyDataSetChanged();
-        mBindPositionId = null;
+        // 1. 清空Adapter数据源
+        mTaskAdapter.updateData(new ArrayList<PositionTaskModel>());
+        // 2. 解绑服务+位置ID（避免下次使用时引用旧数据）
+        this.mMainService = null;
+        this.mBindPositionId = null;
+        // 3. 重置视图模式
+        mCurrentViewMode = VIEW_MODE_SIMPLE;
+        LogUtils.d(TAG, "数据已清空（解绑服务+重置视图）");
     }
 
+    /**
+     * 主动触发任务同步（强制从服务拉取最新数据，刷新视图）
+     * 场景：外部操作后（如新增任务），调用此方法更新列表
+     */
     public void triggerTaskSync() {
+        LogUtils.d(TAG, "主动触发任务同步（从MainService拉取最新数据）");
+        syncTasksFromMainService();
+
+        // 通知外部（如Activity）任务已更新（可选，根据业务需求）
         if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
-            mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<PositionTaskModel>(mTaskList));
+            mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, getCurrentPosTasks());
         }
     }
 
-    // ---------------------- 内部工具方法 ----------------------
+    // ---------------------- 内部工具方法（新增服务空校验） ----------------------
+    private static final String TAG = "PositionTaskListView";
+
+    /**
+     * 校验任务是否与当前绑定的位置匹配
+     * @param task 待校验的任务
+     * @return true=匹配（任务位置ID=当前绑定位置ID），false=不匹配
+     */
     private boolean isTaskMatchedWithPosition(PositionTaskModel task) {
         if (task == null || mBindPositionId == null || mBindPositionId.trim().isEmpty()) {
             return false;
         }
+        // 严格匹配任务的位置ID（确保只加载当前位置的任务）
         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;
+    /**
+     * 显示Toast（简化调用，避免重复代码）
+     */
+    private void showToast(String content) {
+        if (getContext() == null) return;
+        Toast.makeText(getContext(), content, Toast.LENGTH_SHORT).show();
     }
 
+    // ---------------------- 内部Adapter：适配MainService数据源（核心调整） ----------------------
+    private class TaskListAdapter extends RecyclerView.Adapter<TaskListAdapter.TaskViewHolder> {
+        // Adapter数据源（仅保留一份，直接从MainService同步，无本地冗余）
+        private List<PositionTaskModel> mAdapterData;
+
+        // 初始化Adapter（空数据源）
+        public TaskListAdapter(List<PositionTaskModel> data) {
+            this.mAdapterData = new ArrayList<PositionTaskModel>(data); // 防御性拷贝，避免外部修改
+        }
+
+        /**
+         * 更新Adapter数据源（核心：从MainService同步后调用，替换数据源并刷新）
+         * @param newData 从MainService筛选后的当前位置任务列表
+         */
+        public void updateData(List<PositionTaskModel> newData) {
+            if (newData == null) {
+                this.mAdapterData.clear();
+            } else {
+                this.mAdapterData = new ArrayList<PositionTaskModel>(newData); // 防御性拷贝
+            }
+            notifyDataSetChanged(); // 刷新列表（数据源已替换，确保显示最新数据）
+        }
+
+        /**
+         * 获取Adapter当前数据源（对外提供，避免直接操作mAdapterData）
+         * @return 当前数据源（新集合，避免外部修改）
+         */
+        public List<PositionTaskModel> getAdapterData() {
+            return new ArrayList<PositionTaskModel>(mAdapterData);
+        }
+
+        //  getItemCount：空列表显示1个“空提示”项，非空显示任务数
         @Override
         public int getItemCount() {
-            return mData.isEmpty() ? 1 : mData.size();
+            return mAdapterData.isEmpty() ? 1 : mAdapterData.size();
         }
 
-        // 调整：根据“是否空列表”+“视图模式”区分视图类型（确保简单/编辑模式加载对应布局）
+        //  getItemViewType：按“空列表/简单模式/编辑模式”区分视图类型（不变）
         @Override
         public int getItemViewType(int position) {
-            if (mData.isEmpty()) {
-                return 0; // 0=空提示
+            if (mAdapterData.isEmpty()) {
+                return 0; // 0=空提示视图
             } else {
-                return mCurrentViewMode; // 1=简单模式，2=编辑模式（复用视图模式常量）
+                return mCurrentViewMode; // 1=简单模式视图，2=编辑模式视图
             }
         }
 
-        // 调整：按视图类型加载布局（简单模式加载带红点的布局，编辑模式加载原有布局）
+        //  onCreateViewHolder：按视图类型加载对应布局（不变，确保布局与模式匹配）
         @NonNull
         @Override
         public TaskViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
@@ -165,150 +282,298 @@ public class PositionTaskListView extends LinearLayout {
             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 红点）
+                // 简单模式布局（带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);
             }
         }
 
-        // 调整：按视图类型绑定数据（简单模式绑定红点+文本，编辑模式绑定原有逻辑）
+        //  onBindViewHolder：按视图类型绑定数据（核心调整：操作后同步MainService）
         @Override
         public void onBindViewHolder(@NonNull TaskViewHolder holder, int position) {
-            // 空提示处理（不变）
+            // 1. 空提示视图绑定（根据模式显示不同提示文案）
             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 ? "暂无任务，点击\"添加新任务\"创建" : "暂无启用的任务");
+                TextView tvEmptyTip = emptyHolder.itemView.findViewById(R.id.tv_task_empty_tip);
+                tvEmptyTip.setText(mCurrentViewMode == VIEW_MODE_EDIT 
+								   ? "暂无任务，点击\"添加新任务\"创建" 
+								   : "暂无启用的任务");
                 return;
             }
 
-            // 任务项有效性校验（不变）
-            if (position >= mData.size()) {
+            // 2. 任务项有效性校验（避免越界/空数据）
+            if (position >= mAdapterData.size()) {
+                LogUtils.w(TAG, "绑定任务数据失败：位置索引越界（position=" + position + "，数据量=" + mAdapterData.size() + "）");
                 return;
             }
-            final PositionTaskModel task = mData.get(position);
+            final PositionTaskModel task = mAdapterData.get(position);
             if (task == null) {
+                LogUtils.w(TAG, "绑定任务数据失败：第" + position + "项任务为空");
                 return;
             }
 
-            // 简单模式：绑定红点（isBingo）和文本数据
+            // 3. 简单模式绑定（仅展示，无修改操作，不变）
             if (holder instanceof SimpleTaskViewHolder) {
                 SimpleTaskViewHolder simpleHolder = (SimpleTaskViewHolder) holder;
-                // 绑定任务描述
-                simpleHolder.tvSimpleTaskDesc.setText(String.format("任务：%s", task.getTaskDescription()));
-                // 绑定距离条件
+                // 任务描述
+                String taskDesc = task.getTaskDescription() == null ? "未设置描述" : task.getTaskDescription();
+                simpleHolder.tvSimpleTaskDesc.setText(String.format("任务：%s", taskDesc));
+				simpleHolder.tvStartTime.setText(genSelectedTimeText(task.getStartTime()));
+                // 距离条件（大于/小于+距离值）
                 String distanceCond = task.isGreaterThan() ? "大于" : "小于";
                 simpleHolder.tvSimpleDistanceCond.setText(String.format("条件：距离 %s %d 米", distanceCond, task.getDiscussDistance()));
-                // 绑定启用状态
+                // 启用状态
                 simpleHolder.tvSimpleIsEnable.setText(task.isEnable() ? "状态：已启用" : "状态：已禁用");
-                // 核心：根据 isBingo 控制红点显示（true=显示，false=隐藏）
+                // isBingo红点（任务触发时显示，未触发时隐藏）
                 simpleHolder.vBingoDot.setVisibility(task.isBingo() ? View.VISIBLE : View.GONE);
-            }
-            // 编辑模式：沿用原有绑定逻辑（核心修复在此处）
-            else if (holder instanceof TaskContentViewHolder) {
+            } else if (holder instanceof TaskContentViewHolder) {
                 TaskContentViewHolder contentHolder = (TaskContentViewHolder) holder;
-                bindTaskData(contentHolder, task, position);
+                bindEditModeTask(contentHolder, task, position);
             }
         }
 
-        // ---------------------- 核心修复：编辑模式绑定逻辑（解决布局中通知异常） ----------------------
-        private void bindTaskData(final TaskContentViewHolder holder, final PositionTaskModel task, final int position) {
-            String taskDesc = (task.getTaskDescription() == null) ? "未设置描述" : task.getTaskDescription();
+        /**
+         * 编辑模式任务绑定（核心：修改操作→更新MainService→刷新Adapter）
+         */
+        private void bindEditModeTask(final TaskContentViewHolder holder, final PositionTaskModel task, final int position) {
+            // 4.1 绑定基础数据（描述+距离条件）
+            String taskDesc = task.getTaskDescription() == null ? "未设置描述" : task.getTaskDescription();
             holder.tvTaskDesc.setText(String.format("任务：%s", taskDesc));
+            String distanceCond = task.isGreaterThan() ? "大于" : "小于";
+            holder.tvTaskDistance.setText(String.format("条件：%s %d 米", distanceCond, task.getDiscussDistance()));
+			holder.tvStartTime.setText(genSelectedTimeText(task.getStartTime()));
 
-            String distanceCondition = task.isGreaterThan() ? "大于" : "小于";
-            holder.tvTaskDistance.setText(String.format("条件：%s %d 米", distanceCondition, task.getDiscussDistance()));
-
-            // 修复点1：先移除开关监听，再设置状态（避免设值时触发回调导致异常）
+            // 4.2 绑定“启用开关”（修复：先解绑监听→设值→再绑定监听，避免设值触发回调）
             holder.cbTaskEnable.setOnCheckedChangeListener(null);
             holder.cbTaskEnable.setChecked(task.isEnable());
-            holder.cbTaskEnable.setEnabled(mCurrentViewMode == VIEW_MODE_EDIT);
+            holder.cbTaskEnable.setEnabled(mCurrentViewMode == VIEW_MODE_EDIT); // 编辑模式才允许操作
 
-            if (mCurrentViewMode == VIEW_MODE_EDIT) {
+            // 4.3 编辑模式特有：显示编辑/删除按钮（仅编辑模式可见）
             holder.btnEditTask.setVisibility(View.VISIBLE);
             holder.btnDeleteTask.setVisibility(View.VISIBLE);
 
-                // 删除按钮逻辑（不变，本身在点击时执行，不涉及布局中通知）
+            // 4.4 删除按钮逻辑（核心：删除→同步MainService→刷新Adapter）
             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));
+						if (mMainService == null) {
+							showToast("删除失败：服务未就绪");
+							LogUtils.e(TAG, "删除任务失败：MainService实例为空");
+							return;
+						}
+
+						try {
+							// 步骤1：调用MainService删除任务（服务是唯一数据源，确保数据一致性）
+							mMainService.deleteTask(task.getTaskId()); // 需在MainService中实现deleteTask()方法（删除服务内全量任务列表中的对应项）
+							LogUtils.d(TAG, "调用MainService删除任务：ID=" + task.getTaskId() + "（位置ID=" + mBindPositionId + "）");
+
+							// 步骤2：从Adapter数据源移除任务（避免等待同步，立即反馈UI）
+							//mAdapterData.remove(position);
+							// 步骤3：刷新Adapter（局部刷新+范围通知，避免列表错乱）
+							notifyItemRemoved(position);
+							notifyItemRangeChanged(position, mAdapterData.size());
+							
+							LogUtils.d(TAG, "Adapter已移除任务，刷新列表（位置索引=" + position + "）");
+
+							// 步骤4：通知外部（如Activity）任务已更新
+							if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
+								mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<PositionTaskModel>(mAdapterData));
+							}
+							showToast("任务已删除（已同步至服务）");
+
+						} catch (Exception e) {
+							LogUtils.d(TAG, "删除任务失败（服务调用/Adapter刷新异常）：" + e.getMessage());
+							showToast("删除失败，请重试");
+							// 异常时重新同步数据（确保Adapter与服务一致）
+							syncTasksFromMainService();
 						}
-							Toast.makeText(getContext(), "任务已删除", Toast.LENGTH_SHORT).show();
 					}
 				});
 
-                // 编辑按钮逻辑（不变，弹窗保存时修复通知时机）
+            // 4.5 编辑按钮逻辑（核心：修改后同步MainService→刷新Adapter）
             holder.btnEditTask.setOnClickListener(new View.OnClickListener() {
 					@Override
 					public void onClick(View v) {
-							showTaskEditDialog(task, position);
+						if (mMainService == null) {
+							showToast("编辑失败：服务未就绪");
+							LogUtils.e(TAG, "编辑任务失败：MainService实例为空");
+							return;
+						}
+						// 弹出编辑弹窗（修改后同步服务）
+						showEditTaskDialog(task, position);
 					}
 				});
 
-                // 修复点2：开关监听-用 RecyclerView.post 延迟执行 notify（避免布局中调用）
+            // 4.6 启用开关逻辑（核心：状态变更→同步MainService→刷新Adapter）
             holder.cbTaskEnable.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
 					@Override
-						public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
-							task.setIsEnable(isChecked); // 先更新数据源（必须执行）
-							// 关键：通过 mRvTasks.post 延迟通知，确保在布局计算/滚动结束后执行
+					public void onCheckedChanged(CompoundButton buttonView, final boolean isChecked) {
+						if (mMainService == null) {
+							showToast("状态修改失败：服务未就绪");
+							LogUtils.e(TAG, "修改任务启用状态失败：MainService实例为空");
+							// 回滚开关状态（避免UI与服务不一致）
+							buttonView.setChecked(!isChecked);
+							return;
+						}
+
+						try {
+							// 步骤1：更新任务状态（先改内存数据，确保UI反馈及时）
+							task.setIsEnable(isChecked);
+							LogUtils.d(TAG, "更新任务启用状态：ID=" + task.getTaskId() + "，新状态=" + (isChecked ? "启用" : "禁用"));
+
+							// 步骤2：调用MainService同步状态（服务是唯一数据源，持久化变更）
+							mMainService.updateTaskStatus(task); // 需在MainService中实现updateTaskStatus()方法（更新服务内任务的isEnable字段）
+							LogUtils.d(TAG, "调用MainService同步任务状态（已" + (isChecked ? "启用" : "禁用") + "）");
+
+							// 步骤3：延迟刷新Adapter（避免列表滚动/布局计算时异常）
 							mRvTasks.post(new Runnable() {
 									@Override
 									public void run() {
 										notifyItemChanged(position);
+										// 通知外部任务已更新
 										if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
-											mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<PositionTaskModel>(mData));
+											mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<PositionTaskModel>(mAdapterData));
 										}
 									}
 								});
+
+						} catch (Exception e) {
+							LogUtils.d(TAG, "修改任务启用状态失败：" + e.getMessage());
+							showToast("状态修改失败，请重试");
+							// 回滚状态（UI与服务保持一致）
+							buttonView.setChecked(!isChecked);
+							task.setIsEnable(!isChecked);
+							// 重新同步数据（修复可能的不一致）
+							syncTasksFromMainService();
+						}
 					}
 				});
-            } else {
-                holder.btnEditTask.setVisibility(View.GONE);
-                holder.btnDeleteTask.setVisibility(View.GONE);
-                holder.cbTaskEnable.setOnCheckedChangeListener(null);
-            }
         }
 		
-        // ---------------------- 修复：编辑弹窗保存逻辑（延迟通知，避免极端场景异常） ----------------------
-        private void showTaskEditDialog(final PositionTaskModel task, final int position) {
+		private String genSelectedTimeText(long timeMillis) {
+			// 2. 格式化时间字符串（Java 7 用 SimpleDateFormat，需处理 ParseException）
+			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.getDefault());
+			String formattedDateTime = sdf.format(new Date(timeMillis)); // Date 需导入 java.util.Date
+
+			return formattedDateTime;
+		}
+
+        /**
+         * 编辑任务弹窗（核心：保存修改→同步MainService→刷新Adapter）
+         */
+        private void showEditTaskDialog(final PositionTaskModel task, final int position) {
             final Context context = getContext();
+            if (context == null) {
+                LogUtils.w(TAG, "编辑弹窗无法显示：上下文为空");
+                return;
+            }
+
+            // 加载弹窗布局
             View dialogView = LayoutInflater.from(context).inflate(R.layout.dialog_edit_task, null);
+            final EditText etEditDesc = dialogView.findViewById(R.id.et_edit_task_desc);
+            final RadioGroup rgDistanceCondition = dialogView.findViewById(R.id.rg_distance_condition);
+            final EditText etEditDistance = dialogView.findViewById(R.id.et_edit_distance);
+			Button btnCancel = dialogView.findViewById(R.id.btn_dialog_cancel);
+            Button btnSave = dialogView.findViewById(R.id.btn_dialog_save);
 
-            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());
+			// 绑定外层对话框内的控件
+			final Button btnSelectTime = (Button) dialogView.findViewById(R.id.btn_select_time);
+			final TextView tv_SelectedTime = (TextView) dialogView.findViewById(R.id.tv_selected_time);
 
+			tv_SelectedTime.setText(genSelectedTimeText(task.getStartTime()));
+
+			// 核心：从 long 时间戳解析年月日时分，用于初始化弹窗
+			// --------------------------
+			Calendar initCalendar = Calendar.getInstance();
+			initCalendar.setTimeInMillis(task.getStartTime()); // 将 long 时间戳传入 Calendar
+
+			// 从 Calendar 中解析出年月日时分（对应弹窗需要的参数格式）
+			int initYear = initCalendar.get(Calendar.YEAR);
+			int initMonth = initCalendar.get(Calendar.MONTH) + 1; // 关键：Calendar 月份0-11，转成1-12
+			int initDay = initCalendar.get(Calendar.DAY_OF_MONTH);
+			int initHour = initCalendar.get(Calendar.HOUR_OF_DAY); // 24小时制
+			int initMinute = initCalendar.get(Calendar.MINUTE);
+
+			// 初始化弹窗，用解析出的年月日时分设置默认选中时间
+			final DateTimePickerPopup dateTimePopup = new DateTimePickerPopup.Builder(context)
+				.setDateTimeRange(2020, 2030, 1, 12, 1, 31, 0, 23, 0, 59)
+				// 用 long 时间戳解析出的参数设置初始时间
+				.setDefaultDateTime(initYear, initMonth, initDay, initHour, initMinute)
+				.setOnDateTimeSelectedListener(new DateTimePickerPopup.OnDateTimeSelectedListener() {
+					@Override
+					public void onDateTimeSelected(int year, int month, int day, int hour, int minute) {
+						// 处理选择的日期时间
+						// 1. 创建 Calendar 实例（用于组装日期时间）
+						Calendar calendar = Calendar.getInstance();
+						// 2. 设置 Calendar 的年、月、日、时、分（注意：Calendar 月份从 0 开始，需减 1）
+						calendar.set(Calendar.YEAR, year);
+						calendar.set(Calendar.MONTH, month - 1); // 关键：传入的 month 是 1-12，需转为 0-11
+						calendar.set(Calendar.DAY_OF_MONTH, day);
+						calendar.set(Calendar.HOUR_OF_DAY, hour); // 24小时制，对应参数中的 hour（0-23）
+						calendar.set(Calendar.MINUTE, minute);
+						calendar.set(Calendar.SECOND, 0); // 秒默认设为 0，避免随机值
+						calendar.set(Calendar.MILLISECOND, 0); // 毫秒默认设为 0，确保时间戳精确
+
+						// 3. 转为 long 类型时间戳（单位：毫秒，从 1970-01-01 00:00:00 开始计算）
+						long timeMillis = calendar.getTimeInMillis();
+
+						// 4. 后续使用（示例：打印时间戳或传递给其他逻辑）
+						tv_SelectedTime.setText(genSelectedTimeText(timeMillis));
+						task.setStartTime(timeMillis);
+					}
+
+					@Override
+					public void onCancel() {
+						// 处理取消操作
+					}
+				})
+				.build();
+
+			// 3. “选择时间”按钮点击事件（弹出 TimePickerPopup）
+			btnSelectTime.setOnClickListener(new View.OnClickListener() {
+					@Override
+					public void onClick(final View v) {
+						dateTimePopup.showAsDropDown(btnSelectTime);
+					}
+				});
+
+
+            // 初始化弹窗数据（填充当前任务信息）
+            etEditDesc.setText(task.getTaskDescription() == null ? "" : 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())); // 填充当前距离
 
-            etEditDistance.setText(String.valueOf(task.getDiscussDistance()));
-
+            // 创建并显示弹窗
             final android.app.AlertDialog dialog = new android.app.AlertDialog.Builder(context)
 				.setView(dialogView)
+				.setCancelable(false) // 不允许点击外部关闭（避免未保存退出）
 				.create();
             dialog.show();
 
+
+
+			final OnDateSetListener onSateSetListener = new OnDateSetListener(){
+				@Override
+				public void onDateSet(TimePickerDialog timePickerDialog, long p) {
+				}
+			};
+
+            // 取消按钮：关闭弹窗（不做操作）
             btnCancel.setOnClickListener(new View.OnClickListener() {
 					@Override
 					public void onClick(View v) {
@@ -316,14 +581,17 @@ public class PositionTaskListView extends LinearLayout {
 					}
 				});
 
+            // 保存按钮：校验输入→更新任务→同步服务→刷新UI
             btnSave.setOnClickListener(new View.OnClickListener() {
 					@Override
 					public void onClick(View v) {
+						// 1. 输入校验（避免无效数据）
 						String newDesc = etEditDesc.getText().toString().trim();
 						String distanceStr = etEditDistance.getText().toString().trim();
 
 						if (distanceStr.isEmpty()) {
-							Toast.makeText(context, "请输入有效距离", Toast.LENGTH_SHORT).show();
+							showToast("请输入有效距离（1米及以上）");
+							etEditDistance.requestFocus();
 							return;
 						}
 
@@ -331,85 +599,153 @@ public class PositionTaskListView extends LinearLayout {
 						try {
 							newDistance = Integer.parseInt(distanceStr);
 							if (newDistance < 1) {
-								Toast.makeText(context, "距离不能小于1米", Toast.LENGTH_SHORT).show();
+								showToast("距离不能小于1米");
+								etEditDistance.requestFocus();
 								return;
 							}
 						} catch (NumberFormatException e) {
-							Toast.makeText(context, "距离请输入数字", Toast.LENGTH_SHORT).show();
+							showToast("距离请输入数字");
+							etEditDistance.requestFocus();
 							return;
 						}
 
-						task.setTaskDescription(newDesc);
-						task.setDiscussDistance(newDistance);
+						// 2. 收集新数据（更新任务对象）
+						task.setTaskDescription(newDesc); // 新描述
+						task.setDiscussDistance(newDistance); // 新距离
 						boolean isGreater = rgDistanceCondition.getCheckedRadioButtonId() == R.id.rb_greater_than;
-						task.setIsGreaterThan(isGreater);
-						task.setPositionId(mBindPositionId);
+						task.setIsGreaterThan(isGreater); // 新距离条件（大于/小于）
+						task.setPositionId(mBindPositionId); // 确保位置ID不变（防止错位）
 
-						// 修复点3：弹窗保存后延迟通知（同开关逻辑，避免列表滚动时异常）
+						try {
+							// 3. 调用MainService同步修改（服务是唯一数据源，持久化变更）
+							mMainService.updateTask(task); // 需在MainService中实现updateTask()方法（更新服务内任务的字段）
+							LogUtils.d(TAG, "调用MainService更新任务：ID=" + task.getTaskId() + "（描述=" + newDesc + "，距离=" + newDistance + "米）");
+
+							// 4. 更新Adapter数据源（立即反馈UI）
+							mAdapterData.set(position, task);
+							// 5. 延迟刷新Adapter（避免弹窗未关闭时布局异常）
 							mRvTasks.post(new Runnable() {
 									@Override
 									public void run() {
 										notifyItemChanged(position);
+										// 通知外部任务已更新
 										if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
-										mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<PositionTaskModel>(mData));
+											mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<PositionTaskModel>(mAdapterData));
 										}
 									}
 								});
 
 							dialog.dismiss();
-						Toast.makeText(context, "任务已更新", Toast.LENGTH_SHORT).show();
+							showToast("任务已更新（已同步至服务）");
+
+						} catch (Exception e) {
+							LogUtils.d(TAG, "保存任务修改失败：" + e.getMessage());
+							showToast("保存失败，请重试");
+							// 重新同步数据（修复可能的不一致）
+							syncTasksFromMainService();
+						}
 					}
 				});
         }
 
-        // ---------------------- ViewHolder 定义（完全不变） ----------------------
-        // 基础抽象 ViewHolder（不变）
+        // ---------------------- ViewHolder 定义（完全适配布局，无修改） ----------------------
+        // 基础抽象ViewHolder（统一父类，适配多视图类型）
         public abstract class TaskViewHolder extends RecyclerView.ViewHolder {
             public TaskViewHolder(@NonNull View itemView) {
                 super(itemView);
             }
         }
 
-        // 空提示 Holder（不变）
+        // 空提示ViewHolder（对应 item_task_empty.xml）
         public class EmptyViewHolder extends TaskViewHolder {
             public EmptyViewHolder(@NonNull View itemView) {
                 super(itemView);
             }
         }
 
-        // 新增：简单模式 Holder（绑定带红点的布局控件）
+        // 简单模式ViewHolder（对应 item_position_task_simple.xml，带isBingo红点）
         public class SimpleTaskViewHolder extends TaskViewHolder {
             TextView tvSimpleTaskDesc;    // 任务描述
-            TextView tvSimpleDistanceCond;// 距离条件
-            TextView tvSimpleIsEnable;    // 启用状态
-            View vBingoDot;               // isBingo 红点控件
+            TextView tvSimpleDistanceCond;// 距离条件（大于/小于+距离）
+			TextView tvStartTime;
+            TextView tvSimpleIsEnable;    // 启用状态（已启用/已禁用）
+            View vBingoDot;               // isBingo红点（任务触发时显示）
 
             public SimpleTaskViewHolder(@NonNull View itemView) {
                 super(itemView);
-                // 绑定简单模式布局中的控件（与 item_task_simple.xml 完全对应）
+                // 绑定简单模式布局控件（与XML控件ID严格对应）
                 tvSimpleTaskDesc = itemView.findViewById(R.id.tv_simple_task_desc);
                 tvSimpleDistanceCond = itemView.findViewById(R.id.tv_simple_distance_cond);
+				tvStartTime = itemView.findViewById(R.id.tv_starttime);
                 tvSimpleIsEnable = itemView.findViewById(R.id.tv_simple_is_enable);
                 vBingoDot = itemView.findViewById(R.id.v_bingo_dot);
             }
         }
 
-        // 编辑模式 Holder（原有逻辑，完全不变）
+        // 编辑模式ViewHolder（对应 item_task_content.xml，带编辑/删除/开关）
         public class TaskContentViewHolder extends TaskViewHolder {
-            TextView tvTaskDesc;
-            TextView tvTaskDistance;
-            CompoundButton cbTaskEnable;
-            Button btnEditTask;
-            Button btnDeleteTask;
+            TextView tvTaskDesc;         // 任务描述
+            TextView tvTaskDistance;     // 距离条件
+			TextView tvStartTime;
+            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);
-            }
+                // 绑定编辑模式布局控件（与XML控件ID严格对应）
+                tvTaskDesc = itemView.findViewById(R.id.tv_task_desc);
+                tvTaskDistance = itemView.findViewById(R.id.tv_task_distance);
+				tvStartTime = itemView.findViewById(R.id.tv_starttime);
+                cbTaskEnable = itemView.findViewById(R.id.cb_task_enable);
+                btnEditTask = itemView.findViewById(R.id.btn_edit_task);
+                btnDeleteTask = itemView.findViewById(R.id.btn_delete_task);
+            }
+        }
+    }
+
+    // ---------------------- 新增：外部调用“新增任务”方法（适配MainService） ----------------------
+    /**
+     * 新增任务（对外提供，如Activity调用添加任务）
+     * @param newTask 待新增的任务（需关联当前位置ID）
+     */
+    public void addNewTask(PositionTaskModel newTask) {
+        if (mMainService == null) {
+            showToast("新增任务失败：服务未就绪");
+            LogUtils.e(TAG, "新增任务失败：MainService实例为空");
+            return;
+        }
+        if (newTask == null) {
+            showToast("新增任务失败：任务数据为空");
+            LogUtils.e(TAG, "新增任务失败：待新增任务对象为空");
+            return;
+        }
+        if (mBindPositionId == null || mBindPositionId.trim().isEmpty()) {
+            showToast("新增任务失败：未关联位置");
+            LogUtils.e(TAG, "新增任务失败：未绑定位置ID（需先调用init()方法）");
+            return;
+        }
+
+        try {
+            // 1. 关联任务到当前位置（确保任务属于当前位置）
+            newTask.setPositionId(mBindPositionId);
+            // 2. 调用MainService新增任务（服务是唯一数据源，持久化数据）
+            mMainService.addTask(newTask); // 需在MainService中实现addTask()方法（添加到服务内全量任务列表）
+            LogUtils.d(TAG, "调用MainService新增任务：ID=" + newTask.getTaskId() + "（位置ID=" + mBindPositionId + "）");
+
+            // 3. 重新同步数据（从服务拉取最新列表，避免本地计算错误）
+            syncTasksFromMainService();
+            // 4. 通知外部任务已更新
+            if (mOnTaskUpdatedListener != null) {
+                mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, getCurrentPosTasks());
+            }
+            showToast("新增任务成功（已同步至服务）");
+
+        } catch (Exception e) {
+            LogUtils.d(TAG, "新增任务失败：" + e.getMessage());
+            showToast("新增失败，请重试");
+            // 重新同步数据（修复可能的不一致）
+            syncTasksFromMainService();
         }
     }
 }

positions/src/main/res/anim/popup_date_time_picker_in.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+    android:duration="300">
+    <translate
+        android:fromYDelta="50%"
+        android:toYDelta="0%"
+        android:interpolator="@android:anim/decelerate_interpolator" />
+    <alpha
+        android:fromAlpha="0.6"
+        android:toAlpha="1.0"
+        android:interpolator="@android:anim/decelerate_interpolator" />
+</set>

positions/src/main/res/anim/popup_date_time_picker_out.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+    android:duration="250">
+    <translate
+        android:fromYDelta="0%"
+        android:toYDelta="50%"
+        android:interpolator="@android:anim/accelerate_interpolator" />
+    <alpha
+        android:fromAlpha="1.0"
+        android:toAlpha="0.6"
+        android:interpolator="@android:anim/accelerate_interpolator" />
+</set>

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

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <!-- 白色背景 -->
+    <solid android:color="#FFFFFF" />
+    <!-- 圆角（12dp，可根据需求调整） -->
+    <corners android:radius="12dp" />
+    <!-- 轻微阴影（增强层次感） -->
+    <stroke
+        android:width="1dp"
+        android:color="#00000008" /> <!-- 透明黑色阴影，避免生硬 -->
+</shape>
+

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

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <!-- 透明背景 -->
+    <solid android:color="#00000000" />
+    <!-- 灰色边框（与取消按钮文字同色） -->
+    <stroke
+        android:width="1dp"
+        android:color="#FF333333" />
+    <!-- 圆角（与弹窗一致，12dp） -->
+    <corners android:radius="12dp" />
+</shape>
+

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

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <!-- 填充色（示例深灰色，可改为 #FF007AFF 等主题色） -->
+    <solid android:color="#FF333333" />
+    <!-- 圆角（与弹窗一致） -->
+    <corners android:radius="12dp" />
+</shape>
+

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

@@ -0,0 +1,74 @@
+<?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="@drawable/bg_dialog_round">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="center">
+
+        <NumberPicker
+            android:id="@+id/picker_year"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1" />
+
+        <NumberPicker
+            android:id="@+id/picker_month"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1" />
+
+        <NumberPicker
+            android:id="@+id/picker_day"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1" />
+
+        <NumberPicker
+            android:id="@+id/picker_hour"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1" />
+
+        <NumberPicker
+            android:id="@+id/picker_minute"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1" />
+    </LinearLayout>
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="end"
+        android:layout_marginTop="16dp"
+        android:spacing="12dp">
+
+        <Button
+            android:id="@+id/btn_cancel"
+            android:layout_width="wrap_content"
+            android:layout_height="42dp"
+            android:minWidth="80dp"
+            android:background="@drawable/btn_dialog_cancel"
+            android:text="取消"
+            android:textSize="16sp" />
+
+        <Button
+            android:id="@+id/btn_confirm"
+            android:layout_width="wrap_content"
+            android:layout_height="42dp"
+            android:minWidth="80dp"
+            android:background="@drawable/btn_dialog_confirm"
+            android:text="确认"
+            android:textSize="16sp"
+            android:textColor="@android:color/white" />
+    </LinearLayout>
+</LinearLayout>
+

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

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<LinearLayout
+	xmlns:android="http://schemas.android.com/apk/res/android"
 	android:layout_width="match_parent"
 	android:layout_height="wrap_content"
 	android:orientation="vertical"
@@ -14,12 +15,19 @@
 		android:maxLines="1"
 		android:textSize="14sp"/>
 
-    <RadioGroup
-        android:id="@+id/rg_distance_condition"
+	<LinearLayout
+		android:orientation="horizontal"
 		android:layout_width="match_parent"
 		android:layout_height="wrap_content"
+		android:layout_marginTop="12dp"
+		android:gravity="center_vertical">
+
+		<RadioGroup
+			android:id="@+id/rg_distance_condition"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
 			android:orientation="horizontal"
-        android:layout_marginTop="12dp">
+			android:layout_marginRight="10dp">
 
 			<RadioButton
 				android:id="@+id/rb_greater_than"
@@ -35,20 +43,50 @@
 				android:layout_height="wrap_content"
 				android:text="小于"
 				android:textColor="@color/black"
-            android:textSize="14sp"
-            android:layout_marginLeft="24dp" />
+				android:textSize="14sp"/>
 
 		</RadioGroup>
 
 		<EditText
 			android:id="@+id/et_edit_distance"
-        android:layout_width="match_parent"
+			android:layout_width="0dp"
+			android:layout_weight="1.0"
 			android:layout_height="wrap_content"
 			android:hint="输入距离（米）"
 			android:inputType="number"
 			android:maxLines="1"
-        android:textSize="14sp"
-        android:layout_marginTop="8dp" />
+			android:textSize="14sp"/>
+
+		<TextView
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:text="米"
+			android:layout_marginRight="10dp"/>
+
+	</LinearLayout>
+
+	<LinearLayout
+		android:orientation="horizontal"
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:layout_marginTop="12dp"
+		android:gravity="center_vertical">
+
+		<Button
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:text="开始时间"
+			android:id="@+id/btn_select_time"/>
+		
+		<TextView
+			android:id="@+id/tv_selected_time"
+			android:layout_width="0dp"
+			android:layout_height="wrap_content"
+			android:text="Text"
+			android:layout_weight="1.0"/>
+
+
+	</LinearLayout>
 
 	<LinearLayout
 		android:layout_width="match_parent"

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

@@ -1,5 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- 根布局改为 RelativeLayout，支持红点右上角定位（原 LinearLayout 无法便捷实现绝对位置） -->
 <RelativeLayout
 	xmlns:android="http://schemas.android.com/apk/res/android"
 	android:layout_width="match_parent"
@@ -9,7 +8,6 @@
 	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"
@@ -19,9 +17,8 @@
 		android:layout_marginRight="2dp"
 		android:layout_marginTop="2dp"
 		android:background="@drawable/bg_bingo_dot"
-        android:visibility="gone"/>  <!-- 默认隐藏，仅任务触发（isBingo=true）时显示 -->
+		android:visibility="gone"/>
 
-    <!-- 2. 任务描述（原控件不变，位置受红点不影响） -->
 	<TextView
 		android:id="@+id/tv_simple_task_desc"
 		android:layout_width="wrap_content"
@@ -30,7 +27,6 @@
 		android:textColor="#333333"
 		android:text="任务：无描述"/>
 
-    <!-- 3. 距离条件（原控件不变） -->
 	<TextView
 		android:id="@+id/tv_simple_distance_cond"
 		android:layout_width="wrap_content"
@@ -39,9 +35,34 @@
 		android:textColor="#666666"
 		android:layout_marginTop="6dp"
 		android:layout_below="@id/tv_simple_task_desc"
-        android:text="条件：距离 > 0 米"/>
+		android:text="条件：距离 &gt; 0 米"/>
+
+	<LinearLayout
+		android:orientation="horizontal"
+		android:layout_marginTop="6dp"
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:layout_below="@id/tv_simple_distance_cond"
+		android:id="@+id/ll_starttime"
+		android:gravity="center_vertical">
+
+		<TextView
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:textSize="14sp"
+			android:textColor="#666666"
+			android:text="开始时间："/>
+
+		<TextView
+			android:id="@+id/tv_starttime"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:textSize="14sp"
+			android:textColor="#666666"
+			android:text=""/>
+
+	</LinearLayout>
 
-    <!-- 4. 启用状态（原控件不变） -->
 	<TextView
 		android:id="@+id/tv_simple_is_enable"
 		android:layout_width="wrap_content"
@@ -49,7 +70,7 @@
 		android:textSize="14sp"
 		android:textColor="#2E8B57"
 		android:layout_marginTop="4dp"
-        android:layout_below="@id/tv_simple_distance_cond"
+		android:layout_below="@id/ll_starttime"
 		android:text="状态：已启用"/>
 
 </RelativeLayout>

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

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<LinearLayout
+	xmlns:android="http://schemas.android.com/apk/res/android"
 	android:layout_width="match_parent"
 	android:layout_height="wrap_content"
 	android:orientation="horizontal"
@@ -15,10 +16,15 @@
 		android:layout_marginRight="12dp"/>
 
 	<LinearLayout
+		android:orientation="vertical"
 		android:layout_width="0dp"
 		android:layout_height="wrap_content"
-        android:layout_weight="1"
-        android:orientation="vertical">
+		android:layout_weight="1.0">
+
+		<LinearLayout
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:orientation="horizontal">
 
 			<TextView
 				android:id="@+id/tv_task_desc"
@@ -28,6 +34,13 @@
 				android:textSize="16sp"
 				android:textColor="@color/black"/>
 
+		</LinearLayout>
+
+		<LinearLayout
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:orientation="horizontal">
+
 			<TextView
 				android:id="@+id/tv_task_distance"
 				android:layout_width="wrap_content"
@@ -39,11 +52,36 @@
 
 		</LinearLayout>
 
+		<LinearLayout
+			android:orientation="horizontal"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:layout_below="@id/tv_simple_distance_cond"
+			android:id="@+id/ll_starttime"
+			android:gravity="center_vertical">
+
+			<TextView
+				android:layout_width="wrap_content"
+				android:layout_height="wrap_content"
+				android:textSize="12sp"
+				android:textColor="#666666"
+				android:text="开始时间："/>
+
+			<TextView
+				android:id="@+id/tv_starttime"
+				android:layout_width="wrap_content"
+				android:layout_height="wrap_content"
+				android:textSize="12sp"
+				android:textColor="#666666"
+				android:text=""/>
+
+		</LinearLayout>
+
 		<LinearLayout
 			android:layout_width="wrap_content"
 			android:layout_height="wrap_content"
 			android:orientation="horizontal"
-        android:layout_marginLeft="8dp">
+			android:layout_gravity="center">
 
 			<Button
 				android:id="@+id/btn_edit_task"
@@ -68,3 +106,5 @@
 
 	</LinearLayout>
 
+</LinearLayout>
+

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

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <string name="app_name">寻龙记</string>
+    <string name="app_name">悟空笔记</string>
 </resources>

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

@@ -29,5 +29,11 @@
 	<!-- 扩展颜色（避免后续新增功能时再次缺失） -->
 	<color name="green">#4CAF50</color> <!-- 绿色（备用：如“启用”状态标识） -->
 	<color name="yellow">#FFC107</color> <!-- 黄色（备用：如“提醒”标识） -->
+    <color name="color_text_primary">#333333</color>
+    <color name="color_gray">#999999</color>
+    <color name="color_gray_light">#F5F5F5</color>
+    <color name="color_shadow">#1A000000</color>
+    <color name="color_primary">#2196F3</color> <!-- 主题蓝 -->
+    <color name="color_primary_dark">#1976D2</color> <!-- 主题蓝加深 -->
 	
 </resources>

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

@@ -8,4 +8,10 @@
         <item name="colorAccent">@color/colorAccent</item>
     </style>
 
+	<style name="PopupDateTimePickerAnim" parent="android:Animation">
+		<item name="android:windowEnterAnimation">@anim/popup_date_time_picker_in</item>
+		<item name="android:windowExitAnimation">@anim/popup_date_time_picker_out</item>
+	</style>
+
+
 </resources>