<positions>APK 15.12.15 release Publish.

positions/build.properties

@@ -1,8 +1,8 @@
 #Created by .winboll/winboll_app_build.gradle
-#Tue Mar 31 13:03:31 HKT 2026
+#Tue Mar 31 13:51:27 HKT 2026
-stageCount=15
+stageCount=16
 libraryProject=
 baseVersion=15.12
-publishVersion=15.12.14
+publishVersion=15.12.15
 buildCount=0
-baseBetaVersion=15.12.15
+baseBetaVersion=15.12.16

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

@@ -19,6 +19,7 @@ import android.widget.Toast;
 import androidx.appcompat.widget.Toolbar;
 import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
+import cc.winboll.studio.libaes.dialogs.YesNoAlertDialog;
 import cc.winboll.studio.libaes.interfaces.IWinBoLLActivity;
 import cc.winboll.studio.libappbase.LogUtils;
 import cc.winboll.studio.libappbase.ToastUtils;
@@ -228,7 +229,15 @@ public class LocationActivity extends WinBoLLActivity implements IWinBoLLActivit
             // 3. 设置删除回调（删除时同步服务+本地缓存+Adapter）
             mPositionAdapter.setOnDeleteClickListener(new PositionAdapter.OnDeleteClickListener() {
 					@Override
-					public void onDeleteClick(int position) {
+					public void onDeleteClick(final int position) {
+						YesNoAlertDialog.show(LocationActivity.this, "删除位置提示", "是否删除此项锚点位置？", new YesNoAlertDialog.OnDialogResultListener(){
+
+								@Override
+								public void onNo() {
+								}
+
+								@Override
+								public void onYes() {
 									// 安全校验（索引有效+服务绑定+缓存非空）
 									if (position < 0 || position >= mLocalPosCache.size() || !isServiceBound.get() || mMainService == null) {
 										LogUtils.w(TAG, "删除位置失败：索引无效/服务未就绪（索引=" + position + "，缓存量=" + mLocalPosCache.size() + "）");
@@ -251,6 +260,9 @@ public class LocationActivity extends WinBoLLActivity implements IWinBoLLActivit
 								}
 							});
 
+					}
+				});
+
             // 4. 设置保存回调（保存时同步服务+本地缓存+Adapter）
             mPositionAdapter.setOnSavePositionClickListener(new PositionAdapter.OnSavePositionClickListener() {
 					@Override

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

@@ -1,19 +1,12 @@
 package cc.winboll.studio.positions.adapters;
 
 /**
- * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
- * @Date 2025/09/29 20:25
  * @Describe 位置数据适配器（修复视图复用资源加载，支持滚动后重新绑定数据，Java 7语法适配）
+ * @Author 豆包&ZhanGSKen<zhangsken@qq.com>
+ * @CreateTime 2025-09-29 20:25:00
+ * @EditTime 2026-03-31 23:14:55
  */
 
-
-/**
- * Java 7 语法严格适配 + 视图复用资源加载修复：
- * 1. 保留无Lambda/弱引用/线程安全集合等原有适配
- * 2. 修复核心问题：移除 onViewDetachedFromWindow 中关键资源释放，改为 onBind 时重新绑定
- * 3. 强化资源复用：任务视图/距离控件在复用后自动从服务同步最新数据，确保滚动后数据不丢失
- * 4. 优化缓存逻辑：仅清理脱离屏幕且无效的控件缓存，有效控件保留引用供局部更新（如距离）
- */
 import android.content.Context;
 import android.text.TextUtils;
 import android.view.LayoutInflater;
@@ -36,32 +29,32 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.concurrent.ConcurrentHashMap;
 
-public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> implements MainService.TaskUpdateListener {
+public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder>
+implements MainService.TaskUpdateListener {
+
     public static final String TAG = "PositionAdapter";
 
-    // 视图类型常量（静态常量统一管理）
+    // 视图类型常量
     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; // 单位：米
+    private static final int DEFAULT_TASK_DISTANCE = 50;
     private static final String DISTANCE_FORMAT = "实时距离：%.1f 米";
     private static final String DISTANCE_DISABLED = "实时距离：未启用";
     private static final String DISTANCE_ERROR = "实时距离：计算失败";
 
-    // 核心依赖（弱引用+线程安全集合，适配Java 7）
+    // 核心成员变量
     private final Context mContext;
-    private final ArrayList<PositionModel> mCachedPositionList; // 位置缓存（与MainService同步）
+    private final ArrayList<PositionModel> mCachedPositionList;
-    private final WeakReference<MainService> mMainServiceRef;   // 弱引用MainService，防内存泄漏
+    private final WeakReference<MainService> mMainServiceRef;
-    // 控件缓存：位置ID → 对应任务列表视图（分别缓存简单/编辑模式，支持复用后快速同步）
     private final ConcurrentHashMap<String, PositionTaskListView> mSimpleTaskViewMap;
     private final ConcurrentHashMap<String, PositionTaskListView> mEditTaskViewMap;
-    // 距离控件缓存（用于局部更新距离UI，保留有效引用避免复用后更新失效）
     private final ConcurrentHashMap<String, TextView> mPosDistanceViewMap;
 
-    // 回调接口（仅处理位置逻辑，任务逻辑通过PositionTaskListView+MainService完成）
+    // 回调接口
     public interface OnDeleteClickListener {
         void onDeleteClick(int position);
     }
@@ -74,32 +67,32 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
     private OnSavePositionClickListener mOnSavePosListener;
 
     // =========================================================================
-    // 构造函数（初始化依赖+注册服务监听+初始化控件缓存）
+    // 构造函数
     // =========================================================================
     public PositionAdapter(Context context, ArrayList<PositionModel> cachedPositionList, MainService mainService) {
+        LogUtils.d(TAG, "PositionAdapter 构造函数开始，context=" + context
+				   + "，cachedPositionList=" + (cachedPositionList != null ? cachedPositionList.size() : 0)
+				   + "，mainService=" + mainService);
+
         this.mContext = context;
-        // 容错处理：避免传入null导致空指针
         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任务监听：服务任务变化时同步刷新任务列表视图
         if (mainService != null) {
             mainService.registerTaskUpdateListener(this);
-            LogUtils.d(TAG, "已注册MainService任务监听，确保任务数据与服务同步");
+            LogUtils.d(TAG, "已注册 MainService 任务监听");
         } else {
-            LogUtils.w(TAG, "构造函数：MainService为空，PositionTaskListView无法初始化");
+            LogUtils.w(TAG, "构造函数：MainService 为空，无法初始化任务视图");
         }
 
-        LogUtils.d(TAG, "Adapter初始化完成：位置数量=" + mCachedPositionList.size());
+        LogUtils.d(TAG, "PositionAdapter 初始化完成，位置数量=" + mCachedPositionList.size());
     }
 
     // =========================================================================
-    // RecyclerView 核心方法（强化视图复用逻辑，复用后自动重新绑定资源）
+    // RecyclerView 核心方法
     // =========================================================================
     @Override
     public int getItemViewType(int position) {
@@ -109,6 +102,7 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
 
     @Override
     public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+        LogUtils.d(TAG, "onCreateViewHolder viewType=" + viewType);
         LayoutInflater inflater = LayoutInflater.from(mContext);
         if (viewType == VIEW_TYPE_SIMPLE) {
             View simpleView = inflater.inflate(R.layout.item_position_simple, parent, false);
@@ -121,34 +115,28 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
 
     @Override
     public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
+        LogUtils.d(TAG, "onBindViewHolder position=" + position);
         PositionModel posModel = getPositionByIndex(position);
         if (posModel == null) {
-            LogUtils.w(TAG, "onBindViewHolder：位置模型为空（索引=" + position + "），跳过绑定");
+            LogUtils.w(TAG, "onBindViewHolder：位置模型为空，索引=" + position);
             return;
         }
         final String posId = posModel.getPositionId();
         MainService mainService = mMainServiceRef.get();
 
-        // 按视图类型绑定数据（简单模式/编辑模式）—— 核心修复：复用后重新绑定所有资源
         if (holder instanceof SimpleViewHolder) {
-            LogUtils.d(TAG, "instanceof SimpleViewHolder（复用/新创建）：位置ID=" + posId);
+            LogUtils.d(TAG, "绑定 SimpleViewHolder，posId=" + posId);
             SimpleViewHolder simpleHolder = (SimpleViewHolder) holder;
-            // 1. 重新绑定位置基础数据（经纬度/备注/距离，确保复用后显示最新数据）
             bindSimplePositionData(simpleHolder, posModel);
-            // 2. 重新初始化+绑定简单模式任务视图（复用后从服务同步最新任务，避免数据丢失）
             initAndBindSimpleTaskView(simpleHolder.ptlvSimpleTasks, posId, mainService);
-            // 3. 缓存/更新简单模式任务视图+距离控件（覆盖旧缓存，确保引用最新控件）
             mSimpleTaskViewMap.put(posId, simpleHolder.ptlvSimpleTasks);
             mPosDistanceViewMap.put(posId, simpleHolder.tvSimpleDistance);
 
         } else if (holder instanceof EditViewHolder) {
-            LogUtils.d(TAG, "instanceof EditViewHolder（复用/新创建）：位置ID=" + posId);
+            LogUtils.d(TAG, "绑定 EditViewHolder，posId=" + posId);
             EditViewHolder editHolder = (EditViewHolder) holder;
-            // 1. 重新绑定位置基础数据（经纬度/备注/距离/距离开关，复用后显示最新状态）
             bindEditPositionData(editHolder, posModel, position);
-            // 2. 重新初始化+绑定编辑模式任务视图（复用后同步服务最新任务，支持增删改）
             initAndBindEditTaskView(editHolder.ptlvEditTasks, posId, mainService, editHolder.btnAddTask);
-            // 3. 缓存/更新编辑模式任务视图+距离控件（覆盖旧缓存，确保引用最新控件）
             mEditTaskViewMap.put(posId, editHolder.ptlvEditTasks);
             mPosDistanceViewMap.put(posId, editHolder.tvEditDistance);
         }
@@ -157,37 +145,33 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
     @Override
     public void onViewDetachedFromWindow(RecyclerView.ViewHolder holder) {
         super.onViewDetachedFromWindow(holder);
-        // 核心修改：仅清理「无效/已回收」的控件缓存，不释放关键资源（支持复用后重新绑定）
         PositionModel posModel = getPositionByIndex(holder.getAdapterPosition());
         if (posModel == null || TextUtils.isEmpty(posModel.getPositionId())) {
             return;
         }
         String posId = posModel.getPositionId();
 
-        // 1. 清理「已脱离视图树/无效」的距离控件缓存（保留有效控件供局部更新）
         if (mPosDistanceViewMap.containsKey(posId)) {
             TextView distanceView = mPosDistanceViewMap.get(posId);
             if (distanceView == null || !distanceView.isAttachedToWindow()) {
                 mPosDistanceViewMap.remove(posId);
-                LogUtils.d(TAG, "视图脱离屏幕：移除无效距离控件缓存（位置ID=" + posId + "）");
+                LogUtils.d(TAG, "视图脱离：移除无效距离控件缓存 posId=" + posId);
             }
         }
 
-        // 2. 清理「已脱离视图树/无效」的简单模式任务视图缓存（不解绑监听/不清空数据，复用后重新同步）
         if (holder instanceof SimpleViewHolder && mSimpleTaskViewMap.containsKey(posId)) {
             PositionTaskListView taskView = mSimpleTaskViewMap.get(posId);
             if (taskView == null || !taskView.isAttachedToWindow()) {
                 mSimpleTaskViewMap.remove(posId);
-                LogUtils.d(TAG, "简单模式视图脱离屏幕：移除无效任务视图缓存（位置ID=" + posId + "）");
+                LogUtils.d(TAG, "视图脱离：移除无效简单任务视图缓存 posId=" + posId);
             }
         }
 
-        // 3. 清理「已脱离视图树/无效」的编辑模式任务视图缓存（同上，保留数据供复用）
         if (holder instanceof EditViewHolder && mEditTaskViewMap.containsKey(posId)) {
             PositionTaskListView taskView = mEditTaskViewMap.get(posId);
             if (taskView == null || !taskView.isAttachedToWindow()) {
                 mEditTaskViewMap.remove(posId);
-                LogUtils.d(TAG, "编辑模式视图脱离屏幕：移除无效任务视图缓存（位置ID=" + posId + "）");
+                LogUtils.d(TAG, "视图脱离：移除无效编辑任务视图缓存 posId=" + posId);
             }
         }
     }
@@ -198,46 +182,34 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
     }
 
     // =========================================================================
-    // 位置数据绑定（保留原有逻辑，确保复用后数据最新）
+    // 位置数据绑定
     // =========================================================================
-    /**
-     * 绑定简单模式位置数据（仅显示，无编辑操作）—— 复用后重新执行，显示最新数据
-     */
     private void bindSimplePositionData(SimpleViewHolder holder, final PositionModel posModel) {
-        // 1. 经纬度显示（保留6位小数，格式统一）
+        LogUtils.d(TAG, "bindSimplePositionData posId=" + posModel.getPositionId());
         holder.tvSimpleLon.setText(String.format("经度：%.6f", posModel.getLongitude()));
         holder.tvSimpleLat.setText(String.format("纬度：%.6f", posModel.getLatitude()));
 
-        // 2. 备注显示（无备注时显示默认文本）
         String memo = posModel.getMemo();
         holder.tvSimpleMemo.setText("备注：" + (TextUtils.isEmpty(memo) ? DEFAULT_MEMO : memo));
-
-        // 3. 实时距离显示（按状态区分文本+颜色——复用后重新计算显示最新距离）
         updateDistanceDisplay(holder.tvSimpleDistance, posModel);
 
-        // 4. 点击切换到编辑模式
         holder.itemView.setOnClickListener(new View.OnClickListener() {
 				@Override
 				public void onClick(View v) {
 					posModel.setIsSimpleView(false);
-					// 精准刷新当前项（避免全量刷新）
 					notifyItemChanged(getPositionIndexById(posModel.getPositionId()));
-					LogUtils.d(TAG, "简单视图点击：位置ID=" + posModel.getPositionId() + "，切换到编辑视图");
+					LogUtils.d(TAG, "简单视图点击：切换编辑模式 posId=" + posModel.getPositionId());
 				}
 			});
     }
 
-    /**
-     * 绑定编辑模式位置数据（支持备注修改/距离开关/删除/保存）—— 复用后重新执行，恢复编辑状态
-     */
     private void bindEditPositionData(final EditViewHolder holder, final PositionModel posModel, final int position) {
+        LogUtils.d(TAG, "bindEditPositionData posId=" + posModel.getPositionId() + " position=" + position);
         final String posId = posModel.getPositionId();
 
-        // 1. 经纬度显示（不可编辑，仅展示）
         holder.tvEditLon.setText(String.format("经度：%.6f", posModel.getLongitude()));
         holder.tvEditLat.setText(String.format("纬度：%.6f", posModel.getLatitude()));
 
-        // 2. 备注编辑（填充现有备注，光标定位到末尾——复用后恢复输入状态）
         String memo = posModel.getMemo();
         if (!TextUtils.isEmpty(memo)) {
             holder.etEditMemo.setText(memo);
@@ -246,26 +218,22 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
             holder.etEditMemo.setText("");
         }
 
-        // 3. 实时距离显示（与简单模式逻辑一致——复用后显示最新距离）
         updateDistanceDisplay(holder.tvEditDistance, posModel);
 
-        // 4. 距离开关状态（匹配位置模型中的启用状态——复用后恢复开关状态）
         holder.rgDistanceSwitch.check(posModel.isEnableRealPositionDistance()
 									  ? R.id.rb_distance_enable
 									  : R.id.rb_distance_disable);
 
-        // 5. 取消编辑：切换回简单模式+隐藏软键盘
         holder.btnCancel.setOnClickListener(new View.OnClickListener() {
 				@Override
 				public void onClick(View v) {
 					posModel.setIsSimpleView(true);
 					notifyItemChanged(position);
 					hideSoftKeyboard(v);
-					LogUtils.d(TAG, "取消编辑：位置ID=" + posId + "，切换回简单视图");
+					LogUtils.d(TAG, "取消编辑：切换简单视图 posId=" + posId);
 				}
 			});
 
-        // 6. 删除位置：回调Activity处理（Adapter不直接操作数据）
         holder.btnDelete.setOnClickListener(new View.OnClickListener() {
 				@Override
 				public void onClick(View v) {
@@ -273,19 +241,16 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
 						mOnDeleteListener.onDeleteClick(position);
 					}
 					hideSoftKeyboard(v);
-					LogUtils.d(TAG, "触发删除：通知Activity处理位置ID=" + posId + "的删除逻辑");
+					LogUtils.d(TAG, "触发删除位置 posId=" + posId);
 				}
 			});
 
-        // 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);
 					updatedPos.setLongitude(posModel.getLongitude());
@@ -294,176 +259,144 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
 					updatedPos.setIsEnableRealPositionDistance(isDistanceEnable);
 					updatedPos.setIsSimpleView(true);
 
-					// 回调Activity保存（由Activity同步MainService）
 					if (mOnSavePosListener != null) {
 						mOnSavePosListener.onSavePositionClick(position, updatedPos);
 					}
 
-					// 本地同步状态（避免刷新延迟）
 					posModel.setMemo(newMemo);
 					posModel.setIsEnableRealPositionDistance(isDistanceEnable);
 					posModel.setIsSimpleView(true);
 					notifyItemChanged(position);
 					hideSoftKeyboard(v);
-					LogUtils.d(TAG, "保存位置：ID=" + posId + "，新备注=" + newMemo + "，距离启用=" + isDistanceEnable);
+
+					LogUtils.d(TAG, "保存位置 posId=" + posId + " 新备注=" + newMemo + " 距离启用=" + isDistanceEnable);
 				}
 			});
     }
 
     // =========================================================================
-    // PositionTaskListView 集成（强化复用逻辑：复用后重新同步服务数据，确保数据不丢失）
+    // PositionTaskListView 集成
     // =========================================================================
-    /**
+    private void initAndBindSimpleTaskView(PositionTaskListView taskView, String posId, MainService mainService) {
-     * 初始化+绑定简单模式任务列表视图——复用后重新执行，从服务同步最新任务
+        LogUtils.d(TAG, "initAndBindSimpleTaskView posId=" + posId);
-     */
-    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 + "）");
+            LogUtils.w(TAG, "初始化简单任务视图失败：参数无效");
             return;
         }
-
-        // 1. 初始化任务视图（绑定MainService+当前位置ID——复用后重新绑定，确保服务引用有效）
         taskView.init(mainService, posId);
-        // 2. 设置为简单模式（仅展示，隐藏编辑按钮——复用后恢复视图模式）
         taskView.setViewStatus(PositionTaskListView.VIEW_MODE_SIMPLE);
-		// 3. 关键：复用后强制从服务同步最新任务（避免显示旧数据，核心修复点）
         taskView.syncTasksFromMainService();
 
-		// 4. 任务更新回调（服务任务变化时重新同步——复用后重新绑定回调，避免监听失效）
         taskView.setOnTaskUpdatedListener(new PositionTaskListView.OnTaskUpdatedListener() {
 				@Override
 				public void onTaskUpdated(String positionId, ArrayList updatedTasks) {
-					LogUtils.d(TAG, "简单模式任务更新：位置ID=" + positionId + "，已启用任务数=" + updatedTasks.size());
+					LogUtils.d(TAG, "简单模式任务更新 posId=" + positionId + " 任务数=" + updatedTasks.size());
 				}
 			});
-
-		LogUtils.d(TAG, "初始化/复用简单模式任务视图完成：位置ID=" + posId);
     }
 
