<positions>APK 15.0.17 release Publish.

positions/README.md

@@ -2,6 +2,7 @@
 
 #### 介绍
 安卓位置应用，有关于地理位置的相关应用。
+PS:使用感言~~~『記低用唔到』。
 
 #### 软件架构
 适配安卓应用 [AIDE Pro] 的 Gradle 编译结构。

positions/build.gradle

@@ -46,6 +46,9 @@ android {
 dependencies {
     api fileTree(dir: 'libs', include: ['*.jar'])
 	
+	// https://mvnrepository.com/artifact/com.jzxiang.pickerview/TimePickerDialog
+	api 'com.jzxiang.pickerview:TimePickerDialog:1.0.1'
+	
 	// 谷歌定位服务核心依赖（FusedLocationProviderClient所在库）
     api 'com.google.android.gms:play-services-location:21.0.1'
     
@@ -59,7 +62,7 @@ dependencies {
     // 应用介绍页类库
     api 'io.github.medyo:android-about-page:2.0.0'
     // 吐司类库
-    api 'com.github.getActivity:ToastUtils:10.5'
+    //api 'com.github.getActivity:ToastUtils:10.5'
     // 网络连接类库
     api 'com.squareup.okhttp3:okhttp:4.4.1'
     // AndroidX 类库
@@ -70,7 +73,7 @@ dependencies {
     //api 'androidx.vectordrawable:vectordrawable-animated:1.1.0'
     //api 'androidx.fragment:fragment:1.1.0'
     
-    api 'cc.winboll.studio:libaes:15.9.3'
-    api 'cc.winboll.studio:libapputils:15.8.5'
-    api 'cc.winboll.studio:libappbase:15.9.5'
+    api 'cc.winboll.studio:libaes:15.10.2'
+    api 'cc.winboll.studio:libapputils:15.10.2'
+    api 'cc.winboll.studio:libappbase:15.10.9'
 }

positions/build.properties

@@ -1,8 +1,8 @@
 #Created by .winboll/winboll_app_build.gradle
-#Mon Sep 29 18:46:38 HKT 2025
-stageCount=3
+#Tue Oct 28 20:03:59 HKT 2025
+stageCount=18
 libraryProject=
 baseVersion=15.0
-publishVersion=15.0.2
+publishVersion=15.0.17
 buildCount=0
-baseBetaVersion=15.0.3
+baseBetaVersion=15.0.18

positions/src/beta/res/values-zh/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">悟空笔记#</string>
+</resources>

positions/src/main/AndroidManifest.xml

@@ -2,20 +2,29 @@
 <manifest
     xmlns:android="http://schemas.android.com/apk/res/android"
     package="cc.winboll.studio.positions">
-	
-	<!-- 1. 定位必需权限声明 -->
-    <!-- 精确定位权限（GPS+网络定位，核心） -->
-    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
-    <!-- 粗略定位权限（仅安卓12+需要，兼容低版本可加） -->
-    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
-    <!-- 网络权限（可选，用于网络定位，提升室内定位精度） -->
-    <uses-permission android:name="android.permission.INTERNET" />
 
-    <!-- 2. 声明定位硬件支持（可选，告诉系统应用需要定位功能） -->
+	<!-- 1. 声明GPS权限 -->
+	<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+
+    <!-- 前台服务权限（可选，提升后台定位稳定性，避免服务被回收） -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+
+    <!-- 只能在前台获取精确的位置信息 -->
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
+
+    <!-- 只有在前台运行时才能获取大致位置信息 -->
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
+
+    <!-- 拥有完全的网络访问权限 -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+
+    <!-- 在后台使用位置信息 -->
+    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION"/>
+
     <uses-feature
         android:name="android.hardware.location.gps"
-        android:required="false" /> <!-- false=无GPS也能使用（网络定位） -->
-		
+        android:required="false"/>
+
     <application
         android:allowBackup="true"
         android:icon="@drawable/ic_launcher"
@@ -45,11 +54,27 @@
         <activity android:name=".GlobalApplication$CrashActivity"/>
 
         <activity android:name="cc.winboll.studio.positions.activities.LocationActivity"/>
-			
-		<!-- 4. 谷歌定位服务版本声明（避免版本兼容问题） -->
+
         <meta-data
             android:name="com.google.android.gms.version"
-            android:value="@integer/google_play_services_version" />
+            android:value="@integer/google_play_services_version"/>
+
+        <service android:name=".services.MainService"/>
+
+        <service android:name=".services.AssistantService"/>
+
+        <service android:name=".services.DistanceRefreshService"/>
+
+
+		<!-- 2. 注册运动状态Receiver -->
+		<receiver
+			android:name="cc.winboll.studio.positions.receivers.MotionStatusReceiver"
+			android:enabled="true"
+			android:exported="true">
+			<intent-filter>
+				<action android:name="cc.winboll.studio.positions.ACTION_MOTION_STATUS" />
+			</intent-filter>
+		</receiver>
     </application>
 
 </manifest>

positions/src/main/java/cc/winboll/studio/positions/App.java

@@ -22,9 +22,9 @@ import android.widget.HorizontalScrollView;
 import android.widget.ScrollView;
 import android.widget.TextView;
 import android.widget.Toast;
+import cc.winboll.studio.libaes.utils.WinBoLLActivityManager;
 import cc.winboll.studio.libappbase.GlobalApplication;
-import com.hjq.toast.ToastUtils;
-import com.hjq.toast.style.WhiteToastStyle;
+import cc.winboll.studio.libappbase.ToastUtils;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.Closeable;
@@ -45,17 +45,20 @@ import java.util.concurrent.atomic.AtomicBoolean;
 public class App extends GlobalApplication {
 
     private static Handler MAIN_HANDLER = new Handler(Looper.getMainLooper());
-
+	
     @Override
     public void onCreate() {
         super.onCreate();
-        
+		setIsDebuging(BuildConfig.DEBUG);
+		
+		WinBoLLActivityManager.init(this);
+		
         // 初始化 Toast 框架
         ToastUtils.init(this);
         // 设置 Toast 布局样式
         //ToastUtils.setView(R.layout.view_toast);
-        ToastUtils.setStyle(new WhiteToastStyle());
-        ToastUtils.setGravity(Gravity.BOTTOM, 0, 200);
+        //ToastUtils.setStyle(new WhiteToastStyle());
+        //ToastUtils.setGravity(Gravity.BOTTOM, 0, 200);
         
         //CrashHandler.getInstance().registerGlobal(this);
         //CrashHandler.getInstance().registerPart(this);

positions/src/main/java/cc/winboll/studio/positions/MainActivity.java

@@ -1,38 +1,260 @@
 package cc.winboll.studio.positions;
 
-import android.os.Bundle;
-import androidx.appcompat.app.AppCompatActivity;
-import androidx.appcompat.widget.Toolbar;
-import cc.winboll.studio.libappbase.LogView;
-import com.hjq.toast.ToastUtils;
-import android.view.View;
-import cc.winboll.studio.positions.activities.LocationActivity;
+import android.Manifest;
+import android.app.Activity;
 import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.Button;
+import android.widget.CompoundButton;
+import android.widget.Switch;
+import android.widget.Toast;
+import androidx.annotation.NonNull;
+import androidx.appcompat.widget.Toolbar;
+import androidx.core.content.ContextCompat;
+import cc.winboll.studio.libaes.interfaces.IWinBoLLActivity;
+import cc.winboll.studio.libaes.utils.WinBoLLActivityManager;
+import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.positions.activities.LocationActivity;
+import cc.winboll.studio.positions.activities.WinBoLLActivity;
+import cc.winboll.studio.positions.services.MainService;
+import cc.winboll.studio.positions.utils.AppConfigsUtil;
+import cc.winboll.studio.positions.utils.ServiceUtil;
 
-public class MainActivity extends AppCompatActivity {
+/**
+ * 主页面：仅负责
+ * 1. 位置服务启动/停止（通过 Switch 开关控制）
+ * 2. 跳转至“位置管理页（LocationActivity）”和“日志页（LogActivity）”
+ * 3. Java 7 语法适配：无 Lambda、显式接口实现、兼容低版本
+ */
+public class MainActivity extends WinBoLLActivity implements IWinBoLLActivity {
+    public static final String TAG = "MainActivity";
+    // 权限请求码（建议定义为类常量，避免魔法值）
+	private static final int REQUEST_LOCATION_PERMISSIONS = 1001;
+	private static final int REQUEST_BACKGROUND_LOCATION_PERMISSION = 1002;
+	
+    // UI 控件：服务控制开关、顶部工具栏
+    private Switch mServiceSwitch;
+	private Button mManagePositionsButton;
+    private Toolbar mToolbar;
+    // 服务相关：服务实例、绑定状态标记
+    //private DistanceRefreshService mDistanceService;
+    private boolean isServiceBound = false;
 
-    LogView mLogView;
 
+    @Override
+    public Activity getActivity() {
+        return this;
+    }
+
+    @Override
+    public String getTag() {
+        return TAG;
+    }
+
+    // ---------------------- 服务连接回调（仅用于获取服务状态，不依赖服务执行核心逻辑） ----------------------
+//    private final ServiceConnection mServiceConn = new ServiceConnection() {
+//        /**
+//         * 服务绑定成功：获取服务实例，同步开关状态（以服务实际状态为准）
+//         */
+//        @Override
+//        public void onServiceConnected(ComponentName name, IBinder service) {
+//            // Java 7 显式强转 Binder 实例（确保类型匹配，避免ClassCastException）
+//            DistanceRefreshService.DistanceBinder binder = (DistanceRefreshService.DistanceBinder) service;
+//            mDistanceService = binder.getService();
+//            isServiceBound = true;
+//        }
+//
+//        /**
+//         * 服务意外断开（如服务崩溃）：重置服务实例和绑定状态
+//         */
+//        @Override
+//        public void onServiceDisconnected(ComponentName name) {
+//            mDistanceService = null;
+//            isServiceBound = false;
+//        }
+//    };
+
+    // ---------------------- Activity 生命周期（核心：初始化UI、申请权限、绑定服务、释放资源） ----------------------
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        setContentView(R.layout.activity_main);
+        setContentView(R.layout.activity_main); // 关联主页面布局
 
-		Toolbar toolbar=(Toolbar)findViewById(R.id.toolbar);
-		setSupportActionBar(toolbar);
-
-        mLogView = findViewById(R.id.logview);
-        
-        ToastUtils.show("onCreate");
+        // 1. 初始化顶部 Toolbar（保留原逻辑，设置页面标题）
+        initToolbar();
+        // 2. 初始化其他控件
+        initViews();
+        // 3. 检查并申请位置权限（含后台GPS权限，确保服务启动前权限就绪）
+        if (!checkLocationPermissions()) {
+            requestLocationPermissions();
+        }
+        // 4. 绑定服务（仅用于获取服务实时状态，不影响服务独立运行）
+        //bindDistanceService();
     }
 
     @Override
-    protected void onResume() {
-        super.onResume();
-        mLogView.start();
+    protected void onDestroy() {
+        super.onDestroy();
+        // 页面销毁时解绑服务，避免Activity与服务相互引用导致内存泄漏
+//        if (isServiceBound) {
+//            unbindService(mServiceConn);
+//            isServiceBound = false;
+//            mDistanceService = null;
+//        }
     }
-	
-	public void onPositions(View view) {
-		startActivity(new Intent(this, LocationActivity.class));
+
+    // ---------------------- 核心功能1：初始化UI组件（Toolbar + 服务开关） ----------------------
+    /**
+     * 初始化顶部 Toolbar，设置页面标题
+     */
+    private void initToolbar() {
+        mToolbar = (Toolbar) findViewById(R.id.toolbar); // Java 7 显式 findViewById + 强转
+        setSupportActionBar(mToolbar);
+        // 给ActionBar设置标题（先判断非空，避免空指针异常）
+        if (getSupportActionBar() != null) {
+            getSupportActionBar().setTitle(getString(R.string.app_name));
+        }
+    }
+
+    /**
+     * 初始化服务控制开关：读取SP状态、绑定点击事件（含权限检查）
+     */
+    private void initViews() {
+        mServiceSwitch = (Switch) findViewById(R.id.switch_service_control); // 显式强转
+		mServiceSwitch.setChecked(AppConfigsUtil.getInstance(this).isEnableMainService(true));
+
+		mManagePositionsButton = (Button) findViewById(R.id.btn_manage_positions);
+		mManagePositionsButton.setEnabled(mServiceSwitch.isChecked());
+
+        // Java 7 用匿名内部类实现 CompoundButton.OnCheckedChangeListener
+        mServiceSwitch.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
+				@Override
+				public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+					// 开关打开前先检查权限：无权限则终止操作、重置开关、引导申请
+					if (isChecked && !checkLocationPermissions()) {
+						requestLocationPermissions();
+						return;
+					}
+
+					// 权限就绪：执行服务启停逻辑
+					if (isChecked) {
+						LogUtils.d(TAG, "设置启动服务");
+						ServiceUtil.startAutoService(MainActivity.this);
+					} else {
+						LogUtils.d(TAG, "设置关闭服务");
+
+						ServiceUtil.stopAutoService(MainActivity.this);
+					}
+
+					mManagePositionsButton.setEnabled(isChecked);
+				}
+			});
+    }
+
+
+    /**
+     * 绑定服务（仅用于获取服务状态，不启动服务）
+     */
+//    private void bindDistanceService() {
+//        Intent serviceIntent = new Intent(this, MainService.class);
+//        // BIND_AUTO_CREATE：服务未启动则创建（仅为获取状态，启停由开关控制）
+//        bindService(serviceIntent, mServiceConn, Context.BIND_AUTO_CREATE);
+//    }
+
+    // ---------------------- 核心功能3：页面跳转（位置管理页+日志页） ----------------------
+    /**
+     * 跳转至“位置管理页（LocationActivity）”（按钮点击触发，需在布局中设置 android:onClick="onPositions"）
+     * 服务未启动时提示，不允许跳转（避免LocationActivity无数据）
+     */
+    public void onPositions(View view) {
+		//ToastUtils.show("onPositions");
+        // 服务已启动：跳转到位置管理页
+        startActivity(new Intent(MainActivity.this, LocationActivity.class));
+    }
+
+    /**
+     * 跳转至“日志页（LogActivity）”（按钮点击触发，需在布局中设置 android:onClick="onLog"）
+     * 无服务状态限制，直接跳转
+     */
+    public void onLog(View view) {
+        WinBoLLActivityManager.getInstance().startLogActivity(this); // 调用LogActivity静态方法跳转（保留原逻辑）
+    }
+
+    // ---------------------- 新增：位置权限处理（适配Java7 + 后台GPS权限） ----------------------
+    /**
+     * 检查是否拥有「前台+后台」位置权限（适配Android版本差异）
+     * Java7 特性：显式类型判断、无Lambda、兼容低版本API
+     */
+    private boolean checkLocationPermissions() {
+        // 1. 检查前台精确定位权限（Android 6.0+ 必需，显式强转权限常量）
+        int foregroundPermResult = checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION);
+        boolean hasForegroundPerm = (foregroundPermResult == PackageManager.PERMISSION_GRANTED);
+
+        // 2. 检查后台定位权限（仅Android 10+ 需要，Java7 显式用Build.VERSION判断版本）
+        boolean hasBackgroundPerm = true;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            int backgroundPermResult = checkSelfPermission(android.Manifest.permission.ACCESS_BACKGROUND_LOCATION);
+            hasBackgroundPerm = (backgroundPermResult == PackageManager.PERMISSION_GRANTED);
+        }
+
+        // 前台+后台权限均满足，才返回true
+        return hasForegroundPerm && hasBackgroundPerm;
+    }
+
+	private void requestLocationPermissions() {
+		// 1. 先判断前台定位权限（ACCESS_FINE_LOCATION）是否已授予
+		if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
+            != PackageManager.PERMISSION_GRANTED) {
+			// 1.1 未授予前台权限：先申请前台权限（API 30+ 后台权限依赖前台权限）
+			String[] foregroundPermissions = new String[]{Manifest.permission.ACCESS_FINE_LOCATION};
+			// 对API 23+（Android 6.0）动态申请，低版本会直接授予（清单已声明前提下）
+			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+				requestPermissions(foregroundPermissions, REQUEST_LOCATION_PERMISSIONS);
+			}
+		} else {
+			// 2. 已授予前台权限：判断是否需要申请后台权限（仅API 29+需要）
+			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+				// 2.1 检查后台权限是否未授予
+				if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+                    != PackageManager.PERMISSION_GRANTED) {
+					// 2.2 API 30+ 必须单独申请后台权限（不能和前台权限一起弹框）
+					requestPermissions(
+                        new String[]{Manifest.permission.ACCESS_BACKGROUND_LOCATION},
+                        REQUEST_BACKGROUND_LOCATION_PERMISSION
+					);
+				}
+			}
+			// 3. 前台权限已授予（+ 后台权限按需授予）：此处可执行定位相关逻辑
+			// doLocationRelatedLogic(); 
+		}
 	}
