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

修复实时距离显示问题

Browse Source
This commit is contained in:
ZhanGSKen
2025-10-01 02:14:10 +08:00
parent f5b2500f06
commit 80424c523d
4 changed files with 766 additions and 745 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
#Tue Sep 30 13:02:23 GMT 2025 #Tue Sep 30 18:06:22 GMT 2025
stageCount=4 stageCount=4
libraryProject= libraryProject=
baseVersion=15.0 baseVersion=15.0
publishVersion=15.0.3 publishVersion=15.0.3
buildCount=9 buildCount=10
baseBetaVersion=15.0.4 baseBetaVersion=15.0.4

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

@@ -9,6 +9,7 @@ import android.content.ComponentName;
import android.content.Context; import android.content.Context;
import android.content.Intent; import android.content.Intent;
import android.content.ServiceConnection; import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder; import android.os.IBinder;
import android.os.Looper; import android.os.Looper;
import android.view.LayoutInflater; import android.view.LayoutInflater;
@@ -53,9 +54,9 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
private static final int DEFAULT_TASK_DISTANCE = 100; private static final int DEFAULT_TASK_DISTANCE = 100;
// 核心成员变量（Java7：明确泛型声明与初始化） // 核心成员变量（Java7：明确泛型声明与初始化）
private final ArrayList<PositionModel> mPositionList; private final ArrayList<PositionModel> mPositionList; // 数据源：与Service共享同一份引用
private final ArrayList<PositionTaskModel> mAllPositionTasks; private final ArrayList<PositionTaskModel> mAllPositionTasks;
private final Context mContext; private Context mContext;
private PositionModel mCurrentGpsPosition; private PositionModel mCurrentGpsPosition;
private final Map<String, ArrayList<PositionTaskModel>> mPositionTaskMap; private final Map<String, ArrayList<PositionTaskModel>> mPositionTaskMap;
private final Map<String, TextView> mVisibleDistanceViews = new HashMap<String, TextView>(); private final Map<String, TextView> mVisibleDistanceViews = new HashMap<String, TextView>();
@@ -73,13 +74,13 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
mDistanceService = binder.getService(); mDistanceService = binder.getService();
isServiceBound = true; isServiceBound = true;
// 绑定服务后初始化：设置接收器+同步数据 // 绑定服务后初始化：设置接收器+同步数据（传递mPositionList原引用）
mDistanceService.setOnDistanceUpdateReceiver(PositionAdapter.this); mDistanceService.setOnDistanceUpdateReceiver(PositionAdapter.this);
mDistanceService.syncPositionList(mPositionList); mDistanceService.syncPositionList(mPositionList); // 关键：传递原列表引用
mDistanceService.syncAllPositionTasks(mAllPositionTasks); mDistanceService.syncAllPositionTasks(mAllPositionTasks);
mDistanceService.syncCurrentGpsPosition(mCurrentGpsPosition); mDistanceService.syncCurrentGpsPosition(mCurrentGpsPosition);
// 同步已有的可见控件（解决“控件已添加但服务未收到”问题） // 同步已有的可见控件
Iterator<String> posIdIterator = mVisibleDistanceViews.keySet().iterator(); Iterator<String> posIdIterator = mVisibleDistanceViews.keySet().iterator();
while (posIdIterator.hasNext()) { while (posIdIterator.hasNext()) {
String positionId = posIdIterator.next(); String positionId = posIdIterator.next();
@@ -89,7 +90,6 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
LogUtils.d(TAG, "DistanceRefreshService 绑定成功"); LogUtils.d(TAG, "DistanceRefreshService 绑定成功");
} }
@Override @Override
public void onServiceDisconnected(ComponentName name) { public void onServiceDisconnected(ComponentName name) {
mDistanceService = null; mDistanceService = null;
@@ -116,23 +116,23 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
private OnSavePositionTaskClickListener mOnSavePositionTaskClickListener; private OnSavePositionTaskClickListener mOnSavePositionTaskClickListener;
// 构造函数（Java7：明确泛型，非空判断初始化） // 构造函数（Java7：明确泛型，非空判断初始化）
public PositionAdapter(Context context, ArrayList<PositionModel> positionList, ArrayList<PositionTaskModel> allPositionTasks) { public PositionAdapter(Context context, ArrayList positionList, ArrayList allPositionTasks) {
this.mContext = context; this.mContext = context;
// Java7：显式非空判断（避免空指针） // Java7：显式非空判断（避免空指针）
this.mPositionList = (positionList != null) ? positionList : new ArrayList<PositionModel>(); this.mPositionList = (positionList != null) ? positionList : new ArrayList();
this.mAllPositionTasks = (allPositionTasks != null) ? allPositionTasks : new ArrayList<PositionTaskModel>(); this.mAllPositionTasks = (allPositionTasks != null) ? allPositionTasks : new ArrayList();
this.mPositionTaskMap = new HashMap<String, ArrayList<PositionTaskModel>>(); this.mPositionTaskMap = new HashMap<String, ArrayList<PositionTaskModel>>();
// 初始化任务映射表（Java7：双迭代器遍历） // 初始化任务映射表（Java7：双迭代器遍历）
Iterator<PositionModel> modelIterator = mPositionList.iterator(); Iterator modelIterator = mPositionList.iterator();
while (modelIterator.hasNext()) { while (modelIterator.hasNext()) {
PositionModel model = modelIterator.next(); PositionModel model = (PositionModel)modelIterator.next();
String validPosId = model.getPositionId(); String validPosId = model.getPositionId();
ArrayList<PositionTaskModel> matchedTasks = new ArrayList<PositionTaskModel>(); ArrayList matchedTasks = new ArrayList();
Iterator<PositionTaskModel> taskIterator = this.mAllPositionTasks.iterator(); Iterator taskIterator = this.mAllPositionTasks.iterator();
while (taskIterator.hasNext()) { while (taskIterator.hasNext()) {
PositionTaskModel task = taskIterator.next(); PositionTaskModel task = (PositionTaskModel)taskIterator.next();
if (task != null && validPosId.equals(task.getPositionId())) { if (task != null && validPosId.equals(task.getPositionId())) {
matchedTasks.add(task); matchedTasks.add(task);
} }
@@ -193,45 +193,77 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
mVisibleDistanceViews.clear(); mVisibleDistanceViews.clear();
} }
// ---------------------- 服务消息接收（距离更新） ---------------------- // ---------------------- 服务消息接收（仅接收位置ID，从mPositionList读数据） ----------------------
@Override @Override
public void onDistanceUpdate(final String positionId, final String distanceText, final int distanceColor) { public void onDistanceUpdate(final String positionId) {
// 保障主线程更新（Java7：匿名内部类实现Runnable，替代Lambda） // 保障主线程更新UI（Java7：匿名内部类实现Runnable）
if (Looper.myLooper() != Looper.getMainLooper()) { if (Looper.myLooper() != Looper.getMainLooper()) {
mUiHandler.post(new Runnable() { mUiHandler.post(new Runnable() {
@Override @Override
public void run() { public void run() {
updateDistanceView(positionId, distanceText, distanceColor); updateDistanceViewByPositionId(positionId);
} }
}); });
} else { } else {
updateDistanceView(positionId, distanceText, distanceColor); updateDistanceViewByPositionId(positionId);
} }
} }
/** /**
* 精准更新距离TextView（Java7：显式非空判断，避免空指针）
*/
private void updateDistanceView(String positionId, String distanceText, int distanceColor) {
// 1. 检查核心参数（避免无效更新）
if (positionId == null || distanceText == null || mVisibleDistanceViews.isEmpty()) {
LogUtils.w(TAG, "更新距离失败：参数无效（位置ID=" + positionId + "，距离文本=" + distanceText + "）");
return;
}
// 2. 找到目标TextView并更新 - 核心修改：通过位置ID从mPositionList读取realPositionDistance，生成UI数据并更新
*/
private void updateDistanceViewByPositionId(String positionId) {
// 1. 前置校验（避免无效更新）
if (positionId == null || mPositionList.isEmpty() || mVisibleDistanceViews.isEmpty()) {
LogUtils.w(TAG, "更新UI失败：参数无效/列表为空（位置ID=" + positionId + "）");
return;
}// 2. 从mPositionList找到对应位置模型（Java7：迭代器遍历）
PositionModel targetModel = null;
Iterator modelIter = mPositionList.iterator();
while (modelIter.hasNext()) {
PositionModel model = (PositionModel)modelIter.next();
if (positionId.equals(model.getPositionId())) {
targetModel = model;
break;
}
}
if (targetModel == null) {
LogUtils.w(TAG, "更新UI失败：位置ID=" + positionId + " 未找到对应模型");
return;
}// 3. 读取realPositionDistance，生成距离文本和颜色
double distanceM = targetModel.getRealPositionDistance();
String distanceText;
int distanceColor;if (distanceM == -1) {
// 距离为-1：区分“未启用”和“计算异常”
if (targetModel.isEnableRealPositionDistance()) {
distanceText = "实时距离：计算异常";
distanceColor = getColorRes(R.color.colorRed);
} else {
distanceText = "实时距离：未启用";
distanceColor = getColorRes(R.color.colorGrayText);
}
} else {
// 距离有效：格式化显示（米/千米）
if (distanceM < 1000) {
distanceText = String.format("实时距离：%.1f 米", distanceM);
} else {
distanceText = String.format("实时距离：%.1f 千米", distanceM / 1000);
}
distanceColor = getColorRes(R.color.colorEnableGreen);
}// 4. 刷新可见控件（仅更新屏幕上显示的控件）
TextView distanceView = mVisibleDistanceViews.get(positionId); TextView distanceView = mVisibleDistanceViews.get(positionId);
if (distanceView != null && distanceView.isShown()) { // 仅更新“显示中”的控件 if (distanceView != null && distanceView.isShown()) {
LogUtils.d(TAG, "更新距离UI：位置ID=" + positionId + "，文本=" + distanceText);
distanceView.setText(distanceText); distanceView.setText(distanceText);
distanceView.setTextColor(distanceColor); distanceView.setTextColor(distanceColor);
// 同步更新任务状态 LogUtils.d(TAG, "更新UI成功：位置ID=" + positionId + "，文本=" + distanceText);
// 同步刷新任务状态（原逻辑保留）
refreshTaskBingoStatus(positionId); refreshTaskBingoStatus(positionId);
} else { } else {
// 控件不存在/不可见时，移除映射+同步服务 // 控件不存在/不可见：清理映射+同步服务
if (mVisibleDistanceViews.containsKey(positionId)) { if (mVisibleDistanceViews.containsKey(positionId)) {
mVisibleDistanceViews.remove(positionId); mVisibleDistanceViews.remove(positionId);
LogUtils.w(TAG, "更新距离失败：位置ID=" + positionId + " 对应的TextView不存在/已移除"); LogUtils.w(TAG, "更新UI失败：位置ID=" + positionId + " 控件不可见/已移除");
} }
if (isServiceBound && mDistanceService != null) { if (isServiceBound && mDistanceService != null) {
mDistanceService.removeVisibleDistanceView(positionId); mDistanceService.removeVisibleDistanceView(positionId);
@@ -239,21 +271,24 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
} }
} }
/**
- 保留：从上下文获取颜色资源（异常时返回默认灰色）
*/
@Override @Override
public int getColorRes(int resId) { public int getColorRes(int resId) {
if (mContext != null) { if (mContext != null) {
try { try {
// Java7：显式调用getResources()，避免空指针
return mContext.getResources().getColor(resId); return mContext.getResources().getColor(resId);
} catch (Exception e) { } catch (Exception e) {
LogUtils.d(TAG, "获取颜色资源失败（resId=" + resId + "）" + e.getMessage()); LogUtils.d(TAG, "获取颜色资源失败（resId=" + resId + "）" + e.getMessage());
return mContext.getResources().getColor(R.color.colorGrayText); // 异常时返回默认灰色 return mContext.getResources().getColor(R.color.colorGrayText);
} }
} }
return mContext.getResources().getColor(R.color.colorGrayText); return mContext.getResources().getColor(R.color.colorGrayText);
} }
// ---------------------- 任务状态刷新 ---------------------- // ---------------------- 任务状态刷新（原逻辑保留） ----------------------
private void refreshTaskBingoStatus(String positionId) { private void refreshTaskBingoStatus(String positionId) {
Integer targetPosIndex = mPositionIdToIndexMap.get(positionId); Integer targetPosIndex = mPositionIdToIndexMap.get(positionId);
if (targetPosIndex != null && targetPosIndex >= 0 && targetPosIndex < mPositionList.size()) { if (targetPosIndex != null && targetPosIndex >= 0 && targetPosIndex < mPositionList.size()) {
@@ -262,13 +297,12 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
} }
} }
// ---------------------- RecyclerView 核心方法 ---------------------- // ---------------------- RecyclerView 核心方法（原逻辑保留，适配数据来源） ----------------------
@Override @Override
public int getItemViewType(int position) { public int getItemViewType(int position) {
// Java7：显式非空+范围判断（避免越界）
if (position < 0 || position >= mPositionList.size()) { if (position < 0 || position >= mPositionList.size()) {
LogUtils.w(TAG, "getItemViewType：无效列表位置（position=" + position + "）"); LogUtils.w(TAG, "getItemViewType：无效列表位置（position=" + position + "）");
return VIEW_TYPE_SIMPLE; // 异常时返回默认类型 return VIEW_TYPE_SIMPLE;
} }
PositionModel model = mPositionList.get(position); PositionModel model = mPositionList.get(position);
return model.isSimpleView() ? VIEW_TYPE_SIMPLE : VIEW_TYPE_EDIT; return model.isSimpleView() ? VIEW_TYPE_SIMPLE : VIEW_TYPE_EDIT;
@@ -289,7 +323,6 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
@Override @Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) { public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
// Java7：显式范围判断（避免越界）
if (position < 0 || position >= mPositionList.size()) { if (position < 0 || position >= mPositionList.size()) {
LogUtils.w(TAG, "onBindViewHolder：无效列表位置（position=" + position + "）"); LogUtils.w(TAG, "onBindViewHolder：无效列表位置（position=" + position + "）");
return; return;
@@ -297,7 +330,6 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
PositionModel model = mPositionList.get(position); PositionModel model = mPositionList.get(position);
mPositionIdToIndexMap.put(model.getPositionId(), position); mPositionIdToIndexMap.put(model.getPositionId(), position);
// 绑定对应视图
if (holder instanceof SimpleViewHolder) { if (holder instanceof SimpleViewHolder) {
bindSimpleView((SimpleViewHolder) holder, model, position); bindSimpleView((SimpleViewHolder) holder, model, position);
} else if (holder instanceof EditViewHolder) { } else if (holder instanceof EditViewHolder) {
@@ -310,7 +342,7 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
return mPositionList.size(); return mPositionList.size();
} }
// ---------------------- 视图附加/分离/回收（控件管理） ---------------------- // ---------------------- 视图附加/分离/回收（原逻辑保留，优化性能） ----------------------
@Override @Override
public void onViewAttachedToWindow(@NonNull RecyclerView.ViewHolder holder) { public void onViewAttachedToWindow(@NonNull RecyclerView.ViewHolder holder) {
super.onViewAttachedToWindow(holder); super.onViewAttachedToWindow(holder);
@@ -322,9 +354,9 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
PositionModel model = mPositionList.get(position); PositionModel model = mPositionList.get(position);
String positionId = model.getPositionId(); String positionId = model.getPositionId();
mPositionIdToIndexMap.put(positionId, position); // 同步索引 mPositionIdToIndexMap.put(positionId, position);
// 找到距离TextView（Java7：显式类型转换+非空判断） // 找到距离TextView（Java7：显式类型转换）
TextView distanceView = null; TextView distanceView = null;
if (holder instanceof SimpleViewHolder) { if (holder instanceof SimpleViewHolder) {
distanceView = ((SimpleViewHolder) holder).tvSimpleRealDistance; distanceView = ((SimpleViewHolder) holder).tvSimpleRealDistance;
@@ -332,15 +364,12 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
distanceView = ((EditViewHolder) holder).tvEditRealDistance; distanceView = ((EditViewHolder) holder).tvEditRealDistance;
} }
// 仅添加有效控件，避免重复映射 // 添加可见控件映射（避免重复）
if (distanceView != null && !mVisibleDistanceViews.containsKey(positionId)) { if (distanceView != null && !mVisibleDistanceViews.containsKey(positionId)) {
mVisibleDistanceViews.put(positionId, distanceView); mVisibleDistanceViews.put(positionId, distanceView);
LogUtils.d(TAG, "视图附加：添加可见控件（位置ID=" + positionId + "），当前可见数量=" + mVisibleDistanceViews.size()); LogUtils.d(TAG, "视图附加：添加可见控件（位置ID=" + positionId + "），数量=" + mVisibleDistanceViews.size());
// 同步到服务
if (isServiceBound && mDistanceService != null) { if (isServiceBound && mDistanceService != null) {
mDistanceService.addVisibleDistanceView(positionId); mDistanceService.addVisibleDistanceView(positionId);
} else {
LogUtils.w(TAG, "视图附加：服务未绑定，暂未同步控件（位置ID=" + positionId + "）");
} }
} }
} }
@@ -356,10 +385,10 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
PositionModel model = mPositionList.get(position); PositionModel model = mPositionList.get(position);
String positionId = model.getPositionId(); String positionId = model.getPositionId();
// 移除本地映射+同步服务 // 移除可见控件映射
if (mVisibleDistanceViews.containsKey(positionId)) { if (mVisibleDistanceViews.containsKey(positionId)) {
mVisibleDistanceViews.remove(positionId); mVisibleDistanceViews.remove(positionId);
LogUtils.d(TAG, "视图分离：移除可见控件（位置ID=" + positionId + "），当前可见数量=" + mVisibleDistanceViews.size()); LogUtils.d(TAG, "视图分离：移除可见控件（位置ID=" + positionId + "），数量=" + mVisibleDistanceViews.size());
if (isServiceBound && mDistanceService != null) { if (isServiceBound && mDistanceService != null) {
mDistanceService.removeVisibleDistanceView(positionId); mDistanceService.removeVisibleDistanceView(positionId);
} }
@@ -372,17 +401,16 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
int position = holder.getAdapterPosition(); int position = holder.getAdapterPosition();
if (position >= 0 && position < mPositionList.size()) { if (position >= 0 && position < mPositionList.size()) {
String positionId = mPositionList.get(position).getPositionId(); String positionId = mPositionList.get(position).getPositionId();
// 清理本地映射 // 清理映射
mVisibleDistanceViews.remove(positionId); mVisibleDistanceViews.remove(positionId);
mPositionIdToIndexMap.remove(positionId); mPositionIdToIndexMap.remove(positionId);
LogUtils.d(TAG, "视图回收：清理控件映射（位置ID=" + positionId + "）"); LogUtils.d(TAG, "视图回收：清理控件映射（位置ID=" + positionId + "）");
// 同步服务
if (isServiceBound && mDistanceService != null) { if (isServiceBound && mDistanceService != null) {
mDistanceService.removeVisibleDistanceView(positionId); mDistanceService.removeVisibleDistanceView(positionId);
} }
} }
// 清理任务列表资源（Java7：显式非空判断） // 清理任务列表资源
if (holder instanceof SimpleViewHolder) { if (holder instanceof SimpleViewHolder) {
SimpleViewHolder simpleHolder = (SimpleViewHolder) holder; SimpleViewHolder simpleHolder = (SimpleViewHolder) holder;
if (simpleHolder.ptlvSimpleTasks != null) { if (simpleHolder.ptlvSimpleTasks != null) {
@@ -398,30 +426,34 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
} }
} }
// ---------------------- 视图绑定（简单视图/编辑视图） ---------------------- // ---------------------- 视图绑定（简单视图/编辑视图，原逻辑保留） ----------------------
/** /**
* 绑定简单视图（仅展示，无编辑功能）
- 绑定简单视图（仅展示）
*/ */
private void bindSimpleView(final SimpleViewHolder holder, final PositionModel model, final int position) { private void bindSimpleView(final SimpleViewHolder holder, final PositionModel model, final int position) {
// 绑定基础数据（Java7：显式String.format，避免自动类型转换） // 绑定基础数据（保留6位小数）
holder.tvSimpleLongitude.setText(String.format("经度：%.6f", model.getLongitude())); holder.tvSimpleLongitude.setText(String.format("经度：%.6f", model.getLongitude()));
holder.tvSimpleLatitude.setText(String.format("纬度：%.6f", model.getLatitude())); holder.tvSimpleLatitude.setText(String.format("纬度：%.6f", model.getLatitude()));
holder.tvSimpleMemo.setText(String.format("备注：%s", model.getMemo())); holder.tvSimpleMemo.setText(String.format("备注：%s", model.getMemo()));// 初始化距离文本（从mPositionList读realPositionDistance）
// 初始默认文本（记录日志，便于排查未覆盖问题） double initDistance = model.getRealPositionDistance();
holder.tvSimpleRealDistance.setText("实时距离：加载中..."); if (initDistance == -1) {
holder.tvSimpleRealDistance.setTextColor(mContext.getResources().getColor(R.color.colorGrayText)); holder.tvSimpleRealDistance.setText(model.isEnableRealPositionDistance() ? "实时距离：计算异常" : "实时距离：未启用");
LogUtils.d(TAG, "绑定简单视图：初始化距离文本（位置ID=" + model.getPositionId() + "）"); holder.tvSimpleRealDistance.setTextColor(getColorRes(model.isEnableRealPositionDistance() ? R.color.colorRed : R.color.colorGrayText));
} else {
// 长按编辑逻辑（Java7：匿名内部类实现OnLongClickListener+PopupMenu监听） String initText = initDistance < 1000 ?
String.format("实时距离：%.1f 米", initDistance) :
String.format("实时距离：%.1f 千米", initDistance / 1000);
holder.tvSimpleRealDistance.setText(initText);
holder.tvSimpleRealDistance.setTextColor(getColorRes(R.color.colorEnableGreen));
}
LogUtils.d(TAG, "绑定简单视图：初始化距离（位置ID=" + model.getPositionId() + "）");// 长按编辑逻辑（匿名内部类）
holder.itemView.setOnLongClickListener(new View.OnLongClickListener() { holder.itemView.setOnLongClickListener(new View.OnLongClickListener() {
@Override @Override
public boolean onLongClick(View v) { public boolean onLongClick(View v) {
PopupMenu popupMenu = new PopupMenu(mContext, v); PopupMenu popupMenu = new PopupMenu(mContext, v);
MenuInflater menuInflater = popupMenu.getMenuInflater(); MenuInflater menuInflater = popupMenu.getMenuInflater();
menuInflater.inflate(R.menu.menu_item_edit, popupMenu.getMenu()); menuInflater.inflate(R.menu.menu_item_edit, popupMenu.getMenu());popupMenu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
// Java7：匿名内部类实现PopupMenu监听
popupMenu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
@Override @Override
public boolean onMenuItemClick(MenuItem item) { public boolean onMenuItemClick(MenuItem item) {
if (item.getItemId() == R.id.menu_edit) { if (item.getItemId() == R.id.menu_edit) {
@@ -435,11 +467,9 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
popupMenu.show(); popupMenu.show();
return true; return true;
} }
}); });// 绑定任务列表
// 绑定任务列表（Java7：显式获取安全任务列表）
String currentPosId = model.getPositionId(); String currentPosId = model.getPositionId();
ArrayList<PositionTaskModel> matchedTasks = getSafeTasks(currentPosId); ArrayList matchedTasks = getSafeTasks(currentPosId);
if (holder.ptlvSimpleTasks != null) { if (holder.ptlvSimpleTasks != null) {
holder.ptlvSimpleTasks.clearData(); holder.ptlvSimpleTasks.clearData();
holder.ptlvSimpleTasks.setViewStatus(PositionTaskListView.VIEW_MODE_SIMPLE); holder.ptlvSimpleTasks.setViewStatus(PositionTaskListView.VIEW_MODE_SIMPLE);
@@ -450,27 +480,36 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
} }
/** /**
* 绑定编辑视图（支持修改备注、开关距离、增删任务）
- 绑定编辑视图（支持修改）
*/ */
private void bindEditView(final EditViewHolder holder, final PositionModel model, final int position) { private void bindEditView(final EditViewHolder holder, final PositionModel model, final int position) {
// 绑定基础数据 // 绑定基础数据
holder.tvEditLongitude.setText(String.format("经度：%.6f", model.getLongitude())); holder.tvEditLongitude.setText(String.format("经度：%.6f", model.getLongitude()));
holder.tvEditLatitude.setText(String.format("纬度：%.6f", model.getLatitude())); holder.tvEditLatitude.setText(String.format("纬度：%.6f", model.getLatitude()));
holder.etEditMemo.setText(model.getMemo()); holder.etEditMemo.setText(model.getMemo());
holder.etEditMemo.setSelection(holder.etEditMemo.getText().length()); holder.etEditMemo.setSelection(holder.etEditMemo.getText().length());// 初始化距离文本（从mPositionList读realPositionDistance）
// 初始默认文本 double initDistance = model.getRealPositionDistance();
holder.tvEditRealDistance.setText("实时距离：加载中..."); if (initDistance == -1) {
holder.tvEditRealDistance.setTextColor(mContext.getResources().getColor(R.color.colorGrayText)); holder.tvEditRealDistance.setText(model.isEnableRealPositionDistance() ? "实时距离：计算异常" : "实时距离：未启用");
LogUtils.d(TAG, "绑定编辑视图：初始化距离文本（位置ID=" + model.getPositionId() + "）"); holder.tvEditRealDistance.setTextColor(getColorRes(model.isEnableRealPositionDistance() ? R.color.colorRed : R.color.colorGrayText));
} else {
String initText = initDistance < 1000 ?
String.format("实时距离：%.1f 米", initDistance) :
String.format("实时距离：%.1f 千米", initDistance / 1000);
holder.tvEditRealDistance.setText(initText);
holder.tvEditRealDistance.setTextColor(getColorRes(R.color.colorEnableGreen));
}
LogUtils.d(TAG, "绑定编辑视图：初始化距离（位置ID=" + model.getPositionId() + "）");
// 实时距离开关状态（Java7：显式判断设置选中） // 实时距离开关状态（显式判断设置选中）
if (model.isEnableRealPositionDistance()) { if (model.isEnableRealPositionDistance()) {
holder.rgRealDistanceSwitch.check(R.id.rb_enable); holder.rgRealDistanceSwitch.check(R.id.rb_enable);
} else { } else {
holder.rgRealDistanceSwitch.check(R.id.rb_disable); holder.rgRealDistanceSwitch.check(R.id.rb_disable);
} }
// 删除按钮逻辑（Java7：匿名内部类实现OnClickListener） // 删除按钮逻辑（匿名内部类）
holder.btnEditDelete.setOnClickListener(new View.OnClickListener() { holder.btnEditDelete.setOnClickListener(new View.OnClickListener() {
@Override @Override
public void onClick(View v) { public void onClick(View v) {
@@ -479,9 +518,10 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
// 清理本地映射 // 清理本地映射
mPositionTaskMap.remove(model.getPositionId()); mPositionTaskMap.remove(model.getPositionId());
mPositionIdToIndexMap.remove(model.getPositionId()); mPositionIdToIndexMap.remove(model.getPositionId());
// 同步服务 // 同步服务（移除无效位置）
if (isServiceBound && mDistanceService != null) { if (isServiceBound && mDistanceService != null) {
mDistanceService.removeVisibleDistanceView(model.getPositionId()); mDistanceService.removeVisibleDistanceView(model.getPositionId());
mDistanceService.syncPositionList(mPositionList); // 同步更新后的列表
} }
} }
} }
@@ -501,7 +541,7 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
holder.btnEditConfirm.setOnClickListener(new View.OnClickListener() { holder.btnEditConfirm.setOnClickListener(new View.OnClickListener() {
@Override @Override
public void onClick(View v) { public void onClick(View v) {
// 获取输入数据（Java7：显式trim，避免空字符串） // 获取输入数据（显式trim避免空字符串）
String newMemo = holder.etEditMemo.getText().toString().trim(); String newMemo = holder.etEditMemo.getText().toString().trim();
model.setMemo(newMemo); model.setMemo(newMemo);
boolean isEnableDistance = holder.rgRealDistanceSwitch.getCheckedRadioButtonId() == R.id.rb_enable; boolean isEnableDistance = holder.rgRealDistanceSwitch.getCheckedRadioButtonId() == R.id.rb_enable;
@@ -509,13 +549,13 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
// 绑定任务到当前位置 // 绑定任务到当前位置
String currentPosId = model.getPositionId(); String currentPosId = model.getPositionId();
ArrayList<PositionTaskModel> allTasks = (holder.ptlvEditTasks != null) ? holder.ptlvEditTasks.getAllTasks() : new ArrayList<PositionTaskModel>(); ArrayList allTasks = (holder.ptlvEditTasks != null) ? holder.ptlvEditTasks.getAllTasks() : new ArrayList();
ArrayList<PositionTaskModel> boundTasks = new ArrayList<PositionTaskModel>(); ArrayList boundTasks = new ArrayList();
// Java7：迭代器遍历任务列表，绑定位置ID // 迭代器遍历：绑定位置ID到任务
Iterator<PositionTaskModel> taskIterator = allTasks.iterator(); Iterator taskIterator = allTasks.iterator();
while (taskIterator.hasNext()) { while (taskIterator.hasNext()) {
PositionTaskModel task = taskIterator.next(); PositionTaskModel task = (PositionTaskModel)taskIterator.next();
if (task != null) { if (task != null) {
task.setPositionId(currentPosId); task.setPositionId(currentPosId);
boundTasks.add(task); boundTasks.add(task);
@@ -524,21 +564,21 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
// 更新本地任务映射 // 更新本地任务映射
mPositionTaskMap.put(currentPosId, boundTasks); mPositionTaskMap.put(currentPosId, boundTasks);
// 清理旧任务+添加新任务（Java7：迭代器删除，避免ConcurrentModificationException） // 清理旧任务（迭代器安全删除，避免并发异常）
Iterator<PositionTaskModel> globalTaskIter = mAllPositionTasks.iterator(); Iterator globalTaskIter = mAllPositionTasks.iterator();
while (globalTaskIter.hasNext()) { while (globalTaskIter.hasNext()) {
PositionTaskModel task = globalTaskIter.next(); PositionTaskModel task = (PositionTaskModel)globalTaskIter.next();
if (task != null && currentPosId.equals(task.getPositionId())) { if (task != null && currentPosId.equals(task.getPositionId())) {
globalTaskIter.remove(); // Java7：迭代器安全删除 globalTaskIter.remove();
} }
} }
mAllPositionTasks.addAll(boundTasks); mAllPositionTasks.addAll(boundTasks);
// 同步服务数据 // 同步服务数据（传递原列表引用）
if (isServiceBound && mDistanceService != null) { if (isServiceBound && mDistanceService != null) {
mDistanceService.syncPositionList(mPositionList); mDistanceService.syncPositionList(mPositionList); // 同步更新后的位置列表
mDistanceService.syncAllPositionTasks(mAllPositionTasks); mDistanceService.syncAllPositionTasks(mAllPositionTasks); // 同步更新后的任务列表
LogUtils.d(TAG, "编辑视图保存：同步位置+任务数据到服务（位置ID=" + currentPosId + "）"); LogUtils.d(TAG, "编辑保存：同步位置+任务到服务（位置ID=" + currentPosId + "）");
} }
// 切换视图+回调通知 // 切换视图+回调通知
@@ -551,21 +591,21 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
} }
}); });
// 任务列表绑定与更新逻辑（Java7：匿名内部类实现任务更新监听） // 任务列表绑定与更新逻辑（匿名内部类实现监听）
final String currentPosId = model.getPositionId(); final String currentPosId = model.getPositionId();
ArrayList<PositionTaskModel> matchedTasks = getSafeTasks(currentPosId); ArrayList matchedTasks = getSafeTasks(currentPosId);
if (holder.ptlvEditTasks != null) { if (holder.ptlvEditTasks != null) {
holder.ptlvEditTasks.clearData(); holder.ptlvEditTasks.clearData();
// 任务更新监听（Java7：匿名内部类实现） // 任务更新监听
holder.ptlvEditTasks.setOnTaskUpdatedListener(new PositionTaskListView.OnTaskUpdatedListener() { holder.ptlvEditTasks.setOnTaskUpdatedListener(new PositionTaskListView.OnTaskUpdatedListener() {
@Override @Override
public void onTaskUpdated(String posId, ArrayList<PositionTaskModel> updatedTasks) { public void onTaskUpdated(String posId, ArrayList updatedTasks) {
ArrayList<PositionTaskModel> boundTasks = new ArrayList<PositionTaskModel>(); ArrayList boundTasks = new ArrayList();
// 绑定任务到当前位置 // 绑定位置ID到任务
Iterator<PositionTaskModel> taskIterator = updatedTasks.iterator(); Iterator taskIterator = updatedTasks.iterator();
while (taskIterator.hasNext()) { while (taskIterator.hasNext()) {
PositionTaskModel task = taskIterator.next(); PositionTaskModel task = (PositionTaskModel)taskIterator.next();
if (task != null) { if (task != null) {
task.setPositionId(currentPosId); task.setPositionId(currentPosId);
boundTasks.add(task); boundTasks.add(task);
@@ -575,9 +615,9 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
// 更新本地映射 // 更新本地映射
mPositionTaskMap.put(currentPosId, boundTasks); mPositionTaskMap.put(currentPosId, boundTasks);
// 清理旧任务+添加新任务 // 清理旧任务+添加新任务
Iterator<PositionTaskModel> globalTaskIter = mAllPositionTasks.iterator(); Iterator globalTaskIter = mAllPositionTasks.iterator();
while (globalTaskIter.hasNext()) { while (globalTaskIter.hasNext()) {
PositionTaskModel task = globalTaskIter.next(); PositionTaskModel task = (PositionTaskModel)globalTaskIter.next();
if (task != null && currentPosId.equals(task.getPositionId())) { if (task != null && currentPosId.equals(task.getPositionId())) {
globalTaskIter.remove(); globalTaskIter.remove();
} }
@@ -587,7 +627,7 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
// 同步服务 // 同步服务
if (isServiceBound && mDistanceService != null) { if (isServiceBound && mDistanceService != null) {
mDistanceService.syncAllPositionTasks(mAllPositionTasks); mDistanceService.syncAllPositionTasks(mAllPositionTasks);
LogUtils.d(TAG, "任务更新：同步任务数据到服务（位置ID=" + currentPosId + "，任务数量=" + boundTasks.size() + "）"); LogUtils.d(TAG, "任务更新：同步到服务（位置ID=" + currentPosId + "，任务数=" + boundTasks.size() + "）");
} }
// 回调通知 // 回调通知
@@ -605,7 +645,7 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
holder.ptlvEditTasks.setViewStatus(PositionTaskListView.VIEW_MODE_EDIT); holder.ptlvEditTasks.setViewStatus(PositionTaskListView.VIEW_MODE_EDIT);
} }
// 添加任务逻辑（Java7：匿名内部类实现OnClickListener） // 添加任务逻辑（匿名内部类）
holder.btnAddTask.setOnClickListener(new View.OnClickListener() { holder.btnAddTask.setOnClickListener(new View.OnClickListener() {
@Override @Override
public void onClick(View v) { public void onClick(View v) {
@@ -615,7 +655,7 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
return; return;
} }
// 创建新任务（Java7：显式调用构造函数，避免Builder模式） // 创建新任务（显式调用构造函数）
PositionTaskModel newTask = new PositionTaskModel( PositionTaskModel newTask = new PositionTaskModel(
PositionTaskModel.genTaskId(), PositionTaskModel.genTaskId(),
currentPosId, currentPosId,
@@ -626,15 +666,15 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
); );
// 更新本地任务列表 // 更新本地任务列表
ArrayList<PositionTaskModel> currentTasks = getSafeTasks(currentPosId); ArrayList currentTasks = getSafeTasks(currentPosId);
currentTasks.add(newTask); currentTasks.add(newTask);
mPositionTaskMap.put(currentPosId, new ArrayList<PositionTaskModel>(currentTasks)); mPositionTaskMap.put(currentPosId, new ArrayList(currentTasks));
mAllPositionTasks.add(newTask); mAllPositionTasks.add(newTask);
// 同步服务 // 同步服务
if (isServiceBound && mDistanceService != null) { if (isServiceBound && mDistanceService != null) {
mDistanceService.syncAllPositionTasks(mAllPositionTasks); mDistanceService.syncAllPositionTasks(mAllPositionTasks);
LogUtils.d(TAG, "新增任务：同步任务数据到服务（位置ID=" + currentPosId + "，新任务ID=" + newTask.getTaskId() + "）"); LogUtils.d(TAG, "新增任务：同步到服务（位置ID=" + currentPosId + "，任务ID=" + newTask.getTaskId() + "）");
} }
// 刷新任务列表视图 // 刷新任务列表视图
@@ -646,208 +686,177 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
}); });
} }
// ---------------------- 工具方法 ---------------------- // ---------------------- 工具方法（原逻辑保留，适配数据来源） ----------------------
/** /**
* 安全获取任务列表（避免空指针，Java7：显式泛型）
- 安全获取任务列表（避免空指针）
*/ */
private ArrayList<PositionTaskModel> getSafeTasks(String positionId) { private ArrayList getSafeTasks(String positionId) {
if (positionId == null) { if (positionId == null) {
LogUtils.w(TAG, "getSafeTasks：位置ID为空，返回空任务列表"); LogUtils.w(TAG, "getSafeTasks：位置ID为空，返回空列表");
return new ArrayList<PositionTaskModel>(); return new ArrayList();
} }
if (!mPositionTaskMap.containsKey(positionId)) { if (!mPositionTaskMap.containsKey(positionId)) {
mPositionTaskMap.put(positionId, new ArrayList<PositionTaskModel>()); mPositionTaskMap.put(positionId, new ArrayList());
LogUtils.d(TAG, "getSafeTasks：位置ID=" + positionId + " 无任务列表，初始化空列表"); LogUtils.d(TAG, "getSafeTasks：初始化空任务列表（位置ID=" + positionId + "）");
} }
return mPositionTaskMap.get(positionId); return mPositionTaskMap.get(positionId);
} }
/** /**
* 新增位置（Java7：显式非空判断，迭代器同步索引）
- 新增位置（同步服务时传递原列表引用）
*/ */
public void addPosition(PositionModel model) { public void addPosition(PositionModel model) {
if (model == null || model.getPositionId() == null) { if (model == null || model.getPositionId() == null) {
LogUtils.e(TAG, "新增位置失败：位置模型/位置ID为空"); LogUtils.e(TAG, "新增位置失败：模型/位置ID为空");
return; return;
} }
String validPosId = model.getPositionId(); String validPosId = model.getPositionId();
mPositionList.add(model); mPositionList.add(model);
mPositionIdToIndexMap.put(validPosId, mPositionList.size() - 1); mPositionIdToIndexMap.put(validPosId, mPositionList.size() - 1);// 初始化任务列表（若不存在）
// 初始化任务列表（若不存在）
if (!mPositionTaskMap.containsKey(validPosId)) { if (!mPositionTaskMap.containsKey(validPosId)) {
mPositionTaskMap.put(validPosId, new ArrayList<PositionTaskModel>()); mPositionTaskMap.put(validPosId, new ArrayList());
} }// 同步服务（传递原列表引用）
// 同步服务+刷新视图
if (isServiceBound && mDistanceService != null) { if (isServiceBound && mDistanceService != null) {
mDistanceService.syncPositionList(mPositionList); mDistanceService.syncPositionList(mPositionList); // 同步更新后的列表
// 若控件已添加，立即同步服务
if (mVisibleDistanceViews.containsKey(validPosId)) { if (mVisibleDistanceViews.containsKey(validPosId)) {
mDistanceService.addVisibleDistanceView(validPosId); mDistanceService.addVisibleDistanceView(validPosId);
LogUtils.d(TAG, "新增位置：同步服务并添加控件（位置ID=" + validPosId + "）");
} }
} LogUtils.d(TAG, "新增位置：同步到服务（位置ID=" + validPosId + "，列表总数=" + mPositionList.size() + "）");
}notifyItemInserted(mPositionList.size() - 1);
notifyItemInserted(mPositionList.size() - 1);
LogUtils.d(TAG, "新增位置成功：位置ID=" + validPosId + "，当前列表总数=" + mPositionList.size());
} }
/** /**
* 删除位置（Java7：迭代器安全删除，避免并发异常）
- 删除位置（同步服务时传递更新后的列表）
*/ */
public void removePosition(int position) { public void removePosition(int position) {
if (position < 0 || position >= mPositionList.size()) { if (position < 0 || position >= mPositionList.size()) {
LogUtils.w(TAG, "删除位置失败：无效列表位置（position=" + position + "）"); LogUtils.w(TAG, "删除位置失败：无效索引（position=" + position + "）");
return; return;
} }
PositionModel removedModel = mPositionList.get(position); PositionModel removedModel = mPositionList.get(position);
String removedPosId = removedModel.getPositionId(); String removedPosId = removedModel.getPositionId();
if (removedPosId == null) { if (removedPosId == null) {
LogUtils.w(TAG, "删除位置失败：待删除位置ID为空（列表位置=" + position + "）"); LogUtils.w(TAG, "删除位置失败：位置ID为空（索引=" + position + "）");
return; return;
} }// 1. 清理本地映射
// 1. 清理本地缓存和映射
mVisibleDistanceViews.remove(removedPosId); mVisibleDistanceViews.remove(removedPosId);
mPositionIdToIndexMap.remove(removedPosId); mPositionIdToIndexMap.remove(removedPosId);
LogUtils.d(TAG, "删除位置：清理本地映射（位置ID=" + removedPosId + "）"); LogUtils.d(TAG, "删除位置：清理本地映射（位置ID=" + removedPosId + "）");// 2. 重新同步剩余位置的索引
Iterator modelIterator = mPositionList.iterator();
// 2. 重新同步剩余位置的索引映射（Java7：迭代器遍历）
Iterator<PositionModel> modelIterator = mPositionList.iterator();
int index = 0; int index = 0;
while (modelIterator.hasNext()) { while (modelIterator.hasNext()) {
PositionModel remainingModel = modelIterator.next(); PositionModel remainingModel = (PositionModel)modelIterator.next();
mPositionIdToIndexMap.put(remainingModel.getPositionId(), index); mPositionIdToIndexMap.put(remainingModel.getPositionId(), index);
index++; index++;
} }// 3. 清理任务数据
Iterator taskIterator = mAllPositionTasks.iterator();
// 3. 清理全局任务列表和映射表（Java7：迭代器安全删除）
Iterator<PositionTaskModel> taskIterator = mAllPositionTasks.iterator();
while (taskIterator.hasNext()) { while (taskIterator.hasNext()) {
PositionTaskModel task = taskIterator.next(); PositionTaskModel task = (PositionTaskModel)taskIterator.next();
if (task != null && removedPosId.equals(task.getPositionId())) { if (task != null && removedPosId.equals(task.getPositionId())) {
taskIterator.remove(); taskIterator.remove();
} }
} }
mPositionTaskMap.remove(removedPosId); mPositionTaskMap.remove(removedPosId);
mPositionList.remove(position); mPositionList.remove(position);
LogUtils.d(TAG, "删除位置：清理任务数据（位置ID=" + removedPosId + "），剩余列表总数=" + mPositionList.size()); LogUtils.d(TAG, "删除位置：清理任务数据（剩余列表数=" + mPositionList.size() + "）");// 4. 同步服务（传递更新后的列表）
// 4. 同步服务
if (isServiceBound && mDistanceService != null) { if (isServiceBound && mDistanceService != null) {
mDistanceService.syncPositionList(mPositionList); mDistanceService.syncPositionList(mPositionList); // 同步删除后的列表
mDistanceService.syncAllPositionTasks(mAllPositionTasks); mDistanceService.syncAllPositionTasks(mAllPositionTasks);
mDistanceService.removeVisibleDistanceView(removedPosId); mDistanceService.removeVisibleDistanceView(removedPosId);
LogUtils.d(TAG, "删除位置：同步服务数据（位置ID=" + removedPosId + "）"); LogUtils.d(TAG, "删除位置：同步到服务（位置ID=" + removedPosId + "）");
} }notifyItemRemoved(position);
// 刷新视图
notifyItemRemoved(position);
notifyItemRangeChanged(position, mPositionList.size()); notifyItemRangeChanged(position, mPositionList.size());
} }
/** /**
* 更新所有位置（Java7：双迭代器清理无效数据）
- 更新所有位置（传递原列表引用，清理无效映射）
*/ */
public void updateAllPositions(ArrayList<PositionModel> newPositionList) { public void updateAllPositions(ArrayList newPositionList) {
if (newPositionList == null) { if (newPositionList == null) {
LogUtils.e(TAG, "更新所有位置失败：新位置列表为空"); LogUtils.e(TAG, "更新所有位置失败：新列表为空");
return; return;
} }
mPositionList.clear(); mPositionList.clear();
mPositionList.addAll(newPositionList); mPositionList.addAll(newPositionList);
LogUtils.d(TAG, "更新所有位置：接收新列表（数量=" + newPositionList.size() + "）"); LogUtils.d(TAG, "更新所有位置：接收新列表（数量=" + newPositionList.size() + "）");// 1. 清理无效可见控件
Iterator distanceViewIter = mVisibleDistanceViews.keySet().iterator();
// 1. 清理本地无效可见控件（Java7：迭代器遍历+判断存在性）
Iterator<String> distanceViewIter = mVisibleDistanceViews.keySet().iterator();
while (distanceViewIter.hasNext()) { while (distanceViewIter.hasNext()) {
String posId = distanceViewIter.next(); String posId = (String)distanceViewIter.next();
boolean isPosExist = false; boolean isExist = false;
Iterator modelIter = newPositionList.iterator();
Iterator<PositionModel> modelIter = newPositionList.iterator();
while (modelIter.hasNext()) { while (modelIter.hasNext()) {
PositionModel model = modelIter.next(); if (posId.equals(((PositionModel)modelIter.next()).getPositionId())) {
if (posId.equals(model.getPositionId())) { isExist = true;
isPosExist = true;
break; break;
} }
} }
if (!isExist) {
if (!isPosExist) {
distanceViewIter.remove(); distanceViewIter.remove();
LogUtils.d(TAG, "更新所有位置：清理无效可见控件（位置ID=" + posId + "）"); LogUtils.d(TAG, "更新所有位置：清理无效控件（位置ID=" + posId + "）");
} }
} }// 2. 清理无效任务映射
Iterator taskMapIter = mPositionTaskMap.keySet().iterator();
// 2. 清理任务映射表无效项（Java7：迭代器遍历） while (taskMapIter.hasNext()) {
Iterator<String> taskMapKeyIter = mPositionTaskMap.keySet().iterator(); String posId = (String)taskMapIter.next();
while (taskMapKeyIter.hasNext()) { boolean isExist = false;
String posId = taskMapKeyIter.next(); Iterator modelIter = newPositionList.iterator();
boolean isPosExist = false;
Iterator<PositionModel> modelIter = newPositionList.iterator();
while (modelIter.hasNext()) { while (modelIter.hasNext()) {
PositionModel model = modelIter.next(); if (posId.equals(((PositionModel)modelIter.next()).getPositionId())) {
if (posId.equals(model.getPositionId())) { isExist = true;
isPosExist = true;
break; break;
} }
} }
if (!isExist) {
if (!isPosExist) { taskMapIter.remove();
taskMapKeyIter.remove();
LogUtils.d(TAG, "更新所有位置：清理无效任务映射（位置ID=" + posId + "）"); LogUtils.d(TAG, "更新所有位置：清理无效任务映射（位置ID=" + posId + "）");
} }
} }// 3. 重新初始化索引映射
// 3. 重新初始化索引映射（Java7：普通for循环，避免迭代器索引问题）
mPositionIdToIndexMap.clear(); mPositionIdToIndexMap.clear();
for (int i = 0; i < newPositionList.size(); i++) { for (int i = 0; i < newPositionList.size(); i++) {
PositionModel model = newPositionList.get(i); PositionModel model = (PositionModel)newPositionList.get(i);
String posId = model.getPositionId(); String posId = model.getPositionId();
mPositionIdToIndexMap.put(posId, i); mPositionIdToIndexMap.put(posId, i);
// 初始化新位置的任务列表（若不存在） // 初始化新位置的任务列表
if (!mPositionTaskMap.containsKey(posId)) { if (!mPositionTaskMap.containsKey(posId)) {
mPositionTaskMap.put(posId, new ArrayList<PositionTaskModel>()); mPositionTaskMap.put(posId, new ArrayList());
LogUtils.d(TAG, "更新所有位置：初始化新位置任务列表（位置ID=" + posId + "）"); LogUtils.d(TAG, "更新所有位置：初始化新任务列表（位置ID=" + posId + "）");
} }
} }// 4. 同步服务（传递原列表引用）
// 4. 同步服务
if (isServiceBound && mDistanceService != null) { if (isServiceBound && mDistanceService != null) {
mDistanceService.syncPositionList(mPositionList); mDistanceService.syncPositionList(mPositionList); // 同步更新后的列表
mDistanceService.clearVisibleDistanceViews(); mDistanceService.clearVisibleDistanceViews();
// 同步有效可见控件（Java7：迭代器遍历） // 同步有效可见控件
Iterator<String> validPosIter = mVisibleDistanceViews.keySet().iterator(); Iterator validPosIter = mVisibleDistanceViews.keySet().iterator();
while (validPosIter.hasNext()) { while (validPosIter.hasNext()) {
mDistanceService.addVisibleDistanceView(validPosIter.next()); mDistanceService.addVisibleDistanceView((String)validPosIter.next());
} }
LogUtils.d(TAG, "更新所有位置：同步服务数据（可见控件数量=" + mVisibleDistanceViews.size() + "）"); LogUtils.d(TAG, "更新所有位置：同步到服务（可见控件数=" + mVisibleDistanceViews.size() + "）");
} }notifyDataSetChanged();
// 刷新视图
notifyDataSetChanged();
} }
/** /**
* 批量切换简单视图（Java7：迭代器遍历）
- 批量切换简单视图
*/ */
public void switchAllToSimpleView() { public void switchAllToSimpleView() {
Iterator<PositionModel> modelIterator = mPositionList.iterator(); Iterator modelIterator = mPositionList.iterator();
while (modelIterator.hasNext()) { while (modelIterator.hasNext()) {
PositionModel model = modelIterator.next(); ((PositionModel)modelIterator.next()).setIsSimpleView(true);
model.setIsSimpleView(true);
} }
notifyDataSetChanged(); notifyDataSetChanged();
LogUtils.d(TAG, "批量切换简单视图：已切换所有位置（总数=" + mPositionList.size() + "）"); LogUtils.d(TAG, "批量切换简单视图：已切换所有位置（总数=" + mPositionList.size() + "）");
} }
/** /**
* 获取位置列表（Java7：返回新列表，避免外部修改）
- 获取位置列表（返回新列表，避免外部修改原引用）
*/ */
public ArrayList<PositionModel> getPositionList() { public ArrayList getPositionList() {
return new ArrayList<PositionModel>(mPositionList); return new ArrayList(mPositionList);
} }
// ---------------------- ViewHolder 定义（完全兼容Java7） ---------------------- // ---------------------- ViewHolder 定义（完全兼容Java7） ----------------------
@@ -860,7 +869,7 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
public SimpleViewHolder(@NonNull View itemView) { public SimpleViewHolder(@NonNull View itemView) {
super(itemView); super(itemView);
// Java7：显式 findViewById + 类型转换 // 显式findViewById+类型转换（Java7兼容）
tvSimpleLongitude = (TextView) itemView.findViewById(R.id.tv_simple_longitude); tvSimpleLongitude = (TextView) itemView.findViewById(R.id.tv_simple_longitude);
tvSimpleLatitude = (TextView) itemView.findViewById(R.id.tv_simple_latitude); tvSimpleLatitude = (TextView) itemView.findViewById(R.id.tv_simple_latitude);
tvSimpleMemo = (TextView) itemView.findViewById(R.id.tv_simple_memo); tvSimpleMemo = (TextView) itemView.findViewById(R.id.tv_simple_memo);
@@ -873,32 +882,74 @@ public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
TextView tvEditLongitude; TextView tvEditLongitude;
TextView tvEditLatitude; TextView tvEditLatitude;
EditText etEditMemo; EditText etEditMemo;
TextView tvEditRealDistance;
RadioGroup rgRealDistanceSwitch; RadioGroup rgRealDistanceSwitch;
RadioButton rbDisable;
RadioButton rbEnable; RadioButton rbEnable;
Button btnEditDelete; RadioButton rbDisable;
Button btnEditCancel;
Button btnEditConfirm;
PositionTaskListView ptlvEditTasks; PositionTaskListView ptlvEditTasks;
Button btnAddTask; Button btnAddTask;
TextView tvEditRealDistance; Button btnEditConfirm;
Button btnEditCancel;
Button btnEditDelete;
public EditViewHolder(@NonNull View itemView) { public EditViewHolder(@NonNull View itemView) {
super(itemView); super(itemView);
// Java7：显式 findViewById + 类型转换 // 显式findViewById+类型转换（Java7兼容，避免空指针）
tvEditLongitude = (TextView) itemView.findViewById(R.id.tv_edit_longitude); tvEditLongitude = (TextView) itemView.findViewById(R.id.tv_edit_longitude);
tvEditLatitude = (TextView) itemView.findViewById(R.id.tv_edit_latitude); tvEditLatitude = (TextView) itemView.findViewById(R.id.tv_edit_latitude);
etEditMemo = (EditText) itemView.findViewById(R.id.et_edit_memo); etEditMemo = (EditText) itemView.findViewById(R.id.et_edit_memo);
tvEditRealDistance = (TextView) itemView.findViewById(R.id.tv_edit_real_distance);
rgRealDistanceSwitch = (RadioGroup) itemView.findViewById(R.id.rg_real_distance_switch); rgRealDistanceSwitch = (RadioGroup) itemView.findViewById(R.id.rg_real_distance_switch);
rbDisable = (RadioButton) itemView.findViewById(R.id.rb_disable);
rbEnable = (RadioButton) itemView.findViewById(R.id.rb_enable); rbEnable = (RadioButton) itemView.findViewById(R.id.rb_enable);
btnEditDelete = (Button) itemView.findViewById(R.id.btn_edit_delete); rbDisable = (RadioButton) itemView.findViewById(R.id.rb_disable);
btnEditCancel = (Button) itemView.findViewById(R.id.btn_edit_cancel);
btnEditConfirm = (Button) itemView.findViewById(R.id.btn_edit_confirm);
ptlvEditTasks = (PositionTaskListView) itemView.findViewById(R.id.ptlv_edit_tasks); ptlvEditTasks = (PositionTaskListView) itemView.findViewById(R.id.ptlv_edit_tasks);
btnAddTask = (Button) itemView.findViewById(R.id.btn_add_task); btnAddTask = (Button) itemView.findViewById(R.id.btn_add_task);
tvEditRealDistance = (TextView) itemView.findViewById(R.id.tv_edit_real_distance); btnEditConfirm = (Button) itemView.findViewById(R.id.btn_edit_confirm);
} btnEditCancel = (Button) itemView.findViewById(R.id.btn_edit_cancel);
btnEditDelete = (Button) itemView.findViewById(R.id.btn_edit_delete);
} }
} }
/**
- 辅助方法：获取指定位置ID的任务列表（对外提供只读访问）
*/
public ArrayList getTasksByPositionId(String positionId) {
ArrayList tasks = getSafeTasks(positionId);
return new ArrayList(tasks); // 返回拷贝，避免外部修改原数据
}
/**
- 辅助方法：清空所有数据（适配服务同步）
*/
public void clearAllData() {
mPositionList.clear();
mAllPositionTasks.clear();
mPositionTaskMap.clear();
mVisibleDistanceViews.clear();
mPositionIdToIndexMap.clear();// 同步服务清理
if (isServiceBound && mDistanceService != null) {
mDistanceService.syncPositionList(mPositionList);
mDistanceService.syncAllPositionTasks(mAllPositionTasks);
mDistanceService.clearVisibleDistanceViews();
LogUtils.d(TAG, "清空所有数据：同步服务完成");
}notifyDataSetChanged();
LogUtils.d(TAG, "清空所有数据：本地数据已重置");
}
/**
- 生命周期方法：解绑服务（避免内存泄漏，供外部调用）
*/
public void onDestroy() {
unbindDistanceRefreshService();
// 释放强引用
mContext = null;
mCurrentGpsPosition = null;
mOnDeleteClickListener = null;
mOnSavePositionClickListener = null;
mOnSavePositionTaskClickListener = null;
LogUtils.d(TAG, "Adapter生命周期结束：已解绑服务并释放资源");
}
}

2
positions/src/main/java/cc/winboll/studio/positions/models/PositionModel.java
View File

@@ -22,7 +22,7 @@ public class PositionModel extends BaseBean {
double latitude; double latitude;
// 位置备注（空值时显示“无备注”） // 位置备注（空值时显示“无备注”）
String memo; String memo;
// 定位点与指定点实时距离大小 // 定位点与指定点实时距离长度
double realPositionDistance; double realPositionDistance;
// 是否启用实时距离计算 // 是否启用实时距离计算
boolean isEnableRealPositionDistance; boolean isEnableRealPositionDistance;

186
positions/src/main/java/cc/winboll/studio/positions/services/DistanceRefreshService.java
View File

@@ -8,6 +8,7 @@ package cc.winboll.studio.positions.services;
import android.app.Service; import android.app.Service;
import android.content.Intent; import android.content.Intent;
import android.os.Binder; import android.os.Binder;
import android.os.Bundle;
import android.os.Handler; import android.os.Handler;
import android.os.IBinder; import android.os.IBinder;
import android.os.Looper; import android.os.Looper;
@@ -38,21 +39,20 @@ public class DistanceRefreshService extends Service {
public static final long REFRESH_INTERVAL = 5000; // 5秒刷新一次 public static final long REFRESH_INTERVAL = 5000; // 5秒刷新一次
public static final int MSG_UPDATE_DISTANCE = 1001; public static final int MSG_UPDATE_DISTANCE = 1001;
public static final String KEY_POSITION_ID = "key_position_id"; public static final String KEY_POSITION_ID = "key_position_id";
public static final String KEY_DISTANCE_TEXT = "key_distance_text";
public static final String KEY_DISTANCE_COLOR = "key_distance_color";
// 核心成员变量（Java7：明确泛型初始化） // 核心成员变量（Java7：明确泛型初始化）
private Timer mDistanceTimer; private Timer mDistanceTimer;
private Handler mMainHandler; private Handler mMainHandler;
private PositionModel mCurrentGpsPosition; private PositionModel mCurrentGpsPosition;
private ArrayList<PositionModel> mPositionList; private ArrayList<PositionModel> mPositionList; // 持有Adapter传递的原列表引用
private ArrayList<PositionTaskModel> mAllPositionTasks; private ArrayList<PositionTaskModel> mAllPositionTasks;
private Map<String, Integer> mVisibleDistanceViewTags = new HashMap<String, Integer>(); private Map<String, Integer> mVisibleDistanceViewTags = new HashMap<String, Integer>();
private OnDistanceUpdateReceiver mUpdateReceiver; private OnDistanceUpdateReceiver mUpdateReceiver;
private boolean isPositionListSynced = false; // 新增：标记位置列表是否已同步
// 数据同步与消息接收接口（Activity/Adapter实现） // 数据同步与消息接收接口（Activity/Adapter实现）
public interface OnDistanceUpdateReceiver { public interface OnDistanceUpdateReceiver {
void onDistanceUpdate(String positionId, String distanceText, int distanceColor); void onDistanceUpdate(String positionId); // 简化：仅传递位置ID
int getColorRes(int resId); int getColorRes(int resId);
} }
@@ -75,13 +75,13 @@ public class DistanceRefreshService extends Service {
public void handleMessage(Message msg) { public void handleMessage(Message msg) {
super.handleMessage(msg); super.handleMessage(msg);
if (msg.what == MSG_UPDATE_DISTANCE && mUpdateReceiver != null) { if (msg.what == MSG_UPDATE_DISTANCE && mUpdateReceiver != null) {
// 解析消息（Java7：显式调用getData()，避免链式调用） // 解析消息：仅获取位置ID
String positionId = msg.getData().getString(KEY_POSITION_ID); Bundle data = msg.getData();
String distanceText = msg.getData().getString(KEY_DISTANCE_TEXT); String positionId = data.getString(KEY_POSITION_ID);
int distanceColor = msg.getData().getInt(KEY_DISTANCE_COLOR); if (positionId != null) {
LogUtils.d(TAG, "接收消息→转发更新：位置ID=" + positionId + "，距离文本=" + distanceText); LogUtils.d(TAG, "接收消息→转发更新：位置ID=" + positionId);
mUpdateReceiver.onDistanceUpdate(positionId);
mUpdateReceiver.onDistanceUpdate(positionId, distanceText, distanceColor); }
} }
} }
}; };
@@ -117,7 +117,7 @@ public class DistanceRefreshService extends Service {
mDistanceTimer.scheduleAtFixedRate(new TimerTask() { mDistanceTimer.scheduleAtFixedRate(new TimerTask() {
@Override @Override
public void run() { public void run() {
LogUtils.d(TAG, "定时器触发→开始计算距离，可见位置数量=" + mVisibleDistanceViewTags.size()); LogUtils.d(TAG, "定时器触发→开始计算距离，位置列表同步状态=" + isPositionListSynced);
calculateAndSendDistanceUpdates(); calculateAndSendDistanceUpdates();
checkAndTriggerTasks(); checkAndTriggerTasks();
} }
@@ -125,75 +125,47 @@ public class DistanceRefreshService extends Service {
} }
/** /**
* 计算距离并发送UI更新消息 * 核心修改：计算距离并更新到mPositionList，仅发送位置ID通知
* Java7：使用迭代器遍历Map（替代forEach Lambda），显式空判断 * Java7：使用迭代器遍历，显式空判断
*/ */
private void calculateAndSendDistanceUpdates() { private void calculateAndSendDistanceUpdates() {
// 无可见控件/数据/接收器时，直接返回 // 前置校验：位置列表未同步/为空/无GPS，直接返回
if (mVisibleDistanceViewTags.isEmpty()) { if (!isPositionListSynced || mPositionList.isEmpty()) {
LogUtils.d(TAG, "无需要更新的可见控件，跳过计算"); LogUtils.d(TAG, "位置列表未同步/为空，跳过距离计算");
return; return;
} }
if (mPositionList.isEmpty()) { if (mCurrentGpsPosition == null) {
LogUtils.d(TAG, "位置列表为空，无法计算距离"); LogUtils.d(TAG, "无当前GPS位置，跳过距离计算");
return;
}
if (mUpdateReceiver == null) {
LogUtils.d(TAG, "未设置消息接收器（Adapter未绑定），无法发送更新");
return; return;
} }
// Java7：使用Iterator遍历Map.Entry（替代forEach Lambda） // 遍历所有位置项，计算并设置realPositionDistance
Iterator<Map.Entry<String, Integer>> entryIterator = mVisibleDistanceViewTags.entrySet().iterator(); Iterator<PositionModel> positionIter = mPositionList.iterator();
while (entryIterator.hasNext()) { while (positionIter.hasNext()) {
Map.Entry<String, Integer> entry = entryIterator.next(); PositionModel targetModel = positionIter.next();
String positionId = entry.getKey(); String positionId = targetModel.getPositionId();
PositionModel targetModel = findPositionModelById(positionId);
if (targetModel == null) { if (targetModel.isEnableRealPositionDistance()) {
// 位置模型不存在时，发送“无效位置”消息 // 状态为true：计算距离（米），设置到realPositionDistance
sendDistanceUpdateMessage(
positionId,
"实时距离：位置无效",
mUpdateReceiver.getColorRes(R.color.colorRed)
);
LogUtils.d(TAG, "位置ID=" + positionId + " 未找到对应模型，发送无效提示");
continue;
}
// 距离计算与文本生成
String distanceText;
int distanceColor;
if (!targetModel.isEnableRealPositionDistance()) {
distanceText = "实时距离：未启用";
distanceColor = mUpdateReceiver.getColorRes(R.color.colorGrayText);
} else if (mCurrentGpsPosition == null) {
// 无GPS时持续发送“等待定位”（避免默认文本回落）
distanceText = "实时距离：等待GPS定位";
distanceColor = mUpdateReceiver.getColorRes(R.color.colorGrayText);
LogUtils.d(TAG, "位置ID=" + positionId + " 无GPS数据，发送等待提示");
} else {
try { try {
// 计算距离（复用PositionModel静态方法） double distanceM = PositionModel.calculatePositionDistance(
double distanceM = PositionModel.calculatePositionDistance(mCurrentGpsPosition, targetModel, false); mCurrentGpsPosition, targetModel, false
judgeTaskBingoStatus(targetModel, (int) distanceM); );
// 格式化距离文本（Java7：显式类型转换，避免自动拆箱问题） targetModel.setRealPositionDistance(distanceM); // 存储计算结果到列表项
if (distanceM < 1000) { LogUtils.d(TAG, "位置ID=" + positionId + " 计算距离：" + distanceM + "米");
distanceText = String.format("实时距离：%.1f 米", distanceM);
} else {
distanceText = String.format("实时距离：%.1f 千米", distanceM / 1000);
}
distanceColor = mUpdateReceiver.getColorRes(R.color.colorEnableGreen);
LogUtils.d(TAG, "位置ID=" + positionId + " 计算完成：" + distanceText);
} catch (IllegalArgumentException e) { } catch (IllegalArgumentException e) {
distanceText = "实时距离：数据无效"; // 计算异常时，设置为-1（标记无效）
distanceColor = mUpdateReceiver.getColorRes(R.color.colorRed); targetModel.setRealPositionDistance(-1);
LogUtils.e(TAG, "位置ID=" + positionId + " 计算异常：" + e.getMessage()); LogUtils.e(TAG, "位置ID=" + positionId + " 距离计算异常：" + e.getMessage());
} }
} else {
// 状态为false：强制设置realPositionDistance为-1
targetModel.setRealPositionDistance(-1);
LogUtils.d(TAG, "位置ID=" + positionId + " 未启用距离计算，设置距离为-1");
} }
// 发送消息到UI线程 // 发送更新通知（仅传位置ID）
sendDistanceUpdateMessage(positionId, distanceText, distanceColor); sendDistanceUpdateMessage(positionId);
} }
} }
@@ -202,7 +174,7 @@ public class DistanceRefreshService extends Service {
* Java7：使用迭代器遍历任务列表（替代forEach Lambda） * Java7：使用迭代器遍历任务列表（替代forEach Lambda）
*/ */
private void checkAndTriggerTasks() { private void checkAndTriggerTasks() {
if (mAllPositionTasks.isEmpty()) { if (mAllPositionTasks.isEmpty() || !isPositionListSynced || mPositionList.isEmpty()) {
return; return;
} }
// Java7：Iterator遍历ArrayList（替代forEach Lambda） // Java7：Iterator遍历ArrayList（替代forEach Lambda）
@@ -216,65 +188,70 @@ public class DistanceRefreshService extends Service {
} }
/** /**
* 判断任务触发状态（仅修改数据，UI更新由Adapter处理） * 新增：判断任务触发状态（基于mPositionList中的realPositionDistance）
* Java7：迭代器遍历任务列表，显式状态判断 * Java7：迭代器遍历任务列表，显式状态判断
*/ */
private void judgeTaskBingoStatus(PositionModel model, int distanceM) { private void judgeTaskBingoStatus() {
String targetPosId = model.getPositionId(); if (!isPositionListSynced || mPositionList.isEmpty() || mAllPositionTasks.isEmpty()) {
// Java7：Iterator遍历任务列表 return;
Iterator<PositionTaskModel> taskIterator = mAllPositionTasks.iterator(); }
while (taskIterator.hasNext()) {
PositionTaskModel task = taskIterator.next(); Iterator<PositionModel> posIter = mPositionList.iterator();
if (targetPosId.equals(task.getPositionId())) { while (posIter.hasNext()) {
PositionModel posModel = posIter.next();
String posId = posModel.getPositionId();
double distanceM = posModel.getRealPositionDistance();
// 遍历绑定当前位置的任务
Iterator<PositionTaskModel> taskIter = mAllPositionTasks.iterator();
while (taskIter.hasNext()) {
PositionTaskModel task = taskIter.next();
if (posId.equals(task.getPositionId()) && distanceM != -1) {
boolean oldBingoState = task.isBingo(); boolean oldBingoState = task.isBingo();
boolean newBingoState = false; boolean newBingoState = false;
// 根据任务条件判断新状态（Java7：if-else替代三元表达式，增强可读性） // 根据任务条件判断新状态
if (task.isGreaterThan()) { if (task.isGreaterThan()) {
newBingoState = task.isEnable() && distanceM > task.getDiscussDistance(); newBingoState = task.isEnable() && distanceM > task.getDiscussDistance();
} else if (task.isLessThan()) { } else if (task.isLessThan()) {
newBingoState = task.isEnable() && distanceM < task.getDiscussDistance(); newBingoState = task.isEnable() && distanceM < task.getDiscussDistance();
} else {
newBingoState = task.isEnable();
} }
// 更新任务状态（仅状态变化时更新） // 仅状态变化时更新
if (newBingoState != oldBingoState) { if (newBingoState != oldBingoState) {
task.setIsBingo(newBingoState); task.setIsBingo(newBingoState);
} }
} }
} }
} }
}
/** /**
* 发送距离更新消息（通过Handler发送到UI线程） * 简化：仅发送位置ID通知（Adapter从mPositionList读取数据）
* Java7：显式创建Message，避免obtainMessage链式调用 * Java7：显式创建Message，避免obtainMessage链式调用
*/ */
private void sendDistanceUpdateMessage(String positionId, String distanceText, int distanceColor) { private void sendDistanceUpdateMessage(String positionId) {
Message msg = mMainHandler.obtainMessage(MSG_UPDATE_DISTANCE); Message msg = mMainHandler.obtainMessage(MSG_UPDATE_DISTANCE);
// Java7：显式调用put方法（替代链式put） Bundle data = new Bundle();
msg.getData().putString(KEY_POSITION_ID, positionId); data.putString(KEY_POSITION_ID, positionId);
msg.getData().putString(KEY_DISTANCE_TEXT, distanceText); msg.setData(data);
msg.getData().putInt(KEY_DISTANCE_COLOR, distanceColor);
mMainHandler.sendMessage(msg); mMainHandler.sendMessage(msg);
LogUtils.d(TAG, "发送消息→位置ID=" + positionId + "，距离文本=" + distanceText); LogUtils.d(TAG, "发送更新通知：位置ID=" + positionId);
} }
/** /**
* 根据位置ID查找位置模型（工具方法） * 核心修改：同步位置列表（持有原引用，不拷贝）
* Java7：迭代器遍历位置列表（替代stream().filter()）
*/ */
private PositionModel findPositionModelById(String positionId) { public void syncPositionList(ArrayList<PositionModel> positionList) {
// Java7：Iterator遍历ArrayList if (positionList != null) {
Iterator<PositionModel> modelIterator = mPositionList.iterator(); this.mPositionList = positionList; // 持有外部列表引用
while (modelIterator.hasNext()) { this.isPositionListSynced = true;
PositionModel model = modelIterator.next(); LogUtils.d(TAG, "同步位置列表（持有引用）：数量=" + positionList.size());
if (positionId.equals(model.getPositionId())) { } else {
return model; this.isPositionListSynced = false;
LogUtils.w(TAG, "同步位置列表失败：传入列表为null");
} }
} }
return null;
}
// ---------------------- 对外API（供Activity/Adapter调用） ---------------------- // ---------------------- 对外API（供Activity/Adapter调用） ----------------------
public void setOnDistanceUpdateReceiver(OnDistanceUpdateReceiver receiver) { public void setOnDistanceUpdateReceiver(OnDistanceUpdateReceiver receiver) {
@@ -286,14 +263,6 @@ public class DistanceRefreshService extends Service {
LogUtils.d(TAG, "同步GPS位置：纬度=" + (currentGpsPosition != null ? currentGpsPosition.getLatitude() : 0.0f)); LogUtils.d(TAG, "同步GPS位置：纬度=" + (currentGpsPosition != null ? currentGpsPosition.getLatitude() : 0.0f));
} }
public void syncPositionList(ArrayList<PositionModel> positionList) {
if (positionList != null) {
this.mPositionList.clear();
this.mPositionList.addAll(positionList);
LogUtils.d(TAG, "同步位置列表：数量=" + positionList.size());
}
}
public void syncAllPositionTasks(ArrayList<PositionTaskModel> allPositionTasks) { public void syncAllPositionTasks(ArrayList<PositionTaskModel> allPositionTasks) {
if (allPositionTasks != null) { if (allPositionTasks != null) {
this.mAllPositionTasks.clear(); this.mAllPositionTasks.clear();
@@ -331,10 +300,11 @@ public class DistanceRefreshService extends Service {
} }
// 清空数据，解除引用（避免内存泄漏） // 清空数据，解除引用（避免内存泄漏）
mCurrentGpsPosition = null; mCurrentGpsPosition = null;
mPositionList.clear(); mPositionList = null; // 释放列表引用
mAllPositionTasks.clear(); mAllPositionTasks.clear();
mVisibleDistanceViewTags.clear(); mVisibleDistanceViewTags.clear();
mUpdateReceiver = null; mUpdateReceiver = null;
isPositionListSynced = false;
} }
} }