<positions>APK 15.0.3 release Publish.

positions/build.properties

@@ -1,8 +1,8 @@
 #Created by .winboll/winboll_app_build.gradle
-#Mon Sep 29 18:46:38 HKT 2025
+#Tue Sep 30 17:50:26 HKT 2025
-stageCount=3
+stageCount=4
 libraryProject=
 baseVersion=15.0
-publishVersion=15.0.2
+publishVersion=15.0.3
 buildCount=0
-baseBetaVersion=15.0.3
+baseBetaVersion=15.0.4

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

@@ -1,219 +1,446 @@
 package cc.winboll.studio.positions.activities;
 
-
 /**
  * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
  * @Date 2025/09/29 18:22
- * @Describe 当前位置实时显示
+ * @Describe 当前位置实时显示 + 位置列表实时距离计算
  */
-
-
 import android.Manifest;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
 import android.content.pm.PackageManager;
 import android.location.Location;
 import android.os.Bundle;
+import android.text.InputType;
+import android.view.View;
+import android.widget.Button;
+import android.widget.EditText;
 import android.widget.TextView;
 import android.widget.Toast;
 import androidx.annotation.NonNull;
 import androidx.appcompat.app.AppCompatActivity;
 import androidx.core.app.ActivityCompat;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+import cc.winboll.studio.positions.R;
+import cc.winboll.studio.positions.adapters.PositionAdapter;
+import cc.winboll.studio.positions.models.PositionModel;
 import com.google.android.gms.location.FusedLocationProviderClient;
 import com.google.android.gms.location.LocationCallback;
 import com.google.android.gms.location.LocationRequest;
 import com.google.android.gms.location.LocationResult;
 import com.google.android.gms.location.LocationServices;
 import com.google.android.gms.tasks.OnSuccessListener;
-import cc.winboll.studio.positions.R;
+import java.util.ArrayList;
-
+import cc.winboll.studio.positions.models.PositionTaskModel;
 
 /**
  * 实时定位活动窗口：
- * 1. 申请定位必需权限（精确定位+粗略定位）
+ * 1. 申请定位必需权限（精确定位）
  * 2. 初始化FusedLocationProviderClient（谷歌官方定位服务，兼容所有安卓版本）
- * 3. 实时监听位置变化，更新显示经度、纬度
+ * 3. 实时监听位置变化，更新显示经度、纬度 + 同步给Adapter计算实时距离
+ * 4. 右下角圆形悬浮按钮（含大写P字母，支持添加位置）
+ * 5. 位置列表支持实时距离显示（按isEnableRealPositionDistance控制）
  */
 public class LocationActivity extends AppCompatActivity {
 
-	public static final String TAG = "LocationActivity";
+    public static final String TAG = "LocationActivity";
 
-	// 1. 核心组件与常量定义
+    // 1. 核心组件与常量定义（兼容Java 7，移除不必要final）
-	private static final int REQUEST_LOCATION_PERMISSIONS = 1004; // 定位权限请求码
+    private static final int REQUEST_LOCATION_PERMISSIONS = 1004; // 定位权限请求码
-	private FusedLocationProviderClient fusedLocationClient; // 定位核心客户端
+    private FusedLocationProviderClient fusedLocationClient; // 定位核心客户端
-	private LocationCallback locationCallback; // 位置变化监听器
+    private LocationCallback locationCallback; // 位置变化监听器
-	private LocationRequest locationRequest; // 定位请求配置（频率、精度等）
+    private LocationRequest locationRequest; // 定位请求配置（频率、精度等）
+    private Location currentLocation; // 存储当前最新位置（用于同步给Adapter）
 
-	// UI控件：用于显示经纬度（需在布局中定义对应ID）
+    // UI控件（Java 7显式声明+强制转换）
-	private TextView tvLongitude; // 经度显示
+    private TextView tvLongitude; // 经度显示
-	private TextView tvLatitude;  // 纬度显示
+    private TextView tvLatitude;  // 纬度显示
+    private Button fabPButton;    // 右下角圆形悬浮按钮（P字母）
+    private RecyclerView rvPositionList; // 位置列表（RecyclerView）
+    private PositionAdapter positionAdapter; // 列表Adapter（含实时距离逻辑）
+    ArrayList<PositionModel> mPositionList = new ArrayList<PositionModel>(); // 位置数据集合
+    ArrayList<PositionTaskModel> mPositionTasksList = new ArrayList<PositionTaskModel>(); // 位置数据集合
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_location);
+
+        // 绑定UI控件（Java 7显式强制转换）
+        tvLongitude = (TextView) findViewById(R.id.tv_longitude);
+        tvLatitude = (TextView) findViewById(R.id.tv_latitude);
+        fabPButton = (Button) findViewById(R.id.fab_p_button);
+        rvPositionList = (RecyclerView) findViewById(R.id.rv_position_list);
+
+        // 初始化核心逻辑：定位配置→悬浮按钮→列表Adapter→加载历史数据
+        initLocationConfig();
+        initFabPButton();
+        initRecyclerViewAndAdapter();
+        loadHistoryPositions();
+
+        // 检查并申请定位权限（权限通过后启动实时定位）
+        if (checkLocationPermissions()) {
+            startRealTimeLocation();
+        } else {
+            requestLocationPermissions();
+        }
+    }
 
 
-	@Override
+    /**
-	protected void onCreate(Bundle savedInstanceState) {
+     * 初始化定位配置（兼容Java 7，用LocationRequest.create()替代Builder）
-		super.onCreate(savedInstanceState);
+     */
-		// 2. 加载布局（需手动创建对应布局文件，见下方说明）
+    private void initLocationConfig() {
-		setContentView(R.layout.activity_location);
+        // 初始化定位客户端
+        fusedLocationClient = LocationServices.getFusedLocationProviderClient(this);
 
-		// 3. 绑定UI控件（与布局文件中的TextView ID对应）
+        // 定位请求配置（高精度、1秒更新一次，适配旧版Google Play Services）
-		tvLongitude = findViewById(R.id.tv_longitude);
+        locationRequest = LocationRequest.create();
-		tvLatitude = findViewById(R.id.tv_latitude);
+        locationRequest.setInterval(1000); // 定位更新间隔（1秒）
+        locationRequest.setFastestInterval(500); // 最快更新间隔（500毫秒）
+        locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY); // 优先GPS高精度定位
 