-	/**
-	 - 初始化+绑定编辑模式任务列表视图——复用后重新执行，从服务同步最新任务+恢复编辑功能
-	 */
     private void initAndBindEditTaskView(final PositionTaskListView taskView, final String posId,
                                          MainService mainService, Button btnAddTask) {
+        LogUtils.d(TAG, "initAndBindEditTaskView posId=" + posId);
         if (taskView == null || TextUtils.isEmpty(posId) || mainService == null || btnAddTask == null) {
-			LogUtils.w(TAG, "初始化编辑模式任务视图失败：参数无效（posId=" + posId + "，btnAddTask=" + btnAddTask + "）");
+            LogUtils.w(TAG, "初始化编辑任务视图失败：参数无效");
             return;
         }
-		// 1. 初始化任务视图（绑定MainService+当前位置ID——复用后重新绑定，确保服务引用有效）
         taskView.init(mainService, posId);
-		// 2. 设置为编辑模式（显示编辑/删除按钮——复用后恢复视图模式）
         taskView.setViewStatus(PositionTaskListView.VIEW_MODE_EDIT);
-		// 3. 关键：复用后强制从服务同步最新任务（避免显示旧数据，核心修复点）
+        taskView.syncTasksFromMainService();
-		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.setTaskId(PositionTaskModel.genTaskId());
-					newTask.setPositionId(posId);                     // 绑定当前位置
+					newTask.setPositionId(posId);
-					newTask.setTaskDescription(DEFAULT_TASK_DESC);    // 默认描述
+					newTask.setTaskDescription(DEFAULT_TASK_DESC);
-					newTask.setDiscussDistance(DEFAULT_TASK_DISTANCE); // 默认触发距离（50米）
+					newTask.setDiscussDistance(DEFAULT_TASK_DISTANCE);
-					newTask.setIsEnable(true);                        // 默认启用
+					newTask.setIsEnable(true);
-					newTask.setIsBingo(false);                        // 初始未触发// 调用任务视图的新增方法（假设视图已实现addNewTask，内部同步MainService）
+					newTask.setIsBingo(false);
+
 					taskView.addNewTask(newTask);
-					hideSoftKeyboard(v); // 隐藏软键盘，提升体验
+					hideSoftKeyboard(v);
-					LogUtils.d(TAG, "编辑模式新增任务：位置ID=" + posId + "，任务ID=" + newTask.getTaskId());
+					LogUtils.d(TAG, "新增任务 posId=" + posId + " taskId=" + newTask.getTaskId());
 				}
