<positions>APK 15.0.8 release Publish.

positions/build.properties

@@ -1,8 +1,8 @@
 #Created by .winboll/winboll_app_build.gradle
-#Thu Oct 02 13:16:14 GMT 2025
-stageCount=8
+#Fri Oct 03 11:38:10 HKT 2025
+stageCount=9
 libraryProject=
 baseVersion=15.0
-publishVersion=15.0.7
-buildCount=29
-baseBetaVersion=15.0.8
+publishVersion=15.0.8
+buildCount=0
+baseBetaVersion=15.0.9

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,7 +3,7 @@ package cc.winboll.studio.positions.adapters;
 /**
  * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
  * @Date 2025/09/29 20:25
- * @Describe 位置数据适配器（完全独立，无未知接口依赖，仅用LocationActivity缓存数据）
+ * @Describe 位置数据适配器（集成PositionTaskListView，移除未定义onDestroy，Java 7语法适配）
  */
 import android.content.Context;
 import android.view.LayoutInflater;
@@ -15,6 +15,7 @@ import android.widget.EditText;
 import android.widget.RadioGroup;
 import android.widget.TextView;
 import android.text.TextUtils;
+import android.widget.Toast;
 import androidx.recyclerview.widget.RecyclerView;
 
 import cc.winboll.studio.libappbase.LogUtils;
@@ -22,6 +23,7 @@ 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;
@@ -30,20 +32,20 @@ import java.util.Iterator;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
- * Java 7 语法适配：
- * 1. 移除 Lambda/方法引用，用匿名内部类替代
- * 2. 集合操作使用迭代器（避免 ConcurrentModificationException）
- * 3. 弱引用管理 MainService，避免内存泄漏
- * 4. 所有任务数据从 MainService 获取，更新通过 MainService 接口
+ * Java 7 语法严格适配：
+ * 1. 无Lambda/方法引用，全匿名内部类实现回调
+ * 2. 移除未定义的 taskView.onDestroy()，改用「清空数据+解绑监听」替代资源释放
+ * 3. 弱引用管理服务/控件，杜绝内存泄漏
+ * 4. PositionTaskListView 初始化/同步/资源释放全链路适配
  */
 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 +53,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,42 +76,42 @@ 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 弱引用语法）
+        this.mCachedPositionList = (cachedPositionList!= null)? cachedPositionList : new ArrayList<PositionModel>();
+        // 弱引用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 接口实现）
-        if (mainService != null) {
+        // 注册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;
+        return (posModel!= null && posModel.isSimpleView())? VIEW_TYPE_SIMPLE : VIEW_TYPE_EDIT;
     }
 
     @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 +128,100 @@ 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);
-        }
+            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) {
+            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);
-        // 视图离开屏幕时，移除距离控件缓存（避免内存泄漏+引用失效控件）
+        // 视图离开屏幕时：清空对应控件缓存+释放任务列表视图资源（移除未定义的onDestroy()）
         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)) {
+            mPosDistanceViewMap.remove(posId);
+            LogUtils.d(TAG, "视图脱离屏幕：移除位置ID=" + posId + "的距离控件缓存");
+        }
+
+        // 2. 释放简单模式任务视图资源（清空数据+解绑监听，替代onDestroy()）
+        if (holder instanceof SimpleViewHolder && mSimpleTaskViewMap.containsKey(posId)) {
+            PositionTaskListView taskView = mSimpleTaskViewMap.get(posId);
+            if (taskView != null) {
+                taskView.clearData(); // 清空任务数据（假设视图已实现该方法，用于释放列表数据）
+                taskView.setOnTaskUpdatedListener(null); // 解绑任务更新监听，避免内存泄漏
+            }
+            mSimpleTaskViewMap.remove(posId);
+            LogUtils.d(TAG, "简单模式视图脱离屏幕：释放任务列表视图资源（位置ID=" + posId + "）");
+        }
+
+        // 3. 释放编辑模式任务视图资源（清空数据+解绑监听，替代onDestroy()）
+        if (holder instanceof EditViewHolder && mEditTaskViewMap.containsKey(posId)) {
+            PositionTaskListView taskView = mEditTaskViewMap.get(posId);
+            if (taskView != null) {
+                taskView.clearData(); // 清空任务数据
+                taskView.setOnTaskUpdatedListener(null); // 解绑任务更新监听
+            }
+            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));
+        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,151 +229,186 @@ 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，假设视图已实现init方法）
+        taskView.init(mainService, posId);
+        // 2. 设置为简单模式（仅展示，隐藏编辑按钮，需视图支持该状态设置）
+        taskView.setViewStatus(PositionTaskListView.VIEW_MODE_SIMPLE);
+        // 3. 同步任务数据（从MainService拉取当前位置已启用任务）
+        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<PositionTaskModel> 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. 同步任务数据（从MainService拉取当前位置所有任务）
+        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. 任务更新回调（通知外部任务变化，如Activity需要联动）
+        taskView.setOnTaskUpdatedListener(new PositionTaskListView.OnTaskUpdatedListener() {
+				@Override
+				public void onTaskUpdated(String positionId, ArrayList<PositionTaskModel> updatedTasks) {
+					LogUtils.d(TAG, "编辑模式任务更新：位置ID=" + positionId + "，当前任务数=" + updatedTasks.size());
+				}
+			});
+
+        LogUtils.d(TAG, "初始化编辑模式任务视图完成：位置ID=" + posId);
     }
 
     // =========================================================================