-		// 4. 初始化定位相关组件
+        // 位置变化监听器（实时更新UI + 同步位置给Adapter计算距离）
-		initLocationConfig();
+        locationCallback = new LocationCallback() {
+            @Override
+            public void onLocationResult(@NonNull LocationResult locationResult) {
+                super.onLocationResult(locationResult);
+                currentLocation = locationResult.getLastLocation(); // 更新当前最新位置
+                if (currentLocation != null) {
+                    // 1. 更新页面经度、纬度显示
+                    double longitude = currentLocation.getLongitude();
+                    double latitude = currentLocation.getLatitude();
+                    tvLongitude.setText(String.format("当前经度：%.6f", longitude));
+                    tvLatitude.setText(String.format("当前纬度：%.6f", latitude));
 
-		// 5. 检查并申请定位权限（无权限则申请，有权限则直接启动定位）
+                    // 2. 同步当前位置给Adapter（用于计算列表项实时距离）
-		if (checkLocationPermissions()) {
+                    if (positionAdapter != null) {
-			startRealTimeLocation(); // 权限已授予 → 启动实时定位
+                        // 创建仅含经纬度的PositionModel（memo空，isEnable无需关注）
-		} else {
+                        PositionModel currentGpsPos = new PositionModel();
-			requestLocationPermissions(); // 权限未授予 → 申请权限
+                        currentGpsPos.setLongitude(longitude);
-		}
+                        currentGpsPos.setLatitude(latitude);
-	}
+                        // 调用Adapter方法传入当前GPS位置
+                        positionAdapter.setCurrentGpsPosition(currentGpsPos);
+                    }
+                } else {
+                    // 位置为空（如GPS信号弱），显示等待提示
+                    tvLongitude.setText("当前经度：等待更新...");
+                    tvLatitude.setText("当前纬度：等待更新...");
+                }
+            }
+        };
+    }
 
 
-	/**
+    /**
-	 * 初始化定位配置：设置定位精度、更新频率等
+     * 初始化悬浮按钮（点击弹出备注输入框，添加当前位置到列表）
-	 */
+     */
-	private void initLocationConfig() {
+    private void initFabPButton() {
-		// 初始化定位客户端（谷歌官方推荐，替代旧的LocationManager）
+        fabPButton.setOnClickListener(new View.OnClickListener() {
-		fusedLocationClient = LocationServices.getFusedLocationProviderClient(this);
+				@Override
-
+				public void onClick(View v) {
-		// 配置定位请求：实时更新（1秒请求一次，最小间隔500毫秒，最高精度）
+					showLocationRemarkDialog();
-		locationRequest = new LocationRequest.Builder(1000) // 定位更新间隔（毫秒）
-			.setMinUpdateIntervalMillis(500) // 最小更新间隔（避免频繁更新耗电）
-			.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY) // 高精度定位（优先GPS）
-			.build();
-
-		// 初始化位置变化监听器：位置更新时触发（实时更新UI）
-		locationCallback = new LocationCallback() {
-			@Override
-			public void onLocationResult(@NonNull LocationResult locationResult) {
-				super.onLocationResult(locationResult);
-				// 获取最新位置信息（locationResult包含最近一次或多次位置）
-				Location latestLocation = locationResult.getLastLocation();
-				if (latestLocation != null) {
-					// 6. 提取经纬度并更新UI（实时显示）
-					double longitude = latestLocation.getLongitude(); // 经度（东经为正，西经为负）
-					double latitude = latestLocation.getLatitude();   // 纬度（北纬为正，南纬为负）
-
-					// 更新TextView显示（保留6位小数，精度足够日常使用）
-					tvLongitude.setText(String.format("当前经度：%.6f", longitude));
-					tvLatitude.setText(String.format("当前纬度：%.6f", latitude));
 				}
-			}
+			});
-		};
+    }
-	}
 
 
-	/**
+    /**
-	 * 检查定位必需权限是否已授予（精确定位+粗略定位，覆盖所有安卓版本）
+     * 初始化RecyclerView和Adapter（绑定实时距离计算逻辑）
-	 */
+     */
-	private boolean checkLocationPermissions() {
+    private void initRecyclerViewAndAdapter() {
-		// 安卓12+（API31+）新增精确定位权限，需同时检查2个权限；低版本只需检查1个
+        // 1. 配置RecyclerView布局管理器（垂直列表）
-		/*if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
+        LinearLayoutManager layoutManager = new LinearLayoutManager(this);
-			return ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
+        layoutManager.setOrientation(LinearLayoutManager.VERTICAL);
-				&& ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED;
+        rvPositionList.setLayoutManager(layoutManager);
-		} else {*/
+
-			return ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED;
+        // 2. 初始化Adapter（传入上下文和数据集合，兼容Java 7）
-		//}
+		PositionModel.loadBeanList(this, this.mPositionList, PositionModel.class);
-	}
+		PositionTaskModel.loadBeanList(this, this.mPositionTasksList, PositionTaskModel.class);
+        positionAdapter = new PositionAdapter(this, mPositionList, mPositionTasksList);
+        rvPositionList.setAdapter(positionAdapter);
+
+        // 3. 设置Adapter删除监听（删除列表项并同步本地数据）
+        positionAdapter.setOnDeleteClickListener(new PositionAdapter.OnDeleteClickListener() {
+				@Override
+				public void onDeleteClick(int position) {
+					showDeleteConfirmDialog(position);
+				}
+			});
+
+        // 4. 设置Adapter保存监听（编辑备注后同步本地数据）
+        positionAdapter.setOnSavePositionClickListener(new PositionAdapter.OnSavePositionClickListener() {
+				@Override
+				public void onSavePositionClick() {
+					try {
+						PositionModel.saveBeanList(LocationActivity.this, mPositionList, PositionModel.class);
+						Toast.makeText(LocationActivity.this, "位置信息已保存", Toast.LENGTH_SHORT).show();
+					} catch (Exception e) {
+						e.printStackTrace();
+						Toast.makeText(LocationActivity.this, "数据保存失败", Toast.LENGTH_SHORT).show();
+					}
+				}
+			});
+			
+		positionAdapter.setOnSavePositionTaskClickListener(new PositionAdapter.OnSavePositionTaskClickListener() {
+				@Override
+				public void onSavePositionTaskClick() {
+					try {
+						PositionTaskModel.saveBeanList(LocationActivity.this, mPositionTasksList, PositionTaskModel.class);
+						Toast.makeText(LocationActivity.this, "任务信息已保存", Toast.LENGTH_SHORT).show();
+					} catch (Exception e) {
+						e.printStackTrace();
+						Toast.makeText(LocationActivity.this, "数据保存失败", Toast.LENGTH_SHORT).show();
+					}
+				}
+			});
+    }
 
 
-	/**
+    /**
-	 * 申请定位必需权限（弹系统授权弹窗）
+     * 从本地加载历史位置数据（基于BaseBean的持久化逻辑）
-	 */
+     */
-	private void requestLocationPermissions() {
+    private void loadHistoryPositions() {
-		/*if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
+        try {
-			// 安卓12+：同时申请精确定位+粗略定位
+            ArrayList<PositionModel> historyList = new ArrayList<PositionModel>();
-			ActivityCompat.requestPermissions(
+            // 调用PositionModel加载方法（读取本地保存的位置数据）
-				this,
+            PositionModel.loadBeanList(LocationActivity.this, historyList, PositionModel.class);
-				new String[]{Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION},
+            if (historyList != null && !historyList.isEmpty()) {
-				REQUEST_LOCATION_PERMISSIONS
+                mPositionList.clear();
-			);
+                mPositionList.addAll(historyList);
-		} else {*/
+                positionAdapter.notifyDataSetChanged(); // 通知列表刷新
-			// 安卓12以下：仅申请精确定位（包含粗略定位能力）
+            }
-			ActivityCompat.requestPermissions(
+        } catch (Exception e) {
-				this,
+            e.printStackTrace(); // 首次启动无数据时忽略异常
-				new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
+        }
-				REQUEST_LOCATION_PERMISSIONS
+    }
-			);
-		//}
-	}
 
 
-	/**
+    /**
-	 * 启动实时定位：注册位置监听器，开始接收位置更新
+     * 弹出位置备注输入对话框（添加当前位置到列表）
-	 */
+     */
-	private void startRealTimeLocation() {
+    private void showLocationRemarkDialog() {
-		// 权限兜底检查（避免异常）
+        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(LocationActivity.this);
-		if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+        dialogBuilder.setTitle("当前位置备注");
-			Toast.makeText(this, "定位权限未授予，无法启动定位", Toast.LENGTH_SHORT).show();
-			return;
-		}
 
-		// 1. 先获取一次当前位置（快速显示初始经纬度）
+        // 创建输入框（配置提示文本和内边距）
-		fusedLocationClient.getLastLocation()
+        final EditText remarkInput = new EditText(LocationActivity.this);
+        remarkInput.setHint("请输入备注（如：公司/家/学校）");
+        remarkInput.setInputType(InputType.TYPE_CLASS_TEXT);
+        remarkInput.setPadding(
+			dip2px(16),
+			dip2px(8),
+			dip2px(16),
+			dip2px(8)
+        );
+        dialogBuilder.setView(remarkInput);
+
+        // 确定按钮：添加位置到列表 + 保存本地
+        dialogBuilder.setPositiveButton("确定", new DialogInterface.OnClickListener() {
+				@Override
+				public void onClick(DialogInterface dialog, int which) {
+					String inputRemark = remarkInput.getText().toString().trim();
+					if (inputRemark.isEmpty()) {
+						Toast.makeText(LocationActivity.this, "未输入备注", Toast.LENGTH_SHORT).show();
+						return;
+					}
+
+					// 校验当前位置是否有效（避免无定位时添加空数据）
+					if (currentLocation == null) {
+						Toast.makeText(LocationActivity.this, "未获取到当前位置，请稍后再试", Toast.LENGTH_SHORT).show();
+						return;
+					}
+
+					// 添加位置到列表（isEnableRealPositionDistance默认false，需手动开启）
+					double longitude = currentLocation.getLongitude();
+					double latitude = currentLocation.getLatitude();
+					PositionModel newPosition = new PositionModel(
+					    PositionModel.genPositionId(),
+                        longitude,
+                        latitude,
+                        inputRemark,
+                        false // 默认不启用实时距离，用户可后续通过编辑开启
+					);
+					mPositionList.add(newPosition);
+
+					// 保存到本地 + 刷新列表
+					try {
+						PositionModel.saveBeanList(LocationActivity.this, mPositionList, PositionModel.class);
+						positionAdapter.notifyItemInserted(mPositionList.size() - 1); // 局部刷新（性能更优）
+						Toast.makeText(LocationActivity.this, "位置已添加", Toast.LENGTH_SHORT).show();
+					} catch (Exception e) {
+						e.printStackTrace();
+						Toast.makeText(LocationActivity.this, "位置保存失败", Toast.LENGTH_SHORT).show();
+					}
+					dialog.dismiss();
+				}
+			});
+
+        // 取消按钮：仅关闭对话框
+        dialogBuilder.setNegativeButton("取消", new DialogInterface.OnClickListener() {
+				@Override
+				public void onClick(DialogInterface dialog, int which) {
+					dialog.dismiss();
+				}
+			});
+
+        // 配置对话框（禁止外部点击关闭）
+        dialogBuilder.setCancelable(false);
+        AlertDialog remarkDialog = dialogBuilder.create();
+        remarkDialog.show();
+    }
+
+
+    /**
+     * 显示删除确认对话框（删除列表项）
+     */
+    private void showDeleteConfirmDialog(final int position) {
+        AlertDialog.Builder deleteDialogBuilder = new AlertDialog.Builder(this);
+        deleteDialogBuilder.setTitle("删除位置记录")
+			.setMessage("确定要删除这条位置吗？（删除后不可恢复）")
+			.setPositiveButton("确定", new DialogInterface.OnClickListener() {
+				@Override
+				public void onClick(DialogInterface dialog, int which) {
+					// 从列表移除 + 保存本地
+					positionAdapter.removePosition(position);
+					try {
+						PositionModel.saveBeanList(LocationActivity.this, mPositionList, PositionModel.class);
+						Toast.makeText(LocationActivity.this, "删除成功", Toast.LENGTH_SHORT).show();
+					} catch (Exception e) {
+						e.printStackTrace();
+						Toast.makeText(LocationActivity.this, "删除失败，请重试", Toast.LENGTH_SHORT).show();
+					}
+				}
+			})
+			.setNegativeButton("取消", new DialogInterface.OnClickListener() {
+				@Override
+				public void onClick(DialogInterface dialog, int which) {
+					dialog.dismiss();
+				}
+			})
+			.setCancelable(false);
+        deleteDialogBuilder.show();
+    }
+
+
+    /**
+     * 检查定位权限（仅精确定位权限，满足实时距离计算需求）
+     */
+    private boolean checkLocationPermissions() {
+        return ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
+			== PackageManager.PERMISSION_GRANTED;
+    }
+
+
+    /**
+     * 申请定位权限
+     */
+    private void requestLocationPermissions() {
+        String[] permissions = new String[]{Manifest.permission.ACCESS_FINE_LOCATION};
+        ActivityCompat.requestPermissions(
+			this,
+			permissions,
+			REQUEST_LOCATION_PERMISSIONS
+        );
+    }
+
+
+    /**
+     * 启动实时定位（获取当前位置 + 监听位置变化）
+     */
+    private void startRealTimeLocation() {
+        if (!checkLocationPermissions()) {
+            Toast.makeText(this, "定位权限未授予", Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        // 1. 先获取一次当前位置（初始化页面显示）
+        fusedLocationClient.getLastLocation()
 			.addOnSuccessListener(this, new OnSuccessListener<Location>() {
 				@Override
 				public void onSuccess(Location location) {
 					if (location != null) {
-						// 显示初始经纬度
+						currentLocation = location;
 						tvLongitude.setText(String.format("当前经度：%.6f", location.getLongitude()));
 						tvLatitude.setText(String.format("当前纬度：%.6f", location.getLatitude()));
 					} else {
-						// 无历史位置（如首次启动），提示“等待定位更新”
 						tvLongitude.setText("当前经度：等待更新...");
 						tvLatitude.setText("当前纬度：等待更新...");
 					}
 				}
 			});
 
-		// 2. 注册监听器，接收实时位置更新（持续监听）
+        // 2. 注册位置监听器（实时更新位置）
-		fusedLocationClient.requestLocationUpdates(
+        fusedLocationClient.requestLocationUpdates(
 			locationRequest,
 			locationCallback,
-			getMainLooper() // 在主线程更新UI（避免线程异常）
+			getMainLooper() // 主线程更新UI，避免线程异常
-		);
+        );
-	}
+    }
 
 
-	/**
+    /**
-	 * 处理权限申请结果（用户同意/拒绝后触发）
+     * 处理权限申请结果
-	 */
+     */
-	@Override
+    @Override
-	public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
-		super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
-		if (requestCode == REQUEST_LOCATION_PERMISSIONS) {
+        if (requestCode == REQUEST_LOCATION_PERMISSIONS) {
-			// 检查是否所有必需权限都已授予
+            boolean isGranted = false;
-			boolean allGranted = true;
+            for (int result : grantResults) {
-			for (int result : grantResults) {
+                if (result == PackageManager.PERMISSION_GRANTED) {
-				if (result != PackageManager.PERMISSION_GRANTED) {
+                    isGranted = true;
-					allGranted = false;
+                    break;
-					break;
+                }
-				}
+            }
-			}
 
-			if (allGranted) {
+            if (isGranted) {
-				// 权限同意 → 启动实时定位
+                startRealTimeLocation(); // 权限通过，启动定位
-				startRealTimeLocation();
+            } else {
-			} else {
+                // 权限拒绝，提示并显示无权限状态
-				// 权限拒绝 → 提示用户（无法定位）
+                Toast.makeText(this, "定位权限被拒绝，无法显示实时位置和距离", Toast.LENGTH_SHORT).show();
-				Toast.makeText(this, "定位权限被拒绝，无法显示位置信息", Toast.LENGTH_SHORT).show();
+                tvLongitude.setText("当前经度：无权限");
-				tvLongitude.setText("当前经度：无权限");
+                tvLatitude.setText("当前纬度：无权限");
-				tvLatitude.setText("当前纬度：无权限");
+            }
-			}
+        }
-		}
+    }
-	}
 
 
-	/**
+    /**
-	 * 活动销毁时：停止定位监听（避免内存泄漏、减少耗电）
+     * 活动销毁：停止定位 + 停止距离刷新定时器（避免内存泄漏）
-	 */
+     */
-	@Override
+    @Override
-	protected void onDestroy() {
+    protected void onDestroy() {
-		super.onDestroy();
+        super.onDestroy();
-		// 移除定位监听器（核心：防止Activity销毁后仍在监听，导致内存泄漏）
+
-		if (fusedLocationClient != null && locationCallback != null) {
+        // 1. 停止定位监听（释放定位资源）
-			fusedLocationClient.removeLocationUpdates(locationCallback);
+        if (fusedLocationClient != null && locationCallback != null) {
-		}
+            fusedLocationClient.removeLocationUpdates(locationCallback);
-	}
+        }
+
+        // 2. 停止Adapter的距离刷新定时器（关键：避免Timer持有Context导致内存泄漏）
+        if (positionAdapter != null) {
+            positionAdapter.stopTimer();
+        }
+
+        // 3. 最后同步一次数据（确保所有修改保存）
+        try {
+            if (mPositionList != null && !mPositionList.isEmpty()) {
+                PositionModel.saveBeanList(this, mPositionList, PositionModel.class);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    /**
+     * 辅助工具：dp转px（适配不同屏幕分辨率）
+     */
+    private int dip2px(float dpValue) {
+        final float scale = getResources().getDisplayMetrics().density;
+        return (int) (dpValue * scale + 0.5f); // +0.5f用于四舍五入，确保精度
+    }
 }
 

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

@@ -0,0 +1,675 @@
+package cc.winboll.studio.positions.adapters;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/09/29 20:25
+ * @Describe 位置数据适配器（修复定时器：仅刷新实时距离，不干扰编辑中的任务；优化任务触发通知）
+ */
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.LayoutInflater;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.PopupMenu;
+import android.widget.RadioButton;
+import android.widget.RadioGroup;
+import android.widget.TextView;
+import android.widget.Toast;
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+import cc.winboll.studio.positions.R;
+import cc.winboll.studio.positions.models.PositionModel;
+import cc.winboll.studio.positions.models.PositionTaskModel;
+import cc.winboll.studio.positions.views.PositionTaskListView;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Timer;
+import java.util.TimerTask;
+import cc.winboll.studio.positions.utils.NotificationUtils;
+
+public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
+    // 常量定义（不变）
+    public static final String TAG = "PositionAdapter";
+    private static final int VIEW_TYPE_SIMPLE = 1;
+    private static final int VIEW_TYPE_EDIT = 2;
+    private static final long REFRESH_INTERVAL = 5000;
+    private static final String DEFAULT_TASK_DESC = "新位置任务";
+    private static final int DEFAULT_TASK_DISTANCE = 100;
+
+    // 核心成员变量（新增：1.位置ID→索引映射 2.主线程Handler 3.任务触发标记）
+    private final ArrayList<PositionModel> mPositionList;
+    private final ArrayList<PositionTaskModel> mAllPositionTasks;
+    private final Context mContext;
+    private PositionModel mCurrentGpsPosition;
+    private final Timer mDistanceTimer;
+    private final Handler mMainHandler;
+    private final Map<String, ArrayList<PositionTaskModel>> mPositionTaskMap;
+    private final Map<String, TextView> mVisibleDistanceViews = new HashMap<>();
+    // 新增1：存储“位置ID→列表索引”映射（快速定位位置项，避免遍历）
+    private final Map<String, Integer> mPositionIdToIndexMap = new HashMap<>();
+    // 新增2：主线程Handler（确保UI更新在主线程，避免异常）
+    private final Handler mUiHandler = new Handler(Looper.getMainLooper());
+
+    // 接口回调（不变）
+    public interface OnDeleteClickListener {
+        void onDeleteClick(int position);
+    }
+
+    public interface OnSavePositionClickListener {
+        void onSavePositionClick();
+    }
+
+    public interface OnSavePositionTaskClickListener {
+        void onSavePositionTaskClick();
+    }
+
+    private OnDeleteClickListener mOnDeleteClickListener;
+    private OnSavePositionClickListener mOnSavePositionClickListener;
+    private OnSavePositionTaskClickListener mOnSavePositionTaskClickListener;
+
+    // 构造函数（新增：初始化位置ID→索引映射）
+    public PositionAdapter(Context context, ArrayList<PositionModel> positionList, ArrayList<PositionTaskModel> allPositionTasks) {
+        this.mContext = context;
+        this.mPositionList = (positionList != null) ? positionList : new ArrayList<PositionModel>();
+        this.mAllPositionTasks = (allPositionTasks != null) ? allPositionTasks : new ArrayList<PositionTaskModel>();
+        this.mMainHandler = new Handler(Looper.getMainLooper());
+        this.mDistanceTimer = new Timer();
+        this.mPositionTaskMap = new HashMap<String, ArrayList<PositionTaskModel>>();
+
+        // 初始化任务映射表（不变）
+        for (PositionModel model : mPositionList) {
+            String validPosId = model.getPositionId();
+            ArrayList<PositionTaskModel> matchedTasks = new ArrayList<PositionTaskModel>();
+            for (PositionTaskModel task : this.mAllPositionTasks) {
+                if (task != null && validPosId.equals(task.getPositionId())) {
+                    matchedTasks.add(task);
+                }
+            }
+            mPositionTaskMap.put(validPosId, matchedTasks);
+            // 新增：初始化“位置ID→索引”映射（索引即列表中的位置）
+            mPositionIdToIndexMap.put(validPosId, mPositionList.indexOf(model));
+        }
+
+        // 启动距离刷新定时器（不变）
+        startDistanceRefreshTimer();
+    }
+
+    // 对外API：设置当前GPS位置（不变）
+    public void setCurrentGpsPosition(PositionModel currentGpsPosition) {
+        this.mCurrentGpsPosition = currentGpsPosition;
+    }
+
+    // 对外API：设置监听器（不变）
+    public void setOnDeleteClickListener(OnDeleteClickListener listener) {
+        this.mOnDeleteClickListener = listener;
+    }
+
+    public void setOnSavePositionClickListener(OnSavePositionClickListener listener) {
+        this.mOnSavePositionClickListener = listener;
+    }
+
+    public void setOnSavePositionTaskClickListener(OnSavePositionTaskClickListener listener) {
+        this.mOnSavePositionTaskClickListener = listener;
+    }
+
+    // 对外API：停止定时器（不变）
+    public void stopTimer() {
+        if (mDistanceTimer != null) {
+            mDistanceTimer.cancel();
+            mDistanceTimer.purge();
+        }
+        mVisibleDistanceViews.clear();
+    }
+
+    // ---------------------- 核心修复1：定时器逻辑（仅刷新可见的距离TextView）（不变） ----------------------
+    private void startDistanceRefreshTimer() {
+        mDistanceTimer.scheduleAtFixedRate(new TimerTask() {
+				@Override
+				public void run() {
+					mMainHandler.post(new Runnable() {
+							@Override
+							public void run() {
+								for (Map.Entry<String, TextView> entry : mVisibleDistanceViews.entrySet()) {
+									String positionId = entry.getKey();
+									TextView distanceView = entry.getValue();
+
+									PositionModel targetModel = null;
+									for (PositionModel model : mPositionList) {
+										if (positionId.equals(model.getPositionId())) {
+											targetModel = model;
+											break;
+										}
+									}
+
+									if (targetModel != null) {
+										bindRealDistance(distanceView, targetModel);
+									}
+								}
+								for (PositionTaskModel task : mAllPositionTasks) {
+									if (task.isBingo() && task.isEnable()) {
+										NotificationUtils.show(mContext, task.getTaskId(), task.getPositionId(), task.getTaskDescription());
+									}
+								}
+							}
+						});
+				}
+			}, 0, REFRESH_INTERVAL);
+    }
+
+    // ---------------------- 核心修复2：管理可见/不可见的距离TextView（不变） ----------------------
+    @Override
+    public void onViewAttachedToWindow(@NonNull RecyclerView.ViewHolder holder) {
+        super.onViewAttachedToWindow(holder);
+        int position = holder.getAdapterPosition();
+        if (position < 0 || position >= mPositionList.size()) {
+            return;
+        }
+
+        PositionModel model = mPositionList.get(position);
+        String positionId = model.getPositionId();
+        // 同步更新位置ID→索引映射（防止列表项位置变化导致索引失效）
+        mPositionIdToIndexMap.put(positionId, position);
+
+        TextView distanceView = null;
+        if (holder instanceof SimpleViewHolder) {
+            distanceView = ((SimpleViewHolder) holder).tvSimpleRealDistance;
+        } else if (holder instanceof EditViewHolder) {
+            distanceView = ((EditViewHolder) holder).tvEditRealDistance;
+        }
+
+        if (distanceView != null) {
+            mVisibleDistanceViews.put(positionId, distanceView);
+        }
+    }
+
+    @Override
+    public void onViewDetachedFromWindow(@NonNull RecyclerView.ViewHolder holder) {
+        super.onViewDetachedFromWindow(holder);
+        int position = holder.getAdapterPosition();
+        if (position < 0 || position >= mPositionList.size()) {
+            return;
+        }
+
+        PositionModel model = mPositionList.get(position);
+        String positionId = model.getPositionId();
+        if (mVisibleDistanceViews.containsKey(positionId)) {
+            mVisibleDistanceViews.remove(positionId);
+        }
+    }
+
+    // ---------------------- RecyclerView 核心方法（不变） ----------------------
+    @Override
+    public int getItemViewType(int position) {
+        PositionModel model = mPositionList.get(position);
+        return model.isSimpleView() ? VIEW_TYPE_SIMPLE : VIEW_TYPE_EDIT;
+    }
+
+    @NonNull
+    @Override
+    public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+        LayoutInflater inflater = LayoutInflater.from(mContext);
+        if (viewType == VIEW_TYPE_SIMPLE) {
+            View view = inflater.inflate(R.layout.item_position_simple, parent, false);
+            return new SimpleViewHolder(view);
+        } else {
+            View view = inflater.inflate(R.layout.item_position_edit, parent, false);
+            return new EditViewHolder(view);
+        }
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
+        PositionModel model = mPositionList.get(position);
+        // 同步更新位置ID→索引映射（确保索引与当前列表项位置一致）
+        mPositionIdToIndexMap.put(model.getPositionId(), position);
+
+        if (holder instanceof SimpleViewHolder) {
+            bindSimpleView((SimpleViewHolder) holder, model, position);
+        } else if (holder instanceof EditViewHolder) {
+            bindEditView((EditViewHolder) holder, model, position);
+        }
+    }
+
+    @Override
+    public int getItemCount() {
+        return mPositionList.size();
+    }
+
+    // 回收ViewHolder时清理资源（不变）
+    @Override
+    public void onViewRecycled(@NonNull RecyclerView.ViewHolder holder) {
+        super.onViewRecycled(holder);
+        int position = holder.getAdapterPosition();
+        if (position >= 0 && position < mPositionList.size()) {
+            String positionId = mPositionList.get(position).getPositionId();
+            mVisibleDistanceViews.remove(positionId);
+            // 移除已回收位置的索引映射（避免内存泄漏）
+            mPositionIdToIndexMap.remove(positionId);
+        }
+
+        if (holder instanceof SimpleViewHolder) {
+            ((SimpleViewHolder) holder).ptlvSimpleTasks.clearData();
+            ((SimpleViewHolder) holder).ptlvSimpleTasks.setOnTaskUpdatedListener(null);
+        } else if (holder instanceof EditViewHolder) {
+            ((EditViewHolder) holder).ptlvEditTasks.clearData();
+            ((EditViewHolder) holder).ptlvEditTasks.setOnTaskUpdatedListener(null);
+        }
+    }
+
+    // 绑定简单视图（不变）
+    private void bindSimpleView(final SimpleViewHolder holder, final PositionModel model, final int position) {
+        holder.tvSimpleLongitude.setText(String.format("经度：%.6f", model.getLongitude()));
+        holder.tvSimpleLatitude.setText(String.format("纬度：%.6f", model.getLatitude()));
+        holder.tvSimpleMemo.setText(String.format("备注：%s", model.getMemo()));
+        bindRealDistance(holder.tvSimpleRealDistance, model);
+
+        holder.itemView.setOnLongClickListener(new View.OnLongClickListener() {
+				@Override
+				public boolean onLongClick(View v) {
+					PopupMenu popupMenu = new PopupMenu(mContext, v);
+					MenuInflater menuInflater = popupMenu.getMenuInflater();
+					menuInflater.inflate(R.menu.menu_item_edit, popupMenu.getMenu());
+
+					popupMenu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
+							@Override
+							public boolean onMenuItemClick(MenuItem item) {
+								if (item.getItemId() == R.id.menu_edit) {
+									model.setIsSimpleView(false);
+									notifyItemChanged(position);
+									return true;
+								}
+								return false;
+							}
+						});
+
+					popupMenu.show();
+					return true;
+				}
+			});
+
+        String currentPosId = model.getPositionId();
+        ArrayList<PositionTaskModel> matchedTasks = getSafeTasks(currentPosId);
+        holder.ptlvSimpleTasks.clearData();
+        holder.ptlvSimpleTasks.setViewStatus(PositionTaskListView.VIEW_MODE_SIMPLE);
+        if (holder.ptlvSimpleTasks.getAllTasks().isEmpty()) {
+            holder.ptlvSimpleTasks.init(matchedTasks, currentPosId);
+        }
+    }
+
+    // 绑定编辑视图（不变）
+    private void bindEditView(final EditViewHolder holder, final PositionModel model, final int position) {
+        holder.tvEditLongitude.setText(String.format("经度：%.6f", model.getLongitude()));
+        holder.tvEditLatitude.setText(String.format("纬度：%.6f", model.getLatitude()));
+        holder.etEditMemo.setText(model.getMemo());
+        holder.etEditMemo.setSelection(holder.etEditMemo.getText().length());
+        bindRealDistance(holder.tvEditRealDistance, model);
+
+        if (model.isEnableRealPositionDistance()) {
+            holder.rgRealDistanceSwitch.check(R.id.rb_enable);
+        } else {
+            holder.rgRealDistanceSwitch.check(R.id.rb_disable);
+        }
+
+        holder.btnEditDelete.setOnClickListener(new View.OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					if (mOnDeleteClickListener != null) {
+						mOnDeleteClickListener.onDeleteClick(position);
+						mPositionTaskMap.remove(model.getPositionId());
+						// 移除删除位置的索引映射
+						mPositionIdToIndexMap.remove(model.getPositionId());
+					}
+				}
+			});
+
+        holder.btnEditCancel.setOnClickListener(new View.OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					model.setIsSimpleView(true);
+					notifyItemChanged(position);
+					holder.etEditMemo.clearFocus();
+				}
+			});
+
+        holder.btnEditConfirm.setOnClickListener(new View.OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					String newMemo = holder.etEditMemo.getText().toString().trim();
+					model.setMemo(newMemo);
+					boolean isEnableDistance = holder.rgRealDistanceSwitch.getCheckedRadioButtonId() == R.id.rb_enable;
+					model.setIsEnableRealPositionDistance(isEnableDistance);
+
+					String currentPosId = model.getPositionId();
+					ArrayList<PositionTaskModel> allTasks = holder.ptlvEditTasks.getAllTasks();
+					ArrayList<PositionTaskModel> boundTasks = new ArrayList<PositionTaskModel>();
+					for (PositionTaskModel task : allTasks) {
+						if (task != null) {
+							task.setPositionId(currentPosId);
+							boundTasks.add(task);
+						}
+					}
+					mPositionTaskMap.put(currentPosId, boundTasks);
+
+					model.setIsSimpleView(true);
+					notifyItemChanged(position);
+					if (mOnSavePositionClickListener != null) {
+						mOnSavePositionClickListener.onSavePositionClick();
+					}
+					Toast.makeText(mContext, "位置信息已保存", Toast.LENGTH_SHORT).show();
+				}
+			});
+
+        final String currentPosId = model.getPositionId();
+        ArrayList<PositionTaskModel> matchedTasks = getSafeTasks(currentPosId);
+        holder.ptlvEditTasks.clearData();
+
+        holder.ptlvEditTasks.setOnTaskUpdatedListener(new PositionTaskListView.OnTaskUpdatedListener() {
+				@Override
+				public void onTaskUpdated(String posId, ArrayList<PositionTaskModel> updatedTasks) {
+					ArrayList<PositionTaskModel> boundTasks = new ArrayList<PositionTaskModel>();
+					for (PositionTaskModel task : updatedTasks) {
+						if (task != null) {
+							task.setPositionId(currentPosId);
+							boundTasks.add(task);
+						}
+					}
+
+					mPositionTaskMap.put(currentPosId, boundTasks);
+					Iterator<PositionTaskModel> taskIterator = mAllPositionTasks.iterator();
+					while (taskIterator.hasNext()) {
+						PositionTaskModel task = taskIterator.next();
+						if (task != null && currentPosId.equals(task.getPositionId())) {
+							taskIterator.remove();
+						}
+					}
+					mAllPositionTasks.addAll(boundTasks);
+
+					if (mOnSavePositionTaskClickListener != null) {
+						mOnSavePositionTaskClickListener.onSavePositionTaskClick();
+					}
+					Toast.makeText(mContext, "任务信息已保存", Toast.LENGTH_SHORT).show();
+				}
+			});
+
+        if (holder.ptlvEditTasks.getAllTasks().isEmpty()) {
+            holder.ptlvEditTasks.init(matchedTasks, currentPosId);
+        }
+        holder.ptlvEditTasks.setViewStatus(PositionTaskListView.VIEW_MODE_EDIT);
+
+        holder.btnAddTask.setOnClickListener(new View.OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					PositionTaskModel newTask = new PositionTaskModel(
+                        PositionTaskModel.genTaskId(),
+                        currentPosId,
+                        DEFAULT_TASK_DESC,
+                        true,
+                        DEFAULT_TASK_DISTANCE,
+                        true
+					);
+
+					ArrayList<PositionTaskModel> currentTasks = getSafeTasks(currentPosId);
+					currentTasks.add(newTask);
+					mPositionTaskMap.put(currentPosId, new ArrayList<PositionTaskModel>(currentTasks));
+					mAllPositionTasks.add(newTask);
+
+					holder.ptlvEditTasks.clearData();
+					holder.ptlvEditTasks.init(currentTasks, currentPosId);
+					holder.ptlvEditTasks.setViewStatus(PositionTaskListView.VIEW_MODE_EDIT);
+					Toast.makeText(mContext, "已新增1个任务（绑定当前位置）", Toast.LENGTH_SHORT).show();
+				}
+			});
+    }
+
+    // 工具方法：绑定实时距离（不变）
+    private void bindRealDistance(TextView distanceView, PositionModel model) {
+        if (!model.isEnableRealPositionDistance()) {
+            distanceView.setText("实时距离：未启用");
+            distanceView.setTextColor(mContext.getResources().getColor(R.color.colorGrayText));
+            return;
+        }
+
+        if (mCurrentGpsPosition == null) {
+			distanceView.setText("实时距离：等待GPS定位");
+			distanceView.setTextColor(mContext.getResources().getColor(R.color.colorGrayText));
+			return;
+		}
+
+		try {
+			double distanceM = PositionModel.calculatePositionDistance(mCurrentGpsPosition, model, false);
+// 设置任务列表触发状态（调用优化后的通知逻辑）
+			bingoTask(model, (int) distanceM);
+			String distanceText = (distanceM < 1000) ?
+				String.format("实时距离：%.1f 米", distanceM) :
+				String.format("实时距离：%.1f 千米", distanceM / 1000);
+			distanceView.setText(distanceText);
+			distanceView.setTextColor(mContext.getResources().getColor(R.color.colorEnableGreen));
+		} catch (IllegalArgumentException e) {
+			distanceView.setText("实时距离：数据无效");
+			distanceView.setTextColor(mContext.getResources().getColor(R.color.colorRed));
+		}
+	}
+
+// ---------------------- 核心优化：bingoTask 任务触发通知逻辑（替换 notifyDataSetChanged()） ----------------------
+	private void bingoTask(PositionModel model, int distanceM) {
+// 1. 标记是否有任务触发（避免无变化时无效更新）
+		boolean hasTaskTriggered = false;
+// 2. 记录当前位置ID（后续精准定位列表项）
+		final String targetPosId = model.getPositionId();
+
+// 遍历当前位置的任务，判断是否触发
+		for (PositionTaskModel task : mAllPositionTasks) {
+			if (targetPosId.equals(task.getPositionId())) {
+// 暂存旧状态（避免重复触发更新）
+				boolean oldBingoState = task.isBingo();
+				boolean newBingoState = false;
+
+// 根据任务条件判断新触发状态
+				if (task.isGreaterThan()) {
+					newBingoState = task.isEnable() && distanceM > task.getDiscussDistance();
+				} else if (task.isLessThan()) {
+					newBingoState = task.isEnable() && distanceM < task.getDiscussDistance();
+				} else {
+					newBingoState = task.isEnable() && true;
+				}
+
+// 仅当状态变化时，才更新任务状态并标记需要通知
+				if (newBingoState != oldBingoState) {
+					task.setIsBingo(newBingoState);
+					hasTaskTriggered = true;
+				}
+			}
+		}
+
+// 3. 仅当有任务触发且状态变化时，才执行精准更新（避免全局刷新）
+		if (hasTaskTriggered) {
+// 切换到主线程更新UI（解决子线程更新异常）
+			mUiHandler.post(new Runnable() {
+					@Override
+					public void run() {
+// 从映射表快速获取位置索引（避免遍历列表，提升效率）
+						Integer targetPosIndex = mPositionIdToIndexMap.get(targetPosId);
+						if (targetPosIndex != null && targetPosIndex >= 0 && targetPosIndex < mPositionList.size()) {
+// 精准更新单个位置项（仅刷新该位置的任务列表，不干扰其他项）
+							notifyItemChanged(targetPosIndex);
+						}
+					}
+				});
+		}
+	}
+
+// 工具方法：安全获取任务列表（不变）
+	private ArrayList getSafeTasks(String positionId) {
+		if (!mPositionTaskMap.containsKey(positionId)) {
+			mPositionTaskMap.put(positionId, new ArrayList());
+		}
+		return mPositionTaskMap.get(positionId);
+	}
+
+// 对外API：新增位置（补充索引映射更新）
+	public void addPosition(PositionModel model) {
+		if (model == null) return;
+		String validPosId = model.getPositionId();
+		mPositionList.add(model);
+// 新增：添加新位置的索引映射（索引为列表最后一位）
+		mPositionIdToIndexMap.put(validPosId, mPositionList.size() - 1);
+
+		if (!mPositionTaskMap.containsKey(validPosId)) {
+			mPositionTaskMap.put(validPosId, new ArrayList());
+		}
+		notifyItemInserted(mPositionList.size() - 1);
+	}
+
+// 对外API：删除位置（补充索引映射清理）
+	public void removePosition(int position) {
+		if (position < 0 || position >= mPositionList.size()) return;
+		PositionModel removedModel = mPositionList.get(position);
+		String removedPosId = removedModel.getPositionId();
+
+// 1. 清理距离缓存和索引映射（新增）
+		mVisibleDistanceViews.remove(removedPosId);
+		mPositionIdToIndexMap.remove(removedPosId);
+
+// 2. 重新同步剩余位置的索引映射（避免删除后索引错位）
+		for (int i = position; i < mPositionList.size(); i++) {
+			PositionModel remainingModel = mPositionList.get(i);
+			mPositionIdToIndexMap.put(remainingModel.getPositionId(), i);
+		}
+
+// 3. 清理全局任务列表和映射表（不变）
+		Iterator taskIterator = mAllPositionTasks.iterator();
+		while (taskIterator.hasNext()) {
+			PositionTaskModel task = (PositionTaskModel)taskIterator.next();
+			if (task != null && removedPosId.equals(task.getPositionId())) {
+				taskIterator.remove();
+			}
+		}
+		mPositionTaskMap.remove(removedPosId);
+		mPositionList.remove(position);
+
+		notifyItemRemoved(position);
+		notifyItemRangeChanged(position, mPositionList.size());
+	}
+
+// 对外API：更新所有位置（补充索引映射同步）
+	public void updateAllPositions(ArrayList<PositionModel> newPositionList) {
+		if (newPositionList == null) return;
+		mPositionList.clear();
+		mPositionList.addAll(newPositionList);
+
+// 1. 清理距离缓存中无效的位置ID（不变）
+		Iterator distanceViewIter = mVisibleDistanceViews.keySet().iterator();
+		while (distanceViewIter.hasNext()) {
+			String posId = (String)distanceViewIter.next();
+			boolean isPosExist = false;
+			for (PositionModel model : newPositionList) {
+				if (posId.equals(model.getPositionId())) {
+					isPosExist = true;
+					break;
+				}
+			}
+			if (!isPosExist) {
+				distanceViewIter.remove();
+			}
+		}
+
+// 2. 清理任务映射表（不变）
+		Iterator taskMapKeyIter = mPositionTaskMap.keySet().iterator();
+		while (taskMapKeyIter.hasNext()) {
+			String posId = (String)taskMapKeyIter.next();
+			boolean isPosExist = false;
+			for (PositionModel model : newPositionList) {
+				if (posId.equals(model.getPositionId())) {
+					isPosExist = true;
+					break;
+				}
+			}
+			if (!isPosExist) {
+				taskMapKeyIter.remove();
+			}
+		}
+
+// 3. 重新初始化索引映射和任务列表（新增索引同步）
+		mPositionIdToIndexMap.clear();
+		for (int i = 0; i < newPositionList.size(); i++) {
+			PositionModel model = (PositionModel)newPositionList.get(i);
+			String posId = model.getPositionId();
+			mPositionIdToIndexMap.put(posId, i); // 同步新列表的索引
+			if (!mPositionTaskMap.containsKey(posId)) {
+				mPositionTaskMap.put(posId, new ArrayList());
+			}
+		}
+
+		notifyDataSetChanged();
+	}
+
+// 对外API：批量切换简单视图（不变）
+	public void switchAllToSimpleView() {
+		for (PositionModel model : mPositionList) {
+			model.setIsSimpleView(true);
+		}
+		notifyDataSetChanged();
+	}
+
+// 对外API：获取位置列表（不变）
+	public ArrayList getPositionList() {
+		return new ArrayList(mPositionList);
+	}
+
+// ---------------------- ViewHolder 定义（不变） ----------------------
+	public static class SimpleViewHolder extends RecyclerView.ViewHolder {
+		TextView tvSimpleLongitude;
+		TextView tvSimpleLatitude;
+		TextView tvSimpleMemo;
+		TextView tvSimpleRealDistance;
+		PositionTaskListView ptlvSimpleTasks;
+
+		public SimpleViewHolder(@NonNull View itemView) {
+			super(itemView);
+			tvSimpleLongitude = (TextView) itemView.findViewById(R.id.tv_simple_longitude);
+			tvSimpleLatitude = (TextView) itemView.findViewById(R.id.tv_simple_latitude);
+			tvSimpleMemo = (TextView) itemView.findViewById(R.id.tv_simple_memo);
+			tvSimpleRealDistance = (TextView) itemView.findViewById(R.id.tv_simple_real_distance);
+			ptlvSimpleTasks = (PositionTaskListView) itemView.findViewById(R.id.ptlv_simple_tasks);
+		}
+	}
+
+	public static class EditViewHolder extends RecyclerView.ViewHolder {
+		TextView tvEditLongitude;
+		TextView tvEditLatitude;
+		EditText etEditMemo;
+		RadioGroup rgRealDistanceSwitch;
+		RadioButton rbDisable;
+		RadioButton rbEnable;
+		Button btnEditDelete;
+		Button btnEditCancel;
+		Button btnEditConfirm;
+		PositionTaskListView ptlvEditTasks;
+		Button btnAddTask;
+		TextView tvEditRealDistance;
+
+		public EditViewHolder(@NonNull View itemView) {
+			super(itemView);
+			tvEditLongitude = (TextView) itemView.findViewById(R.id.tv_edit_longitude);
+			tvEditLatitude = (TextView) itemView.findViewById(R.id.tv_edit_latitude);
+			etEditMemo = (EditText) itemView.findViewById(R.id.et_edit_memo);
+			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);
+			btnEditDelete = (Button) itemView.findViewById(R.id.btn_edit_delete);
+			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);
+			btnAddTask = (Button) itemView.findViewById(R.id.btn_add_task);
+			tvEditRealDistance = (TextView) itemView.findViewById(R.id.tv_edit_real_distance);
+		}
+	}
+}
+

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

