Studio/APPBase
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

20251003_035831_435

Browse Source
This commit is contained in:
ZhanGSKen
2025-10-03 03:58:36 +08:00
parent 2d78681d9d
commit 1e17d326a0
4 changed files with 448 additions and 175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
positions/build.properties
View File

@@ -1,8 +1,8 @@
#Created by .winboll/winboll_app_build.gradle #Created by .winboll/winboll_app_build.gradle
#Thu Oct 02 19:24:27 GMT 2025 #Thu Oct 02 19:56:28 GMT 2025
stageCount=8 stageCount=8
libraryProject= libraryProject=
baseVersion=15.0 baseVersion=15.0
publishVersion=15.0.7 publishVersion=15.0.7
buildCount=48 buildCount=51
baseBetaVersion=15.0.8 baseBetaVersion=15.0.8

2
positions/src/main/java/cc/winboll/studio/positions/adapters/PositionAdapter.java
View File

@@ -306,7 +306,7 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
newTask.setDiscussDistance(DEFAULT_TASK_DISTANCE);// 默认任务距离（50米） newTask.setDiscussDistance(DEFAULT_TASK_DISTANCE);// 默认任务距离（50米）
// 调用MainService接口新增任务（数据写入服务，由服务处理持久化+通知刷新） // 调用MainService接口新增任务（数据写入服务，由服务处理持久化+通知刷新）
mainService.addPositionTask(newTask); mainService.addTask(newTask);
hideSoftKeyboard(v); hideSoftKeyboard(v);
LogUtils.d(TAG, "触发新增任务：调用MainService接口，位置ID=" + posId + "，任务ID=" + newTask.getTaskId()); LogUtils.d(TAG, "触发新增任务：调用MainService接口，位置ID=" + posId + "，任务ID=" + newTask.getTaskId());
} }

73
positions/src/main/java/cc/winboll/studio/positions/services/MainService.java
View File

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

518
positions/src/main/java/cc/winboll/studio/positions/views/PositionTaskListView.java
View File