+
+// 【必须补充】权限申请结果回调（处理用户同意/拒绝逻辑）
+	@Override
+	public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+		super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+		// 处理前台权限申请结果
+		if (requestCode == REQUEST_LOCATION_PERMISSIONS) {
+			if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+				// 前台权限同意：自动尝试申请后台权限（如果是API 29+）
+				requestLocationPermissions();
+			} else {
+				// 前台权限拒绝：提示用户（可选：引导跳转到应用设置页）
+				Toast.makeText(this, "需要前台定位权限才能使用该功能", Toast.LENGTH_SHORT).show();
+			}
+		} else if (requestCode == REQUEST_BACKGROUND_LOCATION_PERMISSION) {
+			if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+				// 后台权限同意：可执行后台定位逻辑
+				Toast.makeText(this, "已获得后台定位权限", Toast.LENGTH_SHORT).show();
+			} else {
+				// 后台权限拒绝：提示用户（可选：说明后台定位的用途，引导手动开启）
+				Toast.makeText(this, "拒绝后台权限将无法在后台持续定位", Toast.LENGTH_SHORT).show();
+			}
+		}
+	}
+
 }
+

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

@@ -1,219 +1,461 @@
 package cc.winboll.studio.positions.activities;
 
-
 /**
  * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
  * @Date 2025/09/29 18:22
- * @Describe 当前位置实时显示
+ * @Describe 位置列表页面（适配MainService GPS接口+规范服务交互+完善生命周期）
  */
-
-
-import android.Manifest;
-import android.content.pm.PackageManager;
-import android.location.Location;
+import android.app.Activity;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
 import android.os.Bundle;
+import android.os.IBinder;
+import android.view.View;
+import android.view.inputmethod.InputMethodManager;
 import android.widget.TextView;
 import android.widget.Toast;
-import androidx.annotation.NonNull;
-import androidx.appcompat.app.AppCompatActivity;
-import androidx.core.app.ActivityCompat;
-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 androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.libappbase.ToastUtils;
 import cc.winboll.studio.positions.R;
-
+import cc.winboll.studio.positions.adapters.PositionAdapter;
+import cc.winboll.studio.positions.models.PositionModel;
+import cc.winboll.studio.positions.services.MainService;
+import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
- * 实时定位活动窗口：
- * 1. 申请定位必需权限（精确定位+粗略定位）
- * 2. 初始化FusedLocationProviderClient（谷歌官方定位服务，兼容所有安卓版本）
- * 3. 实时监听位置变化，更新显示经度、纬度
+ * Java 7 语法适配：
+ * 1. 服务绑定用匿名内部类实现 ServiceConnection
+ * 2. Adapter 初始化传入 MainService 实例，确保数据来源唯一
+ * 3. 所有位置/任务操作通过 MainService 接口执行
  */
-public class LocationActivity extends AppCompatActivity {
+public class LocationActivity extends Activity {
+    public static final String TAG = "LocationActivity";
+
+    private RecyclerView mRvPosition;
+    private PositionAdapter mPositionAdapter;
+    
+    // MainService 引用+绑定状态（AtomicBoolean 确保多线程状态可见性）
+    private MainService mMainService;
+    private final AtomicBoolean isServiceBound = new AtomicBoolean(false);
+    // 标记 Adapter 是否已初始化（避免重复初始化/销毁后初始化）
+    private final AtomicBoolean isAdapterInited = new AtomicBoolean(false);
+
+	// ---------------------- 新增：GPS监听核心变量 ----------------------
+    private MainService.GpsUpdateListener mGpsUpdateListener; // GPS监听实例
+    private PositionModel mCurrentGpsPos; // 缓存当前GPS位置（供页面使用）
+    // 本地位置缓存（解决服务数据未同步时Adapter空数据问题）
+    private final ArrayList<PositionModel> mLocalPosCache = new ArrayList<PositionModel>();
+
+
+    // 服务连接（Java 7 匿名内部类实现，强化状态同步+数据预加载）
+    private ServiceConnection mServiceConnection = new ServiceConnection() {
+        @Override
+        public void onServiceConnected(ComponentName name, IBinder service) {
+            // 1. 安全获取服务实例（避免强转失败+服务未就绪）
+            if (!(service instanceof MainService.LocalBinder)) {
+                LogUtils.e(TAG, "服务绑定失败：Binder类型不匹配（非MainService.LocalBinder）");
+                isServiceBound.set(false);
+                return;
+            }
+
+            try {
+                MainService.LocalBinder binder = (MainService.LocalBinder) service;
+                mMainService = binder.getService();
+                // 2. 标记服务绑定成功（原子操作，确保多线程可见）
+                isServiceBound.set(true);
+                LogUtils.d(TAG, "MainService绑定成功，开始同步数据+初始化Adapter");
+
+                // 3. 同步服务数据到本地缓存（核心：先同步数据，再初始化Adapter）
+                syncDataFromMainService();
+                // 4. 注册GPS监听（确保监听在Adapter前初始化，数据不丢失）
+                registerGpsListener();
+                // 5. 初始化Adapter（传入本地缓存+服务实例，数据非空）
+                initPositionAdapter();
+
+            } catch (Exception e) {
+                LogUtils.d(TAG, "服务绑定后初始化失败：" + e.getMessage());
+                isServiceBound.set(false);
+                mMainService = null;
+                showToast("服务初始化失败，无法加载数据");
+            }
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName name) {
+            LogUtils.w(TAG, "MainService断开连接，清空引用+标记状态");
+            // 1. 清空服务引用+标记绑定状态
+            mMainService = null;
+            isServiceBound.set(false);
+            // 2. 标记Adapter未初始化（下次绑定需重新初始化）
+            isAdapterInited.set(false);
+        }
+    };
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_location);
+
+        // 1. 初始化视图（优先执行，避免Adapter初始化时视图为空）
+        initView();
+        // 2. 初始化GPS监听（提前创建，避免绑定服务后空指针）
+        initGpsUpdateListener();
+        // 3. 绑定MainService（最后执行，确保视图/监听已就绪）
+        bindMainService();
+    }
+
+    /**
+     * 初始化视图（RecyclerView）- 确保视图先于Adapter初始化
+     */
+    private void initView() {
+        mRvPosition = (RecyclerView) findViewById(R.id.rv_position_list);
+        // 1. 显式设置布局管理器（避免Adapter设置时无布局管理器崩溃）
+        LinearLayoutManager layoutManager = new LinearLayoutManager(this);
+        layoutManager.setOrientation(LinearLayoutManager.VERTICAL);
+        mRvPosition.setLayoutManager(layoutManager);
+        // 2. 初始化本地缓存（避免首次加载时缓存为空）
+        mLocalPosCache.clear();
+        LogUtils.d(TAG, "视图初始化完成（布局管理器+本地缓存已就绪）");
+    }
+
+    /**
+     * 绑定MainService（Java 7 显式Intent，强化绑定安全性）
+     */
+    private void bindMainService() {
+        // 1. 避免重复绑定（快速重建Activity时防止多绑定）
+        if (isServiceBound.get()) {
+            LogUtils.w(TAG, "无需重复绑定：MainService已绑定");
+            return;
+        }
+
+        Intent serviceIntent = new Intent(this, MainService.class);
+        // 2. 绑定服务（BIND_AUTO_CREATE：服务不存在时自动创建，增加绑定成功率）
+        boolean bindSuccess = bindService(serviceIntent, mServiceConnection, BIND_AUTO_CREATE);
+        if (!bindSuccess) {
+            LogUtils.e(TAG, "发起MainService绑定请求失败（服务未找到/系统限制）");
+            showToast("服务绑定失败，无法加载位置数据");
+        } else {
+            LogUtils.d(TAG, "MainService绑定请求已发起");
+        }
+    }
+
+    /**
+     * 从MainService同步数据到本地缓存（核心解决Adapter空数据问题）
+     * 作用：1. 服务数据优先同步到本地，Adapter基于本地缓存初始化
+     *      2. 避免服务数据更新时直接操作Adapter，通过缓存中转
+     */
+    private void syncDataFromMainService() {
+        // 1. 安全校验（服务未绑定/服务空，用本地缓存兜底）
+        if (!isServiceBound.get() || mMainService == null) {
+            LogUtils.w(TAG, "同步数据：服务未就绪，使用本地缓存（当前缓存量=" + mLocalPosCache.size() + "）");
+            return;
+        }
+
+        try {
+            // 2. 从服务获取最新位置数据（同步操作，确保数据拿到后再返回）
+            ArrayList<PositionModel> servicePosList = mMainService.getPositionList();
+            // 3. 同步到本地缓存（清空旧数据+添加新数据，避免重复）
+            synchronized (mLocalPosCache) { // 加锁避免多线程操作缓存冲突
+                mLocalPosCache.clear();
+                if (servicePosList != null && !servicePosList.isEmpty()) {
+                    mLocalPosCache.addAll(servicePosList);
+                }
+            }
+            LogUtils.d(TAG, "数据同步完成：服务位置数=" + (servicePosList == null ? 0 : servicePosList.size()) 
+                      + "，本地缓存数=" + mLocalPosCache.size());
+
+        } catch (Exception e) {
+            LogUtils.d(TAG, "同步服务数据失败：" + e.getMessage());
+            // 异常时保留本地缓存，避免Adapter无数据
+            LogUtils.w(TAG, "同步失败，使用本地缓存兜底（缓存量=" + mLocalPosCache.size() + "）");
+        }
+    }
+
+    /**
+     * 初始化PositionAdapter（核心优化：基于本地缓存初始化，避免空数据）
+     */
+    private void initPositionAdapter() {
+        // 1. 多重安全校验（避免销毁后初始化/重复初始化/依赖未就绪）
+        if (isAdapterInited.get() || !isServiceBound.get() || mMainService == null || mRvPosition == null) {
+            LogUtils.w(TAG, "Adapter初始化跳过：" 
+                      + "已初始化=" + isAdapterInited.get() 
+                      + "，服务绑定=" + isServiceBound.get() 
+                      + "，视图就绪=" + (mRvPosition != null));
+            return;
+        }
+
+        try {
+            // 2. 基于本地缓存初始化Adapter（缓存已同步服务数据，非空）
+            mPositionAdapter = new PositionAdapter(this, mLocalPosCache, mMainService);
+
+            // 3. 设置删除回调（删除时同步服务+本地缓存+Adapter）
+            mPositionAdapter.setOnDeleteClickListener(new PositionAdapter.OnDeleteClickListener() {
+                @Override
+                public void onDeleteClick(int position) {
+                    // 安全校验（索引有效+服务绑定+缓存非空）
+                    if (position < 0 || position >= mLocalPosCache.size() || !isServiceBound.get() || mMainService == null) {
+                        LogUtils.w(TAG, "删除位置失败：索引无效/服务未就绪（索引=" + position + "，缓存量=" + mLocalPosCache.size() + "）");
+                        return;
+                    }
+
+                    PositionModel deletePos = mLocalPosCache.get(position);
+                    if (deletePos != null && !deletePos.getPositionId().isEmpty()) {
+                        // 步骤1：调用服务删除（确保服务数据一致性）
+                        mMainService.removePosition(deletePos.getPositionId());
+                        // 步骤2：删除本地缓存（确保缓存与服务同步）
+                        synchronized (mLocalPosCache) {
+                            mLocalPosCache.remove(position);
+                        }
+                        // 步骤3：通知Adapter刷新（基于缓存操作，避免空数据）
+                        mPositionAdapter.notifyItemRemoved(position);
+                        showToast("删除位置成功：" + deletePos.getMemo());
+                        LogUtils.d(TAG, "删除位置完成：ID=" + deletePos.getPositionId() + "（服务+缓存已同步）");
+                    }
+                }
+            });
+
+            // 4. 设置保存回调（保存时同步服务+本地缓存+Adapter）
+            mPositionAdapter.setOnSavePositionClickListener(new PositionAdapter.OnSavePositionClickListener() {
+                @Override
+                public void onSavePositionClick(int position, PositionModel updatedPos) {
+                    // 安全校验（索引有效+服务绑定+数据非空）
+                    if (!isServiceBound.get() || mMainService == null 
+                        || position < 0 || position >= mLocalPosCache.size() || updatedPos == null) {
+                        LogUtils.w(TAG, "保存位置失败：服务未就绪/索引无效/数据空");
+                        showToast("服务未就绪，保存失败");
+                        return;
+                    }
+
+                    // 步骤1：调用服务更新（确保服务数据一致性）
+                    mMainService.updatePosition(updatedPos);
+                    // 步骤2：更新本地缓存（确保缓存与服务同步）
+                    synchronized (mLocalPosCache) {
+                        mLocalPosCache.set(position, updatedPos);
+                    }
+                    // 步骤3：通知Adapter刷新（基于缓存操作，避免空数据）
+                    mPositionAdapter.notifyItemChanged(position);
+                    showToast("保存位置成功：" + updatedPos.getMemo());
+                    LogUtils.d(TAG, "保存位置完成：ID=" + updatedPos.getPositionId() + "（服务+缓存已同步）");
+                }
+            });
+
+            // 5. 设置Adapter到RecyclerView（最后一步，确保Adapter已配置完成）
+            mRvPosition.setAdapter(mPositionAdapter);
+            // 6. 标记Adapter已初始化（避免重复初始化）
+            isAdapterInited.set(true);
+            LogUtils.d(TAG, "PositionAdapter初始化完成（基于本地缓存，数据量=" + mLocalPosCache.size() + "）");
+
+        } catch (Exception e) {
+            LogUtils.d(TAG, "Adapter初始化失败：" + e.getMessage());
+            isAdapterInited.set(false);
+            mPositionAdapter = null;
+            showToast("位置列表初始化失败，请重试");
+        }
+    }
+
+    /**
+     * 显示Toast（Java 7 显式Toast.makeText，避免空Context）
+     */
+    private void showToast(String content) {
+        if (isFinishing() || isDestroyed()) { // 避免Activity销毁后弹Toast崩溃
+            LogUtils.w(TAG, "Activity已销毁，跳过Toast：" + content);
+            return;
+        }
+        Toast.makeText(this, content, Toast.LENGTH_SHORT).show();
+    }
 	