@@ -0,0 +1,209 @@
+package cc.winboll.studio.positions.models;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/09/29 18:57
+ * @Describe 位置数据模型
+ */
+import android.util.JsonReader;
+import android.util.JsonWriter;
+import cc.winboll.studio.libappbase.BaseBean;
+import java.io.IOException;
+import java.util.UUID;
+
+public class PositionModel extends BaseBean {
+
+    public static final String TAG = "PositionModel";
+	// 位置唯一标识符（与任务的positionId绑定）
+	String positionId;
+	// 经度（范围：-180~180）
+	double longitude;
+	// 纬度（范围：-90~90）
+	double latitude;
+	// 位置备注（空值时显示“无备注”）
+	String memo;
+	// 是否启用实时距离计算
+	boolean isEnableRealPositionDistance;
+	// 是否显示简单视图（true=简单视图，false=编辑视图）
+	boolean isSimpleView = true;
+
+	// 带参构造（强制初始化位置ID和经纬度）
+	public PositionModel(String positionId, double longitude, double latitude, String memo, boolean isEnableRealPositionDistance) {
+		this.positionId = (positionId == null || positionId.trim().isEmpty()) ? genPositionId() : positionId;
+		this.longitude = Math.max(-180, Math.min(180, longitude)); // 经度范围限制
+		this.latitude = Math.max(-90, Math.min(90, latitude)); // 纬度范围限制
+		this.memo = (memo == null || memo.trim().isEmpty()) ? "无备注" : memo;
+		this.isEnableRealPositionDistance = isEnableRealPositionDistance;
+	}
+
+	// 无参构造（默认值初始化，避免空指针）
+	public PositionModel() {
+		this.positionId = genPositionId();
+		this.longitude = 0.0;
+		this.latitude = 0.0;
+		this.memo = "无备注";
+		this.isEnableRealPositionDistance = false;
+	}
+
+	// ---------------------- Getter/Setter（确保字段有效性） ----------------------
+	public void setPositionId(String positionId) {
+		this.positionId = (positionId == null || positionId.trim().isEmpty()) ? genPositionId() : positionId;
+	}
+
+	public String getPositionId() {
+		return positionId;
+	}
+
+	public void setIsEnableRealPositionDistance(boolean isEnableRealPositionDistance) {
+		this.isEnableRealPositionDistance = isEnableRealPositionDistance;
+	}
+
+	public boolean isEnableRealPositionDistance() {
+		return isEnableRealPositionDistance;
+	}
+
+	public void setIsSimpleView(boolean isSimpleView) {
+		this.isSimpleView = isSimpleView;
+	}
+
+	public boolean isSimpleView() {
+		return isSimpleView;
+	}
+
+	public void setMemo(String memo) {
+		this.memo = (memo == null || memo.trim().isEmpty()) ? "无备注" : memo;
+	}
+
+	public String getMemo() {
+		return memo;
+	}
+
+	public void setLongitude(double longitude) {
+		this.longitude = Math.max(-180, Math.min(180, longitude)); // 限制经度范围
+	}
+
+	public double getLongitude() {
+		return longitude;
+	}
+
+	public void setLatitude(double latitude) {
+		this.latitude = Math.max(-90, Math.min(90, latitude)); // 限制纬度范围
+	}
+
+	public double getLatitude() {
+		return latitude;
+	}
+
+	// ---------------------- 父类方法重写 ----------------------
+	@Override
+	public String getName() {
+		return PositionModel.class.getName();
+	}
+
+	// 生成唯一位置ID（与任务ID格式一致，确保关联匹配）
+	public static String genPositionId() {
+        UUID uniqueUuid = UUID.randomUUID();
+        return uniqueUuid.toString(); // 36位标准UUID（含横杠，确保与任务ID格式统一）
+    }
+
+	// JSON序列化（保存位置数据）
+	@Override
+	public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
+		super.writeThisToJsonWriter(jsonWriter);
+		jsonWriter.name("positionId").value(getPositionId());
+		jsonWriter.name("longitude").value(getLongitude());
+		jsonWriter.name("latitude").value(getLatitude());
+		jsonWriter.name("memo").value(getMemo());
+		jsonWriter.name("isEnableRealPositionDistance").value(isEnableRealPositionDistance());
+	}
+
+	// JSON反序列化（加载位置数据，校验字段）
+	@Override
+	public boolean initObjectsFromJsonReader(JsonReader jsonReader, String name) throws IOException {
+		if (super.initObjectsFromJsonReader(jsonReader, name)) { 
+			return true; 
+		} else {
+			if (name.equals("positionId")) {
+				setPositionId(jsonReader.nextString());
+			} else if (name.equals("longitude")) {
+				setLongitude(jsonReader.nextDouble());
+			} else if (name.equals("latitude")) {
+				setLatitude(jsonReader.nextDouble());
+			} else if (name.equals("memo")) {
+				setMemo(jsonReader.nextString());
+			} else if (name.equals("isEnableRealPositionDistance")) {
+				setIsEnableRealPositionDistance(jsonReader.nextBoolean());
+			} else {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	// 从JSON读取位置数据
+	@Override
+	public BaseBean readBeanFromJsonReader(JsonReader jsonReader) throws IOException {
+		jsonReader.beginObject();
+		while (jsonReader.hasNext()) {
+			String name = jsonReader.nextName();
+			if (!initObjectsFromJsonReader(jsonReader, name)) {
+				jsonReader.skipValue(); // 跳过未知字段
+			}
+		}
+		jsonReader.endObject();
+		return this;
+	}
+
+	// ---------------------- 核心工具方法：计算两点距离（Haversine公式，确保精度） ----------------------
+	/**
+	 * 计算两个位置之间的直线距离（地球表面最短距离）
+	 * @param position1 第一个位置（非null）
+	 * @param position2 第二个位置（非null）
+	 * @param isKilometer 是否返回千米单位：true→千米，false→米
+	 * @return 距离（保留1位小数，符合显示需求）
+	 * @throws IllegalArgumentException 位置为null或经纬度无效时抛出
+	 */
+	public static double calculatePositionDistance(PositionModel position1, PositionModel position2, boolean isKilometer) {
+		// 1. 校验参数有效性（避免计算异常）
+		if (position1 == null || position2 == null) {
+			throw new IllegalArgumentException("位置对象不能为null");
+		}
+		double lon1 = position1.getLongitude();
+		double lat1 = position1.getLatitude();
+		double lon2 = position2.getLongitude();
+		double lat2 = position2.getLatitude();
+		// 经纬度范围二次校验（确保有效）
+		if (lat1 < -90 || lat1 > 90 || lat2 < -90 || lat2 > 90 
+			|| lon1 < -180 || lon1 > 180 || lon2 < -180 || lon2 > 180) {
+			throw new IllegalArgumentException("经纬度值无效（纬度：-90~90，经度：-180~180）");
+		}
+
+		// 2. Haversine公式计算（地球半径取6371km，行业标准）
+		final double EARTH_RADIUS_KM = 6371;
+		double radLat1 = Math.toRadians(lat1); // 角度转弧度
+		double radLat2 = Math.toRadians(lat2);
+		double radLon1 = Math.toRadians(lon1);
+		double radLon2 = Math.toRadians(lon2);
+
+		double deltaLat = radLat2 - radLat1; // 纬度差
+		double deltaLon = radLon2 - radLon1; // 经度差
+
+		// 核心公式
+		double a = Math.pow(Math.sin(deltaLat / 2), 2) 
+			+ Math.cos(radLat1) * Math.cos(radLat2) 
+			* Math.pow(Math.sin(deltaLon / 2), 2);
+		double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+		double distanceKm = EARTH_RADIUS_KM * c; // 距离（千米）
+
+		// 3. 单位转换+精度处理（保留1位小数，符合显示需求）
+		double distance;
+		if (isKilometer) {
+			distance = Math.round(distanceKm * 10.0) / 10.0; // 千米→1位小数
+		} else {
+			distance = Math.round(distanceKm * 1000 * 10.0) / 10.0; // 米→1位小数
+		}
+
+		return distance;
+	}
+}
+

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

@@ -0,0 +1,192 @@
+package cc.winboll.studio.positions.models;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/09/30 02:48
+ * @Describe 位置任务数据模型
+ */
+import android.util.JsonReader;
+import android.util.JsonWriter;
+import cc.winboll.studio.libappbase.BaseBean;
+import java.io.IOException;
+import java.util.UUID;
+
+public class PositionTaskModel extends BaseBean {
+    
+    public static final String TAG = "PositionTaskModel";
+    // 任务标识符（唯一）
+	String taskId;
+	// 绑定的位置标识符（与PositionModel的positionId一一对应）
+	String positionId;
+	// 任务描述
+	String taskDescription;
+	// 任务距离条件：是否大于设定距离
+	boolean isGreaterThan;
+	// 任务距离条件：是否小于设定距离（与isGreaterThan互斥）
+	boolean isLessThan;
+	// 任务条件距离（单位：米）
+	int discussDistance;
+	// 任务是否已触发
+	boolean isBingo = false;
+	// 是否启用任务
+	boolean isEnable;
+
+	// 带参构造（强制传入positionId，确保任务与位置绑定）
+	public PositionTaskModel(String taskId, String positionId, String taskDescription, boolean isGreaterThan, int discussDistance, boolean isEnable) {
+		this.taskId = (taskId == null || taskId.trim().isEmpty()) ? genTaskId() : taskId; // 空ID自动生成
+		this.positionId = positionId; // 强制绑定位置ID
+		this.taskDescription = (taskDescription == null || taskDescription.trim().isEmpty()) ? "新任务" : taskDescription;
+		this.isGreaterThan = isGreaterThan;
+		this.isLessThan = !isGreaterThan; // 确保互斥
+		this.discussDistance = Math.max(discussDistance, 1); // 距离最小1米，避免无效值
+		this.isEnable = isEnable;
+	}
+	
+	// 无参构造（初始化默认值，positionId需后续设置）
+	public PositionTaskModel() {
+		this.taskId = genTaskId();
+		this.positionId = "";
+		this.taskDescription = "新任务";
+		this.isGreaterThan = true;
+		this.isLessThan = false; // 初始互斥
+		this.discussDistance = 100; // 默认100米
+		this.isEnable = true;
+	}
+
+	public void setIsBingo(boolean isBingo) {
+		this.isBingo = isBingo;
+	}
+
+	public boolean isBingo() {
+		return isBingo;
+	}
+
+	// ---------------------- Getter/Setter（确保positionId不为空，距离有效） ----------------------
+	public void setTaskId(String taskId) {
+		this.taskId = (taskId == null || taskId.trim().isEmpty()) ? genTaskId() : taskId;
+	}
+
+	public String getTaskId() {
+		return taskId;
+	}
+
+	public void setPositionId(String positionId) {
+		this.positionId = (positionId == null || positionId.trim().isEmpty()) ? "" : positionId; // 空值防护
+	}
+
+	public String getPositionId() {
+		return positionId;
+	}
+
+	public void setTaskDescription(String taskDescription) {
+		this.taskDescription = (taskDescription == null || taskDescription.trim().isEmpty()) ? "新任务" : taskDescription;
+	}
+
+	public String getTaskDescription() {
+		return taskDescription;
+	}
+
+	// 修复：确保isGreaterThan和isLessThan互斥
+	public void setIsGreaterThan(boolean isGreaterThan) {
+		this.isGreaterThan = isGreaterThan;
+		this.isLessThan = !isGreaterThan; // 关键：小于 = 非大于
+	}
+
+	public boolean isGreaterThan() {
+		return isGreaterThan;
+	}
+
+	// 修复：确保isLessThan和isGreaterThan互斥
+	public void setIsLessThan(boolean isLessThan) {
+		this.isLessThan = isLessThan;
+		this.isGreaterThan = !isLessThan; // 关键：大于 = 非小于
+	}
+
+	public boolean isLessThan() {
+		return isLessThan;
+	}
+
+	public void setDiscussDistance(int discussDistance) {
+		this.discussDistance = Math.max(discussDistance, 1); // 距离最小1米，避免0或负数
+	}
+
+	public int getDiscussDistance() {
+		return discussDistance;
+	}
+
+	public void setIsEnable(boolean isEnable) {
+		this.isEnable = isEnable;
+	}
+
+	public boolean isEnable() {
+		return isEnable;
+	}
+
+	// ---------------------- 父类方法重写 ----------------------
+	@Override
+	public String getName() {
+		return PositionTaskModel.class.getName();
+	}
+	
+	// 生成唯一任务ID（与PositionModel保持一致格式）
+	public static String genTaskId() {
+        UUID uniqueUuid = UUID.randomUUID();
+        return uniqueUuid.toString(); // 36位标准UUID（含横杠，确保唯一）
+    }
+
+	// JSON序列化（保存任务数据，包含所有字段）
+	@Override
+	public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
+		super.writeThisToJsonWriter(jsonWriter);
+		jsonWriter.name("taskId").value(getTaskId());
+		jsonWriter.name("positionId").value(getPositionId());
+		jsonWriter.name("taskDescription").value(getTaskDescription());
+		jsonWriter.name("isGreaterThan").value(isGreaterThan());
+		jsonWriter.name("isLessThan").value(isLessThan());
+		jsonWriter.name("discussDistance").value(getDiscussDistance());
+		jsonWriter.name("isEnable").value(isEnable());
+	}
+
+	// JSON反序列化（加载任务数据，校验字段有效性）
+	@Override
+	public boolean initObjectsFromJsonReader(JsonReader jsonReader, String name) throws IOException {
+		if (super.initObjectsFromJsonReader(jsonReader, name)) { 
+			return true; 
+		} else {
+			if (name.equals("taskId")) {
+				setTaskId(jsonReader.nextString());
+			} else if (name.equals("positionId")) {
+				setPositionId(jsonReader.nextString());
+			} else if (name.equals("taskDescription")) {
+				setTaskDescription(jsonReader.nextString());
+			} else if (name.equals("isGreaterThan")) {
+				setIsGreaterThan(jsonReader.nextBoolean());
+			} else if (name.equals("isLessThan")) {
+				setIsLessThan(jsonReader.nextBoolean());
+			} else if (name.equals("discussDistance")) {
+				setDiscussDistance(jsonReader.nextInt());
+			} else if (name.equals("isEnable")) {
+				setIsEnable(jsonReader.nextBoolean());
+			} else {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	// 从JSON读取任务数据（确保反序列化完整）
+	@Override
+	public BaseBean readBeanFromJsonReader(JsonReader jsonReader) throws IOException {
+		jsonReader.beginObject();
+		while (jsonReader.hasNext()) {
+			String name = jsonReader.nextName();
+			if (!initObjectsFromJsonReader(jsonReader, name)) {
+				jsonReader.skipValue(); // 跳过未知字段，避免崩溃
+			}
+		}
+		jsonReader.endObject();
+		return this;
+	}
+    
+}
+

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

@@ -0,0 +1,130 @@
+package cc.winboll.studio.positions.utils;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/09/30 16:09
+ * @Describe NotificationUtils
+ */
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import androidx.core.app.NotificationCompat;
+import cc.winboll.studio.positions.R;
+import cc.winboll.studio.positions.activities.LocationActivity; // 替换为你实际的LocationActivity路径
+
+/**
+ * 通知栏工具类：专注于任务相关通知的显示与点击跳转
+ * 核心功能：显示任务描述通知，点击后携带positionId/taskId跳转到LocationActivity
+ */
+public class NotificationUtils {
+	public static final String TAG = "NotificationUtils";
+	// 1. 通知渠道ID（适配Android O及以上，必须唯一）
+	private static final String TASK_NOTIFICATION_CHANNEL_ID = "task_notification_channel_01";
+	// 2. 通知渠道名称（用户在系统设置中看到的名称）
+	private static final String TASK_NOTIFICATION_CHANNEL_NAME = "任务通知";
+	// 3. 通知ID（确保每次显示通知的ID唯一，这里用taskId哈希值避免重复）
+	private static int getNotificationId(String taskId) {
+		// 用taskId生成唯一ID（避免不同任务通知相互覆盖）
+		return taskId.hashCode() & 0xFFFFFF; // 限制ID在0-16777215范围内（系统推荐）
+	}
+
+	/**
+	 * 显示任务通知
+	 * @param context 上下文（如Activity/Fragment，确保非空）
+	 * @param taskId 任务ID（用于跳转传递+生成唯一通知ID）
+	 * @param positionId 位置ID（用于跳转传递给LocationActivity）
+	 * @param taskDescription 通知显示内容（仅展示该文本给用户）
+	 */
+	public static void show(Context context, String taskId, String positionId, String taskDescription) {
+		// 安全校验：避免空指针（上下文/必要参数为空时不执行）
+		if (context == null || taskId == null || positionId == null) {
+			return;
+		}
+
+		// 步骤1：初始化通知管理器（系统服务，负责发送/取消通知）
+		NotificationManager notificationManager = 
+			(NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+		if (notificationManager == null) {
+			return;
+		}
+
+		// 步骤2：创建通知渠道（Android O及以上必须，否则通知不显示）
+		createNotificationChannel(notificationManager);
+
+		// 步骤3：构建“点击通知跳转”的Intent（携带positionId和taskId）
+		Intent jumpIntent = new Intent(context, LocationActivity.class);
+		// 传递参数：用Intent的Extra携带ID（键名建议定义为常量，避免拼写错误）
+		jumpIntent.putExtra("EXTRA_POSITION_ID", positionId);
+		jumpIntent.putExtra("EXTRA_TASK_ID", taskId);
+		// 配置Intent：清除栈内旧Activity，确保跳转后是最新页面（根据需求调整）
+		jumpIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
+
+		// 步骤4：创建PendingIntent（授权系统在用户点击通知时执行jumpIntent）
+		// 注意：PendingIntent.FLAG_UPDATE_CURRENT 确保参数更新时覆盖旧Intent
+		PendingIntent pendingIntent = PendingIntent.getActivity(
+			context,
+			getNotificationId(taskId), // 请求码：与通知ID一致，确保唯一
+			jumpIntent,
+			Build.VERSION.SDK_INT >= Build.VERSION_CODES.M ? 
+			PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT : 
+			PendingIntent.FLAG_UPDATE_CURRENT
+		);
+
+		// 步骤5：构建通知内容（仅显示taskDescription，样式简洁）
+		Notification notification = new NotificationCompat.Builder(context, TASK_NOTIFICATION_CHANNEL_ID)
+			.setSmallIcon(R.mipmap.ic_launcher) // 通知小图标（必须设置，建议用应用图标）
+			.setContentTitle("任务提醒") // 通知标题（固定，用户快速识别通知类型）
+			.setContentText(taskDescription) // 通知内容（仅显示传入的任务描述）
+			.setContentIntent(pendingIntent) // 绑定点击跳转事件
+			.setAutoCancel(true) // 点击通知后自动消失（符合用户习惯）
+			.setPriority(NotificationCompat.PRIORITY_DEFAULT) // 通知优先级（默认，不抢占焦点）
+			.setDefaults(NotificationCompat.DEFAULT_SOUND) // 默认提示音（可选，根据需求关闭）
+			.build();
+
+		// 步骤6：发送通知（用唯一ID确保不同任务通知不覆盖）
+		notificationManager.notify(getNotificationId(taskId), notification);
+	}
+
+	/**
+	 * 创建通知渠道（Android O/API 26及以上必须）
+	 * 作用：用户可在系统设置中管理该渠道的通知（如关闭声音/屏蔽）
+	 */
+	private static void createNotificationChannel(NotificationManager notificationManager) {
+		// 仅在Android O及以上执行（低版本不需要渠道）
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+			// 配置渠道：重要性为“默认”（不弹窗，仅通知栏显示+提示音）
+			NotificationChannel channel = new NotificationChannel(
+				TASK_NOTIFICATION_CHANNEL_ID,
+				TASK_NOTIFICATION_CHANNEL_NAME,
+				NotificationManager.IMPORTANCE_DEFAULT
+			);
+			// 可选：配置渠道其他属性（根据需求调整）
+			channel.setDescription("接收任务相关提醒，点击可查看任务详情"); // 渠道描述（系统设置中显示）
+			channel.enableVibration(true); // 是否震动（默认开启，可关闭）
+			channel.setVibrationPattern(new long[]{0, 300}); // 震动模式（0延迟，震动300ms）
+
+			// 注册渠道到系统（仅需注册一次，重复注册会覆盖旧配置）
+			notificationManager.createNotificationChannel(channel);
+		}
+	}
+
+	/**
+	 * （可选）取消指定任务的通知
+	 * 场景：任务完成后关闭已显示的通知（如bingo状态取消后）
+	 */
+	public static void cancel(Context context, String taskId) {
+		if (context == null || taskId == null) {
+			return;
+		}
+		NotificationManager notificationManager = 
+			(NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+		if (notificationManager != null) {
+			notificationManager.cancel(getNotificationId(taskId));
+		}
+	}
+}
+

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

@@ -0,0 +1,416 @@
+package cc.winboll.studio.positions.views;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/09/30 08:09
+ * @Describe 位置任务列表视图（支持简单/编辑模式，含 isBingo 红点标识）
+ */
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.CompoundButton;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.RadioButton;
+import android.widget.RadioGroup;
+import android.widget.TextView;
+import android.widget.Toast;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+import cc.winboll.studio.positions.R;
+import cc.winboll.studio.positions.models.PositionTaskModel;
+import java.util.ArrayList;
+import java.util.List;
+
+public class PositionTaskListView extends LinearLayout {
+    // 视图模式常量
+    public static final int VIEW_MODE_SIMPLE = 1;
+    public static final int VIEW_MODE_EDIT = 2;
+
+    // 核心成员变量
+    private String mBindPositionId;
+    private ArrayList<PositionTaskModel> mTaskList;
+    private int mCurrentViewMode;
+    private TaskListAdapter mTaskAdapter;
+    private RecyclerView mRvTasks;
+
+    // 任务修改回调接口
+    public interface OnTaskUpdatedListener {
+        void onTaskUpdated(String positionId, ArrayList<PositionTaskModel> updatedTasks);
+    }
+
+    private OnTaskUpdatedListener mOnTaskUpdatedListener;
+
+    // ---------------------- 构造函数 ----------------------
+    public PositionTaskListView(Context context) {
+        super(context);
+        initView(context);
+    }
+
+    public PositionTaskListView(Context context, @Nullable AttributeSet attrs) {
+        super(context, attrs);
+        initView(context);
+    }
+
+    public PositionTaskListView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        initView(context);
+    }
+
+    // 初始化视图（绑定控件+设置布局）
+    private void initView(Context context) {
+        setOrientation(VERTICAL);
+        LayoutInflater.from(context).inflate(R.layout.view_position_task_list, this, true);
+
+        mRvTasks = (RecyclerView) findViewById(R.id.rv_position_tasks);
+        mRvTasks.setLayoutManager(new LinearLayoutManager(context));
+
+        mTaskList = new ArrayList<PositionTaskModel>();
+        mTaskAdapter = new TaskListAdapter(mTaskList);
+        mRvTasks.setAdapter(mTaskAdapter);
+
+        mCurrentViewMode = VIEW_MODE_SIMPLE;
+    }
+
+    // ---------------------- 对外API ----------------------
+    public void init(ArrayList<PositionTaskModel> taskList, String positionId) {
+        this.mBindPositionId = positionId;
+        if (this.mTaskList.isEmpty()) {
+            ArrayList<PositionTaskModel> matchedTasks = new ArrayList<PositionTaskModel>();
+            if (taskList != null && !taskList.isEmpty()) {
+                for (PositionTaskModel task : taskList) {
+                    if (task != null && positionId.equals(task.getPositionId())) {
+                        matchedTasks.add(task);
+                    }
+                }
+            }
+            mTaskList.clear();
+            mTaskList.addAll(matchedTasks);
+        }
+        mTaskAdapter.notifyDataSetChanged();
+    }
+
+    public void setViewStatus(int viewMode) {
+        if (viewMode != VIEW_MODE_SIMPLE && viewMode != VIEW_MODE_EDIT) {
+            return;
+        }
+        mCurrentViewMode = viewMode;
+        mTaskAdapter.notifyDataSetChanged();
+    }
+
+    public void setOnTaskUpdatedListener(OnTaskUpdatedListener listener) {
+        this.mOnTaskUpdatedListener = listener;
+    }
+
+    public ArrayList<PositionTaskModel> getAllTasks() {
+        return new ArrayList<PositionTaskModel>(mTaskList);
+    }
+
+    public void clearData() {
+        mTaskList.clear();
+        if (mTaskAdapter != null && mTaskAdapter.mData != null) {
+            mTaskAdapter.mData.clear();
+        }
+        mTaskAdapter.notifyDataSetChanged();
+        mBindPositionId = null;
+    }
+
+    public void triggerTaskSync() {
+        if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
+            mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<PositionTaskModel>(mTaskList));
+        }
+    }
+
+    // ---------------------- 内部工具方法 ----------------------
+    private boolean isTaskMatchedWithPosition(PositionTaskModel task) {
+        if (task == null || mBindPositionId == null || mBindPositionId.trim().isEmpty()) {
+            return false;
+        }
+        return mBindPositionId.equals(task.getPositionId());
+    }
+
+    // ---------------------- 内部Adapter：适配 isBingo 红点（核心调整） ----------------------
+    private class TaskListAdapter extends RecyclerView.Adapter<TaskListAdapter.TaskViewHolder> {
+        private final List<PositionTaskModel> mData;
+
+        public TaskListAdapter(List<PositionTaskModel> data) {
+            this.mData = data;
+        }
+
+        @Override
+        public int getItemCount() {
+            return mData.isEmpty() ? 1 : mData.size();
+        }
+
+        // 调整：根据“是否空列表”+“视图模式”区分视图类型（确保简单/编辑模式加载对应布局）
+        @Override
+        public int getItemViewType(int position) {
+            if (mData.isEmpty()) {
+                return 0; // 0=空提示
+            } else {
+                return mCurrentViewMode; // 1=简单模式，2=编辑模式（复用视图模式常量）
+            }
+        }
+
+        // 调整：按视图类型加载布局（简单模式加载带红点的布局，编辑模式加载原有布局）
+        @NonNull
+        @Override
+        public TaskViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+            Context context = parent.getContext();
+            LayoutInflater inflater = LayoutInflater.from(context);
+
+            if (viewType == 0) {
+                // 空提示布局
+                View emptyView = inflater.inflate(R.layout.item_task_empty, parent, false);
+                return new EmptyViewHolder(emptyView);
+            } else if (viewType == VIEW_MODE_SIMPLE) {
+                // 简单模式布局（带 isBingo 红点）
+                View simpleTaskView = inflater.inflate(R.layout.item_position_task_simple, parent, false);
+                return new SimpleTaskViewHolder(simpleTaskView);
+            } else {
+                // 编辑模式布局（原有布局不变）
+                View editTaskView = inflater.inflate(R.layout.item_task_content, parent, false);
+                return new TaskContentViewHolder(editTaskView);
+            }
+        }
+
+        // 调整：按视图类型绑定数据（简单模式绑定红点+文本，编辑模式绑定原有逻辑）
+        @Override
+        public void onBindViewHolder(@NonNull TaskViewHolder holder, int position) {
+            // 空提示处理（不变）
+            if (holder instanceof EmptyViewHolder) {
+                EmptyViewHolder emptyHolder = (EmptyViewHolder) holder;
+                TextView tvEmptyTip = (TextView) emptyHolder.itemView.findViewById(R.id.tv_task_empty_tip);
+                tvEmptyTip.setText(mCurrentViewMode == VIEW_MODE_EDIT ? "暂无任务，点击\"添加新任务\"创建" : "暂无启用的任务");
+                return;
+            }
+
+            // 任务项有效性校验（不变）
+            if (position >= mData.size()) {
+                return;
+            }
+            final PositionTaskModel task = mData.get(position);
+            if (task == null) {
+                return;
+            }
+
+            // 简单模式：绑定红点（isBingo）和文本数据
+            if (holder instanceof SimpleTaskViewHolder) {
+                SimpleTaskViewHolder simpleHolder = (SimpleTaskViewHolder) holder;
+                // 绑定任务描述
+                simpleHolder.tvSimpleTaskDesc.setText(String.format("任务：%s", task.getTaskDescription()));
+                // 绑定距离条件
+                String distanceCond = task.isGreaterThan() ? "大于" : "小于";
+                simpleHolder.tvSimpleDistanceCond.setText(String.format("条件：距离 %s %d 米", distanceCond, task.getDiscussDistance()));
+                // 绑定启用状态
+                simpleHolder.tvSimpleIsEnable.setText(task.isEnable() ? "状态：已启用" : "状态：已禁用");
+                // 核心：根据 isBingo 控制红点显示（true=显示，false=隐藏）
+                simpleHolder.vBingoDot.setVisibility(task.isBingo() ? View.VISIBLE : View.GONE);
+            }
+            // 编辑模式：沿用原有绑定逻辑（核心修复在此处）
+            else if (holder instanceof TaskContentViewHolder) {
+                TaskContentViewHolder contentHolder = (TaskContentViewHolder) holder;
+                bindTaskData(contentHolder, task, position);
+            }
+        }
+
+        // ---------------------- 核心修复：编辑模式绑定逻辑（解决布局中通知异常） ----------------------
+        private void bindTaskData(final TaskContentViewHolder holder, final PositionTaskModel task, final int position) {
+            String taskDesc = (task.getTaskDescription() == null) ? "未设置描述" : task.getTaskDescription();
+            holder.tvTaskDesc.setText(String.format("任务：%s", taskDesc));
+
+            String distanceCondition = task.isGreaterThan() ? "大于" : "小于";
+            holder.tvTaskDistance.setText(String.format("条件：%s %d 米", distanceCondition, task.getDiscussDistance()));
+
+            // 修复点1：先移除开关监听，再设置状态（避免设值时触发回调导致异常）
+            holder.cbTaskEnable.setOnCheckedChangeListener(null);
+            holder.cbTaskEnable.setChecked(task.isEnable());
+            holder.cbTaskEnable.setEnabled(mCurrentViewMode == VIEW_MODE_EDIT);
+
+            if (mCurrentViewMode == VIEW_MODE_EDIT) {
+                holder.btnEditTask.setVisibility(View.VISIBLE);
+                holder.btnDeleteTask.setVisibility(View.VISIBLE);
+
+                // 删除按钮逻辑（不变，本身在点击时执行，不涉及布局中通知）
+                holder.btnDeleteTask.setOnClickListener(new View.OnClickListener() {
+						@Override
+						public void onClick(View v) {
+							mData.remove(position);
+							notifyItemRemoved(position);
+							notifyItemRangeChanged(position, mData.size());
+							if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
+								mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<PositionTaskModel>(mData));
+							}
+							Toast.makeText(getContext(), "任务已删除", Toast.LENGTH_SHORT).show();
+						}
+					});
+
+                // 编辑按钮逻辑（不变，弹窗保存时修复通知时机）
+                holder.btnEditTask.setOnClickListener(new View.OnClickListener() {
+						@Override
+						public void onClick(View v) {
+							showTaskEditDialog(task, position);
+						}
+					});
+
+                // 修复点2：开关监听-用 RecyclerView.post 延迟执行 notify（避免布局中调用）
+                holder.cbTaskEnable.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
+						@Override
+						public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+							task.setIsEnable(isChecked); // 先更新数据源（必须执行）
+							// 关键：通过 mRvTasks.post 延迟通知，确保在布局计算/滚动结束后执行
+							mRvTasks.post(new Runnable() {
+									@Override
+									public void run() {
+										notifyItemChanged(position);
+										if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
+											mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<PositionTaskModel>(mData));
+										}
+									}
+								});
+						}
+					});
+            } else {
+                holder.btnEditTask.setVisibility(View.GONE);
+                holder.btnDeleteTask.setVisibility(View.GONE);
+                holder.cbTaskEnable.setOnCheckedChangeListener(null);
+            }
+        }
+
+        // ---------------------- 修复：编辑弹窗保存逻辑（延迟通知，避免极端场景异常） ----------------------
+        private void showTaskEditDialog(final PositionTaskModel task, final int position) {
+            final Context context = getContext();
+            View dialogView = LayoutInflater.from(context).inflate(R.layout.dialog_edit_task, null);
+
+            final EditText etEditDesc = (EditText) dialogView.findViewById(R.id.et_edit_task_desc);
+            final RadioGroup rgDistanceCondition = (RadioGroup) dialogView.findViewById(R.id.rg_distance_condition);
+            final EditText etEditDistance = (EditText) dialogView.findViewById(R.id.et_edit_distance);
+            Button btnCancel = (Button) dialogView.findViewById(R.id.btn_dialog_cancel);
+            Button btnSave = (Button) dialogView.findViewById(R.id.btn_dialog_save);
+
+            etEditDesc.setText(task.getTaskDescription());
+            etEditDesc.setSelection(etEditDesc.getText().length());
+
+            if (task.isGreaterThan()) {
+                rgDistanceCondition.check(R.id.rb_greater_than);
+            } else {
+                rgDistanceCondition.check(R.id.rb_less_than);
+            }
+
+            etEditDistance.setText(String.valueOf(task.getDiscussDistance()));
+
+            final android.app.AlertDialog dialog = new android.app.AlertDialog.Builder(context)
+				.setView(dialogView)
+				.create();
+            dialog.show();
+
+            btnCancel.setOnClickListener(new View.OnClickListener() {
+					@Override
+					public void onClick(View v) {
+						dialog.dismiss();
+					}
+				});
+
+            btnSave.setOnClickListener(new View.OnClickListener() {
+					@Override
+					public void onClick(View v) {
+						String newDesc = etEditDesc.getText().toString().trim();
+						String distanceStr = etEditDistance.getText().toString().trim();
+
+						if (distanceStr.isEmpty()) {
+							Toast.makeText(context, "请输入有效距离", Toast.LENGTH_SHORT).show();
+							return;
+						}
+
+						int newDistance;
+						try {
+							newDistance = Integer.parseInt(distanceStr);
+							if (newDistance < 1) {
+								Toast.makeText(context, "距离不能小于1米", Toast.LENGTH_SHORT).show();
+								return;
+							}
+						} catch (NumberFormatException e) {
+							Toast.makeText(context, "距离请输入数字", Toast.LENGTH_SHORT).show();
+							return;
+						}
+
+						task.setTaskDescription(newDesc);
+						task.setDiscussDistance(newDistance);
+						boolean isGreater = rgDistanceCondition.getCheckedRadioButtonId() == R.id.rb_greater_than;
+						task.setIsGreaterThan(isGreater);
+						task.setPositionId(mBindPositionId);
+
+						// 修复点3：弹窗保存后延迟通知（同开关逻辑，避免列表滚动时异常）
+						mRvTasks.post(new Runnable() {
+								@Override
+								public void run() {
+									notifyItemChanged(position);
+									if (mOnTaskUpdatedListener != null && mBindPositionId != null) {
+										mOnTaskUpdatedListener.onTaskUpdated(mBindPositionId, new ArrayList<PositionTaskModel>(mData));
+									}
+								}
+							});
+
+						dialog.dismiss();
+						Toast.makeText(context, "任务已更新", Toast.LENGTH_SHORT).show();
+					}
+				});
+        }
+
+        // ---------------------- ViewHolder 定义（完全不变） ----------------------
+        // 基础抽象 ViewHolder（不变）
+        public abstract class TaskViewHolder extends RecyclerView.ViewHolder {
+            public TaskViewHolder(@NonNull View itemView) {
+                super(itemView);
+            }
+        }
+
+        // 空提示 Holder（不变）
+        public class EmptyViewHolder extends TaskViewHolder {
+            public EmptyViewHolder(@NonNull View itemView) {
+                super(itemView);
+            }
+        }
+
+        // 新增：简单模式 Holder（绑定带红点的布局控件）
+        public class SimpleTaskViewHolder extends TaskViewHolder {
+            TextView tvSimpleTaskDesc;    // 任务描述
+            TextView tvSimpleDistanceCond;// 距离条件
+            TextView tvSimpleIsEnable;    // 启用状态
+            View vBingoDot;               // isBingo 红点控件
+
+            public SimpleTaskViewHolder(@NonNull View itemView) {
+                super(itemView);
+                // 绑定简单模式布局中的控件（与 item_task_simple.xml 完全对应）
+                tvSimpleTaskDesc = itemView.findViewById(R.id.tv_simple_task_desc);
+                tvSimpleDistanceCond = itemView.findViewById(R.id.tv_simple_distance_cond);
+                tvSimpleIsEnable = itemView.findViewById(R.id.tv_simple_is_enable);
+                vBingoDot = itemView.findViewById(R.id.v_bingo_dot);
+            }
+        }
+
+        // 编辑模式 Holder（原有逻辑，完全不变）
+        public class TaskContentViewHolder extends TaskViewHolder {
+            TextView tvTaskDesc;
+            TextView tvTaskDistance;
+            CompoundButton cbTaskEnable;
+            Button btnEditTask;
+            Button btnDeleteTask;
+
+            public TaskContentViewHolder(@NonNull View itemView) {
+                super(itemView);
+                tvTaskDesc = (TextView) itemView.findViewById(R.id.tv_task_desc);
+                tvTaskDistance = (TextView) itemView.findViewById(R.id.tv_task_distance);
+                cbTaskEnable = (CompoundButton) itemView.findViewById(R.id.cb_task_enable);
+                btnEditTask = (Button) itemView.findViewById(R.id.btn_edit_task);
+                btnDeleteTask = (Button) itemView.findViewById(R.id.btn_delete_task);
+            }
+        }
+    }
+}
+

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

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="oval">  <!-- 形状：圆形 -->
+    <solid android:color="#FF4444"/>  <!-- 填充色：亮红色（可调整色值） -->
+    <stroke
+        android:width="1dp"
+        android:color="#FFFFFF"/>
+</shape>

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

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+
+    <solid android:color="@color/white" />
+
+    <corners android:radius="4dp" />
+
+    <stroke
+        android:width="1dp"
+        android:color="@color/gray" />
+
+    <padding
+        android:left="8dp"
+        android:top="8dp"
+        android:right="8dp"
+        android:bottom="8dp" />
+
+</shape>
+

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

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- 按压状态（加深灰色） -->
+    <item android:state_pressed="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#666666"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+    <!-- 默认状态（浅灰色） -->
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#999999"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+</selector>
+

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

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- 按压状态（加深蓝色） -->
+    <item android:state_pressed="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#303F9F"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+    <!-- 默认状态（标准蓝色） -->
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#3F51B5"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+</selector>
+

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

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:state_pressed="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#D32F2F"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#F44336"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+</selector>
+

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

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 圆形按钮背景：默认青色，按压时深色 -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- 按钮按压状态（深色，增强交互反馈） -->
+    <item android:state_pressed="true">
+        <shape android:shape="oval"> <!-- oval=圆形 -->
+            <solid android:color="#0F9D58"/> <!-- 按压时颜色：深青色（接近Google绿，美观且醒目） -->
+            <stroke android:width="1dp" android:color="#0F9D58"/> <!-- 边框颜色与背景一致，避免白边 -->
+        </shape>
+    </item>
+
+    <!-- 按钮默认状态（青色） -->
+    <item>
+        <shape android:shape="oval">
+            <solid android:color="#14C38E"/> <!-- 默认颜色：亮青色（视觉舒适，符合悬浮按钮风格） -->
+            <stroke android:width="1dp" android:color="#14C38E"/>
+        </shape>
+    </item>
+
+</selector>

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

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:state_focused="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#FFFFFF"/>
+            <stroke android:width="1.5dp" android:color="#4A90E2"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#FFFFFF"/>
+            <stroke android:width="1dp" android:color="#DDDDDD"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+</selector>
+

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

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- res/drawable/item_bg_edit.xml -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- 状态1：按压时（编辑项被点击，反馈明确） -->
+    <item android:state_pressed="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#E0E6ED" /> <!-- 按压底色：比默认深一点的灰蓝色，反馈清晰 -->
+            <corners android:radius="8dp" />  <!-- 保持圆角统一 -->
+            <stroke
+                android:width="1.5dp"
+                android:color="#A0B4C8" />    <!-- 按压时边框加深，增强视觉焦点 -->
+        </shape>
+    </item>
+
+    <!-- 状态2：默认状态（未按压，区分简单视图） -->
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#EEEEEE" /> <!-- 默认底色：比简单视图深，明确编辑模式 -->
+            <corners android:radius="8dp" />  <!-- 与简单视图一致的圆角，UI不割裂 -->
+            <stroke
+                android:width="1.5dp"
+                android:color="#D0D8E0" />    <!-- 淡蓝色边框，暗示“可编辑” -->
+        </shape>
+    </item>
+</selector>
+

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

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- res/drawable/item_bg_simple.xml -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- 状态1：按压时的背景（深一点的灰色，明确反馈点击动作） -->
+    <item android:state_pressed="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#E8E8E8" /> <!-- 按压底色（比默认深一点） -->
+            <corners android:radius="8dp" />  <!-- 保持和默认状态一致的圆角 -->
+            <stroke
+                android:width="1dp"
+                android:color="#E0E0E0" />
+        </shape>
+    </item>
+
+    <!-- 状态2：默认状态（未按压时的背景，和基础版一致） -->
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#F5F5F5" /> <!-- 默认浅灰底色 -->
+            <corners android:radius="8dp" />  <!-- 8dp圆角 -->
+            <stroke
+                android:width="1dp"
+                android:color="#E0E0E0" />    <!-- 细灰边框 -->
+        </shape>
+    </item>
+</selector>
+

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

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:state_pressed="true">
+        <shape android:shape="rectangle">
+            <solid android:color="#F5F5F5"/>
+            <stroke android:width="1dp" android:color="#DDDDDD"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="#FFFFFF"/>
+            <stroke android:width="1dp" android:color="#DDDDDD"/>
+            <corners android:radius="4dp"/>
+        </shape>
+    </item>
+</selector>
+

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

