<positions>APK 15.0.10 release Publish.

positions/README.md

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

positions/build.properties

@@ -1,8 +1,8 @@
 #Created by .winboll/winboll_app_build.gradle
-#Wed Oct 01 21:01:10 HKT 2025
-stageCount=5
+#Tue Oct 07 02:42:31 HKT 2025
+stageCount=11
 libraryProject=
 baseVersion=15.0
-publishVersion=15.0.4
+publishVersion=15.0.10
 buildCount=0
-baseBetaVersion=15.0.5
+baseBetaVersion=15.0.11

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/java/cc/winboll/studio/positions/App.java

@@ -41,6 +41,7 @@ import java.util.Arrays;
 import java.util.Date;
 import java.util.LinkedHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
+import cc.winboll.studio.libaes.utils.WinBoLLActivityManager;
 
 public class App extends GlobalApplication {
 
@@ -51,6 +52,8 @@ public class App extends GlobalApplication {
         super.onCreate();
 		setIsDebuging(BuildConfig.DEBUG);
 		
+		WinBoLLActivityManager.init(this);
+		
         // 初始化 Toast 框架
         ToastUtils.init(this);
         // 设置 Toast 布局样式

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

@@ -1,24 +1,26 @@
 package cc.winboll.studio.positions;
 
-import android.content.ComponentName;
-import android.content.Context;
+import android.Manifest;
+import android.app.Activity;
 import android.content.Intent;
-import android.content.ServiceConnection;
 import android.content.pm.PackageManager;
 import android.os.Build;
 import android.os.Bundle;
-import android.os.IBinder;
 import android.view.View;
+import android.widget.Button;
 import android.widget.CompoundButton;
 import android.widget.Switch;
-import androidx.appcompat.app.AppCompatActivity;
+import android.widget.Toast;
+import androidx.annotation.NonNull;
 import androidx.appcompat.widget.Toolbar;
-import cc.winboll.studio.libappbase.LogActivity;
+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 com.hjq.toast.ToastUtils;
 
 /**
  * 主页面：仅负责
@@ -26,18 +28,31 @@ import com.hjq.toast.ToastUtils;
  * 2. 跳转至“位置管理页（LocationActivity）”和“日志页（LogActivity）”
  * 3. Java 7 语法适配：无 Lambda、显式接口实现、兼容低版本
  */
-public class MainActivity extends AppCompatActivity {
+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;
 
+
+    @Override
+    public Activity getActivity() {
+        return this;
+    }
+
+    @Override
+    public String getTag() {
+        return TAG;
+    }
+
     // ---------------------- 服务连接回调（仅用于获取服务状态，不依赖服务执行核心逻辑） ----------------------
 //    private final ServiceConnection mServiceConn = new ServiceConnection() {
 //        /**
@@ -69,8 +84,8 @@ public class MainActivity extends AppCompatActivity {
 
         // 1. 初始化顶部 Toolbar（保留原逻辑，设置页面标题）
         initToolbar();
-        // 2. 初始化服务控制开关（核心功能：绑定开关点击事件）
-        initServiceSwitch();
+        // 2. 初始化其他控件
+        initViews();
         // 3. 检查并申请位置权限（含后台GPS权限，确保服务启动前权限就绪）
         if (!checkLocationPermissions()) {
             requestLocationPermissions();
@@ -99,17 +114,20 @@ public class MainActivity extends AppCompatActivity {
         setSupportActionBar(mToolbar);
         // 给ActionBar设置标题（先判断非空，避免空指针异常）
         if (getSupportActionBar() != null) {
-            getSupportActionBar().setTitle("位置管理");
+            getSupportActionBar().setTitle(getString(R.string.app_name));
         }
     }
 
     /**
      * 初始化服务控制开关：读取SP状态、绑定点击事件（含权限检查）
      */
-    private void initServiceSwitch() {
+    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
@@ -136,6 +154,8 @@ public class MainActivity extends AppCompatActivity {
 //						}
 						stopService(new Intent(MainActivity.this, MainService.class));
 					}
+
+					mManagePositionsButton.setEnabled(isChecked);
 				}
 			});
     }
@@ -166,7 +186,7 @@ public class MainActivity extends AppCompatActivity {
      * 无服务状态限制，直接跳转
      */
     public void onLog(View view) {
-        LogActivity.startLogActivity(this); // 调用LogActivity静态方法跳转（保留原逻辑）
+        WinBoLLActivityManager.getInstance().startLogActivity(this); // 调用LogActivity静态方法跳转（保留原逻辑）
     }
 
     // ---------------------- 新增：位置权限处理（适配Java7 + 后台GPS权限） ----------------------
@@ -190,49 +210,57 @@ public class MainActivity extends AppCompatActivity {
         return hasForegroundPerm && hasBackgroundPerm;
     }
 
-    /**
-     * 申请「前台+后台」位置权限（弹出系统权限弹窗，适配版本差异）
-     */
 	private void requestLocationPermissions() {
-        String[] permissions;
-        // Java7 显式版本判断：Android 10+ 需同时申请前台+后台权限
+		// 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) {
-            permissions = new String[]{
-				android.Manifest.permission.ACCESS_FINE_LOCATION,
-				android.Manifest.permission.ACCESS_BACKGROUND_LOCATION
-            };
-        } else {
-            // 低版本仅需申请前台权限
-            permissions = new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION};
+				// 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(); 
 		}
-        // 触发系统权限申请（Java7 显式调用requestPermissions，无方法引用）
-        requestPermissions(permissions, REQUEST_LOCATION_PERMISSIONS);
 	}
 
-    /**
-     * 处理权限申请结果（系统弹窗用户选择后回调，Java7 显式重写方法）
-     */
+// 【必须补充】权限申请结果回调（处理用户同意/拒绝逻辑）
 	@Override
-    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+	public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
 		super.onRequestPermissionsResult(requestCode, permissions, grantResults);
-        // 仅处理位置权限的申请结果
+		// 处理前台权限申请结果
 		if (requestCode == REQUEST_LOCATION_PERMISSIONS) {
-            boolean allGranted = true;
-            // Java7 显式for循环遍历结果（无增强for简化写法）
-            for (int i = 0; i < grantResults.length; i++) {
-                if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
-                    allGranted = false;
-                    break; // 有一个权限未通过，直接终止判断
-                }
-            }
-
-            // 提示用户权限结果，并处理开关状态
-            if (allGranted) {
-                ToastUtils.show("已获取位置权限（含后台），可正常使用定位功能");
+			if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+				// 前台权限同意：自动尝试申请后台权限（如果是API 29+）
+				requestLocationPermissions();
 			} else {
-                ToastUtils.show("位置权限未完全授予，无法后台获取GPS数据，请在设置中开启");
+				// 前台权限拒绝：提示用户（可选：引导跳转到应用设置页）
+				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

@@ -3,360 +3,459 @@ package cc.winboll.studio.positions.activities;
 /**
  * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
  * @Date 2025/09/29 18:22
- * @Describe 位置列表页面（直连服务数据+移除绑定，兼容服务私有字段）
+ * @Describe 位置列表页面（适配MainService GPS接口+规范服务交互+完善生命周期）
  */
+import android.app.Activity;
+import android.content.ComponentName;
 import android.content.Context;
-import android.content.SharedPreferences;
+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.appcompat.app.AppCompatActivity;
 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.models.PositionTaskModel;
 import cc.winboll.studio.positions.services.MainService;
 import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
- * 核心调整说明：
- * 1. 移除服务绑定逻辑，但不直接访问服务私有字段（解决mPositionList未知问题）
- * 2. 通过服务提供的 PUBLIC 方法（如getPositionList、addPosition）操作数据，符合封装规范
- * 3. 保留“直连服务实例”的核心需求，避免绑定，但尊重服务数据私有性
- * 4. 兼容Java 7语法，无Lambda、显式类型转换
+ * 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";
 
-	// SP配置常量（判断服务是否运行）
-    private static final String SP_SERVICE_CONFIG = "service_config";
-    private static final String KEY_SERVICE_RUNNING = "is_service_running";
-    // 页面核心控件与变量
-    private RecyclerView mRecyclerView;
-    private PositionAdapter mAdapter;
-    // 直连服务实例（替代绑定，通过单例/全局初始化获取）
-    private MainService mMainService; 
-    // 缓存服务数据（从服务PUBLIC方法获取，避免重复调用）
-    private ArrayList<PositionModel> mCachedPositionList; 
-    private ArrayList<PositionTaskModel> mCachedTaskList;
+    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. 初始化服务实例（通过单例/全局方式，避免直接new导致数据重置）
-        initServiceInstance();
-        // 2. 检查服务状态（未运行/未初始化则提示关闭）
-        //checkServiceStatus();
-        // 3. 初始化RecyclerView（布局+性能优化）
-        initRecyclerViewConfig();
-        // 4. 缓存服务数据（从服务PUBLIC方法获取，不访问私有字段）
-        cacheServiceData();
-        // 5. 初始化Adapter（传缓存数据，而非直接访问服务私有字段）
-        initAdapter();
-    }
-
-    @Override
-    protected void onDestroy() {
-        super.onDestroy();
-        // 1. 清理Adapter资源
-        if (mAdapter != null) {
-            mAdapter.release();
-            mAdapter = null;
-        }
-        // 2. 置空服务实例+缓存数据（帮助GC回收）
-        mMainService = null;
-        mCachedPositionList = null;
-        mCachedTaskList = null;
-        mRecyclerView = null;
-        LogUtils.d(TAG, "页面销毁：已清理服务实例及缓存数据");
-    }
-
-    // ---------------------- 核心初始化（服务实例+数据缓存+状态检查） ----------------------
-    /**
-     * 初始化服务实例（关键：通过单例获取，确保全局唯一，避免数据重复）
-     * 注：需在DistanceRefreshService中实现单例（getInstance()方法）
-     */
-    private void initServiceInstance() {
-		// 步骤1：先启动Service（确保Service已创建，实例能被初始化）
-        
-        // 步骤2：初始化Service实例（延迟100-200ms，确保Service onCreate执行完成）
-        // （或在startService后，通过ServiceConnection绑定获取实例，更可靠）
-        //initServiceInstance();
-		
-        // 方式：通过服务PUBLIC单例方法获取实例（不直接new，避免私有数据初始化重复）
-        mMainService = MainService.getInstance();
-        
-        // 容错：若单例未初始化（如首次启动），提示并处理
-        if (mMainService == null) {
-            LogUtils.e(TAG, "服务实例初始化失败：单例未创建");
-            Toast.makeText(this, "位置服务初始化失败，请重启应用", Toast.LENGTH_SHORT).show();
-            finish();
-        }
+        // 1. 初始化视图（优先执行，避免Adapter初始化时视图为空）
+        initView();
+        // 2. 初始化GPS监听（提前创建，避免绑定服务后空指针）
+        initGpsUpdateListener();
+        // 3. 绑定MainService（最后执行，确保视图/监听已就绪）
+        bindMainService();
     }
 
     /**
-     * 检查服务状态（替代原绑定检查，通过服务PUBLIC方法判断）
+     * 初始化视图（RecyclerView）- 确保视图先于Adapter初始化
      */
-    private void checkServiceStatus() {
-        // 1. 服务实例未初始化
-        if (mMainService == null) {
-            return; // 已在initServiceInstance中处理，此处避免重复finish
-        }
-
-        // 2. 检查服务运行状态（通过服务PUBLIC方法isServiceRunning()获取，不访问私有字段）
-//        if (!mMainService.isServiceRunning()) {
-//            // 服务未运行：手动触发启动（调用服务PUBLIC方法run()）
-//            mMainService.run();
-//            LogUtils.d(TAG, "服务未运行，已通过PUBLIC方法触发启动");
-//        }
-
-        // 3. 检查SP中服务配置（双重校验，确保一致性）
-        SharedPreferences sp = getSharedPreferences(SP_SERVICE_CONFIG, Context.MODE_PRIVATE);
-        boolean isServiceConfigRunning = sp.getBoolean(KEY_SERVICE_RUNNING, false);
-        if (!isServiceConfigRunning) {
-            Toast.makeText(this, "位置服务配置未启用，数据可能无法更新", Toast.LENGTH_SHORT).show();
-        }
-    }
-
-    /**
-     * 缓存服务数据（从服务PUBLIC方法获取，解决私有字段未知问题）
-     */
-    private void cacheServiceData() {
-        if (mMainService == null) {
-            LogUtils.e(TAG, "缓存数据失败：服务实例为空");
-            mCachedPositionList = new ArrayList<PositionModel>();
-            mCachedTaskList = new ArrayList<PositionTaskModel>();
-            return;
-        }
-
-        // 从服务PUBLIC方法获取数据（不访问mPositionList，而是调用getPositionList()）
-        mCachedPositionList = mMainService.getPositionList();
-        mCachedTaskList = mMainService.getPositionTasksList();
-        
-        // 容错：若服务返回null，初始化空列表避免空指针
-        if (mCachedPositionList == null) mCachedPositionList = new ArrayList<PositionModel>();
-        if (mCachedTaskList == null) mCachedTaskList = new ArrayList<PositionTaskModel>();
-        
-        LogUtils.d(TAG, "缓存服务数据成功：位置数=" + mCachedPositionList.size() + "，任务数=" + mCachedTaskList.size());
-    }
-
-    /**
-     * 初始化RecyclerView（保留原性能优化）
-     */
-    private void initRecyclerViewConfig() {
-        mRecyclerView = (RecyclerView) findViewById(R.id.rv_position_list);
+    private void initView() {
+        mRvPosition = (RecyclerView) findViewById(R.id.rv_position_list);
+        // 1. 显式设置布局管理器（避免Adapter设置时无布局管理器崩溃）
         LinearLayoutManager layoutManager = new LinearLayoutManager(this);
         layoutManager.setOrientation(LinearLayoutManager.VERTICAL);
-        mRecyclerView.setLayoutManager(layoutManager);
-        mRecyclerView.setHasFixedSize(true); // 固定大小，优化绘制
+        mRvPosition.setLayoutManager(layoutManager);
+        // 2. 初始化本地缓存（避免首次加载时缓存为空）
+        mLocalPosCache.clear();
+        LogUtils.d(TAG, "视图初始化完成（布局管理器+本地缓存已就绪）");
     }
 
-    // ---------------------- Adapter初始化与数据交互（全通过服务PUBLIC方法） ----------------------
     /**
-     * 初始化Adapter（通过缓存数据初始化，数据更新时同步调用服务方法）
+     * 绑定MainService（Java 7 显式Intent，强化绑定安全性）
      */
-    private void initAdapter() {
-        if (mCachedPositionList == null || mCachedTaskList == null) {
-            LogUtils.e(TAG, "初始化Adapter失败：缓存数据为空");
+    private void bindMainService() {
+        // 1. 避免重复绑定（快速重建Activity时防止多绑定）
+        if (isServiceBound.get()) {
+            LogUtils.w(TAG, "无需重复绑定：MainService已绑定");
             return;
         }
 
-        // 1. 初始化Adapter（传缓存数据+服务实例，Adapter数据从缓存取，操作通过服务）
-        mAdapter = new PositionAdapter(this, mCachedPositionList, mCachedTaskList);
-        mRecyclerView.setAdapter(mAdapter);
+        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绑定请求已发起");
+        }
+    }
 
-        // 2. 删除回调：通过服务PUBLIC方法removePosition()删除，不直接操作私有字段
-        mAdapter.setOnDeleteClickListener(new PositionAdapter.OnDeleteClickListener() {
+    /**
+     * 从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 (mMainService == null || mCachedPositionList == null) {
-                    Toast.makeText(LocationActivity.this, "删除失败：服务未就绪", Toast.LENGTH_SHORT).show();
-                    return;
-                }
-                if (position < 0 || position >= mCachedPositionList.size()) {
-                    LogUtils.w(TAG, "删除失败：索引无效（" + position + "）");
-                    Toast.makeText(LocationActivity.this, "删除失败：数据位置异常", Toast.LENGTH_SHORT).show();
+                    // 安全校验（索引有效+服务绑定+缓存非空）
+                    if (position < 0 || position >= mLocalPosCache.size() || !isServiceBound.get() || mMainService == null) {
+                        LogUtils.w(TAG, "删除位置失败：索引无效/服务未就绪（索引=" + position + "，缓存量=" + mLocalPosCache.size() + "）");
                         return;
                     }
 
-                // 1. 获取要删除的位置（从缓存取，与服务数据一致）
-                PositionModel targetPos = mCachedPositionList.get(position);
-                String targetPosId = targetPos.getPositionId();
-
-                // 2. 调用服务PUBLIC方法删除（服务内部处理mPositionList/mTaskList，符合封装）
-                mMainService.removePosition(targetPosId);
-                LogUtils.d(TAG, "通过服务删除位置：ID=" + targetPosId);
-
-                // 3. 刷新缓存+Adapter（从服务重新获取数据，确保与服务一致）
-                refreshCachedDataAndAdapter();
-                Toast.makeText(LocationActivity.this, "位置已删除（含关联任务）", Toast.LENGTH_SHORT).show();
+                    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() + "（服务+缓存已同步）");
+                    }
                 }
             });
 
-        // 3. 位置保存回调：通过服务PUBLIC方法updatePosition()更新
-        mAdapter.setOnSavePositionClickListener(new PositionAdapter.OnSavePositionClickListener() {
+            // 4. 设置保存回调（保存时同步服务+本地缓存+Adapter）
+            mPositionAdapter.setOnSavePositionClickListener(new PositionAdapter.OnSavePositionClickListener() {
                 @Override
                 public void onSavePositionClick(int position, PositionModel updatedPos) {
-                // 校验：服务+数据+参数有效
-                if (mMainService == null || mCachedPositionList == null || updatedPos == null) {
-                    Toast.makeText(LocationActivity.this, "保存失败：服务或数据异常", Toast.LENGTH_SHORT).show();
-                    return;
-                }
-                if (position < 0 || position >= mCachedPositionList.size()) {
-                    LogUtils.w(TAG, "保存失败：位置索引无效");
+                    // 安全校验（索引有效+服务绑定+数据非空）
+                    if (!isServiceBound.get() || mMainService == null 
+                        || position < 0 || position >= mLocalPosCache.size() || updatedPos == null) {
+                        LogUtils.w(TAG, "保存位置失败：服务未就绪/索引无效/数据空");
+                        showToast("服务未就绪，保存失败");
                         return;
                     }
 
-                // 1. 调用服务PUBLIC方法更新数据（服务内部修改mPositionList）
+                    // 步骤1：调用服务更新（确保服务数据一致性）
                     mMainService.updatePosition(updatedPos);
-                LogUtils.d(TAG, "通过服务保存位置：ID=" + updatedPos.getPositionId());
-
-                // 2. 刷新缓存+Adapter（确保本地显示与服务一致）
-                refreshCachedDataAndAdapter();
-                Toast.makeText(LocationActivity.this, "位置信息已保存", Toast.LENGTH_SHORT).show();
+                    // 步骤2：更新本地缓存（确保缓存与服务同步）
+                    synchronized (mLocalPosCache) {
+                        mLocalPosCache.set(position, updatedPos);
+                    }
+                    // 步骤3：通知Adapter刷新（基于缓存操作，避免空数据）
+                    mPositionAdapter.notifyItemChanged(position);
+                    showToast("保存位置成功：" + updatedPos.getMemo());
+                    LogUtils.d(TAG, "保存位置完成：ID=" + updatedPos.getPositionId() + "（服务+缓存已同步）");
                 }
             });
 
-        // 4. 任务保存回调：通过服务PUBLIC方法syncAllPositionTasks()同步
-        mAdapter.setOnSavePositionTaskClickListener(new PositionAdapter.OnSavePositionTaskClickListener() {
-            @Override
-            public void onSavePositionTaskClick(PositionTaskModel newTask) {
-                if (mMainService == null || newTask == null) {
-                    Toast.makeText(LocationActivity.this, "保存失败：服务或任务数据为空", Toast.LENGTH_SHORT).show();
+            // 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;
         }
-
-                // 1. 构建新任务列表（缓存任务+新任务，去重）
-                ArrayList<PositionTaskModel> newTaskList = new ArrayList<PositionTaskModel>(mCachedTaskList);
-                // 先移除同ID旧任务（避免重复）
-                for (int i = 0; i < newTaskList.size(); i++) {
-                    PositionTaskModel oldTask = newTaskList.get(i);
-                    if (newTask.getTaskId().equals(oldTask.getTaskId())) {
-                        newTaskList.remove(i);
-                        break;
-                    }
-                }
-                // 添加新任务
-                newTaskList.add(newTask);
-
-                // 2. 调用服务PUBLIC方法同步任务（服务内部更新mTaskList）
-                mMainService.syncAllPositionTasks(newTaskList);
-                LogUtils.d(TAG, "通过服务保存任务：ID=" + newTask.getTaskId());
-
-                // 3. 刷新缓存+Adapter
-                refreshCachedDataAndAdapter();
-                Toast.makeText(LocationActivity.this, "任务信息已保存", Toast.LENGTH_SHORT).show();
-            }
-        });
+        Toast.makeText(this, content, Toast.LENGTH_SHORT).show();
     }
 	
-    // ---------------------- 页面交互（新增位置、同步GPS，全走服务PUBLIC方法） ----------------------
+	// ---------------------- 页面交互（新增位置逻辑保留，适配GPS数据） ----------------------
     /**
-     * 新增位置（调用服务addPosition()，不直接操作mPositionList）
+     * 新增位置（调用服务addPosition()，可选：用当前GPS位置初始化新位置）
      */
     public void addNewPosition(View view) {
-        // 1. 隐藏软键盘
+        // 1. 隐藏软键盘（避免软键盘遮挡操作）
         InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
         if (imm != null && getCurrentFocus() != null) {
             imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
         }
 
-        // 2. 校验服务状态
-        if (mMainService == null) {
-            Toast.makeText(this, "新增失败：服务未初始化", Toast.LENGTH_SHORT).show();
+        // 2. 安全校验（服务未绑定，不允许新增）
+        if (!isServiceBound.get() || mMainService == null) {
+            LogUtils.w(TAG, "新增位置失败：MainService未绑定");
+            showToast("服务未就绪，无法新增位置");
             return;
         }
 
-        // 3. 创建新位置模型
+        // 3. 创建新位置模型（优化：优先用当前GPS位置初始化，无则用默认值）
         PositionModel newPos = new PositionModel();
-        newPos.setPositionId(PositionModel.genPositionId()); // 生成唯一ID（PositionModel需实现）
-        newPos.setLongitude(116.404267); // 示例经度（北京）
-        newPos.setLatitude(39.915119);  // 示例纬度
-        newPos.setMemo("测试位置（可编辑备注）");
+        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); // 启用距离计算
+        newPos.setIsEnableRealPositionDistance(true); // 启用距离计算（依赖GPS）
 
-        // 4. 调用服务PUBLIC方法新增（服务内部处理mPositionList去重+添加）
+        // 4. 调用服务新增+同步本地缓存（确保缓存与服务一致）
         mMainService.addPosition(newPos);
-        LogUtils.d(TAG, "通过服务新增位置：ID=" + newPos.getPositionId());
+        synchronized (mLocalPosCache) {
+            mLocalPosCache.add(newPos);
+        }
+        LogUtils.d(TAG, "通过服务新增位置：ID=" + newPos.getPositionId() + "，纬度=" + newPos.getLatitude() + "（缓存已同步）");
 
-        // 5. 刷新缓存+Adapter（显示新增结果）
-        refreshCachedDataAndAdapter();
-        Toast.makeText(this, "新增位置成功（已启用距离计算）", Toast.LENGTH_SHORT).show();
+        // 5. 刷新Adapter（基于缓存操作，确保数据立即显示）
+        if (isAdapterInited.get() && mPositionAdapter != null) {
+            mPositionAdapter.notifyItemInserted(mLocalPosCache.size() - 1);
+        }
+        showToast("新增位置成功（已启用GPS距离计算）");
+    }
+
+	// ---------------------- 新增：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);
+                }
+            }
+        };
     }
 
 	/**
-     * 同步GPS位置到服务（调用服务syncCurrentGpsPosition()，不访问私有字段）
+     * 注册GPS监听：调用MainService的PUBLIC方法，绑定监听
      */
-    public void syncGpsPositionToService(PositionModel gpsModel) {
-        if (mMainService == null || gpsModel == null) {
-            LogUtils.w(TAG, "同步GPS失败：服务未就绪或GPS数据无效");
+    private void registerGpsListener() {
+        // 安全校验（避免Activity销毁/服务未绑定/监听为空时注册）
+        if (isFinishing() || isDestroyed() || !isServiceBound.get() || mMainService == null || mGpsUpdateListener == null) {
+            LogUtils.w(TAG, "GPS监听注册跳过：Activity状态异常/依赖未就绪");
             return;
         }
-
-        // 调用服务PUBLIC方法同步GPS（服务内部更新mCurrentGpsPosition）
-        mMainService.syncCurrentGpsPosition(gpsModel);
-        // 强制刷新距离（通过服务PUBLIC方法，触发mPositionList距离计算）
-        mMainService.forceRefreshDistance();
-        LogUtils.d(TAG, "GPS位置已同步，通过服务触发距离计算");
-
-        // 刷新缓存+Adapter（显示最新距离）
-        refreshCachedDataAndAdapter();
+        try {
+            mMainService.registerGpsUpdateListener(mGpsUpdateListener);
+            LogUtils.d(TAG, "GPS监听已注册");
+        } catch (Exception e) {
+            LogUtils.d(TAG, "GPS监听注册失败：" + e.getMessage());
+        }
     }
 
-    // ---------------------- 辅助方法（统一刷新缓存与Adapter，确保数据一致） ----------------------
     /**
-     * 刷新缓存数据+Adapter（从服务重新获取数据，避免本地缓存与服务不一致）
+     * 反注册GPS监听：调用MainService的PUBLIC方法，解绑监听（核心防内存泄漏+数据异常）
      */
-    private void refreshCachedDataAndAdapter() {
-        if (mMainService == null) {
-            LogUtils.w(TAG, "刷新失败：服务实例为空");
+    private void unregisterGpsListener() {
+        // 避免Activity销毁后调用服务方法（防止空指针/服务已解绑）
+        if (mMainService == null || mGpsUpdateListener == null) {
+            LogUtils.w(TAG, "GPS监听反注册跳过：服务/监听未初始化");
             return;
         }
-
-        // 1. 从服务重新获取数据（更新缓存，不访问私有字段）
-        mCachedPositionList = mMainService.getPositionList();
-        mCachedTaskList = mMainService.getPositionTasksList();
-        // 容错处理
-        if (mCachedPositionList == null) mCachedPositionList = new ArrayList<PositionModel>();
-        if (mCachedTaskList == null) mCachedTaskList = new ArrayList<PositionTaskModel>();
-
-        // 2. 刷新Adapter（全量刷新，简单可靠；若需性能优化可改为局部刷新）
-        if (mAdapter != null) {
-            mAdapter.updateAllData(mCachedPositionList, mCachedTaskList);
+        try {
+            mMainService.unregisterGpsUpdateListener(mGpsUpdateListener);
+            LogUtils.d(TAG, "GPS监听已反注册");
+        } catch (Exception e) {
+            LogUtils.d(TAG, "GPS监听反注册失败：" + e.getMessage());
         }
-        LogUtils.d(TAG, "刷新完成：当前位置数=" + mCachedPositionList.size() + "，任务数=" + mCachedTaskList.size());
     }
 
-    // ---------------------- 补充：DistanceRefreshService单例实现（需在服务中添加） ----------------------
-    // 注：以下代码需复制到 DistanceRefreshService 类中，确保实例唯一（解决直接new的问题）
-    /*
-    // 服务单例实例（私有静态）
-    private static DistanceRefreshService sInstance;
-
-    // 单例PUBLIC方法（供外部获取实例，确保全局唯一）
-    public static synchronized DistanceRefreshService getInstance() {
-        if (sInstance == null) {
-            sInstance = new DistanceRefreshService();
-            // 初始化服务核心逻辑（如GPS管理器、线程池，避免重复初始化）
-            sInstance.mLocationManager = (LocationManager) sInstance.getApplicationContext().getSystemService(Context.LOCATION_SERVICE);
-            sInstance.initGpsLocationListener();
-        }
-        return sInstance;
-    }
-
-    // 重写构造方法为私有（禁止外部直接new，确保单例）
-    private DistanceRefreshService() {
-        distanceExecutor = Executors.newSingleThreadScheduledExecutor();
-    }
+    /**
+     * 页面可见时同步数据（解决快速切回时数据未更新问题）
+     * 场景：快速关闭再打开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：刷新位置数据（与服务同步）");
+        }
     }
 
+    /**
+     * 页面不可见时暂停操作（避免后台操作导致数据异常）
+     */
+    @Override
+    protected void onPause() {
+        super.onPause();
+        // 避免后台时仍执行UI刷新（如GPS更新触发的视图操作）
+        LogUtils.d(TAG, "onPause：页面不可见，暂停UI相关操作");
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        LogUtils.d(TAG, "onDestroy：开始释放资源");
+
+        // 1. 反注册GPS监听（优先执行，避免服务持有Activity引用导致内存泄漏）
+        unregisterGpsListener();
+
+        // 2. 释放Adapter资源（反注册可能的监听，避免内存泄漏）
+        if (mPositionAdapter != null) {
+            mPositionAdapter.release();
+            mPositionAdapter = null; // 清空引用，帮助GC回收
+            LogUtils.d(TAG, "Adapter资源已释放");
+        }
+
+        // 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执行结束）");
+    }
+
+    // ---------------------- 移除重复定义：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/utils/AppConfigsUtil.java

@@ -54,10 +54,13 @@ public class AppConfigsUtil {
 			loadConfigs();
 		}
 
-		return mAppConfigsModel.isEnableMainService();
+		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/NotificationUtil.java

@@ -3,7 +3,7 @@ package cc.winboll.studio.positions.utils;
 /**
  * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
  * @Date 2025/09/30 16:09
- * @Describe NotificationUtils
+ * @Describe NotificationUtils（适配API 30，修复系统默认铃声获取，任务通知循环响铃）
  */
 import android.app.Notification;
 import android.app.NotificationChannel;
@@ -11,30 +11,31 @@ 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; // 引入你的前台服务类
+import cc.winboll.studio.positions.activities.LocationActivity;
 
 /**
- * 通知栏工具类：专注于任务相关通知的显示与点击跳转 + 前台服务通知管理
- * 核心功能：
- * 1. 显示任务描述通知，点击后携带positionId/taskId跳转到LocationActivity
- * 2. 创建前台服务通知（用于DistanceRefreshService保活，符合系统前台服务规范）
+ * 通知栏工具类：
+ * 1. 任务通知：铃声循环播放（适配API 30），修复系统默认铃声获取方式
+ * 2. 前台服务通知：低打扰（无声无震动），符合API 30规范
  */
 public class NotificationUtil {
     public static final String TAG = "NotificationUtils";
-	// 1. 任务通知相关常量（原有）
+    // 任务通知常量（独立渠道，确保循环铃声配置不冲突）
     private static final String TASK_NOTIFICATION_CHANNEL_ID = "task_notification_channel_01";
-	private static final String TASK_NOTIFICATION_CHANNEL_NAME = "任务通知";
-	// 2. 前台服务通知新增常量（独立渠道，避免与普通任务通知混淆）
+    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（前台服务通知无需动态生成）
+    public static final int FOREGROUND_SERVICE_NOTIFICATION_ID = 10086; // 固定前台服务通知ID
 
-	// ---------------------- 原有功能：任务通知（不变） ----------------------
+    // ---------------------- 核心：任务通知（循环响铃+修复系统默认铃声） ----------------------
     private static int getNotificationId(String taskId) {
-		return taskId.hashCode() & 0xFFFFFF;
+        return taskId.hashCode() & 0xFFFFFF; // 确保通知ID唯一且非负
     }
 
     public static void show(Context context, String taskId, String positionId, String taskDescription) {
@@ -48,63 +49,86 @@ public class NotificationUtil {
             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,
-			Build.VERSION.SDK_INT >= Build.VERSION_CODES.M ? 
-			PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT : 
-			PendingIntent.FLAG_UPDATE_CURRENT
+            PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT
         );
 
-		Notification notification = new NotificationCompat.Builder(context, TASK_NOTIFICATION_CHANNEL_ID)
-			.setSmallIcon(R.mipmap.ic_launcher)
+        // 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)
-			.setDefaults(NotificationCompat.DEFAULT_SOUND)
-			.build();
+            .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
+                NotificationManager.IMPORTANCE_DEFAULT // 重要性≥DEFAULT，否则铃声不响（API 30规则）
             );
-			taskChannel.setDescription("接收任务相关提醒，点击可查看任务详情");
+            taskChannel.setDescription("任务提醒通知，铃声循环播放至点击取消");
             taskChannel.enableVibration(true);
-			taskChannel.setVibrationPattern(new long[]{0, 300});
+            taskChannel.setVibrationPattern(new long[]{0, 300, 200, 300});
+            taskChannel.setAllowBubbles(false); // 避免气泡打断循环铃声
 
-			// 新增：前台服务通知渠道（重要性设为LOW，避免频繁打扰用户）
+            // 关键修复：渠道铃声也用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 // 仅通知栏显示，无提示音/震动，符合后台服务低打扰需求
+                NotificationManager.IMPORTANCE_LOW
             );
-			foregroundChannel.setDescription("位置服务运行中，用于后台持续获取GPS数据，关闭会影响定位功能"); // 明确告知用户服务作用
-			foregroundChannel.enableVibration(false); // 前台服务通知不震动（避免打扰）
-			foregroundChannel.setSound(null, null); // 关闭提示音（低打扰）
+            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;
@@ -112,69 +136,53 @@ public class NotificationUtil {
         NotificationManager notificationManager = 
             (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
         if (notificationManager != null) {
-			notificationManager.cancel(getNotificationId(taskId));
+            notificationManager.cancel(getNotificationId(taskId)); // 取消后循环铃声自动停止
         }
     }
 
-	// ---------------------- 新增核心功能：创建前台服务通知（供DistanceRefreshService调用） ----------------------
-	/**
-	 * 创建前台服务通知（符合Android前台服务规范，用于启动/保活DistanceRefreshService）
-	 * @param context 服务上下文（直接传入DistanceRefreshService的this即可）
-	 * @param serviceStatus 服务状态文本（如“正在后台获取GPS位置...”，动态展示服务状态）
-	 * @return 可直接用于startForeground()的Notification对象
-	 */
+    // ---------------------- 前台服务通知（适配API 30，无声无震动） ----------------------
     public static Notification createForegroundServiceNotification(Context context, String serviceStatus) {
-		// 安全校验：上下文非空（避免服务中调用时的空指针）
         if (context == null) {
             throw new IllegalArgumentException("Context cannot be null for foreground service notification");
         }
 
-		// 步骤1：初始化通知管理器（复用已有逻辑，确保渠道已创建）
+        // 确保前台服务渠道已创建（低打扰配置）
         NotificationManager notificationManager = 
             (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
         if (notificationManager != null) {
-			createNotificationChannel(notificationManager); // 确保前台服务渠道已注册
+            createNotificationChannel(notificationManager);
         }
 
-		// 步骤2：构建“点击通知跳转至位置管理页”的Intent（用户点击通知可进入功能页）
+        // 点击跳转Intent
         Intent jumpIntent = new Intent(context, LocationActivity.class);
-		jumpIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP); // 避免创建重复页面
+        jumpIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
 
-		// 步骤3：创建PendingIntent（授权系统在用户点击时执行跳转）
+        // PendingIntent（API 30必加IMMUTABLE）
         PendingIntent pendingIntent = PendingIntent.getActivity(
             context,
-			FOREGROUND_SERVICE_NOTIFICATION_ID, // 请求码与通知ID一致，确保唯一
+            FOREGROUND_SERVICE_NOTIFICATION_ID,
             jumpIntent,
-			// 适配Android 6.0+：IMMUTABLE确保安全性，UPDATE_CURRENT确保Intent参数更新
-			Build.VERSION.SDK_INT >= Build.VERSION_CODES.M ? 
-			PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT : 
-			PendingIntent.FLAG_UPDATE_CURRENT
+            PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT
         );
 
-		// 步骤4：构建前台服务通知（低打扰、强关联服务状态）
+        // 构建前台服务通知（无声无震动，符合低打扰）
         return new NotificationCompat.Builder(context, FOREGROUND_SERVICE_CHANNEL_ID)
-			.setSmallIcon(R.mipmap.ic_launcher) // 必须设置（系统强制要求，建议用应用图标）
-			.setContentTitle("位置服务运行中") // 固定标题，用户快速识别服务类型
-			.setContentText(serviceStatus) // 动态内容（如“正在获取GPS位置”“已连续运行30分钟”）
-			.setContentIntent(pendingIntent) // 点击跳转至功能页
-			.setOngoing(true) // 关键：设置为“不可手动清除”（仅服务停止时能取消，符合前台服务规范）
-			.setPriority(NotificationCompat.PRIORITY_LOW) // 低优先级：不弹窗、不抢占通知栏焦点
-			.setDefaults(NotificationCompat.DEFAULT_SOUND)
+            .setSmallIcon(R.mipmap.ic_launcher)
+            .setContentTitle("位置服务运行中")
+            .setContentText(serviceStatus)
+            .setContentIntent(pendingIntent)
+            .setOngoing(true) // 不可手动清除（前台服务规范）
+            .setPriority(NotificationCompat.PRIORITY_LOW)
+            .setDefaults(0) // 禁用所有默认提醒（无声无震动）
             .build();
     }
 
-	/**
-	 * （配套工具方法）更新前台服务通知的状态文本（如GPS获取进度、运行时长）
-	 * @param context 服务上下文
-	 * @param newServiceStatus 新的状态文本（如“已获取最新位置：北纬30.123°”）
-	 */
+    // ---------------------- 前台服务通知状态更新（适配API 30） ----------------------
     public static void updateForegroundServiceStatus(Context context, String newServiceStatus) {
         if (context == null) {
             return;
         }
-		// 重新创建通知（复用create方法，传入新状态文本）
         Notification updatedNotification = createForegroundServiceNotification(context, newServiceStatus);
-		// 用相同ID更新通知（覆盖旧通知，实现状态刷新）
         NotificationManager notificationManager = 
             (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
         if (notificationManager != null) {

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

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

@@ -1,10 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
-<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<RelativeLayout
+	xmlns:android="http://schemas.android.com/apk/res/android"
 	android:layout_width="match_parent"
 	android:layout_height="match_parent"
 	android:padding="20dp">
 
-    <!-- 1. 经纬度显示区域（保持居中，上方） -->
 	<LinearLayout
 		android:id="@+id/layout_location_info"
 		android:layout_width="wrap_content"
@@ -14,7 +14,6 @@
 		android:orientation="vertical"
 		android:gravity="center_horizontal">
 
-        <!-- 标题 -->
 		<TextView
 			android:layout_width="wrap_content"
 			android:layout_height="wrap_content"
@@ -22,7 +21,6 @@
 			android:textSize="22sp"
 			android:textStyle="bold"/>
 
-        <!-- 经度显示 -->
 		<TextView
 			android:id="@+id/tv_longitude"
 			android:layout_width="wrap_content"
@@ -31,7 +29,6 @@
 			android:textSize="18sp"
 			android:layout_marginTop="15dp"/>
 
-        <!-- 纬度显示 -->
 		<TextView
 			android:id="@+id/tv_latitude"
 			android:layout_width="wrap_content"
@@ -42,7 +39,6 @@
 
 	</LinearLayout>
 
-    <!-- 2. 新增：位置列表（RecyclerView）- 位于经纬度下方，悬浮按钮上方 -->
 	<androidx.recyclerview.widget.RecyclerView
 		android:id="@+id/rv_position_list"
 		android:layout_width="match_parent"
@@ -52,7 +48,6 @@
 		android:layout_marginTop="20dp"
 		android:paddingBottom="10dp"/>
 
-    <!-- 3. 右下角圆形悬浮按钮（不变） -->
 	<Button
 		android:id="@+id/fab_p_button"
 		android:layout_width="60dp"
@@ -65,7 +60,8 @@
 		android:textColor="@android:color/white"
 		android:textSize="24sp"
 		android:elevation="6dp"
-        android:padding="0dp"/>
+		android:padding="0dp"
+		android:onClick="addNewPosition"/>
 
 </RelativeLayout>
 

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

@@ -16,7 +16,7 @@
 	<Switch
 		android:id="@+id/switch_service_control"
 		android:layout_margin="16dp"
-		android:text="主要服务开关"
+		android:text="GPS服务开关"
 		android:layout_width="match_parent"
 		android:layout_height="wrap_content"/>
 
@@ -25,14 +25,15 @@
 		android:layout_height="wrap_content"
 		android:layout_margin="16dp"
 		android:onClick="onPositions"
-		android:text="进入位置管理"/>
+		android:text="位置与任务管理"
+		android:id="@+id/btn_manage_positions"/>
 
 	<Button
 		android:layout_width="match_parent"
 		android:layout_height="wrap_content"
 		android:layout_margin="16dp"
 		android:onClick="onLog"
-		android:text="查看操作日志"/>
+		android:text="查看应用日志"/>
 
 </LinearLayout>
 

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/strings.xml

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