-	public static final String TAG = "LocationActivity";
-	
-	// 1. 核心组件与常量定义
-	private static final int REQUEST_LOCATION_PERMISSIONS = 1004; // 定位权限请求码
-	private FusedLocationProviderClient fusedLocationClient; // 定位核心客户端
-	private LocationCallback locationCallback; // 位置变化监听器
-	private LocationRequest locationRequest; // 定位请求配置（频率、精度等）
+	// ---------------------- 页面交互（新增位置逻辑保留，适配GPS数据） ----------------------
+    /**
+     * 新增位置（调用服务addPosition()，可选：用当前GPS位置初始化新位置）
+     */
+    public void addNewPosition(View view) {
+        // 1. 隐藏软键盘（避免软键盘遮挡操作）
+        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+        if (imm != null && getCurrentFocus() != null) {
+            imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
+        }
 
-	// UI控件：用于显示经纬度（需在布局中定义对应ID）
-	private TextView tvLongitude; // 经度显示
-	private TextView tvLatitude;  // 纬度显示
+        // 2. 安全校验（服务未绑定，不允许新增）
+        if (!isServiceBound.get() || mMainService == null) {
+            LogUtils.w(TAG, "新增位置失败：MainService未绑定");
+            showToast("服务未就绪，无法新增位置");
+            return;
+        }
 
+        // 3. 创建新位置模型（优化：优先用当前GPS位置初始化，无则用默认值）
+        PositionModel newPos = new PositionModel();
+        newPos.setPositionId(PositionModel.genPositionId()); // 生成唯一ID（需PositionModel实现）
+        if (mCurrentGpsPos != null) {
+            newPos.setLongitude(mCurrentGpsPos.getLongitude());
+            newPos.setLatitude(mCurrentGpsPos.getLatitude());
+            newPos.setMemo("当前GPS位置（可编辑）");
+        } else {
+            newPos.setLongitude(116.404267); // 北京经度（默认值）
+            newPos.setLatitude(39.915119);  // 北京纬度（默认值）
+            newPos.setMemo("默认位置（可编辑备注）");
+        }
+        newPos.setIsSimpleView(true);   // 默认简单视图
+        newPos.setIsEnableRealPositionDistance(true); // 启用距离计算（依赖GPS）
 
-	@Override
-	protected void onCreate(Bundle savedInstanceState) {
-		super.onCreate(savedInstanceState);
-		// 2. 加载布局（需手动创建对应布局文件，见下方说明）
-		setContentView(R.layout.activity_location);
+        // 4. 调用服务新增+同步本地缓存（确保缓存与服务一致）
+        mMainService.addPosition(newPos);
+        synchronized (mLocalPosCache) {
+            mLocalPosCache.add(newPos);
+        }
+        LogUtils.d(TAG, "通过服务新增位置：ID=" + newPos.getPositionId() + "，纬度=" + newPos.getLatitude() + "（缓存已同步）");
 
-		// 3. 绑定UI控件（与布局文件中的TextView ID对应）
-		tvLongitude = findViewById(R.id.tv_longitude);
-		tvLatitude = findViewById(R.id.tv_latitude);
+        // 5. 刷新Adapter（基于缓存操作，确保数据立即显示）
+        if (isAdapterInited.get() && mPositionAdapter != null) {
+            mPositionAdapter.notifyItemInserted(mLocalPosCache.size() - 1);
+        }
+        showToast("新增位置成功（已启用GPS距离计算）");
+    }
 
-		// 4. 初始化定位相关组件
-		initLocationConfig();
-
-		// 5. 检查并申请定位权限（无权限则申请，有权限则直接启动定位）
-		if (checkLocationPermissions()) {
-			startRealTimeLocation(); // 权限已授予 → 启动实时定位
-		} else {
-			requestLocationPermissions(); // 权限未授予 → 申请权限
-		}
-	}
+	// ---------------------- 新增：GPS监听初始化+注册/反注册（核心适配逻辑） ----------------------
+    /**
+     * 初始化GPS监听：实现MainService.GpsUpdateListener，接收实时GPS数据
+     */
+    private void initGpsUpdateListener() {
+        LogUtils.d(TAG, "initGpsUpdateListener()");
+        mGpsUpdateListener = new MainService.GpsUpdateListener() {
+            @Override
+            public void onGpsPositionUpdated(PositionModel currentGpsPos) {
+                if (currentGpsPos == null || isFinishing() || isDestroyed()) {
+                    LogUtils.w(TAG, "GPS位置更新：数据为空或Activity已销毁");
+                    return;
+                }
+                // 缓存当前GPS位置（供页面其他逻辑使用）
+                mCurrentGpsPos = currentGpsPos;
+                LogUtils.d(TAG, String.format("收到GPS更新：纬度=%.4f，经度=%.4f"
+                                              , currentGpsPos.getLatitude(), currentGpsPos.getLongitude()));
+                // 安全更新UI（避免Activity销毁后操作视图崩溃）
+                ((TextView)findViewById(R.id.tv_latitude)).setText(String.format("当前纬度：%f", currentGpsPos.getLatitude()));
+                ((TextView)findViewById(R.id.tv_longitude)).setText(String.format("当前经度：%f", currentGpsPos.getLongitude()));
+            }
 
+            @Override
+            public void onGpsStatusChanged(String status) {
+                if (status == null || isFinishing() || isDestroyed()) return;
+                LogUtils.d(TAG, "GPS状态变化：" + status);
+                if (status.contains("未开启") || status.contains("权限") || status.contains("失败")) {
+                    ToastUtils.show("GPS提示：" + status);
+                }
+            }
+        };
+    }
 
 	/**
-	 * 初始化定位配置：设置定位精度、更新频率等
-	 */
-	private void initLocationConfig() {
-		// 初始化定位客户端（谷歌官方推荐，替代旧的LocationManager）
-		fusedLocationClient = LocationServices.getFusedLocationProviderClient(this);
+     * 注册GPS监听：调用MainService的PUBLIC方法，绑定监听
+     */
+    private void registerGpsListener() {
+        // 安全校验（避免Activity销毁/服务未绑定/监听为空时注册）
+        if (isFinishing() || isDestroyed() || !isServiceBound.get() || mMainService == null || mGpsUpdateListener == null) {
+            LogUtils.w(TAG, "GPS监听注册跳过：Activity状态异常/依赖未就绪");
+            return;
+        }
+        try {
+            mMainService.registerGpsUpdateListener(mGpsUpdateListener);
+            LogUtils.d(TAG, "GPS监听已注册");
+        } catch (Exception e) {
+            LogUtils.d(TAG, "GPS监听注册失败：" + e.getMessage());
+        }
+    }
 
-		// 配置定位请求：实时更新（1秒请求一次，最小间隔500毫秒，最高精度）
-		locationRequest = new LocationRequest.Builder(1000) // 定位更新间隔（毫秒）
-			.setMinUpdateIntervalMillis(500) // 最小更新间隔（避免频繁更新耗电）
-			.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY) // 高精度定位（优先GPS）
-			.build();
+    /**
+     * 反注册GPS监听：调用MainService的PUBLIC方法，解绑监听（核心防内存泄漏+数据异常）
+     */
+    private void unregisterGpsListener() {
+        // 避免Activity销毁后调用服务方法（防止空指针/服务已解绑）
+        if (mMainService == null || mGpsUpdateListener == null) {
+            LogUtils.w(TAG, "GPS监听反注册跳过：服务/监听未初始化");
+            return;
+        }
+        try {
+            mMainService.unregisterGpsUpdateListener(mGpsUpdateListener);
+            LogUtils.d(TAG, "GPS监听已反注册");
+        } catch (Exception e) {
+            LogUtils.d(TAG, "GPS监听反注册失败：" + e.getMessage());
+        }
+    }
 
-		// 初始化位置变化监听器：位置更新时触发（实时更新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();   // 纬度（北纬为正，南纬为负）
+    /**
+     * 页面可见时同步数据（解决快速切回时数据未更新问题）
+     * 场景：快速关闭再打开Activity，服务已绑定但数据未重新同步
+     */
+    @Override
+    protected void onResume() {
+        super.onResume();
+        // 1. 服务已绑定但Adapter未初始化：重新同步数据+初始化Adapter
+        if (isServiceBound.get() && mMainService != null && !isAdapterInited.get()) {
+            LogUtils.d(TAG, "onResume：服务已绑定但Adapter未初始化，重新同步数据");
+            syncDataFromMainService();
+            initPositionAdapter();
+        }
+        // 2. 服务已绑定且Adapter已初始化：刷新数据（确保与服务同步）
+        else if (isServiceBound.get() && mMainService != null && isAdapterInited.get() && mPositionAdapter != null) {
+            syncDataFromMainService();
+            mPositionAdapter.notifyDataSetChanged();
+            LogUtils.d(TAG, "onResume：刷新位置数据（与服务同步）");
+        }
+    }
 
-					// 更新TextView显示（保留6位小数，精度足够日常使用）
-					tvLongitude.setText(String.format("当前经度：%.6f", longitude));
-					tvLatitude.setText(String.format("当前纬度：%.6f", latitude));
-				}
-			}
-		};
-	}
+    /**
+     * 页面不可见时暂停操作（避免后台操作导致数据异常）
+     */
+    @Override
+    protected void onPause() {
+        super.onPause();
+        // 避免后台时仍执行UI刷新（如GPS更新触发的视图操作）
+        LogUtils.d(TAG, "onPause：页面不可见，暂停UI相关操作");
+    }
 
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        LogUtils.d(TAG, "onDestroy：开始释放资源");
 
-	/**
-	 * 检查定位必需权限是否已授予（精确定位+粗略定位，覆盖所有安卓版本）
-	 */
-	private boolean checkLocationPermissions() {
-		// 安卓12+（API31+）新增精确定位权限，需同时检查2个权限；低版本只需检查1个
-		/*if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
-			return ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
-				&& ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED;
-		} else {*/
-			return ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED;
-		//}
-	}
+        // 1. 反注册GPS监听（优先执行，避免服务持有Activity引用导致内存泄漏）
+        unregisterGpsListener();
 
+        // 2. 释放Adapter资源（反注册可能的监听，避免内存泄漏）
+        if (mPositionAdapter != null) {
+            mPositionAdapter.release();
+            mPositionAdapter = null; // 清空引用，帮助GC回收
+            LogUtils.d(TAG, "Adapter资源已释放");
+        }
 
-	/**
-	 * 申请定位必需权限（弹系统授权弹窗）
-	 */
-	private void requestLocationPermissions() {
-		/*if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
-			// 安卓12+：同时申请精确定位+粗略定位
-			ActivityCompat.requestPermissions(
-				this,
-				new String[]{Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION},
-				REQUEST_LOCATION_PERMISSIONS
-			);
-		} else {*/
-			// 安卓12以下：仅申请精确定位（包含粗略定位能力）
-			ActivityCompat.requestPermissions(
-				this,
-				new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
-				REQUEST_LOCATION_PERMISSIONS
-			);
-		//}
-	}
+        // 3. 解绑MainService（最后执行，确保其他资源已释放）
+        if (isServiceBound.get()) {
+            try {
+                unbindService(mServiceConnection);
+                LogUtils.d(TAG, "MainService解绑完成");
+            } catch (IllegalArgumentException e) {
+                // 捕获“服务未绑定”异常（快速开关时可能出现，避免崩溃）
+                LogUtils.d(TAG, "解绑MainService失败：服务未绑定（可能已提前解绑）");
+            }
+            // 重置绑定状态+服务引用
+            isServiceBound.set(false);
+            mMainService = null;
+        }
 
+        // 4. 清空本地缓存+GPS引用（帮助GC回收）
+        synchronized (mLocalPosCache) {
+            mLocalPosCache.clear();
+        }
+        mCurrentGpsPos = null;
+        mGpsUpdateListener = null;
+        isAdapterInited.set(false);
+        LogUtils.d(TAG, "所有资源释放完成（onDestroy执行结束）");
+    }
 
-	/**
-	 * 启动实时定位：注册位置监听器，开始接收位置更新
-	 */
-	private void startRealTimeLocation() {
-		// 权限兜底检查（避免异常）
-		if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
-			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) {
-						// 显示初始经纬度
-						tvLongitude.setText(String.format("当前经度：%.6f", location.getLongitude()));
-						tvLatitude.setText(String.format("当前纬度：%.6f", location.getLatitude()));
-					} else {
-						// 无历史位置（如首次启动），提示“等待定位更新”
-						tvLongitude.setText("当前经度：等待更新...");
-						tvLatitude.setText("当前纬度：等待更新...");
-					}
-				}
-			});
-
-		// 2. 注册监听器，接收实时位置更新（持续监听）
-		fusedLocationClient.requestLocationUpdates(
-			locationRequest,
-			locationCallback,
-			getMainLooper() // 在主线程更新UI（避免线程异常）
-		);
-	}
-
-
-	/**
-	 * 处理权限申请结果（用户同意/拒绝后触发）
-	 */
-	@Override
-	public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
-		super.onRequestPermissionsResult(requestCode, permissions, grantResults);
-		if (requestCode == REQUEST_LOCATION_PERMISSIONS) {
-			// 检查是否所有必需权限都已授予
-			boolean allGranted = true;
-			for (int result : grantResults) {
-				if (result != PackageManager.PERMISSION_GRANTED) {
-					allGranted = false;
-					break;
-				}
-			}
-
-			if (allGranted) {
-				// 权限同意 → 启动实时定位
-				startRealTimeLocation();
-			} else {
-				// 权限拒绝 → 提示用户（无法定位）
-				Toast.makeText(this, "定位权限被拒绝，无法显示位置信息", Toast.LENGTH_SHORT).show();
-				tvLongitude.setText("当前经度：无权限");
-				tvLatitude.setText("当前纬度：无权限");
-			}
-		}
-	}
-
-
-	/**
-	 * 活动销毁时：停止定位监听（避免内存泄漏、减少耗电）
-	 */
-	@Override
-	protected void onDestroy() {
-		super.onDestroy();
-		// 移除定位监听器（核心：防止Activity销毁后仍在监听，导致内存泄漏）
-		if (fusedLocationClient != null && locationCallback != null) {
-			fusedLocationClient.removeLocationUpdates(locationCallback);
-		}
-	}
+    // ---------------------- 移除重复定义：LocalBinder 统一在 MainService 中定义 ----------------------
+    // 说明：原LocationActivity中的LocalBinder是重复定义（MainService已实现），会导致类型强转失败
+    // 此处删除该类，确保Activity绑定服务时强转的是MainService中的LocalBinder
 }
 
+

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

@@ -0,0 +1,60 @@
+package cc.winboll.studio.positions.activities;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/09/29 00:11
+ * @Describe WinBoLL 窗口基础类
+ */
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.MenuItem;
+import androidx.appcompat.app.AppCompatActivity;
+import cc.winboll.studio.libaes.interfaces.IWinBoLLActivity;
+import cc.winboll.studio.libaes.utils.WinBoLLActivityManager;
+import cc.winboll.studio.libappbase.LogUtils;
+
+public class WinBoLLActivity extends AppCompatActivity implements IWinBoLLActivity {
+
+    public static final String TAG = "WinBoLLActivity";
+
+    @Override
+    public Activity getActivity() {
+        return this;
+    }
+
+    @Override
+    public String getTag() {
+        return TAG;
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        LogUtils.d(TAG, String.format("onResume %s", getTag()));
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        /*if (item.getItemId() == R.id.item_log) {
+            WinBoLLActivityManager.getInstance().startLogActivity(this);
+            return true;
+        } else if (item.getItemId() == R.id.item_home) {
+			startActivity(new Intent(this, MainActivity.class));
+            return true;
+        }*/
+        // 在switch语句中处理每个ID，并在处理完后返回true，未处理的情况返回false。
+        return super.onOptionsItemSelected(item);
+    }
+
+    @Override
+    protected void onPostCreate(Bundle savedInstanceState) {
+        super.onPostCreate(savedInstanceState);
+        WinBoLLActivityManager.getInstance().add(this);
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        WinBoLLActivityManager.getInstance().registeRemove(this);
+    }
+}

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

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

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