@@ -1,34 +1,71 @@
 <?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
-    android:gravity="center_horizontal|center_vertical"
-    android:orientation="vertical"
     android:padding="20dp">
 
-    <!-- 标题 -->
+    <!-- 1. 经纬度显示区域（保持居中，上方） -->
-    <TextView
+    <LinearLayout
+        android:id="@+id/layout_location_info"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:text="实时位置信息"
+        android:layout_centerHorizontal="true"
-        android:textSize="22sp"
+        android:layout_marginTop="30dp"
-        android:textStyle="bold"/>
+        android:orientation="vertical"
+        android:gravity="center_horizontal">
 
-    <!-- 经度显示（大字体，清晰可见） -->
+        <!-- 标题 -->
-    <TextView
+        <TextView
-        android:id="@+id/tv_longitude"
+            android:layout_width="wrap_content"
-        android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
-        android:layout_height="wrap_content"
+            android:text="实时位置信息"
-        android:text="当前经度：等待更新..."
+            android:textSize="22sp"
-        android:textSize="18sp"/>
+            android:textStyle="bold"/>
 
-    <!-- 纬度显示（大字体，清晰可见） -->
+        <!-- 经度显示 -->
-    <TextView
+        <TextView
-        android:id="@+id/tv_latitude"
+            android:id="@+id/tv_longitude"
-        android:layout_width="wrap_content"
+            android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
+            android:layout_height="wrap_content"
-        android:text="当前纬度：等待更新..."
+            android:text="当前经度：等待更新..."
-        android:textSize="18sp"/>
+            android:textSize="18sp"
+            android:layout_marginTop="15dp"/>
 