-			});// 5. 任务更新回调（通知外部任务变化——复用后重新绑定回调，确保交互正常）
+			});
+
         taskView.setOnTaskUpdatedListener(new PositionTaskListView.OnTaskUpdatedListener() {
 				@Override
 				public void onTaskUpdated(String positionId, ArrayList updatedTasks) {
-					LogUtils.d(TAG, "编辑模式任务更新：位置ID=" + positionId + "，当前任务数=" + updatedTasks.size());
+					LogUtils.d(TAG, "编辑模式任务更新 posId=" + positionId + " 任务数=" + updatedTasks.size());
 				}
 			});
-			LogUtils.d(TAG, "初始化/复用编辑模式任务视图完成：位置ID=" + posId);
     }
 
     // =========================================================================
-	// 工具方法（保留原有逻辑，适配资源复用场景）
+    // 工具方法
     // =========================================================================
-	/**
-
-	 - 更新距离显示（复用后重新执行，确保显示最新距离+颜色——适配资源复用）
-	 */
     private void updateDistanceDisplay(TextView distanceView, PositionModel posModel) {
         if (distanceView == null || posModel == null) {
-			LogUtils.w(TAG, "更新距离显示失败：参数为空（控件/位置模型）");
+            LogUtils.w(TAG, "updateDistanceDisplay：参数为空");
             return;
-		}// 场景1：距离未启用（灰色文本）
+        }
         if (!posModel.isEnableRealPositionDistance()) {
             distanceView.setText(DISTANCE_DISABLED);
             distanceView.setTextColor(mContext.getResources().getColor(R.color.gray));
             return;
-		}// 场景2：距离计算失败（红色文本，用-1标记失败状态）
+        }
         double distance = posModel.getRealPositionDistance();
         if (distance < 0) {
             distanceView.setText(DISTANCE_ERROR);
             distanceView.setTextColor(mContext.getResources().getColor(R.color.red));
             return;
-		}// 场景3：正常显示距离（按距离范围设置颜色——复用后重新计算颜色）
+        }
         distanceView.setText(String.format(DISTANCE_FORMAT, distance));
         if (distance <= 100) {
-			distanceView.setTextColor(mContext.getResources().getColor(R.color.green)); // 近距离（≤100米）
+            distanceView.setTextColor(mContext.getResources().getColor(R.color.green));
         } else if (distance <= 500) {
-			distanceView.setTextColor(mContext.getResources().getColor(R.color.yellow));// 中距离（≤500米）
+            distanceView.setTextColor(mContext.getResources().getColor(R.color.yellow));
         } else {
-			distanceView.setTextColor(mContext.getResources().getColor(R.color.red));   // 远距离（>500米）
+            distanceView.setTextColor(mContext.getResources().getColor(R.color.red));
         }
     }
 
-	/**
-
-	 - 根据索引获取位置模型（容错处理，避免越界/空指针——适配复用后索引变化场景）
-	 */
     private PositionModel getPositionByIndex(int index) {
         if (mCachedPositionList == null || index < 0 || index >= mCachedPositionList.size()) {
-			LogUtils.w(TAG, "获取位置模型失败：无效索引（" + index + "）或缓存为空");
+            LogUtils.w(TAG, "getPositionByIndex：无效索引 index=" + index);
             return null;
         }
         return mCachedPositionList.get(index);
     }
 
-	/**
-
-	 - 根据位置ID获取列表索引（用于精准刷新视图——适配复用后视图位置变化）
-	 */
     private int getPositionIndexById(String positionId) {
         if (TextUtils.isEmpty(positionId) || mCachedPositionList == null || mCachedPositionList.isEmpty()) {
-			LogUtils.w(TAG, "获取位置索引失败：参数无效（ID/缓存为空）");
+            LogUtils.w(TAG, "getPositionIndexById：参数无效");
             return -1;
-		}// Java 7 增强for循环遍历（替代Lambda，适配语法）
+        }
         for (int i = 0; i < mCachedPositionList.size(); i++) {
             PositionModel pos = mCachedPositionList.get(i);
             if (positionId.equals(pos.getPositionId())) {
                 return i;
             }
         }
-		LogUtils.w(TAG, "获取位置索引失败：未找到ID=" + positionId);
+        LogUtils.w(TAG, "未找到位置ID=" + positionId);
         return -1;
     }
 
-	/**
-
-	 - 局部更新距离UI（仅更新指定位置的距离，避免全量刷新卡顿——适配复用后控件缓存有效场景）
-	 */
     public void updateSinglePositionDistance(String positionId) {
+        LogUtils.d(TAG, "updateSinglePositionDistance posId=" + 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");
+            LogUtils.e(TAG, "无法获取 MainService");
             return;
         }
         PositionModel latestPos = null;
         try {
             ArrayList servicePosList = mainService.getPositionList();
             if (servicePosList != null && !servicePosList.isEmpty()) {
-				// Java 7 迭代器遍历，避免ConcurrentModificationException
                 Iterator iter = servicePosList.iterator();
                 while (iter.hasNext()) {
                     PositionModel pos = (PositionModel) iter.next();
@@ -474,13 +407,13 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
                 }
             }
         } catch (Exception e) {
-			LogUtils.d(TAG, "获取最新位置数据失败（ID=" + positionId + "）" + e);
+            LogUtils.e(TAG, "获取位置数据异常", e);
-			return;
+            return;
-		}if (latestPos == null) {
+        }
-			LogUtils.w(TAG, "局部更新距离失败：未找到位置ID=" + positionId);
+        if (latestPos == null) {
+            LogUtils.w(TAG, "未找到位置 posId=" + positionId);
             return;
         }
-		// 2. 更新距离控件（确保主线程操作，避免跨线程异常——适配复用后控件已重新绑定）
         final TextView distanceView = mPosDistanceViewMap.get(positionId);
         if (distanceView != null && distanceView.isAttachedToWindow()) {
             final PositionModel finalLatestPos = latestPos;
@@ -490,146 +423,130 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
 						updateDistanceDisplay(distanceView, finalLatestPos);
 					}
 				});
-			LogUtils.d(TAG, "局部更新距离完成：位置ID=" + positionId + "，距离=" + latestPos.getRealPositionDistance() + "米");
         } else {
-			mPosDistanceViewMap.remove(positionId); // 移除无效控件缓存（如视图已被销毁）
+            mPosDistanceViewMap.remove(positionId);
-			LogUtils.w(TAG, "局部更新距离失败：控件已回收/脱离视图树（ID=" + positionId + "）");
         }
     }
 
-	/**
-	 - 全量更新位置数据（从服务同步最新数据，过滤无效/重复项——适配复用后全量刷新场景）
-	 */
     public void updateAllPositionData(ArrayList<PositionModel> newPosList) {
+        LogUtils.d(TAG, "updateAllPositionData 新数据数量=" + (newPosList != null ? newPosList.size() : 0));
         if (newPosList == null) {
-			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覆盖，保留最新
+            uniquePosMap.put(pos.getPositionId(), pos);
         }
-		ArrayList uniquePosList = new ArrayList(uniquePosMap.values());// 3. 同步到本地缓存+刷新UI（刷新后触发onBind，自动重新绑定资源）
+        ArrayList uniquePosList = new ArrayList(uniquePosMap.values());
-		this.mCachedPositionList.clear();
+
-		this.mCachedPositionList.addAll(uniquePosList);
+        mCachedPositionList.clear();
-		// 清空旧控件缓存（避免引用失效数据，刷新后重新缓存新控件）
+        mCachedPositionList.addAll(uniquePosList);
         mPosDistanceViewMap.clear();
         mSimpleTaskViewMap.clear();
         mEditTaskViewMap.clear();
         notifyDataSetChanged();
-		LogUtils.d(TAG, "全量更新位置数据完成：原数量=" + newPosList.size() + "，过滤后=" + uniquePosList.size());
+
+        LogUtils.d(TAG, "全量更新完成，有效数量=" + uniquePosList.size());
     }
 