-    // 工具方法（Java 7 风格：无Lambda，纯匿名内部类+迭代器）
+    // 工具方法（距离显示/数据校验/控件管理，Java 7 语法适配）
     // =========================================================================
     /**
-     * 更新距离显示（根据位置模型状态，显示不同文本+颜色）
+     * 更新距离显示（按状态区分文本和颜色，提升视觉区分度）
      */
     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);
@@ -340,7 +416,7 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
             return;
         }
 
-        // 场景3：正常显示距离（按距离范围设置颜色，提升视觉区分度）
+        // 场景3：正常显示距离（按距离范围设置颜色）
         distanceView.setText(String.format(DISTANCE_FORMAT, distance));
         if (distance <= 100) {
             distanceView.setTextColor(mContext.getResources().getColor(R.color.green)); // 近距离（≤100米）
@@ -352,11 +428,11 @@ 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);
@@ -367,18 +443,18 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
      */
     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;
     }
 
@@ -386,57 +462,96 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
      * 局部更新距离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) {
+        try {
             ArrayList<PositionModel> 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<PositionModel> iter = servicePosList.iterator();
+                while (iter.hasNext()) {
+                    PositionModel pos = iter.next();
                     if (positionId.equals(pos.getPositionId())) {
                         latestPos = pos;
                         break;
                     }
                 }
             }
+        } catch (Exception e) {
+            LogUtils.d(TAG, "获取最新位置数据失败（ID=" + positionId + "）" + e);
+            return;
         }
 
-        // 用服务端最新距离更新UI（直接操作缓存的距离控件，无需刷新整个项）
-        if (latestPos != null) {
-            TextView distanceView = mPosDistanceViewMap.get(positionId);
-            updateDistanceDisplay(distanceView, latestPos);
-            LogUtils.d(TAG, "局部更新距离完成：位置ID=" + positionId + "，最新距离=" + latestPos.getRealPositionDistance() + "米");
+        if (latestPos == null) {
+            LogUtils.w(TAG, "局部更新距离失败：未找到位置ID=" + positionId);
+            return;
+        }
+
+        // 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<PositionModel> uniquePosList = new ArrayList<PositionModel>(uniquePosMap.values());
+
+        // 3. 同步到本地缓存+刷新UI
         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());
     }
 
     /**
@@ -444,29 +559,83 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
      */
     private void hideSoftKeyboard(View view) {
         if (mContext == null || view == null) {
-            LogUtils.w(TAG, "hideSoftKeyboard：参数为空（上下文/视图），无法隐藏键盘");
+            LogUtils.w(TAG, "隐藏软键盘失败：参数为空（上下文/视图）");
             return;
         }
 
-        // Java 7 显式获取输入法服务，避免Lambda
         InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
         if (imm != null) {
-            imm.hideSoftInputFromWindow(view.getWindowToken(), 0); // 强制隐藏软键盘
+            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 接口（服务任务变化时回调）
     // =========================================================================
     @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 +646,96 @@ 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. 释放简单模式任务视图资源（清空数据+解绑监听，替代onDestroy()）
+        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. 释放编辑模式任务视图资源（清空数据+解绑监听，替代onDestroy()）
+        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 +746,94 @@ 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>(mainService); // 弱引用服务
+         *     this.mPositionId = positionId; // 绑定当前位置ID
+         * }
+         */
+
+        /**
+         * 2. setViewStatus 方法：设置视图模式（简单/编辑）
+         * 需在 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;
+         *     // 根据模式控制编辑/删除按钮显示（如简单模式隐藏，编辑模式显示）
+         *     updateButtonVisibility();
+         * }
+         */
+
+        /**
+         * 3. syncTasksFromMainService 方法：从服务同步任务数据
+         * 需在 PositionTaskListView 中添加：
+         * public void syncTasksFromMainService() {
+         *     MainService mainService = mMainServiceRef.get();
+         *     if (mainService == null || TextUtils.isEmpty(mPositionId)) return;
+         *     // 根据视图模式拉取任务（简单模式：已启用；编辑模式：所有）
+         *     ArrayList<PositionTaskModel> tasks = (mViewMode == VIEW_MODE_SIMPLE)
+         *            ? mainService.getEnabledTasksByPositionId(mPositionId)
+         *             : mainService.getTasksByPositionId(mPositionId);
+         *     // 更新列表显示（如设置Adapter数据）
+         *     setTaskList(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 方法：清空任务数据（释放资源）
+         * 需在 PositionTaskListView 中添加：
+         * public void clearData() {
+         *     if (mTaskList != null) mTaskList.clear(); // 清空任务列表数据
+         *     if (mTaskAdapter != null) mTaskAdapter.notifyDataSetChanged(); // 刷新列表
+         * }
+         */
+
+        /**
+         * 6. setOnTaskUpdatedListener 方法：设置任务更新回调
+         * 需在 PositionTaskListView 中添加：
+         * public interface OnTaskUpdatedListener {
+         *     void onTaskUpdated(String positionId, ArrayList<PositionTaskModel> updatedTasks);
+         * }
+         * private OnTaskUpdatedListener mTaskUpdateListener;
+         * public void setOnTaskUpdatedListener(OnTaskUpdatedListener listener) {
+         *     this.mTaskUpdateListener = listener;
+         * }
+         * // 任务变化时调用（如同步后/编辑后）
+         * private void notifyTaskUpdated(ArrayList<PositionTaskModel> updatedTasks) {
+         *     if (mTaskUpdateListener != null) {
+         *         mTaskUpdateListener.onTaskUpdated(mPositionId, updatedTasks);
+         *     }
+         * }
+         */
+    }
 }
 

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