-</LinearLayout>
+        <!-- 纬度显示 -->
+        <TextView
+            android:id="@+id/tv_latitude"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="当前纬度：等待更新..."
+            android:textSize="18sp"
+            android:layout_marginTop="10dp"/>
+
+    </LinearLayout>
+
+    <!-- 2. 新增：位置列表（RecyclerView）- 位于经纬度下方，悬浮按钮上方 -->
+    <androidx.recyclerview.widget.RecyclerView
+        android:id="@+id/rv_position_list"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:layout_below="@id/layout_location_info"
+        android:layout_above="@id/fab_p_button"
+        android:layout_marginTop="20dp"
+        android:paddingBottom="10dp"/>
+
+    <!-- 3. 右下角圆形悬浮按钮（不变） -->
+    <Button
+        android:id="@+id/fab_p_button"
+        android:layout_width="60dp"
+        android:layout_height="60dp"
+        android:layout_alignParentBottom="true"
+        android:layout_alignParentRight="true"
+        android:layout_margin="20dp"
+        android:background="@drawable/circle_button_bg"
+        android:text="P"
+        android:textColor="@android:color/white"
+        android:textSize="24sp"
+        android:elevation="6dp"
+        android:padding="0dp"/>
+
+</RelativeLayout>
 

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

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 编辑视图布局：垂直排列（经纬度显示+备注输入框），带内边距确保美观 -->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="16dp">
+
+    <!-- 1. 经度显示（灰色小字体，不可编辑） -->
+    <TextView
+        android:id="@+id/tv_edit_longitude"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#666666"
+        android:layout_marginBottom="8dp"/>
+
+    <!-- 2. 纬度显示（灰色小字体，不可编辑） -->
+    <TextView
+        android:id="@+id/tv_edit_latitude"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#666666"
+        android:layout_marginBottom="16dp"/>
+
+    <!-- 3. 备注输入框（可编辑，带提示文字，适配多行输入） -->
+    <EditText
+        android:id="@+id/et_edit_memo"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:hint="请输入位置备注（如：公司/家/学校）"
+        android:textSize="16sp"
+        android:inputType="textMultiLine"
+        android:minLines="3"
+        android:maxLines="5"
+        android:padding="10dp"
+        android:background="@drawable/edittext_bg"/> <!-- 输入框背景（带边框，区分普通文本） -->
+
+</LinearLayout>
+

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