-	/**
-	 - 隐藏软键盘（编辑完成后调用，提升用户体验——适配复用后软键盘残留问题）
-	 */
     private void hideSoftKeyboard(View view) {
         if (mContext == null || view == null) {
-			LogUtils.w(TAG, "隐藏软键盘失败：参数为空（上下文/视图）");
             return;
-		}InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
+        }
+        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) + "次）");
+                    LogUtils.d(TAG, "重试获取 MainService 成功，第" + (i + 1) + "次");
                     return mainService;
                 }
             } catch (InterruptedException e) {
-				LogUtils.d(TAG, "重试获取服务时线程被中断" + e);
+                LogUtils.e(TAG, "重试被中断", e);
-				Thread.currentThread().interrupt(); // 恢复中断状态
+                Thread.currentThread().interrupt();
                 break;
             }
-		}LogUtils.e(TAG, "重试" + retryCount + "次后仍未获取到MainService");
+        }
+        LogUtils.e(TAG, "重试" + retryCount + "次仍未获取到 MainService");
         return null;
     }
 
     // =========================================================================
-	// 实现 MainService.TaskUpdateListener 接口（服务任务变化时回调——适配复用后任务同步）
+    // 任务更新监听
     // =========================================================================
     @Override
     public void onTaskUpdated() {
-		LogUtils.d(TAG, "收到MainService任务更新通知，同步所有任务列表视图（含复用视图）");
+        LogUtils.d(TAG, "onTaskUpdated：收到服务任务更新");
-
-		// 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(); // 从服务同步最新任务（复用后也能更新）
+                    taskView.syncTasksFromMainService();
                 } else {
-					iter.remove(); // 移除无效视图缓存（如视图已脱离屏幕且未复用）
+                    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(); // 从服务同步最新任务（复用后也能更新）
+                    taskView.syncTasksFromMainService();
                 } else {
-					iter.remove(); // 移除无效视图缓存
+                    iter.remove();
                 }
             }
         }
     }
 
     // =========================================================================
-	// 回调设置方法（供Activity绑定交互逻辑——适配复用后回调不失效）
+    // 外部回调设置
     // =========================================================================
     public void setOnDeleteClickListener(OnDeleteClickListener listener) {
+        LogUtils.d(TAG, "setOnDeleteClickListener listener=" + listener);
         this.mOnDeleteListener = listener;
     }
 
     public void setOnSavePositionClickListener(OnSavePositionClickListener listener) {
+        LogUtils.d(TAG, "setOnSavePositionClickListener listener=" + listener);
         this.mOnSavePosListener = listener;
     }
 
     // =========================================================================
