初步后台GPS获取实现

positions/build.properties

@@ -1,8 +1,8 @@
 #Created by .winboll/winboll_app_build.gradle
-#Wed Oct 01 07:47:20 GMT 2025
+#Wed Oct 01 08:48:18 GMT 2025
 stageCount=4
 libraryProject=
 baseVersion=15.0
 publishVersion=15.0.3
-buildCount=55
+buildCount=56
 baseBetaVersion=15.0.4

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

@@ -16,7 +16,6 @@ import androidx.appcompat.widget.Toolbar;
 import cc.winboll.studio.libappbase.LogActivity;
 import cc.winboll.studio.libappbase.LogUtils;
 import cc.winboll.studio.positions.activities.LocationActivity;
-import cc.winboll.studio.positions.services.DistanceRefreshService;
 import cc.winboll.studio.positions.services.MainService;
 import cc.winboll.studio.positions.utils.AppConfigsUtil;
 import com.hjq.toast.ToastUtils;
@@ -36,31 +35,31 @@ public class MainActivity extends AppCompatActivity {
     private Switch mServiceSwitch;
     private Toolbar mToolbar;
     // 服务相关：服务实例、绑定状态标记
-    private DistanceRefreshService mDistanceService;
+    //private DistanceRefreshService mDistanceService;
     private boolean isServiceBound = false;
 
     // ---------------------- 服务连接回调（仅用于获取服务状态，不依赖服务执行核心逻辑） ----------------------
-    private final ServiceConnection mServiceConn = new ServiceConnection() {
+//    private final ServiceConnection mServiceConn = new ServiceConnection() {
-        /**
+//        /**
-         * 服务绑定成功：获取服务实例，同步开关状态（以服务实际状态为准）
+//         * 服务绑定成功：获取服务实例，同步开关状态（以服务实际状态为准）
-         */
+//         */
-        @Override
+//        @Override
-        public void onServiceConnected(ComponentName name, IBinder service) {
+//        public void onServiceConnected(ComponentName name, IBinder service) {
-            // Java 7 显式强转 Binder 实例（确保类型匹配，避免ClassCastException）
+//            // Java 7 显式强转 Binder 实例（确保类型匹配，避免ClassCastException）
-            DistanceRefreshService.DistanceBinder binder = (DistanceRefreshService.DistanceBinder) service;
+//            DistanceRefreshService.DistanceBinder binder = (DistanceRefreshService.DistanceBinder) service;
-            mDistanceService = binder.getService();
+//            mDistanceService = binder.getService();
-            isServiceBound = true;
+//            isServiceBound = true;
-        }
+//        }
-
+//
-        /**
+//        /**
-         * 服务意外断开（如服务崩溃）：重置服务实例和绑定状态
+//         * 服务意外断开（如服务崩溃）：重置服务实例和绑定状态
-         */
+//         */
-        @Override
+//        @Override
-        public void onServiceDisconnected(ComponentName name) {
+//        public void onServiceDisconnected(ComponentName name) {
-            mDistanceService = null;
+//            mDistanceService = null;
-            isServiceBound = false;
+//            isServiceBound = false;
-        }
+//        }
-    };
+//    };
 
     // ---------------------- Activity 生命周期（核心：初始化UI、申请权限、绑定服务、释放资源） ----------------------
     @Override
@@ -77,18 +76,18 @@ public class MainActivity extends AppCompatActivity {
             requestLocationPermissions();
         }
         // 4. 绑定服务（仅用于获取服务实时状态，不影响服务独立运行）
-        bindDistanceService();
+        //bindDistanceService();
     }
 
     @Override
     protected void onDestroy() {
         super.onDestroy();
         // 页面销毁时解绑服务，避免Activity与服务相互引用导致内存泄漏
-        if (isServiceBound) {
+//        if (isServiceBound) {
-            unbindService(mServiceConn);
+//            unbindService(mServiceConn);
-            isServiceBound = false;
+//            isServiceBound = false;
-            mDistanceService = null;
+//            mDistanceService = null;
-        }
+//        }
     }
 
     // ---------------------- 核心功能1：初始化UI组件（Toolbar + 服务开关） ----------------------
@@ -131,10 +130,10 @@ public class MainActivity extends AppCompatActivity {
 						LogUtils.d(TAG, "设置关闭服务");
 						AppConfigsUtil.getInstance(MainActivity.this).setIsEnableMainService(false);
 						// 停止服务前先解绑，避免服务被Activity持有
-						if (isServiceBound) {
+//						if (isServiceBound) {
-							unbindService(mServiceConn);
+//							unbindService(mServiceConn);
-							isServiceBound = false;
+//							isServiceBound = false;
-						}
+//						}
 						stopService(new Intent(MainActivity.this, MainService.class));
 					}
 				}