@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="16dp"
+    android:background="@color/white">
+
+    <EditText
+        android:id="@+id/et_edit_task_desc"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:hint="输入任务描述"
+        android:maxLines="1"
+        android:textSize="14sp" />
+
+    <RadioGroup
+        android:id="@+id/rg_distance_condition"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:layout_marginTop="12dp">
+
+        <RadioButton
+            android:id="@+id/rb_greater_than"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="大于"
+            android:textColor="@color/black"
+            android:textSize="14sp" />
+
+        <RadioButton
+            android:id="@+id/rb_less_than"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="小于"
+            android:textColor="@color/black"
+            android:textSize="14sp"
+            android:layout_marginLeft="24dp" />
+
+    </RadioGroup>
+
+    <EditText
+        android:id="@+id/et_edit_distance"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:hint="输入距离（米）"
+        android:inputType="number"
+        android:maxLines="1"
+        android:textSize="14sp"
+        android:layout_marginTop="8dp" />
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="end"
+        android:layout_marginTop="16dp">
+
+        <Button
+            android:id="@+id/btn_dialog_cancel"
+            android:layout_width="wrap_content"
+            android:layout_height="40dp"
+            android:text="取消"
+            android:textColor="@color/black"
+            android:textSize="14sp"
+            android:layout_marginRight="8dp"
+            android:background="@color/gray" />
+
+        <Button
+            android:id="@+id/btn_dialog_save"
+            android:layout_width="wrap_content"
+            android:layout_height="40dp"
+            android:text="保存"
+            android:textSize="14sp"
+            android:background="@color/blue"
+            android:textColor="@color/white" />
+
+    </LinearLayout>
+
+</LinearLayout>
+

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