-	// 资源释放（Activity销毁时调用，彻底释放引用，避免内存泄漏——保留原有安全逻辑）
+    // 资源释放
     // =========================================================================
     public void release() {
-		// 1. 反注册MainService任务监听（解除服务绑定）
+        LogUtils.d(TAG, "release：开始释放 Adapter 资源");
         MainService mainService = mMainServiceRef.get();
         if (mainService != null) {
             mainService.unregisterTaskUpdateListener(this);
-			LogUtils.d(TAG, "已反注册MainService任务监听");
+            LogUtils.d(TAG, "已反注册任务监听");
         }
 
-		// 2. 释放简单模式任务视图资源（清空数据+解绑监听——仅在Activity销毁时执行，不复用场景）
         if (!mSimpleTaskViewMap.isEmpty()) {
             Iterator<ConcurrentHashMap.Entry<String, PositionTaskListView>> iter = mSimpleTaskViewMap.entrySet().iterator();
             while (iter.hasNext()) {
@@ -642,7 +559,6 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
             }
         }
 
-		// 3. 释放编辑模式任务视图资源（清空数据+解绑监听——仅在Activity销毁时执行）
         if (!mEditTaskViewMap.isEmpty()) {
             Iterator<ConcurrentHashMap.Entry<String, PositionTaskListView>> iter = mEditTaskViewMap.entrySet().iterator();
             while (iter.hasNext()) {
@@ -655,7 +571,6 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
             }
         }
 
-		// 4. 清空其他缓存+置空引用（彻底释放，避免内存泄漏）
         mPosDistanceViewMap.clear();
         if (mCachedPositionList != null) {
             mCachedPositionList.clear();
@@ -663,24 +578,21 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
         mOnDeleteListener = null;
         mOnSavePosListener = null;
 
-		LogUtils.d(TAG, "Adapter资源已完全释放（任务视图资源释放+缓存清空+引用置空）");
+        LogUtils.d(TAG, "release：资源释放完成");
     }
 
     // =========================================================================
-	// 静态内部类：ViewHolder（与布局严格对应，避免外部引用导致内存泄漏）
+    // ViewHolder
     // =========================================================================
-	/**
-	 - 简单模式ViewHolder（对应 item_position_simple.xml，含简单模式任务列表视图）
-	 */
     public static class SimpleViewHolder extends RecyclerView.ViewHolder {
-		TextView tvSimpleLon;         // 经度显示
+        TextView tvSimpleLon;
-		TextView tvSimpleLat;         // 纬度显示
+        TextView tvSimpleLat;
-		TextView tvSimpleMemo;        // 备注显示
+        TextView tvSimpleMemo;
-		TextView tvSimpleDistance;    // 距离显示
+        TextView tvSimpleDistance;
-		PositionTaskListView ptlvSimpleTasks; // 简单模式任务列表视图
+        PositionTaskListView ptlvSimpleTasks;
+
         public SimpleViewHolder(View itemView) {
             super(itemView);
-			// 绑定布局控件（与XML中ID严格一致，避免运行时空指针）
             tvSimpleLon = (TextView) itemView.findViewById(R.id.tv_simple_longitude);
             tvSimpleLat = (TextView) itemView.findViewById(R.id.tv_simple_latitude);
             tvSimpleMemo = (TextView) itemView.findViewById(R.id.tv_simple_memo);
@@ -689,24 +601,21 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
         }
     }
 
-	/**
-	 - 编辑模式ViewHolder（对应 item_position_edit.xml，含编辑模式任务列表视图）
-	 */
     public static class EditViewHolder extends RecyclerView.ViewHolder {
-		TextView tvEditLon;           // 经度显示（不可编辑）
+        TextView tvEditLon;
-		TextView tvEditLat;           // 纬度显示（不可编辑）
+        TextView tvEditLat;
-		EditText etEditMemo;          // 备注编辑
+        EditText etEditMemo;
-		TextView tvEditDistance;      // 距离显示
+        TextView tvEditDistance;
-		RadioGroup rgDistanceSwitch;  // 距离启用/禁用开关
+        RadioGroup rgDistanceSwitch;
-		Button btnCancel;             // 取消编辑按钮
+        Button btnCancel;
-		Button btnDelete;             // 删除位置按钮
+        Button btnDelete;
-		Button btnSave;               // 保存位置按钮
+        Button btnSave;
-		Button btnAddTask;            // 新增任务按钮
+        Button btnAddTask;
-		TextView tvTaskCount;         // 任务数量显示（兼容旧布局，可隐藏）
+        TextView tvTaskCount;
-		PositionTaskListView ptlvEditTasks; // 编辑模式任务列表视图
+        PositionTaskListView ptlvEditTasks;
+
         public EditViewHolder(View itemView) {
             super(itemView);
-			// 绑定布局控件（与XML中ID严格一致，避免运行时空指针）
             tvEditLon = (TextView) itemView.findViewById(R.id.tv_edit_longitude);
             tvEditLat = (TextView) itemView.findViewById(R.id.tv_edit_latitude);
             etEditMemo = (EditText) itemView.findViewById(R.id.et_edit_memo);
@@ -722,88 +631,9 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
     }
 
     // =========================================================================
-	// 补充：PositionTaskListView 必要方法适配（确保视图类已实现以下基础方法）
+    // 方法说明类（保留不动）
-	// （若视图类未实现，需在 PositionTaskListView 中添加对应逻辑，否则复用后功能异常）
     // =========================================================================
     public static class PositionTaskListViewRequiredMethods {
-		/**
-		 1. - init 方法：初始化任务视图（绑定服务+位置ID——复用后重新绑定，确保服务引用有效）
-		 - 需在 PositionTaskListView 中添加：
-		 - public void init(MainService mainService, String positionId) {
-		 - this.mMainServiceRef = new WeakReference(mainService); // 弱引用服务，防泄漏
-		 - this.mPositionId = positionId; // 绑定当前位置ID（复用后更新为当前位置ID）
-		 - }
-		 */
-
-		/**
-		 2. - setViewStatus 方法：设置视图模式（简单/编辑——复用后恢复对应模式UI）
-		 - 需在 PositionTaskListView 中添加：
-		 - public static final int VIEW_MODE_SIMPLE = 0; // 仅显示（隐藏编辑/删除按钮）
-		 - public static final int VIEW_MODE_EDIT = 1;   // 可编辑（显示编辑/删除按钮）
-		 - private int mViewMode;
-		 - public void setViewStatus(int viewMode) {
-		 - this.mViewMode = viewMode;
-		 - // 根据模式控制按钮显示：简单模式隐藏编辑按钮，编辑模式显示
-		 - if (mEditBtn != null) mEditBtn.setVisibility(viewMode == VIEW_MODE_EDIT ? View.VISIBLE : View.GONE);
-		 - if (mDeleteBtn != null) mDeleteBtn.setVisibility(viewMode == VIEW_MODE_EDIT ? View.VISIBLE : View.GONE);
-		 - }
-		 */
-
-		/**
-		 3. - syncTasksFromMainService 方法：从服务同步任务数据（复用后核心方法，避免旧数据）
-		 - 需在 PositionTaskListView 中添加：
-		 - public void syncTasksFromMainService() {
-		 - MainService mainService = mMainServiceRef.get();
-		 - if (mainService == null || TextUtils.isEmpty(mPositionId)) return;
-		 - // 根据视图模式拉取对应任务：简单模式仅拉已启用，编辑模式拉全部
-		 - ArrayList tasks = (mViewMode == VIEW_MODE_SIMPLE)
-		 - ? mainService.getEnabledTasksByPositionId(mPositionId)
-		 - : mainService.getTasksByPositionId(mPositionId);
-		 - // 更新列表数据（刷新UI，确保复用后显示最新任务）
-		 - if (mTaskAdapter != null) {
-		 - mTaskAdapter.setTaskList(tasks);
-		 - mTaskAdapter.notifyDataSetChanged();
-		 - }
-		 - // 通知外部任务更新（如Adapter需要联动）
-		 - if (mTaskUpdateListener != null) mTaskUpdateListener.onTaskUpdated(mPositionId, tasks);
-		 - }
-		 */
-
-		/**
-		 4. - addNewTask 方法：新增任务（同步服务+刷新列表——复用后功能正常）
-		 - 需在 PositionTaskListView 中添加：
-		 - public void addNewTask(PositionTaskModel newTask) {
-		 - if (newTask == null || TextUtils.isEmpty(newTask.getPositionId())) return;
-		 - MainService mainService = mMainServiceRef.get();
-		 - if (mainService != null) {
-		 - mainService.addTask(newTask); // 同步到服务（确保数据持久化）
-		 - syncTasksFromMainService();   // 新增后立即同步，刷新列表
-		 - Toast.makeText(getContext(), "任务新增成功", Toast.LENGTH_SHORT).show();
-		 - } else {
-		 - Toast.makeText(getContext(), "服务未就绪，新增失败", Toast.LENGTH_SHORT).show();
-		 - }
-		 - }
-		 */
-
-		/**
-		 5. - clearData 方法：清空任务数据（仅在Activity销毁时调用，不复用场景）
-		 - 需在 PositionTaskListView 中添加：
-		 - public void clearData() {
-		 - if (mTaskList != null) mTaskList.clear(); // 清空本地任务列表
-		 - if (mTaskAdapter != null) mTaskAdapter.notifyDataSetChanged(); // 刷新空UI
-		 - }
-		 */
-
-		/**
-		 6. - setOnTaskUpdatedListener 方法：设置任务更新回调（复用后重新绑定，避免回调失效）
-		 - 需在 PositionTaskListView 中添加：
-		 - public interface OnTaskUpdatedListener {
-		 - void onTaskUpdated(String positionId, ArrayList updatedTasks);
-		 - }
-		 - private OnTaskUpdatedListener mTaskUpdateListener;
-		 - public void setOnTaskUpdatedListener(OnTaskUpdatedListener listener) {
-		 - this.mTaskUpdateListener = listener;
-		 - }
-		 */
     }
 }
+

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

@@ -230,7 +230,7 @@ public class MainService extends Service {
      * 删除任务（Adapter调用，通过迭代器安全删除，避免并发异常）
      * @param taskId 待删除任务的ID
      */
-    public void deleteTask(String taskId) {
+    public void deleteTask(final String taskId) {
         if (TextUtils.isEmpty(taskId) || mAllTasks.isEmpty()) {
             LogUtils.w(TAG, "deletePositionTask：任务ID为空或列表为空，删除失败");
             return;

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

@@ -1,10 +1,12 @@
 package cc.winboll.studio.positions.views;
 
 /**
- * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
- * @Date 2025/09/30 08:09
  * @Describe 位置任务列表视图（适配MainService唯一数据源+同步任务状态+支持简单/编辑模式）
+ * @Author 豆包&ZhanGSKen<zhangsken@qq.com>
+ * @CreateTime 2025-09-30 08:09:00
+ * @EditTime 2026-03-31 19:00:00
  */
+
 import android.content.Context;
 import android.util.AttributeSet;
 import android.view.LayoutInflater;
@@ -21,6 +23,7 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
+import cc.winboll.studio.libaes.dialogs.YesNoAlertDialog;
 import cc.winboll.studio.libappbase.LogUtils;
 import cc.winboll.studio.positions.R;
 import cc.winboll.studio.positions.models.PositionTaskModel;
@@ -35,101 +38,96 @@ import java.util.List;
 import java.util.Locale;
 
 public class PositionTaskListView extends LinearLayout {
+
     // 视图模式常量
     public static final int VIEW_MODE_SIMPLE = 1;
     public static final int VIEW_MODE_EDIT = 2;
 
-    // 核心成员变量（新增MainService引用，作为唯一数据源）
+    private static final String TAG = "PositionTaskListView";
+
+    // 核心成员变量
     private String mBindPositionId;
-    private MainService mMainService; // 持有MainService实例，所有任务数据从服务获取
+    private MainService mMainService;
     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);
+        LogUtils.d(TAG, "PositionTaskListView 构造函数 1 参数: context=" + context);
         initView(context);
     }
 
     public PositionTaskListView(Context context, @Nullable AttributeSet attrs) {
         super(context, attrs);
+        LogUtils.d(TAG, "PositionTaskListView 构造函数 2 参数: context=" + context + ", attrs=" + attrs);
         initView(context);
     }
 
     public PositionTaskListView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
         super(context, attrs, defStyleAttr);
+        LogUtils.d(TAG, "PositionTaskListView 构造函数 3 参数: context=" + context + ", attrs=" + attrs + ", defStyleAttr=" + defStyleAttr);
         initView(context);
     }
 
-    // 初始化视图（绑定控件+设置布局，Adapter初始化为空数据）
+    // ---------------------- 初始化视图 ----------------------
     private void initView(Context context) {
+        LogUtils.d(TAG, "initView 开始执行 参数: context=" + context);
         setOrientation(VERTICAL);
         LayoutInflater.from(context).inflate(R.layout.view_position_task_list, this, true);
 
         mRvTasks = (RecyclerView) findViewById(R.id.rv_position_tasks);
         mRvTasks.setLayoutManager(new LinearLayoutManager(context));
 
-        // 初始化为空列表（数据后续从MainService同步）
         mTaskAdapter = new TaskListAdapter(new ArrayList<PositionTaskModel>());
         mRvTasks.setAdapter(mTaskAdapter);
 
         mCurrentViewMode = VIEW_MODE_SIMPLE;
-        LogUtils.d(TAG, "视图初始化完成（等待绑定MainService和位置ID）");
+        LogUtils.d(TAG, "initView 执行完成，视图初始化完毕");
     }
 
-    // ---------------------- 对外API（核心调整：绑定MainService+从服务同步数据） ----------------------
+    // ---------------------- 对外API ----------------------
-    /**
-     * 初始化：绑定MainService+关联位置ID（必须先调用此方法，否则无数据）
-     * @param mainService MainService实例（从Activity传入，确保唯一数据源）
-     * @param positionId 关联的位置ID（只加载该位置下的任务）
-     */
     public void init(MainService mainService, String positionId) {
+        LogUtils.d(TAG, "init 开始执行 参数: mainService=" + mainService + ", positionId=" + positionId);
         if (mainService == null) {
-            LogUtils.e(TAG, "init失败：MainService实例为空（需从Activity传入有效服务实例）");
+            LogUtils.e(TAG, "init 失败：MainService 为空");
             showToast("任务列表初始化失败：服务未就绪");
             return;
         }
         if (positionId == null || positionId.trim().isEmpty()) {
-            LogUtils.e(TAG, "init失败：位置ID为空（需关联有效位置）");
+            LogUtils.e(TAG, "init 失败：positionId 为空");
             showToast("任务列表初始化失败：未关联位置");
             return;
         }
 
-        // 绑定服务实例+位置ID
+        mMainService = mainService;
-        this.mMainService = mainService;
+        mBindPositionId = positionId;
-        this.mBindPositionId = positionId;
+        LogUtils.d(TAG, "init 绑定成功：positionId=" + positionId);
-        LogUtils.d(TAG, "已绑定MainService和位置ID：" + positionId);
 
-        // 从MainService同步当前位置的任务（核心：数据来源改为服务）
         syncTasksFromMainService();
+        LogUtils.d(TAG, "init 执行完成");
     }
 
-    /**
-     * 从MainService同步当前位置的任务（核心方法，所有数据加载入口）
-     * 作用：1. 清空本地缓存→2. 从服务获取全量任务→3. 筛选当前位置任务→4. 刷新Adapter
-     */
     public void syncTasksFromMainService() {
-        // 安全校验（服务未绑定/位置ID为空，不执行同步）
+        LogUtils.d(TAG, "syncTasksFromMainService 开始执行");
         if (mMainService == null || mBindPositionId == null || mBindPositionId.trim().isEmpty()) {
-            LogUtils.w(TAG, "同步任务失败：MainService未绑定或位置ID无效");
+            LogUtils.w(TAG, "syncTasksFromMainService 失败：服务或位置ID无效");
             return;
         }
 
         try {
-            // 1. 从MainService获取全量任务（服务是唯一数据源，避免本地缓存不一致）
             ArrayList<PositionTaskModel> allServiceTasks = mMainService.getAllTasks();
-            LogUtils.d(TAG, "从MainService获取全量任务数：" + (allServiceTasks == null ? 0 : allServiceTasks.size()));
+            LogUtils.d(TAG, "syncTasksFromMainService 从服务获取任务总数: " + (allServiceTasks == null ? 0 : allServiceTasks.size()));
 
-            // 2. 筛选当前位置关联的任务（只保留与mBindPositionId匹配的任务）
+            ArrayList<PositionTaskModel> currentPosTasks = new ArrayList<>();
-            ArrayList<PositionTaskModel> currentPosTasks = new ArrayList<PositionTaskModel>();
             if (allServiceTasks != null && !allServiceTasks.isEmpty()) {
                 for (PositionTaskModel task : allServiceTasks) {
                     if (isTaskMatchedWithPosition(task)) {
@@ -137,144 +135,148 @@ public class PositionTaskListView extends LinearLayout {
                     }
                 }
             }
-            LogUtils.d(TAG, "筛选后当前位置任务数：" + currentPosTasks.size());
+            LogUtils.d(TAG, "syncTasksFromMainService 筛选后当前位置任务数: " + currentPosTasks.size());
 
-            // 3. 更新Adapter数据（直接替换数据源，避免本地缓存）
             mTaskAdapter.updateData(currentPosTasks);
-            LogUtils.d(TAG, "从MainService同步任务完成（Adapter已刷新）");
+            LogUtils.d(TAG, "syncTasksFromMainService 执行完成，Adapter已刷新");
 
         } catch (Exception e) {
-            LogUtils.d(TAG, "同步任务失败（MainService调用异常）：" + e.getMessage());
+            LogUtils.e(TAG, "syncTasksFromMainService 异常: " + e.getMessage(), e);
             showToast("任务同步失败，请重试");
         }
     }
 
-    // 视图模式切换（不变，刷新Adapter触发视图类型变更）
     public void setViewStatus(int viewMode) {
+        LogUtils.d(TAG, "setViewStatus 参数: viewMode=" + viewMode);
         if (viewMode != VIEW_MODE_SIMPLE && viewMode != VIEW_MODE_EDIT) {
-            LogUtils.w(TAG, "设置视图模式失败：无效模式（仅支持简单/编辑模式）");
+            LogUtils.w(TAG, "setViewStatus 无效模式");
             return;
         }
         mCurrentViewMode = viewMode;
         mTaskAdapter.notifyDataSetChanged();
-        LogUtils.d(TAG, "已切换视图模式：" + (viewMode == VIEW_MODE_SIMPLE ? "简单模式" : "编辑模式"));
+        LogUtils.d(TAG, "setViewStatus 切换完成: " + (viewMode == VIEW_MODE_SIMPLE ? "简单模式" : "编辑模式"));
     }
 
-    // 保留回调接口（用于通知外部UI刷新，如Activity更新列表）
     public void setOnTaskUpdatedListener(OnTaskUpdatedListener listener) {
-        this.mOnTaskUpdatedListener = listener;
+        LogUtils.d(TAG, "setOnTaskUpdatedListener 参数: listener=" + listener);
-        LogUtils.d(TAG, "已设置任务更新回调监听");
+        mOnTaskUpdatedListener = listener;
     }
 
-    /**
-     * 获取当前位置的任务（从Adapter数据源获取，而非本地缓存）
-     * @return 当前位置任务列表（新集合，避免外部修改数据源）
-     */
     public ArrayList<PositionTaskModel> getCurrentPosTasks() {
-        return new ArrayList<PositionTaskModel>(mTaskAdapter.getAdapterData());
+        LogUtils.d(TAG, "getCurrentPosTasks 被调用");
+        return new ArrayList<>(mTaskAdapter.getAdapterData());
     }
 
-    /**
-     * 清空数据（解绑服务+清空位置ID+重置Adapter）
-     * 场景：视图销毁/切换位置时调用，避免数据残留
-     */
     public void clearData() {
-        // 1. 清空Adapter数据源
+        LogUtils.d(TAG, "clearData 开始执行");
         mTaskAdapter.updateData(new ArrayList<PositionTaskModel>());
-        // 2. 解绑服务+位置ID（避免下次使用时引用旧数据）
+        mMainService = null;
-        this.mMainService = null;
+        mBindPositionId = null;
-        this.mBindPositionId = null;
-        // 3. 重置视图模式
         mCurrentViewMode = VIEW_MODE_SIMPLE;
-        LogUtils.d(TAG, "数据已清空（解绑服务+重置视图）");
+        LogUtils.d(TAG, "clearData 执行完成，数据已清空");
     }
 
-    /**
-     * 主动触发任务同步（强制从服务拉取最新数据，刷新视图）
-     * 场景：外部操作后（如新增任务），调用此方法更新列表
-     */
     public void triggerTaskSync() {
-        LogUtils.d(TAG, "主动触发任务同步（从MainService拉取最新数据）");
+        LogUtils.d(TAG, "triggerTaskSync 主动触发同步");
         syncTasksFromMainService();
-
-        // 通知外部（如Activity）任务已更新（可选，根据业务需求）
         if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
             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()) {
+        if (task == null || mBindPositionId == null) {
             return false;
         }
-        // 严格匹配任务的位置ID（确保只加载当前位置的任务）
         return mBindPositionId.equals(task.getPositionId());
     }
 
-    /**
-     * 显示Toast（简化调用，避免重复代码）
-     */
     private void showToast(String content) {
         if (getContext() == null) return;
         Toast.makeText(getContext(), content, Toast.LENGTH_SHORT).show();
     }
 
-    // ---------------------- 内部Adapter：适配MainService数据源（核心调整） ----------------------
+    private String genSelectedTimeText(long timeMillis) {
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.getDefault());
+        return sdf.format(new Date(timeMillis));
+    }
+
+    // ---------------------- 外部新增任务 ----------------------
+    public void addNewTask(PositionTaskModel newTask) {
+        LogUtils.d(TAG, "addNewTask 参数: newTask=" + newTask);
+        if (mMainService == null) {
+            LogUtils.e(TAG, "addNewTask 失败：MainService为空");
+            showToast("新增任务失败：服务未就绪");
+            return;
+        }
+        if (newTask == null) {
+            LogUtils.e(TAG, "addNewTask 失败：任务为空");
+            showToast("新增任务失败：任务数据为空");
+            return;
+        }
+        if (mBindPositionId == null || mBindPositionId.trim().isEmpty()) {
+            LogUtils.e(TAG, "addNewTask 失败：未绑定位置");
+            showToast("新增任务失败：未关联位置");
+            return;
+        }
+
+        try {
+            newTask.setPositionId(mBindPositionId);
+            mMainService.addTask(newTask);
+            LogUtils.d(TAG, "addNewTask 服务添加成功 taskId=" + newTask.getTaskId());
+
+            syncTasksFromMainService();
+            if (mOnTaskUpdatedListener != null) {
+                mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, getCurrentPosTasks());
+            }
+            showToast("新增任务成功");
+
+        } catch (Exception e) {
+            LogUtils.e(TAG, "addNewTask 异常: " + e.getMessage(), e);
+            showToast("新增失败，请重试");
+            syncTasksFromMainService();
+        }
+    }
+
+    // ---------------------- Adapter ----------------------
     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); // 防御性拷贝，避免外部修改
+            LogUtils.d(TAG, "TaskListAdapter 构造 参数 data.size=" + data.size());
+            mAdapterData = new ArrayList<>(data);
         }
 