@@ -0,0 +1,75 @@
+package cc.winboll.studio.positions.models;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/10/01 04:50
+ * @Describe AppConfigsModel
+ */
+ import cc.winboll.studio.libappbase.BaseBean;
+import android.util.JsonWriter;
+import android.util.JsonReader;
+import java.io.IOException;
+
+public class AppConfigsModel extends BaseBean {
+    
+    public static final String TAG = "AppConfigsModel";
+	
+	boolean isEnableMainService;
+
+	public AppConfigsModel(boolean isEnableMainService) {
+		this.isEnableMainService = isEnableMainService;
+	}
+	
+	public AppConfigsModel() {
+		this.isEnableMainService = false;
+	}
+
+	public void setIsEnableMainService(boolean isEnableMainService) {
+		this.isEnableMainService = isEnableMainService;
+	}
+
+	public boolean isEnableMainService() {
+		return isEnableMainService;
+	}
+    
+    @Override
+	public String getName() {
+		return AppConfigsModel.class.getName();
+	}
+
+	// JSON序列化（保存位置数据）
+	@Override
+	public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
+		super.writeThisToJsonWriter(jsonWriter);
+		jsonWriter.name("isEnableDistanceRefreshService").value(isEnableMainService());
+	}
+
+	// JSON反序列化（加载位置数据，校验字段）
+	@Override
+	public boolean initObjectsFromJsonReader(JsonReader jsonReader, String name) throws IOException {
+		if (super.initObjectsFromJsonReader(jsonReader, name)) { 
+			return true; 
+		} else {
+			if (name.equals("isEnableDistanceRefreshService")) {
+				setIsEnableMainService(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/models/PositionModel.java

@@ -0,0 +1,219 @@
+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;
+	// 定位点与指定点实时距离长度
+	double realPositionDistance;
+	// 是否启用实时距离计算
+	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;
+	}
+
+	public void setRealPositionDistance(double realPositionDistance) {
+		this.realPositionDistance = realPositionDistance;
+	}
+
+	public double getRealPositionDistance() {
+		return realPositionDistance;
+	}
+
+	// ---------------------- 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,207 @@
+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;
+	// 任务开始启用时间
+	long startTime;
+	// 任务是否已触发
+	boolean isBingo = false;
+	// 是否启用任务
+	boolean isEnable;
+
+	// 带参构造（强制传入positionId，确保任务与位置绑定）
+	public PositionTaskModel(String taskId, String positionId, String taskDescription, boolean isGreaterThan, int discussDistance, long startTime, 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.startTime = startTime;
+		this.isEnable = isEnable;
+	}
+	
+	// 无参构造（初始化默认值，positionId需后续设置）
+	public PositionTaskModel() {
+		this.taskId = genTaskId();
+		this.positionId = "";
+		this.taskDescription = "新任务";
+		this.isGreaterThan = true;
+		this.isLessThan = false; // 初始互斥
+		this.discussDistance = 100; // 默认100米
+		this.startTime = System.currentTimeMillis();
+		this.isEnable = true;
+	}
+
+	public void setStartTime(long startTime) {
+		this.startTime = startTime;
+	}
+
+	public long getStartTime() {
+		return startTime;
+	}
+
+	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("startTime").value(getStartTime());
+		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("startTime")) {
+				setStartTime(jsonReader.nextLong());
+			} 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/receivers/MotionStatusReceiver.java

@@ -0,0 +1,124 @@
+package cc.winboll.studio.positions.receivers;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/10/28 19:07
+ * @Describe MotionStatusReceiver
+ */
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.text.TextUtils;
+import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.positions.services.MainService;
+import cc.winboll.studio.positions.utils.ServiceUtil;
+
+/**
+ * 运动状态监听Receiver
+ * 功能：接收运动状态广播，控制GPS权限申请与GPS监听开关
+ */
+public class MotionStatusReceiver extends BroadcastReceiver {
+	public static final String TAG = "MotionStatusReceiver";
+
+	// 运动状态广播Action（需与运动状态发送方保持一致，如传感器服务）
+	public static final String ACTION_MOTION_STATUS = "cc.winboll.studio.positions.ACTION_MOTION_STATUS";
+	// 运动状态Extra键：0=静止/低运动，1=行走/高运动
+	public static final String EXTRA_MOTION_STATUS = "EXTRA_MOTION_STATUS";
+	// 静止时GPS定时获取间隔（单位：分钟，可配置）
+	public static final long GPS_STATIC_INTERVAL = 1;
+
+	@Override
+	public void onReceive(Context context, Intent intent) {
+		if (context == null || intent == null || !TextUtils.equals(intent.getAction(), ACTION_MOTION_STATUS)) {
+			LogUtils.w(TAG, "无效广播：Action不匹配或上下文为空");
+			return;
+		}
+
+		// 1. 获取运动状态（0=静止/低运动，1=行走/高运动）
+		int motionStatus = intent.getIntExtra(EXTRA_MOTION_STATUS, 0);
+		LogUtils.d(TAG, "接收运动状态：" + (motionStatus == 1 ? "行走中" : "静止/低运动"));
+
+		// 2. 绑定并获取MainService实例（确保服务已启动）
+		MainService mainService = getMainService(context);
+		if (mainService == null) {
+			LogUtils.e(TAG, "MainService未启动，无法控制GPS状态");
+			return;
+		}
+
+		// 3. 根据运动状态处理GPS逻辑
+		if (motionStatus == 1) {
+			// 3.1 行走中：申请GPS权限（若未授予）+ 开启持续GPS监听
+			handleWalkingStatus(mainService, context);
+		} else {
+			// 3.2 静止/低运动：关闭持续GPS监听 + 启动定时GPS获取
+			handleStaticStatus(mainService);
+		}
+	}
+
+	/**
+	 * 处理行走状态：申请GPS权限+开启持续GPS监听
+	 */
+	private void handleWalkingStatus(MainService mainService, Context context) {
+		// 检查GPS权限（Android 6.0+动态权限）
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && 
+			context.checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) 
+			!= PackageManager.PERMISSION_GRANTED) {
+			// 发送权限申请广播（由Activity接收并发起申请，Receiver无法直接申请权限）
+			Intent permissionIntent = new Intent("cc.winboll.studio.positions.ACTION_REQUEST_GPS_PERMISSION");
+			permissionIntent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
+			context.sendBroadcast(permissionIntent);
+			LogUtils.d(TAG, "行走中：GPS权限未授予，已发送权限申请广播");
+			return;
+		}
+
+		// 权限已授予：开启持续GPS监听（调用MainService原有方法）
+		if (!mainService.isGpsListening()) { // 需在MainService中新增isGpsListening()方法
+			mainService.startGpsLocation();
+			LogUtils.d(TAG, "行走中：已开启持续GPS监听");
+		}
+
+		// 停止静止时的GPS定时任务（避免重复获取）
+		mainService.stopGpsStaticTimer();
+	}
+
+	/**
+	 * 处理静止状态：关闭持续GPS监听+启动定时GPS获取
+	 */
+	private void handleStaticStatus(MainService mainService) {
+		// 关闭持续GPS监听（避免耗电）
+		if (mainService.isGpsListening()) {
+			mainService.stopGpsLocation();
+			LogUtils.d(TAG, "静止中：已关闭持续GPS监听");
+		}
+
+		// 启动定时GPS获取（获取一次后关闭，间隔GPS_STATIC_INTERVAL分钟）
+		mainService.startGpsStaticTimer(GPS_STATIC_INTERVAL);
+	}
+
+	/**
+	 * 获取MainService实例（通过绑定服务或单例，确保线程安全）
+	 */
+	private MainService getMainService(Context context) {
+		// 方式1：若MainService单例有效，直接获取（推荐）
+		MainService singleton = MainService.getInstance(context);
+		if (singleton != null && singleton.isServiceRunning()) {
+			return singleton;
+		}
+
+		// 方式2：若单例无效，尝试绑定服务（备用，需处理绑定回调）
+		if (!ServiceUtil.isServiceAlive(context, MainService.class.getName())) {
+			// 启动服务（若未运行）
+			context.startService(new Intent(context, MainService.class));
+			// 等待服务启动（短延时，实际项目建议用ServiceConnection异步绑定）
+			try {
+				Thread.sleep(500);
+			} catch (InterruptedException e) {
+				Thread.currentThread().interrupt();
+			}
+		}
+		return MainService.getInstance(context);
+	}
+}
+

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