@@ -0,0 +1,170 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+	xmlns:android="http://schemas.android.com/apk/res/android"
+	android:layout_width="match_parent"
+	android:layout_height="wrap_content"
+	android:orientation="vertical"
+	android:padding="12dp"
+	android:background="@drawable/item_bg_edit">
+
+	<TextView
+		android:id="@+id/tv_edit_longitude"
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:textSize="14sp"
+		android:textColor="#999999"/>
+
+	<TextView
+		android:id="@+id/tv_edit_latitude"
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:textSize="14sp"
+		android:textColor="#999999"
+		android:layout_marginTop="4dp"/>
+
+	<EditText
+		android:id="@+id/et_edit_memo"
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:hint="请输入位置备注"
+		android:textSize="14sp"
+		android:padding="8dp"
+		android:layout_marginTop="8dp"
+		android:background="@drawable/edittext_bg"/>
+
+	<LinearLayout
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:orientation="vertical"
+		android:layout_marginTop="10dp">
+
+		<TextView
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:textSize="14sp"
+			android:textColor="#333333"
+			android:id="@+id/tv_edit_real_distance"/>
+
+		<RadioGroup
+			android:id="@+id/rg_real_distance_switch"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:orientation="horizontal"
+			android:layout_marginLeft="8dp">
+
+			<RadioButton
+				android:id="@+id/rb_disable"
+				android:layout_width="wrap_content"
+				android:layout_height="wrap_content"
+				android:text="禁用"
+				android:textSize="14sp"
+				android:checked="true"/>
+
+			<RadioButton
+				android:id="@+id/rb_enable"
+				android:layout_width="wrap_content"
+				android:layout_height="wrap_content"
+				android:text="启用"
+				android:textSize="14sp"
+				android:layout_marginLeft="15dp"/>
+
+		</RadioGroup>
+
+	</LinearLayout>
+
+	<LinearLayout
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:orientation="horizontal"
+		android:layout_marginTop="12dp">
+
+		<Button
+			android:id="@+id/btn_edit_delete"
+			android:layout_width="wrap_content"
+			android:layout_height="32dp"
+			android:background="@drawable/btn_delete_bg"
+			android:text="删除位置"
+			android:textColor="@android:color/white"
+			android:textSize="13sp"
+			android:paddingStart="15dp"
+			android:paddingEnd="15dp"/>
+
+		<View
+			android:layout_width="10dp"
+			android:layout_height="match_parent"/>
+
+		<Button
+			android:id="@+id/btn_edit_cancel"
+			android:layout_width="wrap_content"
+			android:layout_height="32dp"
+			android:background="@drawable/btn_cancel_bg"
+			android:text="取消"
+			android:textColor="@android:color/white"
+			android:textSize="13sp"
+			android:paddingStart="15dp"
+			android:paddingEnd="15dp"/>
+
+		<View
+			android:layout_width="10dp"
+			android:layout_height="match_parent"/>
+
+		<Button
+			android:id="@+id/btn_edit_confirm"
+			android:layout_width="wrap_content"
+			android:layout_height="32dp"
+			android:background="@drawable/btn_confirm_bg"
+			android:text="确定"
+			android:textColor="@android:color/white"
+			android:textSize="13sp"
+			android:paddingStart="15dp"
+			android:paddingEnd="15dp"/>
+
+	</LinearLayout>
+
+	<LinearLayout
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:orientation="vertical"
+		android:layout_marginTop="16dp">
+
+		<LinearLayout
+			android:layout_width="match_parent"
+			android:layout_height="30dp"
+			android:orientation="horizontal">
+
+			<TextView
+				android:layout_width="wrap_content"
+				android:layout_height="match_parent"
+				android:gravity="center_vertical"
+				android:text="关联任务（可编辑）："
+				android:textSize="14sp"
+				android:textColor="#333333"/>
+
+			<View
+				android:layout_width="0dp"
+				android:layout_height="match_parent"
+				android:layout_weight="1"/>
+
+			<Button
+				android:id="@+id/btn_add_task"
+				android:layout_width="wrap_content"
+				android:layout_height="match_parent"
+				android:background="@drawable/btn_confirm_bg"
+				android:text="添加新任务"
+				android:textColor="@android:color/white"
+				android:textSize="12sp"
+				android:paddingStart="12dp"
+				android:paddingEnd="12dp"/>
+
+		</LinearLayout>
+
+		<cc.winboll.studio.positions.views.PositionTaskListView
+			android:id="@+id/ptlv_edit_tasks"
+			android:layout_width="match_parent"
+			android:layout_height="wrap_content"
+			android:layout_marginTop="6dp"/>
+
+	</LinearLayout>
+
+</LinearLayout>
+

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