-        /**
-         * 更新Adapter数据源（核心：从MainService同步后调用，替换数据源并刷新）
-         * @param newData 从MainService筛选后的当前位置任务列表
-         */
         public void updateData(List<PositionTaskModel> newData) {
+            LogUtils.d(TAG, "updateData 参数 newData.size=" + (newData == null ? 0 : newData.size()));
             if (newData == null) {
-                this.mAdapterData.clear();
+                mAdapterData.clear();
             } else {
-                this.mAdapterData = new ArrayList<PositionTaskModel>(newData); // 防御性拷贝
+                mAdapterData = new ArrayList<>(newData);
             }
-            notifyDataSetChanged(); // 刷新列表（数据源已替换，确保显示最新数据）
+            notifyDataSetChanged();
         }
 
-        /**
-         * 获取Adapter当前数据源（对外提供，避免直接操作mAdapterData）
-         * @return 当前数据源（新集合，避免外部修改）
-         */
         public List<PositionTaskModel> getAdapterData() {
-            return new ArrayList<PositionTaskModel>(mAdapterData);
+            return new ArrayList<>(mAdapterData);
         }
 
-        //  getItemCount：空列表显示1个“空提示”项，非空显示任务数
         @Override
         public int getItemCount() {
             return mAdapterData.isEmpty() ? 1 : mAdapterData.size();
         }
 
-        //  getItemViewType：按“空列表/简单模式/编辑模式”区分视图类型（不变）
         @Override
         public int getItemViewType(int position) {
             if (mAdapterData.isEmpty()) {
-                return 0; // 0=空提示视图
+                return 0;
             } else {
-                return mCurrentViewMode; // 1=简单模式视图，2=编辑模式视图
+                return mCurrentViewMode;
             }
         }
 
-        //  onCreateViewHolder：按视图类型加载对应布局（不变，确保布局与模式匹配）
         @NonNull
         @Override
         public TaskViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