@@ -0,0 +1,101 @@
+package cc.winboll.studio.positions.services;
+
+/**
+ * @Author ZhanGSKen<zhangsken@qq.com>
+ * @Date 2024/07/19 14:30:57
+ * @Describe 应用主要服务组件类守护进程服务组件类
+ */
+import android.app.Service;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+import cc.winboll.studio.positions.services.MainService;
+import cc.winboll.studio.positions.utils.AppConfigsUtil;
+import cc.winboll.studio.positions.utils.ServiceUtil;
+
+public class AssistantService extends Service {
+
+    public final static String TAG = "AssistantService";
+	public static final String EXTRA_IS_SETTING_TO_ENABLE = "EXTRA_IS_SETTING_TO_ENABLE";
+	
+    MyServiceConnection mMyServiceConnection;
+    volatile boolean mIsServiceRunning;
+    AppConfigsUtil mAppConfigsUtil;
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        mAppConfigsUtil = AppConfigsUtil.getInstance(this);
+        if (mMyServiceConnection == null) {
+            mMyServiceConnection = new MyServiceConnection();
+        }
+        // 设置运行参数
+        mIsServiceRunning = false;
+        if (mAppConfigsUtil.isEnableMainService(true)) {
+			run();
+		}
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+		if (mAppConfigsUtil.isEnableMainService(true)) {
+			run();
+		}
+
+        return  mAppConfigsUtil.isEnableMainService(true) ? Service.START_STICKY : super.onStartCommand(intent, flags, startId);
+    }
+
+    @Override
+    public void onDestroy() {
+        mIsServiceRunning = false;
+        super.onDestroy();
+    }
+
+    //
+    // 运行服务内容
+    //
+    void run() {
+        if (mAppConfigsUtil.isEnableMainService(true)) {
+            if (mIsServiceRunning == false) {
+                // 设置运行状态
+                mIsServiceRunning = true;
+                // 唤醒和绑定主进程
+                wakeupAndBindMain();
+            }
+        }
+    }
+
+    //
+    // 唤醒和绑定主进程
+    //
+    void wakeupAndBindMain() {
+        if (ServiceUtil.isServiceAlive(getApplicationContext(), MainService.class.getName()) == false) {
+            startForegroundService(new Intent(AssistantService.this, MainService.class));
+        }
+
+        bindService(new Intent(AssistantService.this, MainService.class), mMyServiceConnection, Context.BIND_IMPORTANT);
+    }
+
+    //
+    // 主进程与守护进程连接时需要用到此类
+    //
+    class MyServiceConnection implements ServiceConnection {
+        @Override
+        public void onServiceConnected(ComponentName name, IBinder service) {
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName name) {
+            if (mAppConfigsUtil.isEnableMainService(true)) {
+                wakeupAndBindMain();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,433 @@
+//package cc.winboll.studio.positions.services;
+//
+///**
+// * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+// * @Date 2025/09/30 19:53
+// * @Describe 位置距离服务：管理数据+定时计算距离+适配Adapter（Java 7 兼容）+ GPS信号加载
+// */
+//import android.app.Service;
+//import android.content.Context;
+//import android.content.Intent;
+//import android.content.pm.PackageManager;
+//import android.location.Location;
+//import android.location.LocationListener;
+//import android.location.LocationManager;
+//import android.os.Binder;
+//import android.os.Build;
+//import android.os.Bundle;
+//import android.os.IBinder;
+//import android.os.Looper;
+//import android.widget.Toast;
+//import cc.winboll.studio.libappbase.LogUtils;
+//import cc.winboll.studio.positions.adapters.PositionAdapter;
+//import cc.winboll.studio.positions.models.AppConfigsModel;
+//import cc.winboll.studio.positions.models.PositionModel;
+//import cc.winboll.studio.positions.models.PositionTaskModel;
+//import cc.winboll.studio.positions.utils.NotificationUtil;
+//import java.util.ArrayList;
+//import java.util.HashSet;
+//import java.util.Iterator;
+//import java.util.Set;
+//import java.util.concurrent.Executors;
+//import java.util.concurrent.ScheduledExecutorService;
+//import java.util.concurrent.TimeUnit;
+//
+///**
+// * 核心职责：
+// * 1. 实现 PositionAdapter.DistanceServiceInterface 接口，解耦Adapter与服务
+// * 2. 单例式管理位置/任务数据，提供安全增删改查接口
+// * 3. 后台单线程定时计算可见位置距离，主线程回调更新UI
+// * 4. 内置GPS信号加载（通过LocationManager实时获取位置，解决“等待GPS信号”问题）
+// * 5. 服务启动时启动前台通知（保活后台GPS功能，符合系统规范）
+// * 6. 严格Java 7语法：无Lambda/Stream，显式迭代器/匿名内部类
+// */
+//public class DistanceRefreshService extends Service {
+//    public static final String TAG = "DistanceRefreshService";
+//	
+//	
+//    // 服务状态与配置
+//    private boolean isServiceRunning = false;
+//    
+//    private static final int REFRESH_INTERVAL = 3; // 距离刷新间隔（秒）
+//    // 前台通知相关：记录是否已启动前台服务（避免重复调用startForeground）
+//    private boolean isForegroundServiceStarted = false;
+//
+//   
+//    
+//    // 服务绑定与UI回调
+//    private final IBinder mBinder = new DistanceBinder();
+//
+//    
+//
+//
+//    /**
+//     * 在主线程显示Toast（避免子线程无法显示Toast的问题）
+//     */
+//    private void showToastOnMainThread(final String message) {
+//        if (Looper.myLooper() == Looper.getMainLooper()) {
+//            Toast.makeText(this, message, Toast.LENGTH_SHORT).show();
+//        } else {
+//            new android.os.Handler(Looper.getMainLooper()).post(new Runnable() {
+//					@Override
+//					public void run() {
+//						Toast.makeText(DistanceRefreshService.this, message, Toast.LENGTH_SHORT).show();
+//					}
+//				});
+//        }
+//    }
+//
+//    // ---------------------- Binder 内部类（供外部绑定服务） ----------------------
+//    public class DistanceBinder extends Binder {
+//        /**
+//         * 外部绑定后获取服务实例（安全暴露服务引用）
+//         */
+//        public DistanceRefreshService getService() {
+//            return DistanceRefreshService.this;
+//        }
+//    }
+//
+//    
+//
+//    @Override
+//    public void onCreate() {
+//        super.onCreate();
+//		
+//        // 初始化GPS管理器（提前获取系统服务，避免启动时延迟）
+//        mLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
+//        LogUtils.d(TAG, "服务 onCreate：初始化完成，等待启动命令");
+//        run();
+//    }
+//
+//    @Override
+//    public int onStartCommand(Intent intent, int flags, int startId) {
+//        run();
+//        AppConfigsModel bean = AppConfigsModel.loadBean(DistanceRefreshService.this, AppConfigsModel.class);
+//        boolean isEnableService = (bean == null) ? false : bean.isEnableMainService();
+//        // 服务启用时返回START_STICKY（被杀死后尝试重启），禁用时返回默认值
+//        return isEnableService ? Service.START_STICKY : super.onStartCommand(intent, flags, startId);
+//    }
+//
+//    public void run() {
+//        // 仅服务未运行时启动（避免重复启动）
+//        if (!isServiceRunning) {
+//            isServiceRunning = true;
+//			
+//			
+//			
+//            startDistanceRefreshTask(); // 启动定时距离计算
+//            startForegroundNotification(); // 启动前台通知
+//            
+//            LogUtils.d(TAG, "服务 onStartCommand：启动成功，刷新间隔=" + REFRESH_INTERVAL + "秒，前台通知+GPS已启动");
+//        } else {
+//            LogUtils.w(TAG, "服务 onStartCommand：已在运行，无需重复启动（前台通知：" + (isForegroundServiceStarted ? "已启动" : "未启动") + " | GPS：" + (isGpsEnabled ? "已开启" : "未开启") + "）");
+//            // 异常场景恢复：补全未启动的组件
+//            if (!isForegroundServiceStarted) {
+//                startForegroundNotification();
+//                LogUtils.d(TAG, "服务 run：前台通知未启动，已恢复");
+//            }
+//            if (isServiceRunning && !isGpsEnabled) {
+//                startGpsLocation();
+//                LogUtils.d(TAG, "服务 run：GPS未启动，已恢复");
+//            }
+//        }
+//    }
+//
+//    @Override
+//    public IBinder onBind(Intent intent) {
+//		return null; // 按你的业务逻辑返回，无绑定需求则保留null
+//        //LogUtils.d(TAG, "服务 onBind：外部绑定成功（运行状态：" + (isServiceRunning ? "是" : "否") + " | GPS状态：" + (isGpsEnabled ? "可用" : "不可用") + "）");
+//        //return mBinder; // 返回Binder实例，供外部获取服务
+//    }
+//
+//    /*@Override
+//	 public boolean onUnbind(Intent intent) {
+//	 LogUtils.d(TAG, "服务 onUnbind：外部解绑，清理回调与可见位置");
+//	 // 解绑后清理资源，避免内存泄漏
+//	 mDistanceReceiver = null;
+//	 mVisiblePositionIds.clear();
+//	 // 解绑时不停止GPS（服务仍在后台运行，需持续获取位置）
+//	 return super.onUnbind(intent);
+//	 }*/
+//
+//    @Override
+//    public void onDestroy() {
+//        super.onDestroy();
+//		
+//        LogUtils.d(TAG, "服务 onDestroy：销毁完成，资源已释放（GPS+前台通知+线程池）");
+//    }
+//
+//    // ---------------------- 前台服务通知管理（与GPS状态联动优化） ----------------------
+//    /**
+//     * 启动前台服务通知（调用NotificationUtils创建通知，确保仅启动一次）
+//     */
+//    private void startForegroundNotification() {
+//        // 1. 校验：避免重复调用startForeground（系统不允许重复启动）
+//        if (isForegroundServiceStarted) {
+//            LogUtils.w(TAG, "startForegroundNotification：前台通知已启动，无需重复执行");
+//            return;
+//        }
+//
+//        try {
+//// 2. 初始化通知状态文本（根据GPS初始状态动态显示，避免固定“等待”）
+//			String initialStatus;
+//			if (isGpsPermissionGranted && isGpsEnabled) {
+//				initialStatus = "GPS已就绪，正在获取位置（刷新间隔" + REFRESH_INTERVAL + "秒）";
+//			} else if (!isGpsPermissionGranted) {
+//				initialStatus = "缺少定位权限，无法获取GPS位置";
+//			} else {
+//				initialStatus = "GPS未开启，请在设置中打开";
+//			}
+//
+//
+//// 5. 标记前台服务已启动
+//			isForegroundServiceStarted = true;
+//			LogUtils.d(TAG, "startForegroundNotification：前台服务通知启动成功，初始状态：" + initialStatus);
+//
+//		} catch (Exception e) {
+//// 捕获异常（如上下文失效、通知渠道未创建）
+//			isForegroundServiceStarted = false;
+//			LogUtils.d(TAG, "startForegroundNotification：前台通知启动失败" + e);
+//		}
+//	}
+//
+//
+//
+//	/**
+//
+//	 - 主线程回调Adapter更新UI（避免跨线程操作UI异常）
+//	 */
+//	/*private void notifyDistanceUpdateToUI(final String positionId) {
+//	 if (Looper.myLooper() == Looper.getMainLooper()) {
+//	 if (mDistanceReceiver != null) {
+//	 mDistanceReceiver.onDistanceUpdate(positionId);
+//	 }
+//	 } else {
+//	 new android.os.Handler(Looper.getMainLooper()).post(new Runnable() {
+//	 @Override
+//	 public void run() {
+//	 if (mDistanceReceiver != null) {
+//	 mDistanceReceiver.onDistanceUpdate(positionId);
+//	 }
+//	 }
+//	 });
+//	 }
+//	 }*/
+//
+//
+//
+//
+//
+//// ---------------------- 实现 PositionAdapter.DistanceServiceInterface 接口 ----------------------
+//
+//	public ArrayList getPositionList() {
+//		if (!isServiceRunning) {
+//			LogUtils.w(TAG, "getPositionList：服务未运行，返回空列表");
+//			return new ArrayList();
+//		}
+//		return new ArrayList(mPositionList);
+//	}
+//
+//
+//	public ArrayList getPositionTasksList() {
+//		if (!isServiceRunning) {
+//			LogUtils.w(TAG, "getPositionTasksList：服务未运行，返回空列表");
+//			return new ArrayList();
+//		}
+//		return new ArrayList(mTaskList);
+//	}
+//
+//	
+//	
+//
+//	/*public void setOnDistanceUpdateReceiver(PositionAdapter.OnDistanceUpdateReceiver receiver) {
+//		this.mDistanceReceiver = receiver;
+//		LogUtils.d(TAG, "setOnDistanceUpdateReceiver：回调接收器已设置（" + (receiver != null ? "有效" : "无效") + "）");
+//	}*/
+//
+//	public void addVisibleDistanceView(String positionId) {
+//		if (!isServiceRunning || positionId == null) {
+//			LogUtils.w(TAG, "addVisibleDistanceView：服务未运行/位置ID无效，添加失败");
+//			return;
+//		}
+//		if (mVisiblePositionIds.add(positionId)) {
+//			LogUtils.d(TAG, "addVisibleDistanceView：添加成功（位置ID=" + positionId + "，当前可见数=" + mVisiblePositionIds.size() + "）");
+//// 新增：添加可见位置后，立即更新通知（显示最新可见数量）
+//			if (isForegroundServiceStarted && mCurrentGpsPosition != null) {
+//				syncGpsStatusToNotification();
+//			}
+//		}
+//	}
+//
+//	public void removeVisibleDistanceView(String positionId) {
+//		if (positionId == null) {
+//			LogUtils.w(TAG, "removeVisibleDistanceView：位置ID为空，移除失败");
+//			return;
+//		}
+//		if (mVisiblePositionIds.remove(positionId)) {
+//			int remainingCount = mVisiblePositionIds.size();
+//			LogUtils.d(TAG, "removeVisibleDistanceView：移除成功（位置ID=" + positionId + "，当前可见数=" + remainingCount + "）");
+//// 新增：移除可见位置后，更新通知（同步数量变化）
+//			if (isForegroundServiceStarted && mCurrentGpsPosition != null) {
+//				syncGpsStatusToNotification();
+//			}
+//		}
+//	}
+//
+//	public void clearVisibleDistanceViews() {
+//		mVisiblePositionIds.clear();
+//		LogUtils.d(TAG, "clearVisibleDistanceViews：所有可见位置已清空");
+//// 新增：清空可见位置后，更新通知（提示计算暂停）
+//		if (isForegroundServiceStarted) {
+//			updateNotificationGpsStatus("无可见位置，距离计算暂停");
+//		}
+//	}
+//
+//// ---------------------- 数据管理接口（修复原有语法错误+优化逻辑） ----------------------
+//	/**
+//
+//	 - 获取服务运行状态
+//	 */
+//	public boolean isServiceRunning() {
+//		return isServiceRunning;
+//	}
+//
+//	/**
+//
+//	 - 添加位置（修复迭代器泛型缺失问题）
+//	 */
+//	public void addPosition(PositionModel position) {
+//		if (!isServiceRunning || position == null || position.getPositionId() == null) {
+//			LogUtils.w(TAG, "addPosition：服务未运行/数据无效，添加失败");
+//			return;
+//		}// 修复：显式声明PositionModel泛型，避免类型转换警告
+//		boolean isDuplicate = false;
+//		Iterator posIter = mPositionList.iterator();
+//		while (posIter.hasNext()) {
+//			PositionModel existingPos = (PositionModel)posIter.next();
+//			if (position.getPositionId().equals(existingPos.getPositionId())) {
+//				isDuplicate = true;
+//				break;
+//			}
+//		}if (!isDuplicate) {
+//			mPositionList.add(position);
+//			LogUtils.d(TAG, "addPosition：添加成功（位置ID=" + position.getPositionId() + "，总数=" + mPositionList.size() + "）");
+//		} else {
+//			LogUtils.w(TAG, "addPosition：位置ID=" + position.getPositionId() + "已存在，添加失败");
+//		}
+//	}
+//
+//	/**
+//
+//	 - 删除位置（修复任务删除时的类型转换错误）
+//	 */
+//	public void removePosition(String positionId) {
+//		if (!isServiceRunning || positionId == null) {
+//			LogUtils.w(TAG, "removePosition：服务未运行/位置ID无效，删除失败");
+//			return;
+//		}// 1. 删除位置
+//		boolean isRemoved = false;
+//		Iterator posIter = mPositionList.iterator();
+//		while (posIter.hasNext()) {
+//			PositionModel pos = (PositionModel)posIter.next();
+//			if (positionId.equals(pos.getPositionId())) {
+//				posIter.remove();
+//				isRemoved = true;
+//				break;
+//			}
+//		}if (isRemoved) {
+//// 修复：任务列表迭代时用PositionTaskModel泛型（原错误用PositionModel导致转换失败）
+//			Iterator taskIter = mTaskList.iterator();
+//			while (taskIter.hasNext()) {
+//				PositionTaskModel task = (PositionTaskModel)taskIter.next();
+//				if (positionId.equals(task.getPositionId())) {
+//					taskIter.remove();
+//				}
+//			}// 3. 移除可见位置
+//			mVisiblePositionIds.remove(positionId);
+//			LogUtils.d(TAG, "removePosition：删除成功（位置ID=" + positionId + "，剩余位置数=" + mPositionList.size() + "，剩余任务数=" + mTaskList.size() + "）");
+//		} else {
+//			LogUtils.w(TAG, "removePosition：位置ID=" + positionId + "不存在，删除失败");
+//		}
+//	}
+//
+//	/**
+//
+//	 - 更新位置信息（修复代码格式+迭代器泛型）
+//	 */
+//	public void updatePosition(PositionModel updatedPosition) {
+//		if (!isServiceRunning || updatedPosition == null || updatedPosition.getPositionId() == null) {
+//			LogUtils.w(TAG, "updatePosition：服务未运行/数据无效，更新失败");
+//			return;
+//		}boolean isUpdated = false;
+//		Iterator posIter = mPositionList.iterator();
+//		while (posIter.hasNext()) {
+//			PositionModel pos = (PositionModel)posIter.next();
+//			if (updatedPosition.getPositionId().equals(pos.getPositionId())) {
+//				pos.setMemo(updatedPosition.getMemo());
+//				pos.setIsEnableRealPositionDistance(updatedPosition.isEnableRealPositionDistance());
+//				if (!updatedPosition.isEnableRealPositionDistance()) {
+//					pos.setRealPositionDistance(-1);
+//					//notifyDistanceUpdateToUI(pos.getPositionId());
+//				}
+//				isUpdated = true;
+//				break;
+//			}
+//		}if (isUpdated) {
+//			LogUtils.d(TAG, "updatePosition：更新成功（位置ID=" + updatedPosition.getPositionId() + "）");
+//		} else {
+//			LogUtils.w(TAG, "updatePosition：位置ID=" + updatedPosition.getPositionId() + "不存在，更新失败");
+//		}
+//	}
+//
+//	/**
+//
+//	 - 同步任务列表（修复泛型缺失+代码格式）
+//	 */
+//	public void syncAllPositionTasks(ArrayList tasks) {
+//		if (!isServiceRunning || tasks == null) {
+//			LogUtils.w(TAG, "syncAllPositionTasks：服务未运行/任务列表为空，同步失败");
+//			return;
+//		}// 1. 清空旧任务
+//		mTaskList.clear();
+//// 2. 添加新任务（修复泛型+去重逻辑）
+//		Set taskIdSet = new HashSet();
+//		Iterator taskIter = tasks.iterator();
+//		while (taskIter.hasNext()) {
+//			PositionTaskModel task = (PositionTaskModel)taskIter.next();
+//			if (task != null && task.getTaskId() != null && !taskIdSet.contains(task.getTaskId())) {
+//				taskIdSet.add(task.getTaskId());
+//				mTaskList.add(task);
+//			}
+//		}LogUtils.d(TAG, "syncAllPositionTasks：同步成功（接收任务数=" + tasks.size() + "，去重后=" + mTaskList.size() + "）");
+//	}
+//
+//
+//
+//
+//// ---------------------- 补充：修复LocationProvider引用缺失问题（避免编译错误） ----------------------
+//// 注：原代码中onStatusChanged使用LocationProvider枚举，需补充静态导入或显式声明
+//// 此处通过内部静态类定义，解决系统API引用问题（兼容Java 7语法）
+//	private static class LocationProvider {
+//		public static final int AVAILABLE = 2;
+//		public static final int OUT_OF_SERVICE = 0;
+//		public static final int TEMPORARILY_UNAVAILABLE = 1;
+//	}
+//
+//// ---------------------- 补充：Context引用工具（避免服务销毁后Context失效） ----------------------
+//	/*private Context getSafeContext() {
+//	 // 服务未销毁时返回自身Context，已销毁时返回应用Context（避免内存泄漏）
+//	 if (isDestroyed()) {
+//	 return getApplicationContext();
+//	 }
+//	 return this;
+//	 }*/
+//
+//// 注：isDestroyed()为API 17+方法，若需兼容更低版本，可添加版本判断
+//	/*private boolean isDestroyed() {
+//	 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+//	 return super.isDestroyed();
+//	 }
+//	 // 低版本通过状态标记间接判断（服务销毁时会置为false）
+//	 return !isServiceRunning && !isForegroundServiceStarted;
+//	 }*/
+//}

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

@@ -0,0 +1,68 @@
+package cc.winboll.studio.positions.utils;
+import android.content.Context;
+import cc.winboll.studio.positions.models.AppConfigsModel;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/10/01 12:15
+ * @Describe AppConfigsUtils
+ */
+public class AppConfigsUtil {
+
+    public static final String TAG = "AppConfigsUtils";
+
+    // 1. 私有静态成员变量（volatile 防止指令重排，确保实例初始化完全）
+    private static volatile AppConfigsUtil sInstance;
+	Context mContext;
+	AppConfigsModel mAppConfigsModel;
+
+    // 2. 私有构造方法（禁止外部 new 实例）
+    private AppConfigsUtil(Context context) {
+        // 可选：防止通过反射创建实例（增强单例安全性）
+        if (sInstance != null) {
+            throw new RuntimeException("禁止通过反射创建单例实例");
+        }
+		mContext = context;
+		loadConfigs();
+    }
+
+    // 3. 公开静态方法（双重校验锁，获取唯一实例）
+    public static AppConfigsUtil getInstance(Context context) {
+        // 第一次校验：无锁，快速判断实例是否存在（提升性能）
+        if (sInstance == null) {
+            // 加锁：确保同一时间只有一个线程进入初始化逻辑
+            synchronized (AppConfigsUtil.class) {
+                // 第二次校验：防止多线程并发时重复创建实例（线程安全）
+                if (sInstance == null) {
+                    sInstance = new AppConfigsUtil(context);
+                }
+            }
+        }
+        return sInstance;
+    }
+
+	public void loadConfigs() {
+		mAppConfigsModel = AppConfigsModel.loadBean(mContext, AppConfigsModel.class);
+	}
+
+	public void saveConfigs() {
+		AppConfigsModel.saveBean(mContext, mAppConfigsModel);
+	}
+
+	public boolean isEnableMainService(boolean isReloadConfigs) {
+		if (isReloadConfigs) {
+			loadConfigs();
+		}
+
+		return (mAppConfigsModel == null) ?false: mAppConfigsModel.isEnableMainService();
+	}
+
+	public void setIsEnableMainService(boolean isEnableMainService) {
+		if(mAppConfigsModel == null) {
+			mAppConfigsModel = new AppConfigsModel();
+		}
+		mAppConfigsModel.setIsEnableMainService(isEnableMainService);
+		saveConfigs();
+	}
+}
+

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

@@ -0,0 +1,45 @@
+package cc.winboll.studio.positions.utils;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/10/22 01:16
+ * @Describe DensityUtils
+ */
+
+import android.content.Context;
+import android.util.DisplayMetrics;
+import android.view.WindowManager;
+
+/**
+ * 屏幕密度工具类（dp/sp 转 px、获取屏幕尺寸）
+ */
+public class DensityUtils {
+	public static final String TAG = "DensityUtils";
+
+	/**
+	 * dp 转 px（根据屏幕密度）
+	 */
+	public static int dp2px(Context context, float dpValue) {
+		final float scale = context.getResources().getDisplayMetrics().density;
+		return (int) (dpValue * scale + 0.5f);
+	}
+
+	/**
+	 * sp 转 px（根据文字缩放比例）
+	 */
+	public static int sp2px(Context context, float spValue) {
+		final float scale = context.getResources().getDisplayMetrics().scaledDensity;
+		return (int) (spValue * scale + 0.5f);
+	}
+
+	/**
+	 * 获取屏幕宽度（像素）
+	 */
+	public static int getScreenWidth(Context context) {
+		WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
+		DisplayMetrics dm = new DisplayMetrics();
+		wm.getDefaultDisplay().getMetrics(dm);
+		return dm.widthPixels;
+	}
+}
+

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

@@ -0,0 +1,246 @@
+package cc.winboll.studio.positions.utils;
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.text.TextUtils;
+import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.libappbase.ToastUtils;
+import cc.winboll.studio.positions.models.PositionModel;
+import cc.winboll.studio.positions.models.PositionTaskModel;
+import cc.winboll.studio.positions.services.MainService;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/10/27 18:40
+ * @Describe 距离计算工具集（单例模式）
+ */
+public class DistanceCalculatorUtil {
+
+    public static final String TAG = "DistanceCalculatorUtil";
+
+    // 1. 私有静态 volatile 实例：保证多线程下实例可见性，避免指令重排序导致的空指针
+    private static volatile DistanceCalculatorUtil sInstance;
+	Context mContext;
+	ArrayList<PositionModel> mPositionList;   // 位置数据列表
+    ArrayList<PositionTaskModel> mAllTasks;// 任务数据列表
+	PositionModel mGpsPositionCalculated;
+	long mLastCalculatedTime = 0;
+	long mMinCalculatedTimeBettween = 30000; // GPS数据更新时，两次计算之间的最小时间间隔
+	double mMinjumpDistance = 10.0f; // GPS数据更新时，能跳跃距离最小有效值，达到有效值时，两次计算之间的最小时间间隔阀值将被忽略。
+
+    // 2. 私有构造器：禁止外部通过 new 关键字创建实例，确保单例唯一性
+    private DistanceCalculatorUtil(Context context) {
+        // 可选：初始化工具类依赖的资源（如配置参数、缓存等）
+		mContext = context;
+
+        LogUtils.d(TAG, "DistanceCalculatorUtil 单例实例初始化");
+    }
+
+    // 3. 公开静态方法：双重校验锁获取单例，兼顾线程安全与性能
+    public static DistanceCalculatorUtil getInstance(Context context) {
+        // 第一重校验：避免已创建实例时的频繁加锁，提升性能
+        if (sInstance == null) {
+            // 加锁：确保多线程下仅一个线程进入实例创建逻辑
+            synchronized (DistanceCalculatorUtil.class) {
+                // 第二重校验：防止多线程并发时重复创建实例
+                if (sInstance == null) {
+                    sInstance = new DistanceCalculatorUtil(context);
+                }
+            }
+        }
+        return sInstance;
+    }
+
+    // ---------------------- 以下可补充距离计算相关工具方法 ----------------------
+    /**
+     * 示例：Haversine 公式计算两点间距离（单位：米）
+     * @param lat1 第一点纬度
+     * @param lon1 第一点经度
+     * @param lat2 第二点纬度
+     * @param lon2 第二点经度
+     * @return 两点间直线距离（米），计算失败返回 -1
+     */
+    public static double calculateHaversineDistance(double lat1, double lon1, double lat2, double lon2) {
+        try {
+            final double EARTH_RADIUS = 6371000; // 地球半径（米）
+            // 角度转弧度
+            double latDiff = Math.toRadians(lat2 - lat1);
+            double lonDiff = Math.toRadians(lon2 - lon1);
+
+            // Haversine 核心公式
+            double a = Math.sin(latDiff / 2) * Math.sin(latDiff / 2)
+				+ Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2))
+				* Math.sin(lonDiff / 2) * Math.sin(lonDiff / 2);
+            double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+            return EARTH_RADIUS * c; // 返回距离（米）
+        } catch (Exception e) {
+            LogUtils.d(TAG, "Haversine 距离计算失败：" + e.getMessage());
+            return -1; // 标记计算失败
+        }
+    }
+
+
+    /**
+     * 计算两点间距离（Haversine公式，纯Java 7 基础API，无数学工具类依赖）
+     * @param gpsLat GPS纬度
+     * @param gpsLon GPS经度
+     * @param posLat 目标位置纬度
+     * @param posLon 目标位置经度
+     * @return 两点间距离（单位：米）
+     */
+    /*private double calculateHaversineDistance(double gpsLat, double gpsLon, double posLat, double posLon) {
+	 final double EARTH_RADIUS = 6371000; // 地球半径（米）
+	 double latDiff = Math.toRadians(posLat - gpsLat);
+	 double lonDiff = Math.toRadians(posLon - gpsLon);
+	 // Haversine公式核心计算（Java 7 基础数学方法）
+	 double a = Math.sin(latDiff / 2) * Math.sin(latDiff / 2)
+	 + Math.cos(Math.toRadians(gpsLat)) * Math.cos(Math.toRadians(posLat))
+	 * Math.sin(lonDiff / 2) * Math.sin(lonDiff / 2);
+	 double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+	 return EARTH_RADIUS * c;
+	 }*/
+
+	/**
+     * 校验所有任务触发条件（距离达标则触发任务通知）
+     */
+    public void checkAllTaskTriggerCondition(PositionModel currentGpsPosition) {
+		if (currentGpsPosition == null) {
+			LogUtils.d(TAG, "传入坐标参数为空，退出函数。");
+			return;
+		}
+
+		// 计算频率控制模块
+		//
+		// 计算与最近一次GPS计算的时间间隔
+		long nCalculatedTimeBettween = System.currentTimeMillis() - mLastCalculatedTime;
+		// 计算跳跃距离
+		double gpsPositionCalculatedLatitude = mGpsPositionCalculated == null ?0.0f: mGpsPositionCalculated.getLatitude();
+		double gpsPositionCalculatedLongitude = mGpsPositionCalculated == null ?0.0f: mGpsPositionCalculated.getLongitude();
+		double jumpDistance = calculateHaversineDistance(gpsPositionCalculatedLatitude, gpsPositionCalculatedLongitude, currentGpsPosition.getLatitude(), currentGpsPosition.getLongitude());
+		if (jumpDistance < mMinjumpDistance) {
+			LogUtils.d(TAG, String.format("checkAllTaskTriggerCondition：跳跃距离%f，小于50米。", jumpDistance));
+			// 跳跃距离小于最小有效跳跃值
+			if (nCalculatedTimeBettween < mMinCalculatedTimeBettween) {
+				//间隔小于最小时间间隔设定
+				LogUtils.d(TAG, String.format("checkAllTaskTriggerCondition：与最近一次计算间隔时间%d，坐标变化忽略。", nCalculatedTimeBettween));
+				return;
+			}
+		}
+
+		if (mGpsPositionCalculated == null) {
+			mGpsPositionCalculated = currentGpsPosition;
+			LogUtils.d(TAG, "最后计算位置记录为空，现在使用新坐标为初始化。");
+		}
+
+		LogUtils.d(TAG, String.format("checkAllTaskTriggerCondition：跳跃距离%f，与上次计算间隔%d，现在启动任务数据计算。", jumpDistance, nCalculatedTimeBettween));
+
+		// 获取位置任务基础数据
+		MainService mainService = MainService.getInstance(mContext);
+		mPositionList = mainService.getPositionList();
+		mAllTasks = mainService.getAllTasks();
+
+		// 位置数据为空，跳过校验。
+        if (mPositionList.isEmpty()) {
+            LogUtils.d(TAG, "checkAllTaskTriggerCondition：位置数据为空，跳过距离计算。");
+            return;
+        }
+
+		// 更新所有位置点的位置距离数据
+		refreshRealPositionDistance(currentGpsPosition);
+
+		// 任务数据为空，跳过校验。
+        if (mAllTasks.isEmpty()) {
+            LogUtils.d(TAG, "checkAllTaskTriggerCondition：任务数据为空，跳过任务提醒检查计算。");
+            return;
+        }
+
+        // 迭代器遍历任务（Java 7 安全遍历，避免并发修改异常）
+        Iterator<PositionTaskModel> taskIter = mAllTasks.iterator();
+        while (taskIter.hasNext()) {
+            PositionTaskModel task = taskIter.next();
+            // 仅校验“已启用”且“绑定有效位置”的任务
+            if (!task.isEnable() || TextUtils.isEmpty(task.getPositionId())) {
+                continue;
+            }
+
+            // 查找任务绑定的位置（Java 7 迭代器遍历位置列表）
+            PositionModel bindPos = null;
+            Iterator<PositionModel> posIter = mPositionList.iterator();
+            while (posIter.hasNext()) {
+                PositionModel pos = posIter.next();
+                if (task.getPositionId().equals(pos.getPositionId())) {
+                    bindPos = pos;
+                    break;
+                }
+            }
+            if (bindPos == null) {
+                LogUtils.w(TAG, "任务ID=" + task.getTaskId() + "：绑定位置不存在，跳过");
+                task.setIsBingo(false);
+                continue;
+            }
+
+			// 校验任务开始时间
+			if (task.getStartTime() > System.currentTimeMillis()) {
+				continue;
+			}
+
+            // 校验距离条件（判断是否满足任务触发阈值）
+            double currentDistance = bindPos.getRealPositionDistance();
+            if (currentDistance < 0) {
+                LogUtils.w(TAG, "任务ID=" + task.getTaskId() + "：距离计算失败，跳过");
+                task.setIsBingo(false);
+                continue;
+            }
+
+            boolean isTriggered = false;
+            int taskDistance = task.getDiscussDistance();
+            // 任务触发条件：大于/小于指定距离（Java 7 基础判断，无三元运算符嵌套）
+            if (task.isGreaterThan()) {
+                isTriggered = currentDistance > taskDistance;
+            } else if (task.isLessThan()) {
+                isTriggered = currentDistance < taskDistance;
+            }
+
+            // 更新任务触发状态+发送通知（状态变化时才处理）
+            if (task.isBingo() != isTriggered) {
+                task.setIsBingo(isTriggered);
+                if (isTriggered) {
+                    MainService.getInstance(mContext).sendTaskTriggerNotification(task, bindPos, currentDistance);
+                }
+            }
+        }
+
+        MainService.getInstance(mContext).saveAllTasks(); // 持久化更新后的任务状态
+		// 记录最后坐标更新点
+		mGpsPositionCalculated = currentGpsPosition;
+		// 记录数据计算时间
+		mLastCalculatedTime = System.currentTimeMillis();
+    }
+
+
+    /**
+     * 强制刷新所有位置距离（GPS更新后调用，计算距离+校验任务触发条件）
+     */
+    public void refreshRealPositionDistance(PositionModel currentGpsPosition) {
+        // 遍历所有位置计算距离（Java 7 增强for循环，无Stream）
+        for (PositionModel pos : mPositionList) {
+            if (pos.isEnableRealPositionDistance()) {
+				double distance = DistanceCalculatorUtil.calculateHaversineDistance(
+					currentGpsPosition.getLatitude(),
+					currentGpsPosition.getLongitude(),
+					pos.getLatitude(),
+					pos.getLongitude()
+				);
+				pos.setRealPositionDistance(distance);
+            } else {
+                pos.setRealPositionDistance(-1); // 未启用距离计算，标记为无效
+            }
+        }
+
+        // 距离刷新后通知GPS监听者
+        MainService.getInstance(mContext).notifyAllGpsListeners(currentGpsPosition);
+    }
+}

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

@@ -0,0 +1,193 @@
+package cc.winboll.studio.positions.utils;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/09/30 16:09
+ * @Describe NotificationUtils（适配API 30，修复系统默认铃声获取，任务通知循环响铃）
+ */
+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.media.RingtoneManager; // 导入RingtoneManager（关键：用于获取系统默认铃声）
+import android.net.Uri; // 导入Uri（存储铃声路径）
+import android.os.Build;
+import androidx.core.app.NotificationCompat;
+import cc.winboll.studio.positions.R;
+import cc.winboll.studio.positions.activities.LocationActivity;
+
+/**
+ * 通知栏工具类：
+ * 1. 任务通知：铃声循环播放（适配API 30），修复系统默认铃声获取方式
+ * 2. 前台服务通知：低打扰（无声无震动），符合API 30规范
+ */
+public class NotificationUtil {
+    public static final String TAG = "NotificationUtils";
+    // 任务通知常量（独立渠道，确保循环铃声配置不冲突）
+    private static final String TASK_NOTIFICATION_CHANNEL_ID = "task_notification_channel_01";
+    private static final String TASK_NOTIFICATION_CHANNEL_NAME = "任务通知（循环铃声）";
+    // 前台服务通知常量（独立渠道，低打扰）
+    private static final String FOREGROUND_SERVICE_CHANNEL_ID = "foreground_location_service_channel_02";
+    private static final String FOREGROUND_SERVICE_CHANNEL_NAME = "位置服务";
+    public static final int FOREGROUND_SERVICE_NOTIFICATION_ID = 10086; // 固定前台服务通知ID
+
+    // ---------------------- 核心：任务通知（循环响铃+修复系统默认铃声） ----------------------
+    private static int getNotificationId(String taskId) {
+        return taskId.hashCode() & 0xFFFFFF; // 确保通知ID唯一且非负
+    }
+
+    public static void show(Context context, String taskId, String positionId, String taskDescription) {
+        if (context == null || taskId == null || positionId == null) {
+            return;
+        }
+
+        NotificationManager notificationManager = 
+            (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+        if (notificationManager == null) {
+            return;
+        }
+
+        // 1. 初始化通知渠道（配置循环铃声参数，使用修复后的铃声获取方式）
+        createNotificationChannel(notificationManager);
+
+        // 2. 点击跳转Intent（携带任务/位置参数，适配API 30页面栈）
+        Intent jumpIntent = new Intent(context, LocationActivity.class);
+        jumpIntent.putExtra("EXTRA_POSITION_ID", positionId);
+        jumpIntent.putExtra("EXTRA_TASK_ID", taskId);
+        jumpIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
+
+        // 3. PendingIntent（API 30强制加IMMUTABLE，避免安全异常）
+        PendingIntent pendingIntent = PendingIntent.getActivity(
+            context,
+            getNotificationId(taskId),
+            jumpIntent,
+            PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT
+        );
+
+        // 4. 构建通知（核心：循环响铃+修复的系统默认铃声）
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, TASK_NOTIFICATION_CHANNEL_ID)
+            .setSmallIcon(R.mipmap.ic_launcher) // API 30强制要求，否则通知不显示
+            .setContentTitle("任务提醒")
+            .setContentText(taskDescription)
+            .setContentIntent(pendingIntent)
+            .setAutoCancel(true) // 点击后取消通知，停止循环响铃
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT) // 确保铃声能正常播放（API 30规则）
+            //.setVibrationPattern(new long[]{0, 300, 200, 300}) // 震动与铃声同步循环
+            .setOnlyAlertOnce(false); // 重复通知也触发循环提醒
+
+        // 关键修复：用RingtoneManager获取系统默认通知铃声（替代废弃的NotificationManager.getDefaultUri）
+        Uri defaultNotificationRingtone = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
+        if (defaultNotificationRingtone != null) {
+            builder.setSound(defaultNotificationRingtone); // 设置系统默认铃声
+        } else {
+            builder.setDefaults(NotificationCompat.DEFAULT_SOUND); // 极端情况：铃声Uri为空时，用默认提醒音兜底
+        }
+
+        // 5. 循环响铃核心：设置FLAG_INSISTENT（通知未取消则持续循环）
+        Notification notification = builder.build();
+        notification.flags |= Notification.FLAG_INSISTENT;
+
+        // 6. 显示通知（触发循环响铃）
+        notificationManager.notify(getNotificationId(taskId), notification);
+    }
+
+    // ---------------------- 核心：创建通知渠道（修复铃声配置，适配API 30） ----------------------
+    private static void createNotificationChannel(NotificationManager notificationManager) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            // 1. 任务通知渠道（用修复后的方式配置系统默认铃声）
+            NotificationChannel taskChannel = new NotificationChannel(
+                TASK_NOTIFICATION_CHANNEL_ID,
+                TASK_NOTIFICATION_CHANNEL_NAME,
+                NotificationManager.IMPORTANCE_DEFAULT // 重要性≥DEFAULT，否则铃声不响（API 30规则）
+            );
+            taskChannel.setDescription("任务提醒通知，铃声循环播放至点击取消");
+            taskChannel.enableVibration(true);
+            taskChannel.setVibrationPattern(new long[]{0, 300, 200, 300});
+            taskChannel.setAllowBubbles(false); // 避免气泡打断循环铃声
+
+            // 关键修复：渠道铃声也用RingtoneManager获取（与通知Builder保持一致，确保铃声统一）
+            Uri channelDefaultRingtone = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
+            taskChannel.setSound(channelDefaultRingtone, null); // 绑定系统默认铃声到渠道
+
+            // 2. 前台服务渠道（低打扰，无声无震动）
+            NotificationChannel foregroundChannel = new NotificationChannel(
+                FOREGROUND_SERVICE_CHANNEL_ID,
+                FOREGROUND_SERVICE_CHANNEL_NAME,
+                NotificationManager.IMPORTANCE_LOW
+            );
+            foregroundChannel.setDescription("位置服务运行中，无声音/震动提醒");
+            foregroundChannel.enableVibration(false);
+            foregroundChannel.setSound(null, null); // 明确关闭铃声
+            foregroundChannel.setShowBadge(false);
+
+            // 注册渠道（API 30覆盖旧配置，确保修复后的铃声生效）
+            notificationManager.createNotificationChannel(taskChannel);
+            notificationManager.createNotificationChannel(foregroundChannel);
+        }
+    }
+
+    // ---------------------- 原有功能：取消任务通知（停止循环响铃） ----------------------
+    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)); // 取消后循环铃声自动停止
+        }
+    }
+
+    // ---------------------- 前台服务通知（适配API 30，无声无震动） ----------------------
+    public static Notification createForegroundServiceNotification(Context context, String serviceStatus) {
+        if (context == null) {
+            throw new IllegalArgumentException("Context cannot be null for foreground service notification");
+        }
+
+        // 确保前台服务渠道已创建（低打扰配置）
+        NotificationManager notificationManager = 
+            (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+        if (notificationManager != null) {
+            createNotificationChannel(notificationManager);
+        }
+
+        // 点击跳转Intent
+        Intent jumpIntent = new Intent(context, LocationActivity.class);
+        jumpIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
+
+        // PendingIntent（API 30必加IMMUTABLE）
+        PendingIntent pendingIntent = PendingIntent.getActivity(
+            context,
+            FOREGROUND_SERVICE_NOTIFICATION_ID,
+            jumpIntent,
+            PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT
+        );
+
+        // 构建前台服务通知（无声无震动，符合低打扰）
+        return new NotificationCompat.Builder(context, FOREGROUND_SERVICE_CHANNEL_ID)
+            .setSmallIcon(R.mipmap.ic_launcher)
+            .setContentTitle("位置服务运行中")
+            .setContentText(serviceStatus)
+            .setContentIntent(pendingIntent)
+            .setOngoing(true) // 不可手动清除（前台服务规范）
+            .setPriority(NotificationCompat.PRIORITY_LOW)
+            .setDefaults(0) // 禁用所有默认提醒（无声无震动）
+            .build();
+    }
+
+    // ---------------------- 前台服务通知状态更新（适配API 30） ----------------------
+    public static void updateForegroundServiceStatus(Context context, String newServiceStatus) {
+        if (context == null) {
+            return;
+        }
+        Notification updatedNotification = createForegroundServiceNotification(context, newServiceStatus);
+        NotificationManager notificationManager = 
+            (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+        if (notificationManager != null) {
+            notificationManager.notify(FOREGROUND_SERVICE_NOTIFICATION_ID, updatedNotification);
+        }
+    }
+}
+

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

@@ -0,0 +1,69 @@
+package cc.winboll.studio.positions.utils;
+
+/**
+ * @Author ZhanGSKen<zhangsken@qq.com>
+ * @Date 2024/07/19 14:30:57
+ * @Describe 应用服务组件工具类
+ */
+import android.app.ActivityManager;
+import android.content.Context;
+import android.content.Intent;
+import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.positions.services.AssistantService;
+import cc.winboll.studio.positions.services.MainService;
+import java.util.List;
+
+public class ServiceUtil {
+    public final static String TAG = "ServiceUtil";
+
+    public static boolean isServiceAlive(Context context, String szServiceName) {
+        // 获取Activity管理者对象
+        ActivityManager manager = (ActivityManager) context
+            .getSystemService(Context.ACTIVITY_SERVICE);
+        // 获取正在运行的服务（此处设置最多取1000个）
+        List<ActivityManager.RunningServiceInfo> runningServices = manager
+            .getRunningServices(1000);
+        if (runningServices.size() <= 0) {
+            return false;
+        }
+        // 遍历，若存在名字和传入的serviceName的一致则说明存在
+        for (ActivityManager.RunningServiceInfo runningServiceInfo : runningServices) {
+            if (runningServiceInfo.service.getClassName().equals(szServiceName)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+	public static void stopAutoService(Context context) {
+		AppConfigsUtil appConfigsUtil = AppConfigsUtil.getInstance(context);
+		appConfigsUtil.setIsEnableMainService(false);
+		appConfigsUtil.saveConfigs();
+		// 关闭并设置主服务
+		Intent intent1 = new Intent(context, MainService.class);
+		intent1.putExtra(MainService.EXTRA_IS_SETTING_TO_ENABLE, false);
+		context.stopService(intent1); // 先停止旧服务
+		context.startService(intent1); // 传入新的启动标志位，返回给系统
+		// 关闭并设置主服务守护进程
+		Intent intent2 = new Intent(context, AssistantService.class);
+		intent2.putExtra(AssistantService.EXTRA_IS_SETTING_TO_ENABLE, false);
+		context.stopService(intent2); // 先停止旧服务
+		context.startService(intent2); // 传入新的启动标志位，返回给系统
+		// 再次关闭所有服务
+		context.stopService(intent1);
+		context.stopService(intent2);
+
+		LogUtils.d(TAG, "stopAutoService");
+	}
+
+	public static void startAutoService(Context context) {
+		AppConfigsUtil appConfigsUtil = AppConfigsUtil.getInstance(context);
+		appConfigsUtil.setIsEnableMainService(true);
+		appConfigsUtil.saveConfigs();
+		Intent intent = new Intent(context, MainService.class);
+		intent.putExtra(MainService.EXTRA_IS_SETTING_TO_ENABLE, true);
+		context.startService(intent);
+		LogUtils.d(TAG, "startAutoService");
+	}
+}

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

@@ -0,0 +1,254 @@
+package cc.winboll.studio.positions.views;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/10/22 02:15
+ * @Describe DateTimePickerPopup
+ */
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.NumberPicker;
+import android.widget.PopupWindow;
+import java.util.Calendar;
+import cc.winboll.studio.positions.R;
+import cc.winboll.studio.positions.utils.DensityUtils;
+
+/**
+ * 日期时间选择弹窗（竖直滚动行：年、月、日、时、分）
+ */
+public class DateTimePickerPopup extends PopupWindow {
+	public static final String TAG = "DateTimePickerPopup";
+
+    private Context mContext;
+    private NumberPicker mPickerYear;
+    private NumberPicker mPickerMonth;
+    private NumberPicker mPickerDay;
+    private NumberPicker mPickerHour;
+    private NumberPicker mPickerMinute;
+    private Button mBtnCancel;
+    private Button mBtnConfirm;
+    private OnDateTimeSelectedListener mListener;
+
+    // 时间范围默认值
+    private int mMinYear = 2000;
+    private int mMaxYear = Calendar.getInstance().get(Calendar.YEAR) + 10;
+    private int mMinMonth = 1;
+    private int mMaxMonth = 12;
+    private int mMinDay = 1;
+    private int mMaxDay = 31;
+    private int mMinHour = 0;
+    private int mMaxHour = 23;
+    private int mMinMinute = 0;
+    private int mMaxMinute = 59;
+
+    // 默认选中时间
+    private int mDefaultYear;
+    private int mDefaultMonth;
+    private int mDefaultDay;
+    private int mDefaultHour;
+    private int mDefaultMinute;
+
+    /**
+     * 日期时间选择回调
+     */
+    public interface OnDateTimeSelectedListener {
+        void onDateTimeSelected(int year, int month, int day, int hour, int minute);
+        void onCancel();
+    }
+
+    /**
+     * Builder 模式
+     */
+    public static class Builder {
+        private Context mContext;
+        private DateTimePickerPopup mPopup;
+
+        public Builder(Context context) {
+            this.mContext = context;
+            mPopup = new DateTimePickerPopup(context);
+            Calendar calendar = Calendar.getInstance();
+            mPopup.mDefaultYear = calendar.get(Calendar.YEAR);
+            mPopup.mDefaultMonth = calendar.get(Calendar.MONTH) + 1;
+            mPopup.mDefaultDay = calendar.get(Calendar.DAY_OF_MONTH);
+            mPopup.mDefaultHour = calendar.get(Calendar.HOUR_OF_DAY);
+            mPopup.mDefaultMinute = calendar.get(Calendar.MINUTE);
+        }
+
+        public Builder setDateTimeRange(int minYear, int maxYear, int minMonth, int maxMonth,
+                                       int minDay, int maxDay, int minHour, int maxHour,
+                                       int minMinute, int maxMinute) {
+            mPopup.mMinYear = minYear;
+            mPopup.mMaxYear = maxYear;
+            mPopup.mMinMonth = minMonth;
+            mPopup.mMaxMonth = maxMonth;
+            mPopup.mMinDay = minDay;
+            mPopup.mMaxDay = maxDay;
+            mPopup.mMinHour = minHour;
+            mPopup.mMaxHour = maxHour;
+            mPopup.mMinMinute = minMinute;
+            mPopup.mMaxMinute = maxMinute;
+            return this;
+        }
+
+        public Builder setDefaultDateTime(int year, int month, int day, int hour, int minute) {
+            mPopup.mDefaultYear = year;
+            mPopup.mDefaultMonth = month;
+            mPopup.mDefaultDay = day;
+            mPopup.mDefaultHour = hour;
+            mPopup.mDefaultMinute = minute;
+            return this;
+        }
+
+        public Builder setOnDateTimeSelectedListener(OnDateTimeSelectedListener listener) {
+            mPopup.mListener = listener;
+            return this;
+        }
+
+        public DateTimePickerPopup build() {
+            mPopup.initView();
+            mPopup.initPickers();
+            mPopup.bindButtonClick();
+            mPopup.setPopupStyle();
+            return mPopup;
+        }
+    }
+
+    private DateTimePickerPopup(Context context) {
+        super(context);
+        this.mContext = context;
+    }
+
+    private void initView() {
+        LayoutInflater inflater = LayoutInflater.from(mContext);
+        View rootView = inflater.inflate(R.layout.dialog_date_time_picker, null, false);
+        setContentView(rootView);
+
+        mPickerYear = (NumberPicker) rootView.findViewById(R.id.picker_year);
+        mPickerMonth = (NumberPicker) rootView.findViewById(R.id.picker_month);
+        mPickerDay = (NumberPicker) rootView.findViewById(R.id.picker_day);
+        mPickerHour = (NumberPicker) rootView.findViewById(R.id.picker_hour);
+        mPickerMinute = (NumberPicker) rootView.findViewById(R.id.picker_minute);
+        mBtnCancel = (Button) rootView.findViewById(R.id.btn_cancel);
+        mBtnConfirm = (Button) rootView.findViewById(R.id.btn_confirm);
+    }
+
+    private void initPickers() {
+        // 初始化年选择器
+        mPickerYear.setMinValue(mMinYear);
+        mPickerYear.setMaxValue(mMaxYear);
+        mPickerYear.setValue(mDefaultYear);
+        mPickerYear.setWrapSelectorWheel(false);
+
+        // 初始化月选择器
+        mPickerMonth.setMinValue(mMinMonth);
+        mPickerMonth.setMaxValue(mMaxMonth);
+        mPickerMonth.setValue(mDefaultMonth);
+        mPickerMonth.setWrapSelectorWheel(false);
+
+        // 初始化日选择器（根据年月动态调整范围）
+        updateDayRange(mDefaultYear, mDefaultMonth);
+        mPickerDay.setValue(mDefaultDay);
+        mPickerDay.setWrapSelectorWheel(false);
+
+        // 初始化时选择器
+        mPickerHour.setMinValue(mMinHour);
+        mPickerHour.setMaxValue(mMaxHour);
+        mPickerHour.setValue(mDefaultHour);
+        mPickerHour.setWrapSelectorWheel(false);
+
+        // 初始化分选择器
+        mPickerMinute.setMinValue(mMinMinute);
+        mPickerMinute.setMaxValue(mMaxMinute);
+        mPickerMinute.setValue(mDefaultMinute);
+        mPickerMinute.setWrapSelectorWheel(false);
+
+        // 年月变化时更新日范围（Java 7 匿名内部类）
+        mPickerYear.setOnValueChangedListener(new NumberPicker.OnValueChangeListener() {
+            @Override
+            public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+                updateDayRange(newVal, mPickerMonth.getValue());
+            }
+        });
+
+        mPickerMonth.setOnValueChangedListener(new NumberPicker.OnValueChangeListener() {
+            @Override
+            public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+                updateDayRange(mPickerYear.getValue(), newVal);
+            }
+        });
+    }
+
+    private void updateDayRange(int year, int month) {
+        int maxDay;
+        switch (month) {
+            case 2:
+                if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
+                    maxDay = 29;
+                } else {
+                    maxDay = 28;
+                }
+                break;
+            case 4:
+            case 6:
+            case 9:
+            case 11:
+                maxDay = 30;
+                break;
+            default:
+                maxDay = 31;
+        }
+        mPickerDay.setMaxValue(maxDay);
+        if (mPickerDay.getValue() > maxDay) {
+            mPickerDay.setValue(maxDay);
+        }
+    }
+
+    private void bindButtonClick() {
+        // 取消按钮（Java 7 匿名内部类）
+        mBtnCancel.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                dismiss();
+                if (mListener != null) {
+                    mListener.onCancel();
+                }
+            }
+        });
+
+        // 确认按钮（Java 7 匿名内部类）
+        mBtnConfirm.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                int year = mPickerYear.getValue();
+                int month = mPickerMonth.getValue();
+                int day = mPickerDay.getValue();
+                int hour = mPickerHour.getValue();
+                int minute = mPickerMinute.getValue();
+
+                if (mListener != null) {
+                    mListener.onDateTimeSelected(year, month, day, hour, minute);
+                }
+                dismiss();
+            }
+        });
+    }
+
+    private void setPopupStyle() {
+        int width = (int) (DensityUtils.getScreenWidth(mContext) * 0.85f);
+        int height = ViewGroup.LayoutParams.WRAP_CONTENT;
+
+        setWidth(width);
+        setHeight(height);
+        setFocusable(true);
+        setOutsideTouchable(true);
+        setBackgroundDrawable(mContext.getResources().getDrawable(R.drawable.bg_dialog_round));
+        setAnimationStyle(R.style.PopupDateTimePickerAnim);
+    }
+
+    public void showAsDropDown(View anchorView) {
+        super.showAsDropDown(anchorView, 0, DensityUtils.dp2px(mContext, 10));
+    }
+}

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

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