@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="12dp"
+    android:background="@drawable/item_bg_simple">
+    <TextView
+        android:id="@+id/tv_simple_longitude"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#333333"/>
+
+    <TextView
+        android:id="@+id/tv_simple_latitude"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#333333"
+        android:layout_marginTop="4dp"/>
+
+    <TextView
+        android:id="@+id/tv_simple_memo"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#666666"
+        android:layout_marginTop="4dp"/>
+
+    <TextView
+        android:id="@+id/tv_simple_real_distance"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#2E8B57"
+        android:layout_marginTop="6dp"/>
+
+    <TextView
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="关联任务（已启用）："
+        android:textSize="14sp"
+        android:textColor="#333333"
+        android:layout_marginTop="8dp"
+        android:layout_marginBottom="4dp"/>
+
+    <cc.winboll.studio.positions.views.PositionTaskListView
+        android:id="@+id/ptlv_simple_tasks"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="4dp"/>
+
+</LinearLayout>
+

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

@@ -0,0 +1,184 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="12dp"
+    android:background="@drawable/item_bg_edit"
+    android:layout_marginBottom="8dp">
+
+    <!-- 1. 不可编辑字段（仅显示，灰色文字） -->
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        android:layout_marginBottom="10dp">
+
+        <TextView
+            android:id="@+id/tv_edit_task_id"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:textSize="12sp"
+            android:textColor="#999999"
+            android:text="任务ID："/>
+
+        <TextView
+            android:id="@+id/tv_edit_position_id"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:textSize="12sp"
+            android:textColor="#999999"
+            android:layout_marginTop="2dp"
+            android:text="位置ID："/>
+    </LinearLayout>
+
+    <!-- 2. 任务描述（可编辑） -->
+    <EditText
+        android:id="@+id/et_edit_task_desc"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:hint="请输入任务描述（如：到达后提醒打卡）"
+        android:textSize="14sp"
+        android:padding="8dp"
+        android:background="@drawable/edittext_bg"
+        android:layout_marginBottom="10dp"/>
+
+    <!-- 3. 距离条件（单选组：大于/小于） -->
+    <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:layout_marginBottom="10dp">
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="距离条件："
+            android:textSize="14sp"
+            android:textColor="#333333"
+            android:layout_marginRight="10dp"/>
+
+        <RadioGroup
+            android:id="@+id/rg_edit_distance_cond"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal">
+
+            <RadioButton
+                android:id="@+id/rb_edit_greater"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="大于"
+                android:textSize="14sp"
+                android:layout_marginRight="15dp"/>
+
+            <RadioButton
+                android:id="@+id/rb_edit_less"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="小于"
+                android:textSize="14sp"/>
+        </RadioGroup>
+    </LinearLayout>
+
+    <!-- 4. 商议距离（可编辑，仅整数） -->
+    <EditText
+        android:id="@+id/et_edit_discuss_dist"
+        android:layout_width="120dp"
+        android:layout_height="wrap_content"
+        android:hint="请输入距离（米）"
+        android:textSize="14sp"
+        android:inputType="number"
+        android:padding="8dp"
+        android:background="@drawable/edittext_bg"
+        android:layout_marginBottom="10dp"/>
+
+    <!-- 5. 启用状态（单选组：是/否） -->
+    <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:layout_marginBottom="12dp">
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="启用任务："
+            android:textSize="14sp"
+            android:textColor="#333333"
+            android:layout_marginRight="10dp"/>
+
+        <RadioGroup
+            android:id="@+id/rg_edit_is_enable"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal">
+
+            <RadioButton
+                android:id="@+id/rb_edit_enable_yes"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="是"
+                android:textSize="14sp"
+                android:layout_marginRight="15dp"/>
+
+            <RadioButton
+                android:id="@+id/rb_edit_enable_no"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="否"
+                android:textSize="14sp"/>
+        </RadioGroup>
+    </LinearLayout>
+
+    <!-- 6. 功能按钮（删除-红 / 取消-灰 / 确定-蓝） -->
+    <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="center_vertical">
+
+        <Button
+            android:id="@+id/btn_edit_delete"
+            android:layout_width="wrap_content"
+            android:layout_height="32dp"
+            android:background="@drawable/btn_delete_bg"
+            android:text="删除"
+            android:textColor="@android:color/white"
+            android:textSize="13sp"
+            android:paddingStart="15dp"
+            android:paddingEnd="15dp"/>
+
+        <View
+            android:layout_width="10dp"
+            android:layout_height="match_parent"/>
+
+        <Button
+            android:id="@+id/btn_edit_cancel"
+            android:layout_width="wrap_content"
+            android:layout_height="32dp"
+            android:background="@drawable/btn_cancel_bg"
+            android:text="取消"
+            android:textColor="@android:color/white"
+            android:textSize="13sp"
+            android:paddingStart="15dp"
+            android:paddingEnd="15dp"/>
+
+        <View
+            android:layout_width="10dp"
+            android:layout_height="match_parent"/>
+
+        <Button
+            android:id="@+id/btn_edit_confirm"
+            android:layout_width="wrap_content"
+            android:layout_height="32dp"
+            android:background="@drawable/btn_confirm_bg"
+            android:text="确定"
+            android:textColor="@android:color/white"
+            android:textSize="13sp"
+            android:paddingStart="15dp"
+            android:paddingEnd="15dp"/>
+    </LinearLayout>
+
+</LinearLayout>
+

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

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 根布局改为 RelativeLayout，支持红点右上角定位（原 LinearLayout 无法便捷实现绝对位置） -->
+<RelativeLayout 
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="12dp"
+    android:background="@drawable/item_bg_simple"
+    android:layout_marginBottom="8dp">
+
+    <!-- 1. 右上角小红点（仅 isBingo=true 时显示，绑定 isBingo 属性） -->
+    <View
+        android:id="@+id/v_bingo_dot"
+        android:layout_width="12dp"
+        android:layout_height="12dp"
+        android:layout_alignParentRight="true"
+        android:layout_alignParentTop="true"
+        android:layout_marginRight="2dp"
+        android:layout_marginTop="2dp"
+        android:background="@drawable/bg_bingo_dot"
+        android:visibility="gone"/>  <!-- 默认隐藏，仅任务触发（isBingo=true）时显示 -->
+
+    <!-- 2. 任务描述（原控件不变，位置受红点不影响） -->
+    <TextView
+        android:id="@+id/tv_simple_task_desc"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="16sp"
+        android:textColor="#333333"
+        android:text="任务：无描述"/>
+
+    <!-- 3. 距离条件（原控件不变） -->
+    <TextView
+        android:id="@+id/tv_simple_distance_cond"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#666666"
+        android:layout_marginTop="6dp"
+        android:layout_below="@id/tv_simple_task_desc"
+        android:text="条件：距离 > 0 米"/>
+
+    <!-- 4. 启用状态（原控件不变） -->
+    <TextView
+        android:id="@+id/tv_simple_is_enable"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="14sp"
+        android:textColor="#2E8B57"
+        android:layout_marginTop="4dp"
+        android:layout_below="@id/tv_simple_distance_cond"
+        android:text="状态：已启用"/>
+
+</RelativeLayout>
+

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

@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="horizontal"
+    android:gravity="center_vertical"
+    android:padding="8dp"
+    android:background="@drawable/bg_task_item"
+    android:layout_marginVertical="4dp">
+
+    <CheckBox
+        android:id="@+id/cb_task_enable"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginRight="12dp" />
+
+    <LinearLayout
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:orientation="vertical">
+
+        <TextView
+            android:id="@+id/tv_task_desc"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="任务描述"
+            android:textSize="16sp"
+            android:textColor="@color/black" />
+
+        <TextView
+            android:id="@+id/tv_task_distance"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="条件：大于 100 米"
+            android:textSize="12sp"
+            android:textColor="@color/gray_dark"
+            android:layout_marginTop="2dp" />
+
+    </LinearLayout>
+
+    <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:layout_marginLeft="8dp">
+
+        <Button
+            android:id="@+id/btn_edit_task"
+            android:layout_width="wrap_content"
+            android:layout_height="30dp"
+            android:text="修改"
+            android:textSize="12sp"
+            android:layout_marginRight="4dp"
+            android:background="@color/blue"
+            android:textColor="@color/white" />
+
+        <Button
+            android:id="@+id/btn_delete_task"
+            android:layout_width="wrap_content"
+            android:layout_height="30dp"
+            android:text="删除"
+            android:textSize="12sp"
+            android:background="@color/red"
+            android:textColor="@color/white" />
+
+    </LinearLayout>
+
+</LinearLayout>
+

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

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="80dp"
+    android:gravity="center"
+    android:orientation="vertical"
+    android:background="@color/background_light">
+
+    <TextView
+        android:id="@+id/tv_task_empty_tip"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="暂无任务"
+        android:textColor="@color/gray"
+        android:textSize="14sp" />
+
+</LinearLayout>
+

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

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="8dp">
+
+    <androidx.recyclerview.widget.RecyclerView
+        android:id="@+id/rv_position_tasks"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:background="@color/white"
+        android:paddingVertical="4dp" />
+
+</LinearLayout>
+

positions/src/main/res/menu/menu_item_edit.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- 编辑菜单：点击后切换到编辑视图 -->
+    <item
+        android:id="@+id/menu_edit"
+        android:title="编辑"
+        android:orderInCategory="100"
+        android:showAsAction="never"/> <!-- 仅在菜单中显示，不显示在按钮栏 -->
+</menu>

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

@@ -3,4 +3,31 @@
     <color name="colorPrimary">#009688</color>
     <color name="colorPrimaryDark">#00796B</color>
     <color name="colorAccent">#FF9800</color>
+	<!-- 1. colorEnableGreen：简单视图“已启用”状态文字颜色（柔和绿色，不刺眼） -->
+    <color name="colorEnableGreen">#2E8B57</color> <!-- 海绿色：比纯绿柔和，适合文字提示 -->
+
+    <!-- 2. colorGrayText：编辑视图“不可编辑字段”文字颜色（浅灰色，暗示“不可修改”） -->
+    <color name="colorGrayText">#999999</color> <!-- 中浅灰：既不模糊，又能和可编辑文字区分开 -->
+
+    <!-- （可选补充）适配之前的背景资源颜色（避免后续新增资源报错，提前定义） -->
+    <color name="colorItemSimpleBg">#F5F5F5</color> <!-- item_bg_simple 底色 -->
+    <color name="colorItemEditBg">#EEEEEE</color>   <!-- item_bg_edit 底色 -->
+    <color name="colorItemBorder">#E0E0E0</color>   <!-- 列表项边框颜色 -->
+	<color name="colorRed">#F44336</color> <!-- 标准 Material 红色，可自定义RGB值 -->
+
+	<!-- 基础颜色：解决@color/gray未定义问题 -->
+	<color name="gray">#9E9E9E</color> <!-- 浅灰色（用于提示文本、次要信息） -->
+	<color name="gray_dark">#616161</color> <!-- 深灰色（备用，避免后续扩展缺失） -->
+
+	<!-- 其他已用颜色：确保布局中所有颜色引用都有定义 -->
+	<color name="white">#FFFFFF</color> <!-- 白色（任务列表背景、弹窗背景） -->
+	<color name="black">#000000</color> <!-- 黑色（任务描述文本） -->
+	<color name="blue">#2196F3</color> <!-- 蓝色（编辑/保存按钮背景） -->
+	<color name="red">#F44336</color> <!-- 红色（删除按钮背景） -->
+	<color name="background_light">#F5F5F5</color> <!-- 浅灰背景（备用，提升页面质感） -->
+
+	<!-- 扩展颜色（避免后续新增功能时再次缺失） -->
+	<color name="green">#4CAF50</color> <!-- 绿色（备用：如“启用”状态标识） -->
+	<color name="yellow">#FFC107</color> <!-- 黄色（备用：如“提醒”标识） -->
+
 </resources>