@@ -282,302 +284,230 @@ 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红点，仅展示）
+                View simpleView = inflater.inflate(R.layout.item_position_task_simple, parent, false);
-                View simpleTaskView = inflater.inflate(R.layout.item_position_task_simple, parent, false);
+                return new SimpleTaskViewHolder(simpleView);
-                return new SimpleTaskViewHolder(simpleTaskView);
             } else {
-                // 编辑模式布局（带编辑/删除按钮+启用开关，支持修改）
+                View editView = inflater.inflate(R.layout.item_task_content, parent, false);
-                View editTaskView = inflater.inflate(R.layout.item_task_content, parent, false);
+                return new TaskContentViewHolder(editView);
-                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 = emptyHolder.itemView.findViewById(R.id.tv_task_empty_tip);
+                TextView tv = emptyHolder.itemView.findViewById(R.id.tv_task_empty_tip);
-                tvEmptyTip.setText(mCurrentViewMode == VIEW_MODE_EDIT 
+                tv.setText(mCurrentViewMode == VIEW_MODE_EDIT
 						   ? "暂无任务，点击\"添加新任务\"创建"
 						   : "暂无启用的任务");
                 return;
             }
 
-            // 2. 任务项有效性校验（避免越界/空数据）
             if (position >= mAdapterData.size()) {
-                LogUtils.w(TAG, "绑定任务数据失败：位置索引越界（position=" + position + "，数据量=" + mAdapterData.size() + "）");
+                LogUtils.w(TAG, "onBindViewHolder 越界 position=" + position);
                 return;
             }
+
             final PositionTaskModel task = mAdapterData.get(position);
             if (task == null) {
-                LogUtils.w(TAG, "绑定任务数据失败：第" + position + "项任务为空");
+                LogUtils.w(TAG, "onBindViewHolder task为空 position=" + position);
                 return;
             }
 
-            // 3. 简单模式绑定（仅展示，无修改操作，不变）
             if (holder instanceof SimpleTaskViewHolder) {
-                SimpleTaskViewHolder simpleHolder = (SimpleTaskViewHolder) holder;
+                SimpleTaskViewHolder h = (SimpleTaskViewHolder) holder;
-                // 任务描述
+                String desc = task.getTaskDescription() == null ? "未设置描述" : task.getTaskDescription();
-                String taskDesc = task.getTaskDescription() == null ? "未设置描述" : task.getTaskDescription();
+                h.tvSimpleTaskDesc.setText(String.format("任务：%s", desc));
-                simpleHolder.tvSimpleTaskDesc.setText(String.format("任务：%s", taskDesc));
+                h.tvStartTime.setText(genSelectedTimeText(task.getStartTime()));
-				simpleHolder.tvStartTime.setText(genSelectedTimeText(task.getStartTime()));
+                String cond = task.isGreaterThan() ? "大于" : "小于";
-                // 距离条件（大于/小于+距离值）
+                h.tvSimpleDistanceCond.setText(String.format("条件：距离 %s %d 米", cond, task.getDiscussDistance()));
-                String distanceCond = task.isGreaterThan() ? "大于" : "小于";
+                h.tvSimpleIsEnable.setText(task.isEnable() ? "状态：已启用" : "状态：已禁用");
-                simpleHolder.tvSimpleDistanceCond.setText(String.format("条件：距离 %s %d 米", distanceCond, task.getDiscussDistance()));
+                h.tvSimpleIsEnable.setTextColor(task.isEnable()
-                // 启用状态
-				simpleHolder.tvSimpleIsEnable.setText(task.isEnable() ? "状态：已启用" : "状态：已禁用");
-				// 修改为从colors.xml读取颜色
-				simpleHolder.tvSimpleIsEnable.setTextColor(task.isEnable() 
 												? getContext().getResources().getColor(R.color.colorEnableGreen)
 												: getContext().getResources().getColor(R.color.colorGrayText));
-                // isBingo红点（任务触发时显示，未触发时隐藏）
+                h.vBingoDot.setVisibility(task.isBingo() ? View.VISIBLE : View.GONE);
-                simpleHolder.vBingoDot.setVisibility(task.isBingo() ? View.VISIBLE : View.GONE);
+
             } else if (holder instanceof TaskContentViewHolder) {
-                TaskContentViewHolder contentHolder = (TaskContentViewHolder) holder;
+                TaskContentViewHolder h = (TaskContentViewHolder) holder;
-                bindEditModeTask(contentHolder, task, position);
+                bindEditModeTask(h, task, position);
             }
         }
 
-        /**
-         * 编辑模式任务绑定（核心：修改操作→更新MainService→刷新Adapter）
-         */
         private void bindEditModeTask(final TaskContentViewHolder holder, final PositionTaskModel task, final int position) {
-            // 4.1 绑定基础数据（描述+距离条件）
+            LogUtils.d(TAG, "bindEditModeTask position=" + position + " taskId=" + task.getTaskId());
-            String taskDesc = task.getTaskDescription() == null ? "未设置描述" : task.getTaskDescription();
+
-            holder.tvTaskDesc.setText(String.format("任务：%s", taskDesc));
+            String desc = task.getTaskDescription() == null ? "未设置描述" : task.getTaskDescription();
-            String distanceCond = task.isGreaterThan() ? "大于" : "小于";
+            holder.tvTaskDesc.setText(String.format("任务：%s", desc));
-            holder.tvTaskDistance.setText(String.format("条件：%s %d 米", distanceCond, task.getDiscussDistance()));
+            String cond = task.isGreaterThan() ? "大于" : "小于";
+            holder.tvTaskDistance.setText(String.format("条件：%s %d 米", cond, task.getDiscussDistance()));
             holder.tvStartTime.setText(genSelectedTimeText(task.getStartTime()));
 
-            // 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);
 
-            // 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) {
-						if (mMainService == null) {
+						YesNoAlertDialog.show(getContext(), "删除任务提示", "是否删除此项位置任务？", new YesNoAlertDialog.OnDialogResultListener(){
-							showToast("删除失败：服务未就绪");
+								@Override
-							LogUtils.e(TAG, "删除任务失败：MainService实例为空");
+								public void onNo() {
-							return;
 								}
 
+								@Override
+								public void onYes() {
+									LogUtils.d(TAG, "删除按钮点击 position=" + position + " taskId=" + task.getTaskId());
+									if (mMainService == null) {
+										showToast("删除失败：服务未就绪");
+										LogUtils.e(TAG, "删除失败：MainService为空");
+										return;
+									}
 									try {
-							// 步骤1：调用MainService删除任务（服务是唯一数据源，确保数据一致性）
+										mMainService.deleteTask(task.getTaskId());
-							mMainService.deleteTask(task.getTaskId()); // 需在MainService中实现deleteTask()方法（删除服务内全量任务列表中的对应项）
+										LogUtils.d(TAG, "服务删除任务成功 taskId=" + task.getTaskId());
-							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));
+											mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<>(mAdapterData));
 										}
-							showToast("任务已删除（已同步至服务）");
+										showToast("任务已删除");
 
 									} catch (Exception e) {
-							LogUtils.d(TAG, "删除任务失败（服务调用/Adapter刷新异常）：" + e.getMessage());
+										LogUtils.e(TAG, "删除异常: " + e.getMessage(), e);
 										showToast("删除失败，请重试");
-							// 异常时重新同步数据（确保Adapter与服务一致）
 										syncTasksFromMainService();
 									}
 								}
+
+							});
+					}
 				});
 
-            // 4.5 编辑按钮逻辑（核心：修改后同步MainService→刷新Adapter）
             holder.btnEditTask.setOnClickListener(new View.OnClickListener() {
 					@Override
 					public void onClick(View v) {
+						LogUtils.d(TAG, "编辑按钮点击 position=" + position + " taskId=" + task.getTaskId());
 						if (mMainService == null) {
 							showToast("编辑失败：服务未就绪");
-							LogUtils.e(TAG, "编辑任务失败：MainService实例为空");
+							LogUtils.e(TAG, "编辑失败：MainService为空");
 							return;
 						}
-						// 弹出编辑弹窗（修改后同步服务）
 						showEditTaskDialog(task, position);
 					}
 				});
 
-            // 4.6 启用开关逻辑（核心：状态变更→同步MainService→刷新Adapter）
             holder.cbTaskEnable.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
 					@Override
 					public void onCheckedChanged(CompoundButton buttonView, final boolean isChecked) {
+						LogUtils.d(TAG, "开关状态变更 taskId=" + task.getTaskId() + " isChecked=" + 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 ? "启用" : "禁用"));
+							mMainService.updateTaskStatus(task);
-
-							// 步骤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>(mAdapterData));
+											mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<>(mAdapterData));
 										}
 									}
 								});
-
 						} catch (Exception e) {
-							LogUtils.d(TAG, "修改任务启用状态失败：" + e.getMessage());
+							LogUtils.e(TAG, "开关变更异常: " + e.getMessage(), e);
-							showToast("状态修改失败，请重试");
-							// 回滚状态（UI与服务保持一致）
 							buttonView.setChecked(!isChecked);
 							task.setIsEnable(!isChecked);
-							// 重新同步数据（修复可能的不一致）
 							syncTasksFromMainService();
 						}
 					}
 				});
         }
 