positions/src/main/res/anim/popup_date_time_picker_in.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+    android:duration="300">
+    <translate
+        android:fromYDelta="50%"
+        android:toYDelta="0%"
+        android:interpolator="@android:anim/decelerate_interpolator" />
+    <alpha
+        android:fromAlpha="0.6"
+        android:toAlpha="1.0"
+        android:interpolator="@android:anim/decelerate_interpolator" />
+</set>

positions/src/main/res/anim/popup_date_time_picker_out.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+    android:duration="250">
+    <translate
+        android:fromYDelta="0%"
+        android:toYDelta="50%"
+        android:interpolator="@android:anim/accelerate_interpolator" />
+    <alpha
+        android:fromAlpha="1.0"
+        android:toAlpha="0.6"
+        android:interpolator="@android:anim/accelerate_interpolator" />
+</set>

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_dialog_round.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <!-- 白色背景 -->
+    <solid android:color="#FFFFFF" />
+    <!-- 圆角（12dp，可根据需求调整） -->
+    <corners android:radius="12dp" />
+    <!-- 轻微阴影（增强层次感） -->
+    <stroke
+        android:width="1dp"
+        android:color="#00000008" /> <!-- 透明黑色阴影，避免生硬 -->
+</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/btn_dialog_cancel.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <!-- 透明背景 -->
+    <solid android:color="#00000000" />
+    <!-- 灰色边框（与取消按钮文字同色） -->
+    <stroke
+        android:width="1dp"
+        android:color="#FF333333" />
+    <!-- 圆角（与弹窗一致，12dp） -->
+    <corners android:radius="12dp" />
+</shape>
+

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

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <!-- 填充色（示例深灰色，可改为 #FF007AFF 等主题色） -->
+    <solid android:color="#FF333333" />
+    <!-- 圆角（与弹窗一致） -->
+    <corners android:radius="12dp" />
+</shape>
+

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,67 @@
 <?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="match_parent"