@@ -145,11 +144,11 @@ public class MainActivity extends AppCompatActivity {
     /**
      * 绑定服务（仅用于获取服务状态，不启动服务）
      */
-    private void bindDistanceService() {
+//    private void bindDistanceService() {
-        Intent serviceIntent = new Intent(this, MainService.class);
+//        Intent serviceIntent = new Intent(this, MainService.class);
-        // BIND_AUTO_CREATE：服务未启动则创建（仅为获取状态，启停由开关控制）
+//        // BIND_AUTO_CREATE：服务未启动则创建（仅为获取状态，启停由开关控制）
-        bindService(serviceIntent, mServiceConn, Context.BIND_AUTO_CREATE);
+//        bindService(serviceIntent, mServiceConn, Context.BIND_AUTO_CREATE);
-    }
+//    }
 
     // ---------------------- 核心功能3：页面跳转（位置管理页+日志页） ----------------------
     /**

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

@@ -11,18 +11,15 @@ import android.os.Bundle;
 import android.view.View;
 import android.view.inputmethod.InputMethodManager;
 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.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.DistanceRefreshService;
+import cc.winboll.studio.positions.services.MainService;
-
 import java.util.ArrayList;
 
 /**
@@ -42,7 +39,7 @@ public class LocationActivity extends AppCompatActivity {
     private RecyclerView mRecyclerView;
     private PositionAdapter mAdapter;
     // 直连服务实例（替代绑定，通过单例/全局初始化获取）
-    private DistanceRefreshService mDistanceService; 
+    private MainService mMainService; 
     // 缓存服务数据（从服务PUBLIC方法获取，避免重复调用）
     private ArrayList<PositionModel> mCachedPositionList; 
     private ArrayList<PositionTaskModel> mCachedTaskList;
@@ -74,7 +71,7 @@ public class LocationActivity extends AppCompatActivity {
             mAdapter = null;
         }
         // 2. 置空服务实例+缓存数据（帮助GC回收）
-        mDistanceService = null;
+        mMainService = null;
         mCachedPositionList = null;
         mCachedTaskList = null;
         mRecyclerView = null;
@@ -89,16 +86,15 @@ public class LocationActivity extends AppCompatActivity {
     private void initServiceInstance() {
 		// 步骤1：先启动Service（确保Service已创建，实例能被初始化）
         
-
         // 步骤2：初始化Service实例（延迟100-200ms，确保Service onCreate执行完成）
         // （或在startService后，通过ServiceConnection绑定获取实例，更可靠）
-        initServiceInstance();
+        //initServiceInstance();
 		
         // 方式：通过服务PUBLIC单例方法获取实例（不直接new，避免私有数据初始化重复）
-        mDistanceService = DistanceRefreshService.getInstance();
+        mMainService = MainService.getInstance();
         
         // 容错：若单例未初始化（如首次启动），提示并处理
-        if (mDistanceService == null) {
+        if (mMainService == null) {
             LogUtils.e(TAG, "服务实例初始化失败：单例未创建");
             Toast.makeText(this, "位置服务初始化失败，请重启应用", Toast.LENGTH_SHORT).show();
             finish();
@@ -110,16 +106,16 @@ public class LocationActivity extends AppCompatActivity {
      */
     private void checkServiceStatus() {
         // 1. 服务实例未初始化
-        if (mDistanceService == null) {
+        if (mMainService == null) {
             return; // 已在initServiceInstance中处理，此处避免重复finish
         }
 
         // 2. 检查服务运行状态（通过服务PUBLIC方法isServiceRunning()获取，不访问私有字段）
-        if (!mDistanceService.isServiceRunning()) {
+//        if (!mMainService.isServiceRunning()) {
-            // 服务未运行：手动触发启动（调用服务PUBLIC方法run()）
+//            // 服务未运行：手动触发启动（调用服务PUBLIC方法run()）
-            mDistanceService.run();
+//            mMainService.run();
-            LogUtils.d(TAG, "服务未运行，已通过PUBLIC方法触发启动");
+//            LogUtils.d(TAG, "服务未运行，已通过PUBLIC方法触发启动");
-        }
+//        }
 
         // 3. 检查SP中服务配置（双重校验，确保一致性）
         SharedPreferences sp = getSharedPreferences(SP_SERVICE_CONFIG, Context.MODE_PRIVATE);
@@ -133,7 +129,7 @@ public class LocationActivity extends AppCompatActivity {
      * 缓存服务数据（从服务PUBLIC方法获取，解决私有字段未知问题）
      */
     private void cacheServiceData() {
-        if (mDistanceService == null) {
+        if (mMainService == null) {
             LogUtils.e(TAG, "缓存数据失败：服务实例为空");
             mCachedPositionList = new ArrayList<PositionModel>();
             mCachedTaskList = new ArrayList<PositionTaskModel>();
@@ -141,8 +137,8 @@ public class LocationActivity extends AppCompatActivity {
         }
 
         // 从服务PUBLIC方法获取数据（不访问mPositionList，而是调用getPositionList()）
-        mCachedPositionList = mDistanceService.getPositionList();
+        mCachedPositionList = mMainService.getPositionList();
-        mCachedTaskList = mDistanceService.getPositionTasksList();
+        mCachedTaskList = mMainService.getPositionTasksList();
         
         // 容错：若服务返回null，初始化空列表避免空指针
         if (mCachedPositionList == null) mCachedPositionList = new ArrayList<PositionModel>();
@@ -181,7 +177,7 @@ public class LocationActivity extends AppCompatActivity {
             @Override
             public void onDeleteClick(int position) {
                 // 校验：服务实例有效+索引合法
-                if (mDistanceService == null || mCachedPositionList == null) {
+                if (mMainService == null || mCachedPositionList == null) {
                     Toast.makeText(LocationActivity.this, "删除失败：服务未就绪", Toast.LENGTH_SHORT).show();
                     return;
                 }
@@ -196,7 +192,7 @@ public class LocationActivity extends AppCompatActivity {
                 String targetPosId = targetPos.getPositionId();
 
                 // 2. 调用服务PUBLIC方法删除（服务内部处理mPositionList/mTaskList，符合封装）
-                mDistanceService.removePosition(targetPosId);
+                mMainService.removePosition(targetPosId);
                 LogUtils.d(TAG, "通过服务删除位置：ID=" + targetPosId);
 
                 // 3. 刷新缓存+Adapter（从服务重新获取数据，确保与服务一致）
@@ -210,7 +206,7 @@ public class LocationActivity extends AppCompatActivity {
             @Override
             public void onSavePositionClick(int position, PositionModel updatedPos) {
                 // 校验：服务+数据+参数有效
-                if (mDistanceService == null || mCachedPositionList == null || updatedPos == null) {
+                if (mMainService == null || mCachedPositionList == null || updatedPos == null) {
                     Toast.makeText(LocationActivity.this, "保存失败：服务或数据异常", Toast.LENGTH_SHORT).show();
                     return;
                 }
@@ -220,7 +216,7 @@ public class LocationActivity extends AppCompatActivity {
                 }
 
                 // 1. 调用服务PUBLIC方法更新数据（服务内部修改mPositionList）
-                mDistanceService.updatePosition(updatedPos);
+                mMainService.updatePosition(updatedPos);
                 LogUtils.d(TAG, "通过服务保存位置：ID=" + updatedPos.getPositionId());
 
                 // 2. 刷新缓存+Adapter（确保本地显示与服务一致）
@@ -233,7 +229,7 @@ public class LocationActivity extends AppCompatActivity {
         mAdapter.setOnSavePositionTaskClickListener(new PositionAdapter.OnSavePositionTaskClickListener() {
             @Override
             public void onSavePositionTaskClick(PositionTaskModel newTask) {
-                if (mDistanceService == null || newTask == null) {
+                if (mMainService == null || newTask == null) {
                     Toast.makeText(LocationActivity.this, "保存失败：服务或任务数据为空", Toast.LENGTH_SHORT).show();
                     return;
                 }
@@ -252,7 +248,7 @@ public class LocationActivity extends AppCompatActivity {
                 newTaskList.add(newTask);
 
                 // 2. 调用服务PUBLIC方法同步任务（服务内部更新mTaskList）
-                mDistanceService.syncAllPositionTasks(newTaskList);
+                mMainService.syncAllPositionTasks(newTaskList);
                 LogUtils.d(TAG, "通过服务保存任务：ID=" + newTask.getTaskId());
 
                 // 3. 刷新缓存+Adapter
@@ -274,7 +270,7 @@ public class LocationActivity extends AppCompatActivity {
         }
 
         // 2. 校验服务状态
-        if (mDistanceService == null) {
+        if (mMainService == null) {
             Toast.makeText(this, "新增失败：服务未初始化", Toast.LENGTH_SHORT).show();
             return;
         }
@@ -289,7 +285,7 @@ public class LocationActivity extends AppCompatActivity {
         newPos.setIsEnableRealPositionDistance(true); // 启用距离计算
 
         // 4. 调用服务PUBLIC方法新增（服务内部处理mPositionList去重+添加）
-        mDistanceService.addPosition(newPos);
+        mMainService.addPosition(newPos);
         LogUtils.d(TAG, "通过服务新增位置：ID=" + newPos.getPositionId());
 
         // 5. 刷新缓存+Adapter（显示新增结果）
@@ -301,15 +297,15 @@ public class LocationActivity extends AppCompatActivity {
      * 同步GPS位置到服务（调用服务syncCurrentGpsPosition()，不访问私有字段）
      */
     public void syncGpsPositionToService(PositionModel gpsModel) {
-        if (mDistanceService == null || gpsModel == null) {
+        if (mMainService == null || gpsModel == null) {
             LogUtils.w(TAG, "同步GPS失败：服务未就绪或GPS数据无效");
             return;
         }
 
         // 调用服务PUBLIC方法同步GPS（服务内部更新mCurrentGpsPosition）
-        mDistanceService.syncCurrentGpsPosition(gpsModel);
+        mMainService.syncCurrentGpsPosition(gpsModel);
         // 强制刷新距离（通过服务PUBLIC方法，触发mPositionList距离计算）
-        mDistanceService.forceRefreshDistance();
+        mMainService.forceRefreshDistance();
         LogUtils.d(TAG, "GPS位置已同步，通过服务触发距离计算");
 
         // 刷新缓存+Adapter（显示最新距离）
@@ -321,14 +317,14 @@ public class LocationActivity extends AppCompatActivity {
      * 刷新缓存数据+Adapter（从服务重新获取数据，避免本地缓存与服务不一致）
      */
     private void refreshCachedDataAndAdapter() {
-        if (mDistanceService == null) {
+        if (mMainService == null) {
             LogUtils.w(TAG, "刷新失败：服务实例为空");
             return;
         }
 
         // 1. 从服务重新获取数据（更新缓存，不访问私有字段）
-        mCachedPositionList = mDistanceService.getPositionList();
+        mCachedPositionList = mMainService.getPositionList();
-        mCachedTaskList = mDistanceService.getPositionTasksList();
+        mCachedTaskList = mMainService.getPositionTasksList();
         // 容错处理
         if (mCachedPositionList == null) mCachedPositionList = new ArrayList<PositionModel>();
         if (mCachedTaskList == null) mCachedTaskList = new ArrayList<PositionTaskModel>();

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

@@ -1,839 +1 @@
-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 final ScheduledExecutorService distanceExecutor; // 定时计算线程池（单线程）
-    private static final int REFRESH_INTERVAL = 3; // 距离刷新间隔（秒）
-    // 前台通知相关：记录是否已启动前台服务（避免重复调用startForeground）
-    private boolean isForegroundServiceStarted = false;
-
-    // ---------------------- 新增：GPS信号加载核心变量 ----------------------
-    private LocationManager mLocationManager; // 系统GPS管理类（核心）
-    private LocationListener mGpsLocationListener; // GPS位置监听回调
-    private static final long GPS_UPDATE_INTERVAL = 2000; // GPS位置更新间隔（2秒，平衡耗电与实时性）
-    private static final float GPS_UPDATE_DISTANCE = 1; // 位置变化超过1米时更新（避免频繁回调）
-    private boolean isGpsEnabled = false; // GPS是否已开启（系统设置中）
-    private boolean isGpsPermissionGranted = false; // 是否拥有GPS权限
-
-    // 核心数据存储（服务内唯一数据源，避免外部直接修改）
-    private final ArrayList<PositionModel> mPositionList = new ArrayList<PositionModel>();
-    private final ArrayList<PositionTaskModel> mTaskList = new ArrayList<PositionTaskModel>();
-    private final Set<String> mVisiblePositionIds = new HashSet<String>(); // 可见位置ID（优化性能）
-    private PositionModel mCurrentGpsPosition; // 当前GPS位置（外部传入/内部GPS获取）
-
-    // 服务绑定与UI回调
-    private final IBinder mBinder = new DistanceBinder();
-
-    // ---------------------- 构造初始化（线程池+GPS监听器提前创建） ----------------------
-	// 关键：添加/修改为 PUBLIC 无参构造函数
-    
-    public DistanceRefreshService() {
-        // Java 7 显式初始化线程池（单线程，避免并发修改数据）
-        distanceExecutor = Executors.newSingleThreadScheduledExecutor();
-        // 初始化GPS位置监听器（接收系统GPS位置更新）
-        initGpsLocationListener();
-    }
-
-    // ---------------------- 新增：GPS核心逻辑（初始化监听+权限/状态检查+启动定位） ----------------------
-    /**
-     * 初始化GPS位置监听器：系统GPS位置变化时触发，实时更新当前位置
-     */
-    private void initGpsLocationListener() {
-        // Java 7 匿名内部类实现 LocationListener（接收GPS位置回调）
-        mGpsLocationListener = new LocationListener() {
-            // GPS位置发生变化时回调（核心：更新当前GPS位置）
-            @Override
-            public void onLocationChanged(Location location) {
-                if (location != null) {
-                    // 将系统Location对象转为自定义PositionModel（适配现有逻辑）
-                    PositionModel gpsPos = new PositionModel();
-                    gpsPos.setLatitude(location.getLatitude()); // 纬度
-                    gpsPos.setLongitude(location.getLongitude()); // 经度
-                    gpsPos.setPositionId("CURRENT_GPS_POS"); // 标记为“当前GPS位置”（自定义ID）
-                    gpsPos.setMemo("实时GPS位置");
-
-                    // 同步GPS位置到服务（触发距离计算+通知更新）
-                    syncCurrentGpsPosition(gpsPos);
-                    LogUtils.d(TAG, "GPS位置更新：纬度=" + location.getLatitude() + "，经度=" + location.getLongitude());
-                }
-            }
-
-            // GPS状态变化时回调（如从“搜索中”变为“可用”）
-            @Override
-            public void onStatusChanged(String provider, int status, Bundle extras) {
-                if (provider.equals(LocationManager.GPS_PROVIDER)) {
-                    switch (status) {
-                        case LocationProvider.AVAILABLE:
-                            LogUtils.d(TAG, "GPS状态：已就绪（可用）");
-                            updateNotificationGpsStatus("GPS已就绪，正在获取位置...");
-                            break;
-                        case LocationProvider.OUT_OF_SERVICE:
-                            LogUtils.w(TAG, "GPS状态：无服务（信号弱/无信号）");
-                            updateNotificationGpsStatus("GPS无服务，尝试重新连接...");
-                            break;
-                        case LocationProvider.TEMPORARILY_UNAVAILABLE:
-                            LogUtils.w(TAG, "GPS状态：临时不可用（如遮挡）");
-                            updateNotificationGpsStatus("GPS临时不可用，稍后重试...");
-                            break;
-                    }
-                }
-            }
-
-            // GPS被开启时回调（用户在设置中打开GPS）
-            @Override
-            public void onProviderEnabled(String provider) {
-                if (provider.equals(LocationManager.GPS_PROVIDER)) {
-                    isGpsEnabled = true;
-                    LogUtils.d(TAG, "GPS已开启（用户手动打开）");
-                    updateNotificationGpsStatus("GPS已开启，正在获取位置...");
-                    // 重新启动GPS定位（确保获取最新位置）
-                    startGpsLocation();
-                }
-            }
-
-            // GPS被关闭时回调（用户在设置中关闭GPS）
-            @Override
-            public void onProviderDisabled(String provider) {
-                if (provider.equals(LocationManager.GPS_PROVIDER)) {
-                    isGpsEnabled = false;
-                    mCurrentGpsPosition = null; // 清空无效GPS位置
-                    LogUtils.w(TAG, "GPS已关闭（用户手动关闭）");
-                    updateNotificationGpsStatus("GPS已关闭，请在设置中开启");
-                    // 提示用户打开GPS（主线程显示Toast）
-                    showToastOnMainThread("GPS已关闭，无法获取位置，请在设置中开启");
-                }
-            }
-        };
-    }
-
-    /**
-     * 检查GPS权限+系统状态（解决“等待GPS信号”的前提：权限+GPS开启）
-     * @return true：权限+状态都满足；false：缺少权限或GPS未开启
-     */
-    private boolean checkGpsReady() {
-        // 1. 检查GPS权限（前台精确定位权限，必须拥有）
-        isGpsPermissionGranted = checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) 
-			== PackageManager.PERMISSION_GRANTED;
-
-        // 2. 检查GPS是否开启（系统设置中）
-        if (mLocationManager == null) {
-            mLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
-        }
-        isGpsEnabled = mLocationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
-
-        // 3. 异常场景处理（权限缺失/GPS未开启）
-        if (!isGpsPermissionGranted) {
-            LogUtils.e(TAG, "GPS准备失败：缺少精确定位权限");
-            updateNotificationGpsStatus("缺少定位权限，无法获取GPS");
-            showToastOnMainThread("请授予定位权限，否则无法获取GPS位置");
-            return false;
-        }
-        if (!isGpsEnabled) {
-            LogUtils.e(TAG, "GPS准备失败：系统GPS未开启");
-            updateNotificationGpsStatus("GPS未开启，请在设置中打开");
-            showToastOnMainThread("GPS已关闭，请在设置中开启以获取位置");
-            return false;
-        }
-
-        // 权限+状态都满足
-        LogUtils.d(TAG, "GPS准备就绪：权限已获取，GPS已开启");
-        return true;
-    }
-
-    /**
-     * 启动GPS定位（注册监听器，开始接收系统GPS位置更新）
-     */
-    private void startGpsLocation() {
-        // 先检查GPS是否就绪（避免无效调用）
-        if (!checkGpsReady()) {
-            return;
-        }
-
-        try {
-            // 注册GPS监听器：指定GPS provider、更新间隔、距离变化阈值
-            mLocationManager.requestLocationUpdates(
-				LocationManager.GPS_PROVIDER,
-				GPS_UPDATE_INTERVAL,
-				GPS_UPDATE_DISTANCE,
-				mGpsLocationListener,
-				Looper.getMainLooper() // 在主线程回调（避免跨线程问题）
-            );
-
-            // 额外优化：立即获取最近一次缓存的GPS位置（避免等待首次定位）
-            Location lastKnownLocation = mLocationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
-            if (lastKnownLocation != null) {
-                PositionModel lastGpsPos = new PositionModel();
-                lastGpsPos.setLatitude(lastKnownLocation.getLatitude());
-                lastGpsPos.setLongitude(lastKnownLocation.getLongitude());
-                lastGpsPos.setPositionId("CURRENT_GPS_POS");
-                syncCurrentGpsPosition(lastGpsPos);
-                LogUtils.d(TAG, "已获取最近缓存的GPS位置：纬度=" + lastKnownLocation.getLatitude());
-            } else {
-                LogUtils.d(TAG, "无缓存GPS位置，等待实时定位...");
-                updateNotificationGpsStatus("GPS搜索中（请移至开阔地带）");
-            }
-
-        } catch (SecurityException e) {
-            // 异常防护：避免权限突然被回收导致崩溃
-            LogUtils.e(TAG, "启动GPS定位失败（权限异常）：" + e.getMessage());
-            isGpsPermissionGranted = false;
-            updateNotificationGpsStatus("定位权限异常，无法获取GPS");
-        } catch (Exception e) {
-            LogUtils.e(TAG, "启动GPS定位失败：" + e.getMessage());
-            updateNotificationGpsStatus("GPS启动失败，尝试重试...");
-        }
-    }
-
-    /**
-     * 停止GPS定位（服务销毁/暂停时调用，避免耗电+内存泄漏）
-     */
-    private void stopGpsLocation() {
-        if (mLocationManager != null && mGpsLocationListener != null && isGpsPermissionGranted) {
-            try {
-                mLocationManager.removeUpdates(mGpsLocationListener);
-                LogUtils.d(TAG, "GPS定位已停止（移除监听器）");
-            } catch (Exception e) {
-                LogUtils.e(TAG, "停止GPS定位失败：" + e.getMessage());
-            }
-        }
-    }
-
-    // ---------------------- 新增：辅助方法（通知更新+主线程Toast） ----------------------
-    /**
-     * 统一更新通知栏的GPS状态文本（简化代码，避免重复）
-     */
-    private void updateNotificationGpsStatus(String statusText) {
-        if (isForegroundServiceStarted) {
-            NotificationUtil.updateForegroundServiceStatus(this, statusText);
-        }
-    }
-
-    /**
-     * 在主线程显示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;
-        }
-    }
-
-    // ---------------------- 服务生命周期方法（集成GPS启停逻辑） ----------------------
-
-	// 服务单例实例（私有静态）
-	// 1. 单例实例（volatile确保多线程可见性）
-    private static volatile DistanceRefreshService sInstance;
-    // 2. 单独持有ApplicationContext（避免内存泄漏+确保非null）
-    private static Context sAppContext;
-    // 单例PUBLIC方法（供外部获取实例，确保全局唯一）
-    public static synchronized DistanceRefreshService getInstance() {
-	// 4. 修复后的单例方法：先判空，再返回（避免空指针）
-    
-        // 第一步：先判断实例是否存在（未创建则返回null，不强行调用Context）
-        if (sInstance == null) {
-            // 可选：若调用时Service未启动，主动启动Service（避免后续空指针）
-             Intent intent = new Intent(sAppContext, DistanceRefreshService.class);
-             sAppContext.startService(intent);
-            return null; // 或抛明确异常（如"Service未启动"），不触发空指针
-        }
-        // 第二步：实例存在时，确保Context非null（双重保险）
-        if (sAppContext == null) {
-            sAppContext = sInstance.getApplicationContext();
-        }
-        return sInstance;
-    }
-
-    @Override
-    public void onCreate() {
-        super.onCreate();
-		sInstance = this; // 此时Service已创建，Context非null
-        // 保存ApplicationContext（全局唯一，不会因Service销毁而失效）
-        sAppContext = getApplicationContext();
-		
-        // 初始化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;
-			
-			mLocationManager = (LocationManager) sInstance.getApplicationContext().getSystemService(Context.LOCATION_SERVICE);
-            initGpsLocationListener();
-			
-            startDistanceRefreshTask(); // 启动定时距离计算
-            startForegroundNotification(); // 启动前台通知
-            startGpsLocation(); // 新增：启动GPS定位（核心修复：解决“等待GPS信号”）
-            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();
-		sInstance = null; // 释放实例，避免内存泄漏
-        // sAppContext 不清空（ApplicationContext全局有效）
-		
-        // 停止所有核心组件+释放资源（避免内存泄漏/耗电）
-        stopDistanceRefreshTask(); // 停止距离计算
-        stopGpsLocation(); // 新增：停止GPS定位（关键：避免服务销毁后仍耗电）
-        clearAllData(); // 清空数据
-        stopForeground(true); // 停止前台服务（移除通知）
-
-        // 重置状态标记
-        isForegroundServiceStarted = false;
-        isServiceRunning = false;
-        isGpsEnabled = false;
-        mLocationManager = null; // 释放GPS管理器引用
-
-        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);
-		}
-	}
-
-// ---------------------- 核心：定时距离计算（与GPS状态联动优化） ----------------------
-	/**
-
-	 - 启动定时距离计算任务（延迟1秒开始，周期执行）
-	 */
-	private void startDistanceRefreshTask() {
-		if (distanceExecutor == null || distanceExecutor.isShutdown()) {
-			LogUtils.e(TAG, "启动计算失败：线程池未初始化/已关闭");
-			return;
-		}distanceExecutor.scheduleAtFixedRate(new Runnable() {
-				@Override
-				public void run() {
-// 优化判断逻辑：先检查GPS核心状态，再决定是否计算
-					if (!isGpsPermissionGranted) {
-						LogUtils.d(TAG, "跳过距离计算：缺少定位权限");
-						updateNotificationGpsStatus("缺少定位权限，无法计算距离");
-						return;
-					}
-					if (!isGpsEnabled) {
-						LogUtils.d(TAG, "跳过距离计算：GPS未开启");
-						updateNotificationGpsStatus("GPS未开启，无法计算距离");
-						return;
-					}// 原有逻辑：服务运行+GPS位置有效+有可见位置才计算
-					if (isServiceRunning && mCurrentGpsPosition != null && !mVisiblePositionIds.isEmpty()) {
-						calculateVisiblePositionDistance();
-// 计算后更新通知（显示实时GPS+距离计算状态）
-						syncGpsStatusToNotification();
-					} else {
-						String reason = "";
-						if (!isServiceRunning) reason = "服务未运行";
-						else if (mCurrentGpsPosition == null) reason = "GPS信号弱（获取位置中）";
-						else if (mVisiblePositionIds.isEmpty()) reason = "无可见位置（无需计算）";
-						LogUtils.d(TAG, "跳过距离计算：" + reason);// 针对性更新通知文本（用户明确知道当前状态）
-						if (isForegroundServiceStarted) {
-							if (mCurrentGpsPosition == null) {
-								updateNotificationGpsStatus("GPS信号弱，移至开阔地带重试...");
-							} else if (mVisiblePositionIds.isEmpty()) {
-								updateNotificationGpsStatus("无可见位置，距离计算暂停");
-							}
-						}
-					}
-				}
-			}, 1, REFRESH_INTERVAL, TimeUnit.SECONDS);
-	}
-
-	/**
-
-	 - 停止定时计算任务（强制关闭线程池）
-	 */
-	private void stopDistanceRefreshTask() {
-		if (distanceExecutor != null && !distanceExecutor.isShutdown()) {
-			distanceExecutor.shutdownNow();
-			LogUtils.d(TAG, "距离计算任务已停止");
-		}
-	}
-
-	/**
-
-	 - 计算可见位置与GPS的距离（Haversine公式，后台线程执行）
-	 */
-	private void calculateVisiblePositionDistance() {
-		Set tempVisibleIds = new HashSet(mVisiblePositionIds);
-		if (tempVisibleIds.isEmpty()) return;Iterator posIter = mPositionList.iterator();
-		while (posIter.hasNext()) {
-			PositionModel pos = (PositionModel)posIter.next();
-			String posId = pos.getPositionId();if (tempVisibleIds.contains(posId) && pos.isEnableRealPositionDistance()) {
-				try {
-					double distanceM = calculateHaversineDistance(
-						mCurrentGpsPosition.getLatitude(), mCurrentGpsPosition.getLongitude(),
-						pos.getLatitude(), pos.getLongitude()
-					);
-					pos.setRealPositionDistance(distanceM);
-					LogUtils.d(TAG, "计算完成：位置ID=" + posId + "，距离=" + String.format("%.1f", distanceM) + "米");
-					
-				} catch (Exception e) {
-					pos.setRealPositionDistance(-1);
-					
-					LogUtils.e(TAG, "计算失败（位置ID=" + posId + "）：" + e.getMessage());
-				}
-			}
-		}
-	}
-
-	/**
-
-	 - 主线程回调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);
-	 }
-	 }
-	 });
-	 }
-	 }*/
-
-	/**
-
-	 - Haversine公式：计算两点间直线距离（经纬度→米）
-	 */
-	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);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;
-	}
-
-	/**
-
-	 - 同步GPS状态到前台通知（显示实时经纬度+计算状态）
-	 */
-	private void syncGpsStatusToNotification() {
-		if (!isForegroundServiceStarted || mCurrentGpsPosition == null) {
-			return;
-		}// 构造详细状态文本（包含经纬度+可见位置数量，用户感知更清晰）
-		final String gpsStatus = String.format(
-			"GPS位置：北纬%.4f° 东经%.4f° | 计算中（可见位置：%d个）",
-			mCurrentGpsPosition.getLatitude(),
-			mCurrentGpsPosition.getLongitude(),
-			mVisiblePositionIds.size()
-		);if (Looper.myLooper() == Looper.getMainLooper()) {
-			NotificationUtil.updateForegroundServiceStatus(this, gpsStatus);
-		} else {
-			new android.os.Handler(Looper.getMainLooper()).post(new Runnable() {
-					@Override
-					public void run() {
-						NotificationUtil.updateForegroundServiceStatus(DistanceRefreshService.this, gpsStatus);
-					}
-				});
-		}
-	}
-
-// ---------------------- 实现 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 syncCurrentGpsPosition(PositionModel position) {
-		if (position == null) {
-			LogUtils.w(TAG, "syncCurrentGpsPosition：GPS位置为空，同步失败");
-			return;
-		}
-		this.mCurrentGpsPosition = position;
-		LogUtils.d(TAG, "syncCurrentGpsPosition：同步成功（纬度=" + position.getLatitude() + "，经度=" + position.getLongitude() + "）");
-
-// GPS位置同步后，立即更新通知（避免延迟）
-		if (isForegroundServiceStarted) {
-			syncGpsStatusToNotification();
-		}
-	}
-
-	/*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() + "）");
-	}
-
-	/**
-
-	 - 清空所有数据
-	 */
-	public void clearAllData() {
-		mPositionList.clear();
-		mTaskList.clear();
-		mVisiblePositionIds.clear();
-		mCurrentGpsPosition = null;
-		LogUtils.d(TAG, "clearAllData：所有数据已清空（位置/任务/GPS/可见位置）");
-	}
-
-	/**
-
-	 - 强制刷新距离（优化：刷新后同步通知状态）
-	 */
-	public void forceRefreshDistance() {
-		if (!isServiceRunning) {
-			LogUtils.w(TAG, "forceRefreshDistance：服务未运行，刷新失败");
-			return;
-		}
-		if (distanceExecutor != null && !distanceExecutor.isShutdown()) {
-// 提交即时任务（不等待定时周期）
-			distanceExecutor.submit(new Runnable() {
-					@Override
-					public void run() {
-// 强制刷新前先检查GPS状态，避免无效计算
-						if (isGpsPermissionGranted && isGpsEnabled && mCurrentGpsPosition != null) {
-							calculateVisiblePositionDistance();
-							syncGpsStatusToNotification(); // 刷新后同步通知
-							LogUtils.d(TAG, "forceRefreshDistance：即时距离计算完成，通知已更新");
-						} else {
-							String reason = !isGpsPermissionGranted ? "缺少定位权限" :
-								(!isGpsEnabled ? "GPS未开启" : "未获取到GPS位置");
-							LogUtils.w(TAG, "forceRefreshDistance：刷新失败，原因：" + reason);
-							updateNotificationGpsStatus("强制刷新失败：" + reason);
-						}
-					}
-				});
-			LogUtils.d(TAG, "forceRefreshDistance：已触发即时距离计算请求");
-		} else {
-			LogUtils.e(TAG, "forceRefreshDistance：线程池已关闭，无法触发刷新");
-			updateNotificationGpsStatus("线程池已关闭，无法执行强制刷新");
-		}
-	}
-
-// ---------------------- 补充：修复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/services/MainService.java

@@ -5,30 +5,80 @@ package cc.winboll.studio.positions.services;
  * @Date 2024/07/19 14:30:57
  * @Describe 应用主要服务组件类
  */
-import android.app.Notification;
 import android.app.Service;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
-import android.content.IntentFilter;
 import android.content.ServiceConnection;
+import android.content.pm.PackageManager;
+import android.location.Location;
+import android.location.LocationListener;
+import android.location.LocationManager;
+import android.location.LocationProvider;
+import android.os.Bundle;
 import android.os.IBinder;
+import android.os.Looper;
 import cc.winboll.studio.libappbase.LogUtils;
-import cc.winboll.studio.positions.R;
+import cc.winboll.studio.positions.models.PositionModel;
-import com.hjq.toast.ToastUtils;
+import cc.winboll.studio.positions.models.PositionTaskModel;
-import cc.winboll.studio.positions.models.AppConfigsModel;
 import cc.winboll.studio.positions.utils.AppConfigsUtil;
-import cc.winboll.studio.positions.utils.ServiceUtil;
 import cc.winboll.studio.positions.utils.NotificationUtil;
+import cc.winboll.studio.positions.utils.ServiceUtil;
+import com.hjq.toast.ToastUtils;
+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;
 
 public class MainService extends Service {
 
     public static final String TAG = "MainService";
 
-    //MyBinder mMyBinder;
+	// ---------------------- 新增：GPS信号加载核心变量 ----------------------
+    private LocationManager mLocationManager; // 系统GPS管理类（核心）
+    private LocationListener mGpsLocationListener; // GPS位置监听回调
+    private static final long GPS_UPDATE_INTERVAL = 2000; // GPS位置更新间隔（2秒，平衡耗电与实时性）
+    private static final float GPS_UPDATE_DISTANCE = 1; // 位置变化超过1米时更新（避免频繁回调）
+    private boolean isGpsEnabled = false; // GPS是否已开启（系统设置中）
+    private boolean isGpsPermissionGranted = false; // 是否拥有GPS权限
+
+    // 核心数据存储（服务内唯一数据源，避免外部直接修改）
+    private final ArrayList<PositionModel> mPositionList = new ArrayList<PositionModel>();
+    private final ArrayList<PositionTaskModel> mTaskList = new ArrayList<PositionTaskModel>();
+	private PositionModel mCurrentGpsPosition; // 当前GPS位置（外部传入/内部GPS获取）
+
     MyServiceConnection mMyServiceConnection;
-    volatile static boolean _mIsServiceAlive;
+    volatile static boolean _mIsServiceRunning;
     AppConfigsUtil mAppConfigsUtil;
+	private final ScheduledExecutorService distanceExecutor; // 定时计算线程池（单线程）
+	private final Set<String> mVisiblePositionIds = new HashSet<String>(); // 可见位置ID（优化性能）
+
+	// ---------------------- 服务生命周期方法（集成GPS启停逻辑） ----------------------
+
+	// 服务单例实例（私有静态）
+	// 1. 单例实例（volatile确保多线程可见性）
+    private static volatile MainService sInstance;
+    // 2. 单独持有ApplicationContext（避免内存泄漏+确保非null）
+    private static Context sAppContext;
+    // 单例PUBLIC方法（供外部获取实例，确保全局唯一）
+    public static synchronized MainService getInstance() {
+		// 4. 修复后的单例方法：先判空，再返回（避免空指针）
+
+        // 第一步：先判断实例是否存在（未创建则返回null，不强行调用Context）
+        if (sInstance == null) {
+            // 可选：若调用时Service未启动，主动启动Service（避免后续空指针）
+			Intent intent = new Intent(sAppContext, MainService.class);
+			sAppContext.startService(intent);
+            return null; // 或抛明确异常（如"Service未启动"），不触发空指针
+        }
+        // 第二步：实例存在时，确保Context非null（双重保险）
+        if (sAppContext == null) {
+            sAppContext = sInstance.getApplicationContext();
+        }
+        return sInstance;
+    }
 
     @Override
     public IBinder onBind(Intent intent) {
@@ -40,7 +90,11 @@ public class MainService extends Service {
     public void onCreate() {
         LogUtils.d(TAG, "onCreate");
         super.onCreate();
-        _mIsServiceAlive = false;
+		sInstance = this; // 此时Service已创建，Context非null
+        // 保存ApplicationContext（全局唯一，不会因Service销毁而失效）
+        sAppContext = getApplicationContext();
+
+        _mIsServiceRunning = false;
         mAppConfigsUtil = AppConfigsUtil.getInstance(this);
 
         //mMyBinder = new MyBinder();
@@ -55,16 +109,14 @@ public class MainService extends Service {
 
     private void run() {
         if (mAppConfigsUtil.isEnableMainService(true)) {
-            if (_mIsServiceAlive == false) {
+            if (_mIsServiceRunning == false) {
                 // 设置运行状态
-                _mIsServiceAlive = true;
+                _mIsServiceRunning = true;
                 //LogUtils.d(TAG, "_mIsServiceAlive set to true.");
 
                 // 唤醒守护进程
                 wakeupAndBindAssistant();
 
-                // 运行其它服务内容
-				
                 // 显示前台通知栏
 				String initialStatus = "[ Positions ] is in Service.";
                 // 调用NotificationUtils创建前台通知（传入动态状态文本）
@@ -73,6 +125,11 @@ public class MainService extends Service {
 				startForeground(NotificationUtil.FOREGROUND_SERVICE_NOTIFICATION_ID,
 								NotificationUtil.createForegroundServiceNotification(this, initialStatus));
 
+                // 运行其它服务内容
+				mLocationManager = (LocationManager) sInstance.getApplicationContext().getSystemService(Context.LOCATION_SERVICE);
+				initGpsLocationListener();
+				startGpsLocation(); // 新增：启动GPS定位（核心修复：解决“等待GPS信号”）
+
                 ToastUtils.show(initialStatus);
                 LogUtils.i(TAG, initialStatus);
             }
@@ -86,8 +143,223 @@ public class MainService extends Service {
     @Override
     public void onDestroy() {
         super.onDestroy();
+		sInstance = null; // 释放实例，避免内存泄漏
+        // sAppContext 不清空（ApplicationContext全局有效）
+
+        // 停止所有核心组件+释放资源（避免内存泄漏/耗电）
+        //stopDistanceRefreshTask(); // 停止距离计算
+        stopGpsLocation(); // 新增：停止GPS定位（关键：避免服务销毁后仍耗电）
+        clearAllData(); // 清空数据
+        stopForeground(true); // 停止前台服务（移除通知）
+
+        // 重置状态标记
+        _mIsServiceRunning = false;
+        isGpsEnabled = false;
+        mLocationManager = null; // 释放GPS管理器引用
+
     }
 
+	public ArrayList<PositionModel> getPositionList() {
+		return mPositionList;
+	}
+
+	public ArrayList<PositionTaskModel> getPositionTasksList() {
+		return mTaskList;
+	}
+
+	public void removePosition(String targetPosId) {
+		LogUtils.d(TAG, "removePosition 未实现");
+	}
+
+	public void updatePosition(PositionModel updatedPos) {
+		LogUtils.d(TAG, "updatePosition 未实现");
+	}
+
+	public void syncAllPositionTasks(ArrayList<PositionTaskModel> newTaskList) {
+		LogUtils.d(TAG, "syncAllPositionTasks 未实现");
+	}
+
+	public void addPosition(PositionModel newPos) {
+		LogUtils.d(TAG, "addPosition 未实现");
+	}
+
+	/**
+	 * 清空所有数据
+	 */
+	public void clearAllData() {
+		mPositionList.clear();
+		mTaskList.clear();
+		//mVisiblePositionIds.clear();
+		mCurrentGpsPosition = null;
+		LogUtils.d(TAG, "clearAllData：所有数据已清空（位置/任务/GPS/可见位置）");
+	}
+
+	public void syncCurrentGpsPosition(PositionModel position) {
+		if (position == null) {
+			LogUtils.w(TAG, "syncCurrentGpsPosition：GPS位置为空，同步失败");
+			return;
+		}
+		this.mCurrentGpsPosition = position;
+		LogUtils.d(TAG, "syncCurrentGpsPosition：同步成功（纬度=" + position.getLatitude() + "，经度=" + position.getLongitude() + "）");
+
+// GPS位置同步后，立即更新通知（避免延迟）
+		if (_mIsServiceRunning) {
+			syncGpsStatusToNotification();
+		}
+
+	}
+
+	/**
+	 - 同步GPS状态到前台通知（显示实时经纬度+计算状态）
+	 */
+	private void syncGpsStatusToNotification() {
+		if (!_mIsServiceRunning || mCurrentGpsPosition == null) {
+			return;
+		}// 构造详细状态文本（包含经纬度+可见位置数量，用户感知更清晰）
+		final String gpsStatus = String.format(
+			"GPS位置：北纬%.4f° 东经%.4f° | 计算中（可见位置：%d个）",
+			mCurrentGpsPosition.getLatitude(),
+			mCurrentGpsPosition.getLongitude(),
+			666//mVisiblePositionIds.size()
+		);if (Looper.myLooper() == Looper.getMainLooper()) {
+			NotificationUtil.updateForegroundServiceStatus(this, gpsStatus);
+		} else {
+			new android.os.Handler(Looper.getMainLooper()).post(new Runnable() {
+					@Override
+					public void run() {
+						NotificationUtil.updateForegroundServiceStatus(MainService.this, gpsStatus);
+					}
+				});
+		}
+	}
+	
+	// ---------------------- 核心：定时距离计算（与GPS状态联动优化） ----------------------
+	/**
+	 - 启动定时距离计算任务（延迟1秒开始，周期执行）
+	 */
+//	private void startDistanceRefreshTask() {
+//		if (distanceExecutor == null || distanceExecutor.isShutdown()) {
+//			LogUtils.e(TAG, "启动计算失败：线程池未初始化/已关闭");
+//			return;
+//		}distanceExecutor.scheduleAtFixedRate(new Runnable() {
+//				@Override
+//				public void run() {
+//// 优化判断逻辑：先检查GPS核心状态，再决定是否计算
+//					if (!isGpsPermissionGranted) {
+//						LogUtils.d(TAG, "跳过距离计算：缺少定位权限");
+//						updateNotificationGpsStatus("缺少定位权限，无法计算距离");
+//						return;
+//					}
+//					if (!isGpsEnabled) {
+//						LogUtils.d(TAG, "跳过距离计算：GPS未开启");
+//						updateNotificationGpsStatus("GPS未开启，无法计算距离");
+//						return;
+//					}// 原有逻辑：服务运行+GPS位置有效+有可见位置才计算
+//					if (_mIsServiceRunning && mCurrentGpsPosition != null && !mVisiblePositionIds.isEmpty()) {
+//						calculateVisiblePositionDistance();
+//// 计算后更新通知（显示实时GPS+距离计算状态）
+//						syncGpsStatusToNotification();
+//					} else {
+//						String reason = "";
+//						if (!_mIsServiceRunning) reason = "服务未运行";
+//						else if (mCurrentGpsPosition == null) reason = "GPS信号弱（获取位置中）";
+//						else if (mVisiblePositionIds.isEmpty()) reason = "无可见位置（无需计算）";
+//						LogUtils.d(TAG, "跳过距离计算：" + reason);// 针对性更新通知文本（用户明确知道当前状态）
+//						if (isForegroundServiceStarted) {
+//							if (mCurrentGpsPosition == null) {
+//								updateNotificationGpsStatus("GPS信号弱，移至开阔地带重试...");
+//							} else if (mVisiblePositionIds.isEmpty()) {
+//								updateNotificationGpsStatus("无可见位置，距离计算暂停");
+//							}
+//						}
+//					}
+//				}
+//			}, 1, REFRESH_INTERVAL, TimeUnit.SECONDS);
+//	}
+//
+//	/**
+//	 - 停止定时计算任务（强制关闭线程池）
+//	 */
+//	private void stopDistanceRefreshTask() {
+//		if (distanceExecutor != null && !distanceExecutor.isShutdown()) {
+//			distanceExecutor.shutdownNow();
+//			LogUtils.d(TAG, "距离计算任务已停止");
+//		}
+//	}
+
+	/**
+	 - 计算可见位置与GPS的距离（Haversine公式，后台线程执行）
+	 */
+	private void calculateVisiblePositionDistance() {
+		Set tempVisibleIds = new HashSet(mVisiblePositionIds);
+		if (tempVisibleIds.isEmpty()) return;Iterator posIter = mPositionList.iterator();
+		while (posIter.hasNext()) {
+			PositionModel pos = (PositionModel)posIter.next();
+			String posId = pos.getPositionId();if (tempVisibleIds.contains(posId) && pos.isEnableRealPositionDistance()) {
+				try {
+					double distanceM = calculateHaversineDistance(
+						mCurrentGpsPosition.getLatitude(), mCurrentGpsPosition.getLongitude(),
+						pos.getLatitude(), pos.getLongitude()
+					);
+					pos.setRealPositionDistance(distanceM);
+					LogUtils.d(TAG, "计算完成：位置ID=" + posId + "，距离=" + String.format("%.1f", distanceM) + "米");
+
+				} catch (Exception e) {
+					pos.setRealPositionDistance(-1);
+
+					LogUtils.e(TAG, "计算失败（位置ID=" + posId + "）：" + e.getMessage());
+				}
+			}
+		}
+	}
+	
+	/**
+	 - Haversine公式：计算两点间直线距离（经纬度→米）
+	 */
+	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);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 forceRefreshDistance() {
+		if (!_mIsServiceRunning) {
+			LogUtils.w(TAG, "forceRefreshDistance：服务未运行，刷新失败");
+			return;
+		}
+		if (distanceExecutor != null && !distanceExecutor.isShutdown()) {
+// 提交即时任务（不等待定时周期）
+			distanceExecutor.submit(new Runnable() {
+					@Override
+					public void run() {
+// 强制刷新前先检查GPS状态，避免无效计算
+						if (isGpsPermissionGranted && isGpsEnabled && mCurrentGpsPosition != null) {
+							calculateVisiblePositionDistance();
+							syncGpsStatusToNotification(); // 刷新后同步通知
+							LogUtils.d(TAG, "forceRefreshDistance：即时距离计算完成，通知已更新");
+						} else {
+							String reason = !isGpsPermissionGranted ? "缺少定位权限" :
+								(!isGpsEnabled ? "GPS未开启" : "未获取到GPS位置");
+							LogUtils.w(TAG, "forceRefreshDistance：刷新失败，原因：" + reason);
+							updateNotificationGpsStatus("强制刷新失败：" + reason);
+						}
+					}
+				});
+			LogUtils.d(TAG, "forceRefreshDistance：已触发即时距离计算请求");
+		} else {
+			LogUtils.e(TAG, "forceRefreshDistance：线程池已关闭，无法触发刷新");
+			updateNotificationGpsStatus("线程池已关闭，无法执行强制刷新");
+		}
+	}
+
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
         //return super.onStartCommand(intent, flags, startId);
@@ -122,4 +394,191 @@ public class MainService extends Service {
             bindService(new Intent(MainService.this, AssistantService.class), mMyServiceConnection, Context.BIND_IMPORTANT);
         }
     }
+
+	// ---------------------- 构造初始化（线程池+GPS监听器提前创建） ----------------------
+	// 关键：添加/修改为 PUBLIC 无参构造函数
+
+    public MainService() {
+        // Java 7 显式初始化线程池（单线程，避免并发修改数据）
+        distanceExecutor = Executors.newSingleThreadScheduledExecutor();
+        // 初始化GPS位置监听器（接收系统GPS位置更新）
+        initGpsLocationListener();
+    }
+
+    // ---------------------- 新增：GPS核心逻辑（初始化监听+权限/状态检查+启动定位） ----------------------
+    /**
+     * 初始化GPS位置监听器：系统GPS位置变化时触发，实时更新当前位置
+     */
+    private void initGpsLocationListener() {
+        // Java 7 匿名内部类实现 LocationListener（接收GPS位置回调）
+        mGpsLocationListener = new LocationListener() {
+            // GPS位置发生变化时回调（核心：更新当前GPS位置）
+            @Override
+            public void onLocationChanged(Location location) {
+                if (location != null) {
+                    // 将系统Location对象转为自定义PositionModel（适配现有逻辑）
+                    PositionModel gpsPos = new PositionModel();
+                    gpsPos.setLatitude(location.getLatitude()); // 纬度
+                    gpsPos.setLongitude(location.getLongitude()); // 经度
+                    gpsPos.setPositionId("CURRENT_GPS_POS"); // 标记为“当前GPS位置”（自定义ID）
+                    gpsPos.setMemo("实时GPS位置");
+
+                    // 同步GPS位置到服务（触发距离计算+通知更新）
+                    syncCurrentGpsPosition(gpsPos);
+                    LogUtils.d(TAG, "GPS位置更新：纬度=" + location.getLatitude() + "，经度=" + location.getLongitude());
+                }
+            }
+
+            // GPS状态变化时回调（如从“搜索中”变为“可用”）
+            @Override
+            public void onStatusChanged(String provider, int status, Bundle extras) {
+                if (provider.equals(LocationManager.GPS_PROVIDER)) {
+                    switch (status) {
+                        case LocationProvider.AVAILABLE:
+                            LogUtils.d(TAG, "GPS状态：已就绪（可用）");
+                            updateNotificationGpsStatus("GPS已就绪，正在获取位置...");
+                            break;
+                        case LocationProvider.OUT_OF_SERVICE:
+                            LogUtils.w(TAG, "GPS状态：无服务（信号弱/无信号）");
+                            updateNotificationGpsStatus("GPS无服务，尝试重新连接...");
+                            break;
+                        case LocationProvider.TEMPORARILY_UNAVAILABLE:
+                            LogUtils.w(TAG, "GPS状态：临时不可用（如遮挡）");
+                            updateNotificationGpsStatus("GPS临时不可用，稍后重试...");
+                            break;
+                    }
+                }
+            }
+
+            // GPS被开启时回调（用户在设置中打开GPS）
+            @Override
+            public void onProviderEnabled(String provider) {
+                if (provider.equals(LocationManager.GPS_PROVIDER)) {
+                    isGpsEnabled = true;
+                    LogUtils.d(TAG, "GPS已开启（用户手动打开）");
+                    updateNotificationGpsStatus("GPS已开启，正在获取位置...");
+                    // 重新启动GPS定位（确保获取最新位置）
+                    startGpsLocation();
+                }
+            }
+
+            // GPS被关闭时回调（用户在设置中关闭GPS）
+            @Override
+            public void onProviderDisabled(String provider) {
+                if (provider.equals(LocationManager.GPS_PROVIDER)) {
+                    isGpsEnabled = false;
+                    mCurrentGpsPosition = null; // 清空无效GPS位置
+                    LogUtils.w(TAG, "GPS已关闭（用户手动关闭）");
+                    updateNotificationGpsStatus("GPS已关闭，请在设置中开启");
+                    // 提示用户打开GPS（主线程显示Toast）
+                    //showToastOnMainThread("GPS已关闭，无法获取位置，请在设置中开启");
+                }
+            }
+        };
+    }
+
+
+    /**
+     * 检查GPS权限+系统状态（解决“等待GPS信号”的前提：权限+GPS开启）
+     * @return true：权限+状态都满足；false：缺少权限或GPS未开启
+     */
+    private boolean checkGpsReady() {
+        // 1. 检查GPS权限（前台精确定位权限，必须拥有）
+        isGpsPermissionGranted = checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) 
+			== PackageManager.PERMISSION_GRANTED;
+
+        // 2. 检查GPS是否开启（系统设置中）
+        if (mLocationManager == null) {
+            mLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
+        }
+        isGpsEnabled = mLocationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
+
+        // 3. 异常场景处理（权限缺失/GPS未开启）
+        if (!isGpsPermissionGranted) {
+            LogUtils.e(TAG, "GPS准备失败：缺少精确定位权限");
+            updateNotificationGpsStatus("缺少定位权限，无法获取GPS");
+			ToastUtils.show("请授予定位权限，否则无法获取GPS位置");
+            //showToastOnMainThread("请授予定位权限，否则无法获取GPS位置");
+            return false;
+        }
+        if (!isGpsEnabled) {
+            LogUtils.e(TAG, "GPS准备失败：系统GPS未开启");
+			ToastUtils.show("GPS已关闭，请在设置中开启以获取位置");
+            updateNotificationGpsStatus("GPS未开启，请在设置中打开");
+            //showToastOnMainThread("GPS已关闭，请在设置中开启以获取位置");
+            return false;
+        }
+
+        // 权限+状态都满足
+        LogUtils.d(TAG, "GPS准备就绪：权限已获取，GPS已开启");
+        return true;
+    }
+
+    /**
+     * 启动GPS定位（注册监听器，开始接收系统GPS位置更新）
+     */
+    private void startGpsLocation() {
+        // 先检查GPS是否就绪（避免无效调用）
+        if (!checkGpsReady()) {
+            return;
+        }
+
+        try {
+            // 注册GPS监听器：指定GPS provider、更新间隔、距离变化阈值
+            mLocationManager.requestLocationUpdates(
+				LocationManager.GPS_PROVIDER,
+				GPS_UPDATE_INTERVAL,
+				GPS_UPDATE_DISTANCE,
+				mGpsLocationListener,
+				Looper.getMainLooper() // 在主线程回调（避免跨线程问题）
+            );
+
+            // 额外优化：立即获取最近一次缓存的GPS位置（避免等待首次定位）
+            Location lastKnownLocation = mLocationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
+            if (lastKnownLocation != null) {
+                PositionModel lastGpsPos = new PositionModel();
+                lastGpsPos.setLatitude(lastKnownLocation.getLatitude());
+                lastGpsPos.setLongitude(lastKnownLocation.getLongitude());
+                lastGpsPos.setPositionId("CURRENT_GPS_POS");
+                syncCurrentGpsPosition(lastGpsPos);
+                LogUtils.d(TAG, "已获取最近缓存的GPS位置：纬度=" + lastKnownLocation.getLatitude());
+            } else {
+                LogUtils.d(TAG, "无缓存GPS位置，等待实时定位...");
+                updateNotificationGpsStatus("GPS搜索中（请移至开阔地带）");
+            }
+
+        } catch (SecurityException e) {
+            // 异常防护：避免权限突然被回收导致崩溃
+            LogUtils.e(TAG, "启动GPS定位失败（权限异常）：" + e.getMessage());
+            isGpsPermissionGranted = false;
+            updateNotificationGpsStatus("定位权限异常，无法获取GPS");
+        } catch (Exception e) {
+            LogUtils.e(TAG, "启动GPS定位失败：" + e.getMessage());
+            updateNotificationGpsStatus("GPS启动失败，尝试重试...");
+        }
+    }
+
+    /**
+     * 停止GPS定位（服务销毁/暂停时调用，避免耗电+内存泄漏）
+     */
+    private void stopGpsLocation() {
+        if (mLocationManager != null && mGpsLocationListener != null && isGpsPermissionGranted) {
+            try {
+                mLocationManager.removeUpdates(mGpsLocationListener);
+                LogUtils.d(TAG, "GPS定位已停止（移除监听器）");
+            } catch (Exception e) {
+                LogUtils.e(TAG, "停止GPS定位失败：" + e.getMessage());
+            }
+        }
+    }
+
+    // ---------------------- 新增：辅助方法（通知更新+主线程Toast） ----------------------
+    /**
+     * 统一更新通知栏的GPS状态文本（简化代码，避免重复）
+     */
+    private void updateNotificationGpsStatus(String statusText) {
+        if (_mIsServiceRunning) {
+            NotificationUtil.updateForegroundServiceStatus(this, statusText);
+        }
+    }
 }