-		private String genSelectedTimeText(long timeMillis) {
-			// 2. 格式化时间字符串（Java 7 用 SimpleDateFormat，需处理 ParseException）
-			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.getDefault());
-			String formattedDateTime = sdf.format(new Date(timeMillis)); // Date 需导入 java.util.Date
-
-			return formattedDateTime;
-		}
-
-        /**
-         * 编辑任务弹窗（核心：保存修改→同步MainService→刷新Adapter）
-         */
         private void showEditTaskDialog(final PositionTaskModel task, final int position) {
+            LogUtils.d(TAG, "showEditTaskDialog position=" + position + " taskId=" + task.getTaskId());
             final Context context = getContext();
             if (context == null) {
-                LogUtils.w(TAG, "编辑弹窗无法显示：上下文为空");
+                LogUtils.w(TAG, "showEditTaskDialog 上下文为空");
                 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 Button btnSelectTime = dialogView.findViewById(R.id.btn_select_time);
+            final TextView tvSelectedTime = dialogView.findViewById(R.id.tv_selected_time);
 
+            tvSelectedTime.setText(genSelectedTimeText(task.getStartTime()));
 
-			// 绑定外层对话框内的控件
+            Calendar initCal = Calendar.getInstance();
-			final Button btnSelectTime = (Button) dialogView.findViewById(R.id.btn_select_time);
+            initCal.setTimeInMillis(task.getStartTime());
-			final TextView tv_SelectedTime = (TextView) dialogView.findViewById(R.id.tv_selected_time);
+            int y = initCal.get(Calendar.YEAR);
+            int M = initCal.get(Calendar.MONTH) + 1;
+            int d = initCal.get(Calendar.DAY_OF_MONTH);
+            int h = initCal.get(Calendar.HOUR_OF_DAY);
+            int m = initCal.get(Calendar.MINUTE);
 
-			tv_SelectedTime.setText(genSelectedTimeText(task.getStartTime()));
-
-			// 核心：从 long 时间戳解析年月日时分，用于初始化弹窗
-			// --------------------------
-			Calendar initCalendar = Calendar.getInstance();
-			initCalendar.setTimeInMillis(task.getStartTime()); // 将 long 时间戳传入 Calendar
-
-			// 从 Calendar 中解析出年月日时分（对应弹窗需要的参数格式）
-			int initYear = initCalendar.get(Calendar.YEAR);
-			int initMonth = initCalendar.get(Calendar.MONTH) + 1; // 关键：Calendar 月份0-11，转成1-12
-			int initDay = initCalendar.get(Calendar.DAY_OF_MONTH);
-			int initHour = initCalendar.get(Calendar.HOUR_OF_DAY); // 24小时制
-			int initMinute = initCalendar.get(Calendar.MINUTE);
-
-			// 初始化弹窗，用解析出的年月日时分设置默认选中时间
             final DateTimePickerPopup dateTimePopup = new DateTimePickerPopup.Builder(context)
 				.setDateTimeRange(2020, 2030, 1, 12, 1, 31, 0, 23, 0, 59)
-				// 用 long 时间戳解析出的参数设置初始时间
+				.setDefaultDateTime(y, M, d, h, m)
-				.setDefaultDateTime(initYear, initMonth, initDay, initHour, initMinute)
 				.setOnDateTimeSelectedListener(new DateTimePickerPopup.OnDateTimeSelectedListener() {
 					@Override
 					public void onDateTimeSelected(int year, int month, int day, int hour, int minute) {
-						// 处理选择的日期时间
+						Calendar cal = Calendar.getInstance();
-						// 1. 创建 Calendar 实例（用于组装日期时间）
+						cal.set(year, month - 1, day, hour, minute, 0);
-						Calendar calendar = Calendar.getInstance();
+						cal.set(Calendar.MILLISECOND, 0);
-						// 2. 设置 Calendar 的年、月、日、时、分（注意：Calendar 月份从 0 开始，需减 1）
+						long time = cal.getTimeInMillis();
-						calendar.set(Calendar.YEAR, year);
+						tvSelectedTime.setText(genSelectedTimeText(time));
-						calendar.set(Calendar.MONTH, month - 1); // 关键：传入的 month 是 1-12，需转为 0-11
+						task.setStartTime(time);
-						calendar.set(Calendar.DAY_OF_MONTH, day);
-						calendar.set(Calendar.HOUR_OF_DAY, hour); // 24小时制，对应参数中的 hour（0-23）
-						calendar.set(Calendar.MINUTE, minute);
-						calendar.set(Calendar.SECOND, 0); // 秒默认设为 0，避免随机值
-						calendar.set(Calendar.MILLISECOND, 0); // 毫秒默认设为 0，确保时间戳精确
-
-						// 3. 转为 long 类型时间戳（单位：毫秒，从 1970-01-01 00:00:00 开始计算）
-						long timeMillis = calendar.getTimeInMillis();
-
-						// 4. 后续使用（示例：打印时间戳或传递给其他逻辑）
-						tv_SelectedTime.setText(genSelectedTimeText(timeMillis));
-						task.setStartTime(timeMillis);
 					}
 
 					@Override
-					public void onCancel() {
+					public void onCancel() {}
-						// 处理取消操作
-					}
 				})
 				.build();
 
-			// 3. “选择时间”按钮点击事件（弹出 TimePickerPopup）
             btnSelectTime.setOnClickListener(new View.OnClickListener() {
 					@Override
-					public void onClick(final View v) {
+					public void onClick(View v) {
 						dateTimePopup.showAsDropDown(btnSelectTime);
 					}
 				});
 
-
-            // 初始化弹窗数据（填充当前任务信息）
             etEditDesc.setText(task.getTaskDescription() == null ? "" : task.getTaskDescription());
-            etEditDesc.setSelection(etEditDesc.getText().length()); // 光标定位到末尾
+            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) // 不允许点击外部关闭（避免未保存退出）
+				.setCancelable(false)
 				.create();
             dialog.show();
 
-
+            final OnDateSetListener listener = new OnDateSetListener() {
-
-			final OnDateSetListener onSateSetListener = new OnDateSetListener(){
                 @Override
-				public void onDateSet(TimePickerDialog timePickerDialog, long p) {
+                public void onDateSet(TimePickerDialog timePickerDialog, long p) {}
-				}
             };
 
-            // 取消按钮：关闭弹窗（不做操作）
             btnCancel.setOnClickListener(new View.OnClickListener() {
 					@Override
 					public void onClick(View v) {
@@ -585,24 +515,22 @@ 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();
+						String distStr = etEditDistance.getText().toString().trim();
 
-						if (distanceStr.isEmpty()) {
+						if (distStr.isEmpty()) {
-							showToast("请输入有效距离（1米及以上）");
+							showToast("请输入有效距离");
 							etEditDistance.requestFocus();
 							return;
 						}
 
-						int newDistance;
+						int newDist;
 						try {
-							newDistance = Integer.parseInt(distanceStr);
+							newDist = Integer.parseInt(distStr);
-							if (newDistance < 1) {
+							if (newDist < 1) {
 								showToast("距离不能小于1米");
 								etEditDistance.requestFocus();
 								return;
@@ -613,71 +541,58 @@ public class PositionTaskListView extends LinearLayout {
 							return;
 						}
 
-						// 2. 收集新数据（更新任务对象）
+						task.setTaskDescription(newDesc);
-						task.setTaskDescription(newDesc); // 新描述
+						task.setDiscussDistance(newDist);
-						task.setDiscussDistance(newDistance); // 新距离
 						boolean isGreater = rgDistanceCondition.getCheckedRadioButtonId() == R.id.rb_greater_than;
-						task.setIsGreaterThan(isGreater); // 新距离条件（大于/小于）
+						task.setIsGreaterThan(isGreater);
-						task.setPositionId(mBindPositionId); // 确保位置ID不变（防止错位）
+						task.setPositionId(mBindPositionId);
 
 						try {
-							// 3. 调用MainService同步修改（服务是唯一数据源，持久化变更）
+							mMainService.updateTask(task);
-							mMainService.updateTask(task); // 需在MainService中实现updateTask()方法（更新服务内任务的字段）
+							LogUtils.d(TAG, "保存修改成功 taskId=" + task.getTaskId());
-							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>(mAdapterData));
+											mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<>(mAdapterData));
 										}
 									}
 								});
-
 							dialog.dismiss();
-							showToast("任务已更新（已同步至服务）");
+							showToast("任务已更新");
-
 						} catch (Exception e) {
-							LogUtils.d(TAG, "保存任务修改失败：" + e.getMessage());
+							LogUtils.e(TAG, "保存异常: " + e.getMessage(), e);
 							showToast("保存失败，请重试");
-							// 重新同步数据（修复可能的不一致）
 							syncTasksFromMainService();
 						}
 					}
 				});
         }
 
-        // ---------------------- ViewHolder 定义（完全适配布局，无修改） ----------------------
+        // ---------------------- ViewHolder ----------------------
-        // 基础抽象ViewHolder（统一父类，适配多视图类型）
         public abstract class TaskViewHolder extends RecyclerView.ViewHolder {
             public TaskViewHolder(@NonNull View itemView) {
                 super(itemView);
             }
         }
 
-        // 空提示ViewHolder（对应 item_task_empty.xml）
         public class EmptyViewHolder extends TaskViewHolder {
             public EmptyViewHolder(@NonNull View itemView) {
                 super(itemView);
             }
         }
 
-        // 简单模式ViewHolder（对应 item_position_task_simple.xml，带isBingo红点）
         public class SimpleTaskViewHolder extends TaskViewHolder {
-            TextView tvSimpleTaskDesc;    // 任务描述
+            TextView tvSimpleTaskDesc;
-            TextView tvSimpleDistanceCond;// 距离条件（大于/小于+距离）
+            TextView tvSimpleDistanceCond;
             TextView tvStartTime;
-            TextView tvSimpleIsEnable;    // 启用状态（已启用/已禁用）
+            TextView tvSimpleIsEnable;
-            View vBingoDot;               // isBingo红点（任务触发时显示）
+            View vBingoDot;
 
             public SimpleTaskViewHolder(@NonNull View itemView) {
                 super(itemView);
-                // 绑定简单模式布局控件（与XML控件ID严格对应）
                 tvSimpleTaskDesc = itemView.findViewById(R.id.tv_simple_task_desc);
                 tvSimpleDistanceCond = itemView.findViewById(R.id.tv_simple_distance_cond);
                 tvStartTime = itemView.findViewById(R.id.tv_starttime);
@@ -686,18 +601,16 @@ public class PositionTaskListView extends LinearLayout {
             }
         }
 
-        // 编辑模式ViewHolder（对应 item_task_content.xml，带编辑/删除/开关）
         public class TaskContentViewHolder extends TaskViewHolder {
-            TextView tvTaskDesc;         // 任务描述
+            TextView tvTaskDesc;
-            TextView tvTaskDistance;     // 距离条件
+            TextView tvTaskDistance;
             TextView tvStartTime;
-            CompoundButton cbTaskEnable; // 启用开关
+            CompoundButton cbTaskEnable;
-            Button btnEditTask;          // 编辑按钮
+            Button btnEditTask;
-            Button btnDeleteTask;        // 删除按钮
+            Button btnDeleteTask;
 
             public TaskContentViewHolder(@NonNull View itemView) {
                 super(itemView);
-                // 绑定编辑模式布局控件（与XML控件ID严格对应）
                 tvTaskDesc = itemView.findViewById(R.id.tv_task_desc);
                 tvTaskDistance = itemView.findViewById(R.id.tv_task_distance);
                 tvStartTime = itemView.findViewById(R.id.tv_starttime);
@@ -707,50 +620,5 @@ public class PositionTaskListView extends LinearLayout {
             }
         }
     }
-
-    // ---------------------- 新增：外部调用“新增任务”方法（适配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();
-        }
-    }
 }