-    android:gravity="center_horizontal|center_vertical"
-    android:orientation="vertical"
-    android:padding="20dp">
+<RelativeLayout
+	xmlns:android="http://schemas.android.com/apk/res/android"
+	android:layout_width="match_parent"
+	android:layout_height="match_parent"
+	android:padding="20dp">
 
-    <!-- 标题 -->
-    <TextView
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="实时位置信息"
-        android:textSize="22sp"
-        android:textStyle="bold"/>
+	<LinearLayout
+		android:id="@+id/layout_location_info"
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:layout_centerHorizontal="true"
+		android:layout_marginTop="30dp"
+		android:orientation="vertical"
+		android:gravity="center_horizontal">
 
-    <!-- 经度显示（大字体，清晰可见） -->
-    <TextView
-        android:id="@+id/tv_longitude"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="当前经度：等待更新..."
-        android:textSize="18sp"/>
+		<TextView
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:text="实时位置信息"
+			android:textSize="22sp"
+			android:textStyle="bold"/>
 
-    <!-- 纬度显示（大字体，清晰可见） -->
-    <TextView
-        android:id="@+id/tv_latitude"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="当前纬度：等待更新..."
-        android:textSize="18sp"/>
+		<TextView
+			android:id="@+id/tv_longitude"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:text="当前经度：等待更新..."
+			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>
+
+	<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"/>
+
+	<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"
+		android:onClick="addNewPosition"/>
+
+</RelativeLayout>
 

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