@@ -69,7 +69,7 @@ public class MainService extends Service {
 
     // 数据存储集合（Java 7 基础集合，避免Stream/forEach等Java 8+特性）
     private final ArrayList<PositionModel> mPositionList = new ArrayList<PositionModel>();   // 位置数据列表
-    private final ArrayList<PositionTaskModel> mTaskList = new ArrayList<PositionTaskModel>();// 任务数据列表
+    private final ArrayList<PositionTaskModel> mAllTasks = new ArrayList<PositionTaskModel>();// 任务数据列表
     private PositionModel mCurrentGpsPosition; // 当前GPS定位数据
 
     // 服务相关变量（Java 7 显式声明，保持原逻辑）
@@ -91,7 +91,7 @@ public class MainService extends Service {
      * 新增任务（Adapter调用，通过MainService统一管理任务，保证数据一致性）
      * @param newTask 待新增的任务模型
      */
-    public void addPositionTask(PositionTaskModel newTask) {
+    public void addTask(PositionTaskModel newTask) {
         // 参数校验（Java 7 基础判断，无Optional等Java 8+特性）
         if (newTask == null || TextUtils.isEmpty(newTask.getPositionId())) {
             LogUtils.w(TAG, "addPositionTask：任务为空或未绑定位置ID，新增失败");
@@ -100,7 +100,7 @@ public class MainService extends Service {
 
         // 任务去重（Java 7 迭代器遍历，避免增强for循环删除/新增导致的并发异常）
         boolean isDuplicate = false;
-        Iterator<PositionTaskModel> taskIter = mTaskList.iterator();
+        Iterator<PositionTaskModel> taskIter = mAllTasks.iterator();
         while (taskIter.hasNext()) {
             PositionTaskModel task = taskIter.next();
             if (newTask.getTaskId().equals(task.getTaskId())) {
@@ -114,8 +114,8 @@ public class MainService extends Service {
         }
 
         // 新增任务+持久化+通知刷新（全Java 7 语法）
-        mTaskList.add(newTask);
-        saveTaskList();
+        mAllTasks.add(newTask);
+        saveAllTasks();
         notifyTaskUpdated(); // 通知所有监听者（如Adapter）任务已更新
         LogUtils.d(TAG, "addPositionTask：成功（位置ID=" + newTask.getPositionId() + "，任务ID=" + newTask.getTaskId() + "）");
     }
@@ -127,12 +127,12 @@ public class MainService extends Service {
      */
     public ArrayList<PositionTaskModel> getTasksByPositionId(String positionId) {
         ArrayList<PositionTaskModel> posTasks = new ArrayList<PositionTaskModel>();
-        if (TextUtils.isEmpty(positionId) || mTaskList.isEmpty()) {
+        if (TextUtils.isEmpty(positionId) || mAllTasks.isEmpty()) {
             return posTasks;
         }
 
         // 筛选任务（Java 7 迭代器遍历，安全筛选）
-        Iterator<PositionTaskModel> taskIter = mTaskList.iterator();
+        Iterator<PositionTaskModel> taskIter = mAllTasks.iterator();
         while (taskIter.hasNext()) {
             PositionTaskModel task = taskIter.next();
             if (positionId.equals(task.getPositionId())) {
@@ -147,26 +147,51 @@ public class MainService extends Service {
      * @return 所有任务的拷贝列表
      */
     public ArrayList<PositionTaskModel> getAllTasks() {
-        return new ArrayList<PositionTaskModel>(mTaskList); // Java 7 集合拷贝方式
+        return new ArrayList<PositionTaskModel>(mAllTasks); // Java 7 集合拷贝方式
     }
 	
+	public void updateTask(PositionTaskModel updatedTask) {
+        if (updatedTask == null || updatedTask.getTaskId() == null) return;
+        for (int i = 0; i < mAllTasks.size(); i++) {
+            PositionTaskModel task = mAllTasks.get(i);
+            if (updatedTask.getTaskId().equals(task.getTaskId())) {
+                mAllTasks.set(i, updatedTask); // 替换为更新后的任务
+                break;
+            }
+		}
+        saveAllTasks(); // 持久化更新后的数据
+    }
+
+    // 4. 仅更新任务启用状态（优化性能，避免全量字段更新）
+    public void updateTaskStatus(PositionTaskModel task) {
+        if (task == null || task.getTaskId() == null) return;
+        for (PositionTaskModel item : mAllTasks) {
+            if (task.getTaskId().equals(item.getTaskId())) {
+                item.setIsEnable(task.isEnable()); // 只更新启用状态字段
+                break;
+            }
+        }
+        saveAllTasks(); // 持久化状态变更
+    }
+	
+	
     /**
      * 删除任务（Adapter调用，通过迭代器安全删除，避免并发异常）
      * @param taskId 待删除任务的ID
      */
-    public void deletePositionTask(String taskId) {
-        if (TextUtils.isEmpty(taskId) || mTaskList.isEmpty()) {
+    public void deleteTask(String taskId) {
+        if (TextUtils.isEmpty(taskId) || mAllTasks.isEmpty()) {
             LogUtils.w(TAG, "deletePositionTask：任务ID为空或列表为空，删除失败");
             return;
         }
 
         // 迭代器删除（Java 7 唯一安全删除集合元素的方式）
-        Iterator<PositionTaskModel> taskIter = mTaskList.iterator();
+        Iterator<PositionTaskModel> taskIter = mAllTasks.iterator();
         while (taskIter.hasNext()) {
             PositionTaskModel task = taskIter.next();
             if (taskId.equals(task.getTaskId())) {
                 taskIter.remove(); // 迭代器安全删除，无ConcurrentModificationException
-                saveTaskList();
+                saveAllTasks();
                 notifyTaskUpdated();
                 LogUtils.d(TAG, "deletePositionTask：成功（任务ID=" + taskId + "）");
                 break;
@@ -312,7 +337,7 @@ public class MainService extends Service {
 
                 // 加载本地数据（Java 7 静态方法调用，无方法引用）
                 PositionModel.loadBeanList(MainService.this, mPositionList, PositionModel.class);
-                PositionTaskModel.loadBeanList(MainService.this, mTaskList, PositionTaskModel.class);
+                PositionTaskModel.loadBeanList(MainService.this, mAllTasks, PositionTaskModel.class);
 
                 // 提示与日志（Java 7 基础调用）
                 ToastUtils.show(initialStatus);
@@ -425,9 +450,9 @@ public class MainService extends Service {
             return;
         }
         // 全量替换+持久化+通知（Java 7 基础集合操作）
-        mTaskList.clear();
-        mTaskList.addAll(newTaskList);
-        saveTaskList();
+        mAllTasks.clear();
+        mAllTasks.addAll(newTaskList);
+        saveAllTasks();
         notifyTaskUpdated();
     }
 
@@ -465,9 +490,9 @@ public class MainService extends Service {
     /**
      * 持久化任务数据（Java 7 静态方法调用，保持原逻辑）
      */
-    void saveTaskList() {
-        LogUtils.d(TAG, String.format("saveTaskList : size=%d", mTaskList.size()));
-        PositionTaskModel.saveBeanList(MainService.this, mTaskList, PositionTaskModel.class);
+    void saveAllTasks() {
+        LogUtils.d(TAG, String.format("saveTaskList : size=%d", mAllTasks.size()));
+        PositionTaskModel.saveBeanList(MainService.this, mAllTasks, PositionTaskModel.class);
     }
 
     /**
@@ -475,7 +500,7 @@ public class MainService extends Service {
      */
     public void clearAllData() {
         mPositionList.clear();
-        mTaskList.clear();
+        mAllTasks.clear();
         mCurrentGpsPosition = null;
         LogUtils.d(TAG, "clearAllData：已清空所有数据");
     }
@@ -596,14 +621,14 @@ public class MainService extends Service {
      * 校验所有任务触发条件（距离达标则触发任务通知）
      */
     private void checkAllTaskTriggerCondition() {
-        if (mCurrentGpsPosition == null || mPositionList.isEmpty() || mTaskList.isEmpty()) {
+        if (mCurrentGpsPosition == null || mPositionList.isEmpty() || mAllTasks.isEmpty()) {
             LogUtils.d(TAG, "checkAllTaskTriggerCondition：跳过校验（GPS/位置/任务为空）");
             return;
         }
 
-        LogUtils.d(TAG, "checkAllTaskTriggerCondition：开始校验（任务总数=" + mTaskList.size() + "）");
+        LogUtils.d(TAG, "checkAllTaskTriggerCondition：开始校验（任务总数=" + mAllTasks.size() + "）");
         // 迭代器遍历任务（Java 7 安全遍历，避免并发修改异常）
-        Iterator<PositionTaskModel> taskIter = mTaskList.iterator();
+        Iterator<PositionTaskModel> taskIter = mAllTasks.iterator();
         while (taskIter.hasNext()) {
             PositionTaskModel task = taskIter.next();
             // 仅校验“已启用”且“绑定有效位置”的任务
@@ -652,7 +677,7 @@ public class MainService extends Service {
                 }
             }
         }
-        saveTaskList(); // 持久化更新后的任务状态
+        saveAllTasks(); // 持久化更新后的任务状态
     }
 
     /**
@@ -661,7 +686,7 @@ public class MainService extends Service {
      * @param bindPos 任务绑定的位置
      * @param currentDistance 当前距离
      */
-    private void sendTaskTriggerNotification(PositionTaskModel task, PositionModel bindPos, double currentDistance) {
+    private void sendTaskTriggerNotification(final PositionTaskModel task, PositionModel bindPos, double currentDistance) {
         if (!_mIsServiceRunning) {
             return;
         }
@@ -682,11 +707,13 @@ public class MainService extends Service {
         // 显示Toast（主线程安全调用，Java 7 匿名内部类）
         if (Looper.myLooper() == Looper.getMainLooper()) {
             ToastUtils.show(triggerContent);
+			NotificationUtil.show(MainService.this, task.getTaskId(), task.getPositionId(), task.getTaskDescription());
         } else {
             new Handler(Looper.getMainLooper()).post(new Runnable() {
 					@Override
 					public void run() {
 						ToastUtils.show(triggerContent);
+						NotificationUtil.show(MainService.this, task.getTaskId(), task.getPositionId(), task.getTaskDescription());
 					}
 				});
         }

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;
@@ -22,8 +22,10 @@ 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 java.util.ArrayList;
 import java.util.List;
 
@@ -32,21 +34,21 @@ 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 +64,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 +72,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 +277,219 @@ 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));
+                // 距离条件（大于/小于+距离值）
                 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);
             }
-            // 编辑模式：沿用原有绑定逻辑（核心修复在此处）
+
+            // 4. 编辑模式绑定（核心调整：所有修改操作后同步MainService）
             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()));
 
-            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) {
-            final Context context = getContext();
+        /**
+         * 编辑任务弹窗（核心：保存修改→同步MainService→刷新Adapter）
+         */
+        private void showEditTaskDialog(final PositionTaskModel task, final int position) {
+            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());
-
+            // 初始化弹窗数据（填充当前任务信息）
+            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();
 
+            // 取消按钮：关闭弹窗（不做操作）
             btnCancel.setOnClickListener(new View.OnClickListener() {
 					@Override
 					public void onClick(View v) {
@@ -316,14 +497,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,62 +515,80 @@ 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 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);
                 tvSimpleIsEnable = itemView.findViewById(R.id.tv_simple_is_enable);
@@ -394,23 +596,69 @@ public class PositionTaskListView extends LinearLayout {
             }
         }
 
-        // 编辑模式 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;     // 距离条件
+            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);
+                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();
+        }
+    }
 }