@@ -3,7 +3,7 @@ package cc.winboll.studio.positions.views;
/** /**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com> * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/09/30 08:09 * @Date 2025/09/30 08:09
* @Describe 位置任务列表视图（支持简单/编辑模式，含 isBingo 红点标识） * @Describe 位置任务列表视图（适配MainService唯一数据源+同步任务状态+支持简单/编辑模式）
*/ */
import android.content.Context; import android.content.Context;
import android.util.AttributeSet; import android.util.AttributeSet;
@@ -22,8 +22,10 @@ import androidx.annotation.NonNull;
import androidx.annotation.Nullable; import androidx.annotation.Nullable;
import androidx.recyclerview.widget.LinearLayoutManager; import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView; import androidx.recyclerview.widget.RecyclerView;
import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.positions.R; import cc.winboll.studio.positions.R;
import cc.winboll.studio.positions.models.PositionTaskModel; import cc.winboll.studio.positions.models.PositionTaskModel;
import cc.winboll.studio.positions.services.MainService;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; 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_SIMPLE = 1;
public static final int VIEW_MODE_EDIT = 2; public static final int VIEW_MODE_EDIT = 2;
// 核心成员变量 // 核心成员变量（新增MainService引用，作为唯一数据源）
private String mBindPositionId; private String mBindPositionId;
private ArrayList<PositionTaskModel> mTaskList; private MainService mMainService; // 持有MainService实例，所有任务数据从服务获取
private int mCurrentViewMode; private int mCurrentViewMode;
private TaskListAdapter mTaskAdapter; private TaskListAdapter mTaskAdapter;
private RecyclerView mRvTasks; private RecyclerView mRvTasks;
// 任务修改回调接口 // 任务修改回调接口（保留，用于通知外部同步UI）
public interface OnTaskUpdatedListener { public interface OnTaskUpdatedListener {
void onTaskUpdated(String positionId, ArrayList<PositionTaskModel> updatedTasks); void onTaskUpdated(String positionId, ArrayList<PositionTaskModel> updatedTasks);
} }
private OnTaskUpdatedListener mOnTaskUpdatedListener; private OnTaskUpdatedListener mOnTaskUpdatedListener;
// ---------------------- 构造函数 ---------------------- // ---------------------- 构造函数（不变，新增MainService空校验） ----------------------
public PositionTaskListView(Context context) { public PositionTaskListView(Context context) {
super(context); super(context);
initView(context); initView(context);
@@ -62,7 +64,7 @@ public class PositionTaskListView extends LinearLayout {
initView(context); initView(context);
} }
// 初始化视图（绑定控件+设置布局） // 初始化视图（绑定控件+设置布局，Adapter初始化为空数据）
private void initView(Context context) { private void initView(Context context) {
setOrientation(VERTICAL); setOrientation(VERTICAL);
LayoutInflater.from(context).inflate(R.layout.view_position_task_list, this, true); 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 = (RecyclerView) findViewById(R.id.rv_position_tasks);
mRvTasks.setLayoutManager(new LinearLayoutManager(context)); mRvTasks.setLayoutManager(new LinearLayoutManager(context));
mTaskList = new ArrayList<PositionTaskModel>(); // 初始化为空列表（数据后续从MainService同步）
mTaskAdapter = new TaskListAdapter(mTaskList); mTaskAdapter = new TaskListAdapter(new ArrayList<PositionTaskModel>());
mRvTasks.setAdapter(mTaskAdapter); mRvTasks.setAdapter(mTaskAdapter);
mCurrentViewMode = VIEW_MODE_SIMPLE; mCurrentViewMode = VIEW_MODE_SIMPLE;
LogUtils.d(TAG, "视图初始化完成（等待绑定MainService和位置ID）");
} }
// ---------------------- 对外API ---------------------- // ---------------------- 对外API（核心调整：绑定MainService+从服务同步数据） ----------------------
public void init(ArrayList<PositionTaskModel> taskList, String positionId) { /**
* 初始化：绑定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; this.mBindPositionId = positionId;
if (this.mTaskList.isEmpty()) { LogUtils.d(TAG, "已绑定MainService和位置ID：" + positionId);
ArrayList<PositionTaskModel> matchedTasks = new ArrayList<PositionTaskModel>();
if (taskList != null && !taskList.isEmpty()) { // 从MainService同步当前位置的任务（核心：数据来源改为服务）
for (PositionTaskModel task : taskList) { syncTasksFromMainService();
if (task != null && positionId.equals(task.getPositionId())) {
matchedTasks.add(task);
}
}
}
mTaskList.clear();
mTaskList.addAll(matchedTasks);
}
mTaskAdapter.notifyDataSetChanged();
} }
/**
* 从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) { public void setViewStatus(int viewMode) {
if (viewMode != VIEW_MODE_SIMPLE && viewMode != VIEW_MODE_EDIT) { if (viewMode != VIEW_MODE_SIMPLE && viewMode != VIEW_MODE_EDIT) {
LogUtils.w(TAG, "设置视图模式失败：无效模式（仅支持简单/编辑模式）");
return; return;
} }
mCurrentViewMode = viewMode; mCurrentViewMode = viewMode;
mTaskAdapter.notifyDataSetChanged(); mTaskAdapter.notifyDataSetChanged();
LogUtils.d(TAG, "已切换视图模式：" + (viewMode == VIEW_MODE_SIMPLE ? "简单模式" : "编辑模式"));
} }
// 保留回调接口（用于通知外部UI刷新，如Activity更新列表）
public void setOnTaskUpdatedListener(OnTaskUpdatedListener listener) { public void setOnTaskUpdatedListener(OnTaskUpdatedListener listener) {
this.mOnTaskUpdatedListener = 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() { public void clearData() {
mTaskList.clear(); // 1. 清空Adapter数据源
if (mTaskAdapter != null && mTaskAdapter.mData != null) { mTaskAdapter.updateData(new ArrayList<PositionTaskModel>());
mTaskAdapter.mData.clear(); // 2. 解绑服务+位置ID（避免下次使用时引用旧数据）
} this.mMainService = null;
mTaskAdapter.notifyDataSetChanged(); this.mBindPositionId = null;
mBindPositionId = null; // 3. 重置视图模式
mCurrentViewMode = VIEW_MODE_SIMPLE;
LogUtils.d(TAG, "数据已清空（解绑服务+重置视图）");
} }
/**
* 主动触发任务同步（强制从服务拉取最新数据，刷新视图）
* 场景：外部操作后（如新增任务），调用此方法更新列表
*/
public void triggerTaskSync() { public void triggerTaskSync() {
LogUtils.d(TAG, "主动触发任务同步（从MainService拉取最新数据）");
syncTasksFromMainService();
// 通知外部（如Activity）任务已更新（可选，根据业务需求）
if (mOnTaskUpdatedListener != null && mBindPositionId != null) { 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) { private boolean isTaskMatchedWithPosition(PositionTaskModel task) {
if (task == null || mBindPositionId == null || mBindPositionId.trim().isEmpty()) { if (task == null || mBindPositionId == null || mBindPositionId.trim().isEmpty()) {
return false; return false;
} }
// 严格匹配任务的位置ID（确保只加载当前位置的任务）
return mBindPositionId.equals(task.getPositionId()); return mBindPositionId.equals(task.getPositionId());
} }
// ---------------------- 内部Adapter：适配 isBingo 红点（核心调整） ---------------------- /**
private class TaskListAdapter extends RecyclerView.Adapter<TaskListAdapter.TaskViewHolder> { * 显示Toast（简化调用，避免重复代码）
private final List<PositionTaskModel> mData; */
private void showToast(String content) {
public TaskListAdapter(List<PositionTaskModel> data) { if (getContext() == null) return;
this.mData = data; 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 @Override
public int getItemCount() { public int getItemCount() {
return mData.isEmpty() ? 1 : mData.size(); return mAdapterData.isEmpty() ? 1 : mAdapterData.size();
} }
// 调整：根据“是否空列表”+“视图模式”区分视图类型（确保简单/编辑模式加载对应布局） // getItemViewType：按“空列表/简单模式/编辑模式”区分视图类型（不变）
@Override @Override
public int getItemViewType(int position) { public int getItemViewType(int position) {
if (mData.isEmpty()) { if (mAdapterData.isEmpty()) {
return 0; // 0=空提示 return 0; // 0=空提示视图
} else { } else {
return mCurrentViewMode; // 1=简单模式，2=编辑模式（复用视图模式常量） return mCurrentViewMode; // 1=简单模式视图，2=编辑模式视图
} }
} }
// 调整：按视图类型加载布局（简单模式加载带红点的布局，编辑模式加载原有布局） // onCreateViewHolder：按视图类型加载对应布局（不变，确保布局与模式匹配）
@NonNull @NonNull
@Override @Override
public TaskViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) { public TaskViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
@@ -165,150 +277,219 @@ public class PositionTaskListView extends LinearLayout {
LayoutInflater inflater = LayoutInflater.from(context); LayoutInflater inflater = LayoutInflater.from(context);
if (viewType == 0) { if (viewType == 0) {
// 空提示布局 // 空提示布局（无任务时显示）
View emptyView = inflater.inflate(R.layout.item_task_empty, parent, false); View emptyView = inflater.inflate(R.layout.item_task_empty, parent, false);
return new EmptyViewHolder(emptyView); return new EmptyViewHolder(emptyView);
} else if (viewType == VIEW_MODE_SIMPLE) { } else if (viewType == VIEW_MODE_SIMPLE) {
// 简单模式布局（带 isBingo 红点） // 简单模式布局（带isBingo红点，仅展示）
View simpleTaskView = 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(simpleTaskView); return new SimpleTaskViewHolder(simpleTaskView);
} else { } else {
// 编辑模式布局（原有布局不变） // 编辑模式布局（带编辑/删除按钮+启用开关，支持修改）
View editTaskView = inflater.inflate(R.layout.item_task_content, parent, false); View editTaskView = inflater.inflate(R.layout.item_task_content, parent, false);
return new TaskContentViewHolder(editTaskView); return new TaskContentViewHolder(editTaskView);
} }
} }
// 调整：按视图类型绑定数据（简单模式绑定红点+文本，编辑模式绑定原有逻辑） // onBindViewHolder：按视图类型绑定数据（核心调整：操作后同步MainService）
@Override @Override
public void onBindViewHolder(@NonNull TaskViewHolder holder, int position) { public void onBindViewHolder(@NonNull TaskViewHolder holder, int position) {
// 空提示处理（不变） // 1. 空提示视图绑定（根据模式显示不同提示文案）
if (holder instanceof EmptyViewHolder) { if (holder instanceof EmptyViewHolder) {
EmptyViewHolder emptyHolder = (EmptyViewHolder) holder; EmptyViewHolder emptyHolder = (EmptyViewHolder) holder;
TextView tvEmptyTip = (TextView) emptyHolder.itemView.findViewById(R.id.tv_task_empty_tip); TextView tvEmptyTip = emptyHolder.itemView.findViewById(R.id.tv_task_empty_tip);
tvEmptyTip.setText(mCurrentViewMode == VIEW_MODE_EDIT ? "暂无任务，点击\"添加新任务\"创建" : "暂无启用的任务"); tvEmptyTip.setText(mCurrentViewMode == VIEW_MODE_EDIT
? "暂无任务，点击\"添加新任务\"创建"
: "暂无启用的任务");
return; return;
} }
// 任务项有效性校验（不变） // 2. 任务项有效性校验（避免越界/空数据）
if (position >= mData.size()) { if (position >= mAdapterData.size()) {
LogUtils.w(TAG, "绑定任务数据失败：位置索引越界（position=" + position + "，数据量=" + mAdapterData.size() + "）");
return; return;
} }
final PositionTaskModel task = mData.get(position); final PositionTaskModel task = mAdapterData.get(position);
if (task == null) { if (task == null) {
LogUtils.w(TAG, "绑定任务数据失败：第" + position + "项任务为空");
return; return;
} }
// 简单模式：绑定红点（isBingo）和文本数据 // 3. 简单模式绑定（仅展示，无修改操作，不变）
if (holder instanceof SimpleTaskViewHolder) { if (holder instanceof SimpleTaskViewHolder) {
SimpleTaskViewHolder simpleHolder = (SimpleTaskViewHolder) holder; 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() ? "大于" : "小于"; String distanceCond = task.isGreaterThan() ? "大于" : "小于";
simpleHolder.tvSimpleDistanceCond.setText(String.format("条件：距离 %s %d 米", distanceCond, task.getDiscussDistance())); simpleHolder.tvSimpleDistanceCond.setText(String.format("条件：距离 %s %d 米", distanceCond, task.getDiscussDistance()));
// 绑定启用状态 // 启用状态
simpleHolder.tvSimpleIsEnable.setText(task.isEnable() ? "状态：已启用" : "状态：已禁用"); simpleHolder.tvSimpleIsEnable.setText(task.isEnable() ? "状态：已启用" : "状态：已禁用");
// 核心：根据 isBingo 控制红点显示（true=显示，false=隐藏） // isBingo红点（任务触发时显示，未触发时隐藏）
simpleHolder.vBingoDot.setVisibility(task.isBingo() ? View.VISIBLE : View.GONE); simpleHolder.vBingoDot.setVisibility(task.isBingo() ? View.VISIBLE : View.GONE);
} }
// 编辑模式：沿用原有绑定逻辑（核心修复在此处）
// 4. 编辑模式绑定（核心调整：所有修改操作后同步MainService）
else if (holder instanceof TaskContentViewHolder) { else if (holder instanceof TaskContentViewHolder) {
TaskContentViewHolder contentHolder = (TaskContentViewHolder) holder; TaskContentViewHolder contentHolder = (TaskContentViewHolder) holder;
bindTaskData(contentHolder, task, position); bindEditModeTask(contentHolder, task, position);
} }
} }
// ---------------------- 核心修复：编辑模式绑定逻辑（解决布局中通知异常） ---------------------- /**
private void bindTaskData(final TaskContentViewHolder holder, final PositionTaskModel task, final int position) { * 编辑模式任务绑定（核心：修改操作→更新MainService→刷新Adapter）
String taskDesc = (task.getTaskDescription() == null) ? "未设置描述" : task.getTaskDescription(); */
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)); 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() ? "大于" : "小于"; // 4.2 绑定“启用开关”（修复：先解绑监听→设值→再绑定监听，避免设值触发回调）
holder.tvTaskDistance.setText(String.format("条件：%s %d 米", distanceCondition, task.getDiscussDistance()));
// 修复点1：先移除开关监听，再设置状态（避免设值时触发回调导致异常）
holder.cbTaskEnable.setOnCheckedChangeListener(null); holder.cbTaskEnable.setOnCheckedChangeListener(null);
holder.cbTaskEnable.setChecked(task.isEnable()); 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.btnEditTask.setVisibility(View.VISIBLE);
holder.btnDeleteTask.setVisibility(View.VISIBLE); holder.btnDeleteTask.setVisibility(View.VISIBLE);
// 删除按钮逻辑（不变，本身在点击时执行，不涉及布局中通知） // 4.4 删除按钮逻辑（核心：删除→同步MainService→刷新Adapter）
holder.btnDeleteTask.setOnClickListener(new View.OnClickListener() { holder.btnDeleteTask.setOnClickListener(new View.OnClickListener() {
@Override @Override
public void onClick(View v) { public void onClick(View v) {
mData.remove(position); if (mMainService == null) {
notifyItemRemoved(position); showToast("删除失败：服务未就绪");
notifyItemRangeChanged(position, mData.size()); LogUtils.e(TAG, "删除任务失败：MainService实例为空");
if (mOnTaskUpdatedListener != null && mBindPositionId != null) { return;
mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<PositionTaskModel>(mData)); }
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() { holder.btnEditTask.setOnClickListener(new View.OnClickListener() {
@Override @Override
public void onClick(View v) { 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() { holder.cbTaskEnable.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override @Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { public void onCheckedChanged(CompoundButton buttonView, final boolean isChecked) {
task.setIsEnable(isChecked); // 先更新数据源（必须执行） if (mMainService == null) {
// 关键：通过 mRvTasks.post 延迟通知，确保在布局计算/滚动结束后执行 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() { mRvTasks.post(new Runnable() {
@Override @Override
public void run() { public void run() {
notifyItemChanged(position); notifyItemChanged(position);
// 通知外部任务已更新
if (mOnTaskUpdatedListener != null && mBindPositionId != null) { 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) { * 编辑任务弹窗（核心：保存修改→同步MainService→刷新Adapter）
final Context context = getContext(); */
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); 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); etEditDesc.setText(task.getTaskDescription() == null ? "" : task.getTaskDescription());
final EditText etEditDistance = (EditText) dialogView.findViewById(R.id.et_edit_distance); etEditDesc.setSelection(etEditDesc.getText().length()); // 光标定位到末尾
Button btnCancel = (Button) dialogView.findViewById(R.id.btn_dialog_cancel); // 初始化距离条件（大于/小于）
Button btnSave = (Button) dialogView.findViewById(R.id.btn_dialog_save);
etEditDesc.setText(task.getTaskDescription());
etEditDesc.setSelection(etEditDesc.getText().length());
if (task.isGreaterThan()) { if (task.isGreaterThan()) {
rgDistanceCondition.check(R.id.rb_greater_than); rgDistanceCondition.check(R.id.rb_greater_than);
} else { } else {
rgDistanceCondition.check(R.id.rb_less_than); 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) final android.app.AlertDialog dialog = new android.app.AlertDialog.Builder(context)
.setView(dialogView) .setView(dialogView)
.setCancelable(false) // 不允许点击外部关闭（避免未保存退出）
.create(); .create();
dialog.show(); dialog.show();
// 取消按钮：关闭弹窗（不做操作）
btnCancel.setOnClickListener(new View.OnClickListener() { btnCancel.setOnClickListener(new View.OnClickListener() {
@Override @Override
public void onClick(View v) { public void onClick(View v) {
@@ -316,14 +497,17 @@ public class PositionTaskListView extends LinearLayout {
} }
}); });
// 保存按钮：校验输入→更新任务→同步服务→刷新UI
btnSave.setOnClickListener(new View.OnClickListener() { btnSave.setOnClickListener(new View.OnClickListener() {
@Override @Override
public void onClick(View v) { public void onClick(View v) {
// 1. 输入校验（避免无效数据）
String newDesc = etEditDesc.getText().toString().trim(); String newDesc = etEditDesc.getText().toString().trim();
String distanceStr = etEditDistance.getText().toString().trim(); String distanceStr = etEditDistance.getText().toString().trim();
if (distanceStr.isEmpty()) { if (distanceStr.isEmpty()) {
Toast.makeText(context, "请输入有效距离", Toast.LENGTH_SHORT).show(); showToast("请输入有效距离（1米及以上）");
etEditDistance.requestFocus();
return; return;
} }
@@ -331,62 +515,80 @@ public class PositionTaskListView extends LinearLayout {
try { try {
newDistance = Integer.parseInt(distanceStr); newDistance = Integer.parseInt(distanceStr);
if (newDistance < 1) { if (newDistance < 1) {
Toast.makeText(context, "距离不能小于1米", Toast.LENGTH_SHORT).show(); showToast("距离不能小于1米");
etEditDistance.requestFocus();
return; return;
} }
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
Toast.makeText(context, "距离请输入数字", Toast.LENGTH_SHORT).show(); showToast("距离请输入数字");
etEditDistance.requestFocus();
return; return;
} }
task.setTaskDescription(newDesc); // 2. 收集新数据（更新任务对象）
task.setDiscussDistance(newDistance); task.setTaskDescription(newDesc); // 新描述
task.setDiscussDistance(newDistance); // 新距离
boolean isGreater = rgDistanceCondition.getCheckedRadioButtonId() == R.id.rb_greater_than; boolean isGreater = rgDistanceCondition.getCheckedRadioButtonId() == R.id.rb_greater_than;
task.setIsGreaterThan(isGreater); task.setIsGreaterThan(isGreater); // 新距离条件（大于/小于）
task.setPositionId(mBindPositionId); 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() { mRvTasks.post(new Runnable() {
@Override @Override
public void run() { public void run() {
notifyItemChanged(position); notifyItemChanged(position);
// 通知外部任务已更新
if (mOnTaskUpdatedListener != null && mBindPositionId != null) { if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<PositionTaskModel>(mData)); mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<PositionTaskModel>(mAdapterData));
} }
} }
}); });
dialog.dismiss(); 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 abstract class TaskViewHolder extends RecyclerView.ViewHolder {
public TaskViewHolder(@NonNull View itemView) { public TaskViewHolder(@NonNull View itemView) {
super(itemView); super(itemView);
} }
} }
// 空提示 Holder（不变） // 空提示ViewHolder（对应 item_task_empty.xml）
public class EmptyViewHolder extends TaskViewHolder { public class EmptyViewHolder extends TaskViewHolder {
public EmptyViewHolder(@NonNull View itemView) { public EmptyViewHolder(@NonNull View itemView) {
super(itemView); super(itemView);
} }
} }
// 新增：简单模式 Holder（绑定带红点的布局控件） // 简单模式ViewHolder（对应 item_position_task_simple.xml，带isBingo红点）
public class SimpleTaskViewHolder extends TaskViewHolder { public class SimpleTaskViewHolder extends TaskViewHolder {
TextView tvSimpleTaskDesc; // 任务描述 TextView tvSimpleTaskDesc; // 任务描述
TextView tvSimpleDistanceCond;// 距离条件 TextView tvSimpleDistanceCond;// 距离条件（大于/小于+距离）
TextView tvSimpleIsEnable; // 启用状态 TextView tvSimpleIsEnable; // 启用状态（已启用/已禁用）
View vBingoDot; // isBingo 红点控件 View vBingoDot; // isBingo红点（任务触发时显示）
public SimpleTaskViewHolder(@NonNull View itemView) { public SimpleTaskViewHolder(@NonNull View itemView) {
super(itemView); super(itemView);
// 绑定简单模式布局中的控件（与 item_task_simple.xml 完全对应） // 绑定简单模式布局控件（与XML控件ID严格对应）
tvSimpleTaskDesc = itemView.findViewById(R.id.tv_simple_task_desc); tvSimpleTaskDesc = itemView.findViewById(R.id.tv_simple_task_desc);
tvSimpleDistanceCond = itemView.findViewById(R.id.tv_simple_distance_cond); tvSimpleDistanceCond = itemView.findViewById(R.id.tv_simple_distance_cond);
tvSimpleIsEnable = itemView.findViewById(R.id.tv_simple_is_enable); tvSimpleIsEnable = itemView.findViewById(R.id.tv_simple_is_enable);
@@ -394,22 +596,68 @@ public class PositionTaskListView extends LinearLayout {
} }
} }
// 编辑模式 Holder（原有逻辑，完全不变） // 编辑模式ViewHolder（对应 item_task_content.xml，带编辑/删除/开关）
public class TaskContentViewHolder extends TaskViewHolder { public class TaskContentViewHolder extends TaskViewHolder {
TextView tvTaskDesc; TextView tvTaskDesc; // 任务描述
TextView tvTaskDistance; TextView tvTaskDistance; // 距离条件
CompoundButton cbTaskEnable; CompoundButton cbTaskEnable; // 启用开关
Button btnEditTask; Button btnEditTask; // 编辑按钮
Button btnDeleteTask; Button btnDeleteTask; // 删除按钮
public TaskContentViewHolder(@NonNull View itemView) { public TaskContentViewHolder(@NonNull View itemView) {
super(itemView); super(itemView);
tvTaskDesc = (TextView) itemView.findViewById(R.id.tv_task_desc); // 绑定编辑模式布局控件（与XML控件ID严格对应）
tvTaskDistance = (TextView) itemView.findViewById(R.id.tv_task_distance); tvTaskDesc = itemView.findViewById(R.id.tv_task_desc);
cbTaskEnable = (CompoundButton) itemView.findViewById(R.id.cb_task_enable); tvTaskDistance = itemView.findViewById(R.id.tv_task_distance);
btnEditTask = (Button) itemView.findViewById(R.id.btn_edit_task); cbTaskEnable = itemView.findViewById(R.id.cb_task_enable);
btnDeleteTask = (Button) itemView.findViewById(R.id.btn_delete_task); 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();
} }
} }
} }