@@ -6,46 +6,34 @@
 	android:layout_height="match_parent"
 	android:orientation="vertical">
 
-	<com.google.android.material.appbar.AppBarLayout
+	<androidx.appcompat.widget.Toolbar
+		android:id="@+id/toolbar"
+		android:layout_width="match_parent"
+		android:layout_height="?attr/actionBarSize"
+		android:background="?attr/colorPrimary"
+		android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar"/>
+
+	<Switch
+		android:id="@+id/switch_service_control"
+		android:layout_margin="16dp"
+		android:text="GPS服务开关"
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"/>
+
+	<Button
 		android:layout_width="match_parent"
 		android:layout_height="wrap_content"
-		android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar">
+		android:layout_margin="16dp"
+		android:onClick="onPositions"
+		android:text="位置与任务管理"
+		android:id="@+id/btn_manage_positions"/>
 
-		<androidx.appcompat.widget.Toolbar
-			android:id="@+id/toolbar"
-			android:layout_width="match_parent"
-			android:layout_height="?attr/actionBarSize"
-			app:popupTheme="@style/ThemeOverlay.AppCompat.Light"/>
-
-	</com.google.android.material.appbar.AppBarLayout>
-
-	<LinearLayout
-		android:orientation="vertical"
+	<Button
 		android:layout_width="match_parent"
-		android:layout_height="0dp"
-		android:layout_weight="1.0"
-		android:gravity="center_vertical|center_horizontal">
-
-		<Button
-			android:layout_width="wrap_content"
-			android:layout_height="wrap_content"
-			android:text="Positions"
-			android:onClick="onPositions"/>
-
-	</LinearLayout>
-
-	<LinearLayout
-		android:orientation="vertical"
-		android:layout_width="match_parent"
-		android:layout_height="0dp"
-		android:layout_weight="1.0">
-
-		<cc.winboll.studio.libappbase.LogView
-			android:layout_width="match_parent"
-			android:layout_height="match_parent"
-			android:id="@+id/logview"/>
-
-	</LinearLayout>
+		android:layout_height="wrap_content"
+		android:layout_margin="16dp"
+		android:onClick="onLog"
+		android:text="查看应用日志"/>
 
 </LinearLayout>
 

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

@@ -0,0 +1,74 @@
+<?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="@drawable/bg_dialog_round">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="center">
+
+        <NumberPicker
+            android:id="@+id/picker_year"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1" />
+
+        <NumberPicker
+            android:id="@+id/picker_month"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1" />
+
+        <NumberPicker
+            android:id="@+id/picker_day"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1" />
+
+        <NumberPicker
+            android:id="@+id/picker_hour"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1" />
+
+        <NumberPicker
+            android:id="@+id/picker_minute"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1" />
+    </LinearLayout>
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="end"
+        android:layout_marginTop="16dp"
+        android:spacing="12dp">
+
+        <Button
+            android:id="@+id/btn_cancel"
+            android:layout_width="wrap_content"
+            android:layout_height="42dp"
+            android:minWidth="80dp"
+            android:background="@drawable/btn_dialog_cancel"
+            android:text="取消"
+            android:textSize="16sp" />
+
+        <Button
+            android:id="@+id/btn_confirm"
+            android:layout_width="wrap_content"
+            android:layout_height="42dp"
+            android:minWidth="80dp"
+            android:background="@drawable/btn_dialog_confirm"
+            android:text="确认"
+            android:textSize="16sp"
+            android:textColor="@android:color/white" />
+    </LinearLayout>
+</LinearLayout>
+

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,120 @@
+<?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"/>
+
+	<LinearLayout
+		android:orientation="horizontal"
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:layout_marginTop="12dp"
+		android:gravity="center_vertical">
+
+		<RadioGroup
+			android:id="@+id/rg_distance_condition"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:orientation="horizontal"
+			android:layout_marginRight="10dp">
+
+			<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"/>
+
+		</RadioGroup>
+
+		<EditText
+			android:id="@+id/et_edit_distance"
+			android:layout_width="0dp"
+			android:layout_weight="1.0"
+			android:layout_height="wrap_content"
+			android:hint="输入距离（米）"
+			android:inputType="number"
+			android:maxLines="1"
+			android:textSize="14sp"/>
+
+		<TextView
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:text="米"
+			android:layout_marginRight="10dp"/>
+
+	</LinearLayout>
+
+	<LinearLayout
+		android:orientation="horizontal"
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:layout_marginTop="12dp"
+		android:gravity="center_vertical">
+
+		<Button
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:text="开始时间"
+			android:id="@+id/btn_select_time"/>
+		
+		<TextView
+			android:id="@+id/tv_selected_time"
+			android:layout_width="0dp"
+			android:layout_height="wrap_content"
+			android:text="Text"
+			android:layout_weight="1.0"/>
+
+
+	</LinearLayout>
+
+	<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,178 @@
+<?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_distance"/>
+
+		<RadioGroup
+			android:id="@+id/rg_distance_switch"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:orientation="horizontal"
+			android:layout_marginLeft="8dp">
+
+			<RadioButton
+				android:id="@+id/rb_distance_disable"
+				android:layout_width="wrap_content"
+				android:layout_height="wrap_content"
+				android:text="禁用"
+				android:textSize="14sp"
+				android:checked="true"/>
+
+			<RadioButton
+				android:id="@+id/rb_distance_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_save"
+			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"/>
+
+			<TextView
+				android:id="@+id/tv_task_count"
+				android:layout_width="wrap_content"
+				android:layout_height="match_parent"
+				android:gravity="center_vertical"
+				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_empty.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="100dp"
+    android:gravity="center"
+    android:orientation="vertical">
+
+    <TextView
+        android:id="@+id/tv_empty_tip"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textColor="@color/colorGrayText"
+        android:textSize="16sp" />
+
+</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_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,77 @@
+<?xml version="1.0" encoding="utf-8"?>
+<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">
+
+	<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"/>
+
+	<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="任务：无描述"/>
+
+	<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="条件：距离 &gt; 0 米"/>
+
+	<LinearLayout
+		android:orientation="horizontal"
+		android:layout_marginTop="6dp"
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:layout_below="@id/tv_simple_distance_cond"
+		android:id="@+id/ll_starttime"
+		android:gravity="center_vertical">
+
+		<TextView
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:textSize="14sp"
+			android:textColor="#666666"
+			android:text="开始时间："/>
+
+		<TextView
+			android:id="@+id/tv_starttime"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:textSize="14sp"
+			android:textColor="#666666"
+			android:text=""/>
+
+	</LinearLayout>
+
+	<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/ll_starttime"
+		android:text="状态：已启用"/>
+
+</RelativeLayout>
+

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

@@ -0,0 +1,110 @@
+<?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:orientation="vertical"
+		android:layout_width="0dp"
+		android:layout_height="wrap_content"
+		android:layout_weight="1.0">
+
+		<LinearLayout
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:orientation="horizontal">
+
+			<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"/>
+
+		</LinearLayout>
+
+		<LinearLayout
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:orientation="horizontal">
+
+			<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:orientation="horizontal"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:layout_below="@id/tv_simple_distance_cond"
+			android:id="@+id/ll_starttime"
+			android:gravity="center_vertical">
+
+			<TextView
+				android:layout_width="wrap_content"
+				android:layout_height="wrap_content"
+				android:textSize="12sp"
+				android:textColor="#666666"
+				android:text="开始时间："/>
+
+			<TextView
+				android:id="@+id/tv_starttime"
+				android:layout_width="wrap_content"
+				android:layout_height="wrap_content"
+				android:textSize="12sp"
+				android:textColor="#666666"
+				android:text=""/>
+
+		</LinearLayout>
+
+		<LinearLayout
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:orientation="horizontal"
+			android:layout_gravity="center">
+
+			<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>
+
+</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-zh/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">悟空笔记</string>
+</resources>

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

@@ -3,4 +3,37 @@
     <color name="colorPrimary">#009688</color>
     <color name="colorPrimaryDark">#00796B</color>
     <color name="colorAccent">#FF9800</color>
-</resources>
+	<!-- 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> <!-- 黄色（备用：如“提醒”标识） -->
+    <color name="color_text_primary">#333333</color>
+    <color name="color_gray">#999999</color>
+    <color name="color_gray_light">#F5F5F5</color>
+    <color name="color_shadow">#1A000000</color>
+    <color name="color_primary">#2196F3</color> <!-- 主题蓝 -->
+    <color name="color_primary_dark">#1976D2</color> <!-- 主题蓝加深 -->
+	
+</resources>

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

@@ -1,4 +1,3 @@
 <resources>
     <string name="app_name">Positions</string>
-    
 </resources>

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

@@ -8,4 +8,10 @@
         <item name="colorAccent">@color/colorAccent</item>
     </style>
 
+	<style name="PopupDateTimePickerAnim" parent="android:Animation">
+		<item name="android:windowEnterAnimation">@anim/popup_date_time_picker_in</item>
+		<item name="android:windowExitAnimation">@anim/popup_date_time_picker_out</item>
+	</style>
+
+
 </resources>