Merge remote-tracking branch 'origin/positions' into appbase

appbase/build.properties

@@ -1,8 +1,8 @@
 #Created by .winboll/winboll_app_build.gradle
-#Fri Sep 26 05:36:14 HKT 2025
+#Sat Sep 27 21:03:20 HKT 2025
-stageCount=9
+stageCount=10
 libraryProject=libappbase
 baseVersion=15.10
-publishVersion=15.10.8
+publishVersion=15.10.9
 buildCount=0
-baseBetaVersion=15.10.9
+baseBetaVersion=15.10.10

libappbase/build.properties

@@ -1,8 +1,8 @@
 #Created by .winboll/winboll_app_build.gradle
-#Fri Sep 26 05:36:14 HKT 2025
+#Sat Sep 27 21:03:08 HKT 2025
-stageCount=9
+stageCount=10
 libraryProject=libappbase
 baseVersion=15.10
-publishVersion=15.10.8
+publishVersion=15.10.9
 buildCount=0
-baseBetaVersion=15.10.9
+baseBetaVersion=15.10.10

libappbase/src/main/java/cc/winboll/studio/libappbase/GlobalApplication.java

@@ -22,12 +22,12 @@ public class GlobalApplication extends Application {
         GlobalApplication.isDebuging = isDebuging;
     }
     
-    public static void saveDebugStatus(GlobalApplication application) {
+    public static void saveDebugStatus(Context context) {
-        APPModel.saveBeanToFile(application.getAPPModelFilePath(application), new APPModel(GlobalApplication.isDebuging));
+        APPModel.saveBeanToFile(getAPPModelFilePath(context), new APPModel(GlobalApplication.isDebuging));
     }
 	
-    static String getAPPModelFilePath(GlobalApplication application) {
+    static String getAPPModelFilePath(Context context) {
-        return application.getDataDir().getPath() + "/APPModel.json";
+        return context.getDataDir().getPath() + "/APPModel.json";
     }
 
     public static boolean isDebuging() {

positions/build.gradle

@@ -70,7 +70,7 @@ dependencies {
     //api 'androidx.vectordrawable:vectordrawable-animated:1.1.0'
     //api 'androidx.fragment:fragment:1.1.0'
     
-    api 'cc.winboll.studio:libaes:15.9.3'
+    api 'cc.winboll.studio:libaes:15.10.2'
-    api 'cc.winboll.studio:libapputils:15.8.5'
+    api 'cc.winboll.studio:libapputils:15.10.2'
-    api 'cc.winboll.studio:libappbase:15.9.5'
+    api 'cc.winboll.studio:libappbase:15.10.9'
 }

positions/build.properties

@@ -1,8 +1,8 @@
 #Created by .winboll/winboll_app_build.gradle
-#Tue Sep 30 17:50:26 HKT 2025
+#Thu Oct 02 13:16:14 GMT 2025
-stageCount=4
+stageCount=8
 libraryProject=
 baseVersion=15.0
-publishVersion=15.0.3
+publishVersion=15.0.7
-buildCount=0
+buildCount=29
-baseBetaVersion=15.0.4
+baseBetaVersion=15.0.8

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

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

positions/src/main/AndroidManifest.xml

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

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

@@ -41,15 +41,19 @@ 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 {
 
     private static Handler MAIN_HANDLER = new Handler(Looper.getMainLooper());
-
+	
     @Override
     public void onCreate() {
         super.onCreate();
-        
+		setIsDebuging(BuildConfig.DEBUG);
+		
+		WinBoLLActivityManager.init(this);
+		
         // 初始化 Toast 框架
         ToastUtils.init(this);
         // 设置 Toast 布局样式

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

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

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

@@ -3,444 +3,225 @@ package cc.winboll.studio.positions.activities;
 /**
  * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
  * @Date 2025/09/29 18:22
- * @Describe 当前位置实时显示 + 位置列表实时距离计算
+ * @Describe 位置列表页面（适配MainService GPS接口+规范服务交互+完善生命周期）
  */
-import android.Manifest;
-import android.app.AlertDialog;
-import android.content.DialogInterface;
-import android.content.pm.PackageManager;
-import android.location.Location;
 import android.os.Bundle;
-import android.text.InputType;
+import android.os.IBinder;
-import android.view.View;
+import android.app.Activity;
-import android.widget.Button;
+import android.content.ComponentName;
-import android.widget.EditText;
+import android.content.Intent;
-import android.widget.TextView;
+import android.content.ServiceConnection;
 import android.widget.Toast;
-import androidx.annotation.NonNull;
-import androidx.appcompat.app.AppCompatActivity;
-import androidx.core.app.ActivityCompat;
 import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
-import cc.winboll.studio.positions.R;
+
+import cc.winboll.studio.libappbase.LogUtils;
 import cc.winboll.studio.positions.adapters.PositionAdapter;
 import cc.winboll.studio.positions.models.PositionModel;
-import com.google.android.gms.location.FusedLocationProviderClient;
-import com.google.android.gms.location.LocationCallback;
-import com.google.android.gms.location.LocationRequest;
-import com.google.android.gms.location.LocationResult;
-import com.google.android.gms.location.LocationServices;
-import com.google.android.gms.tasks.OnSuccessListener;
-import java.util.ArrayList;
 import cc.winboll.studio.positions.models.PositionTaskModel;
+import cc.winboll.studio.positions.services.MainService;
+import cc.winboll.studio.positions.R;
+import java.util.ArrayList;
 
 /**
- * 实时定位活动窗口：
+ * Java 7 语法适配：
- * 1. 申请定位必需权限（精确定位）
+ * 1. 服务绑定用匿名内部类实现 ServiceConnection
- * 2. 初始化FusedLocationProviderClient（谷歌官方定位服务，兼容所有安卓版本）
+ * 2. Adapter 初始化传入 MainService 实例，确保数据来源唯一
- * 3. 实时监听位置变化，更新显示经度、纬度 + 同步给Adapter计算实时距离
+ * 3. 所有位置/任务操作通过 MainService 接口执行
- * 4. 右下角圆形悬浮按钮（含大写P字母，支持添加位置）
- * 5. 位置列表支持实时距离显示（按isEnableRealPositionDistance控制）
  */
-public class LocationActivity extends AppCompatActivity {
+public class LocationActivity extends Activity {
+    private static final String TAG = "LocationActivity";
 
-    public static final String TAG = "LocationActivity";
+    private RecyclerView mRvPosition;
+    private PositionAdapter mPositionAdapter;
+    private ArrayList<PositionModel> mLocalPosCache; // 本地位置缓存（与MainService同步）
 
-    // 1. 核心组件与常量定义（兼容Java 7，移除不必要final）
+    // MainService 引用+绑定状态
-    private static final int REQUEST_LOCATION_PERMISSIONS = 1004; // 定位权限请求码
+    private MainService mMainService;
-    private FusedLocationProviderClient fusedLocationClient; // 定位核心客户端
+    private boolean isServiceBound = false;
-    private LocationCallback locationCallback; // 位置变化监听器
-    private LocationRequest locationRequest; // 定位请求配置（频率、精度等）
-    private Location currentLocation; // 存储当前最新位置（用于同步给Adapter）
 
-    // UI控件（Java 7显式声明+强制转换）
+    // 服务连接（Java 7 匿名内部类实现）
-    private TextView tvLongitude; // 经度显示
+    private ServiceConnection mServiceConnection = new ServiceConnection() {
-    private TextView tvLatitude;  // 纬度显示
+        @Override
-    private Button fabPButton;    // 右下角圆形悬浮按钮（P字母）
+        public void onServiceConnected(ComponentName name, IBinder service) {
-    private RecyclerView rvPositionList; // 位置列表（RecyclerView）
+            // 假设 MainService 用 LocalBinder 暴露实例（Java 7 强转）
-    private PositionAdapter positionAdapter; // 列表Adapter（含实时距离逻辑）
+            MainService.LocalBinder binder = (MainService.LocalBinder) service;
-    ArrayList<PositionModel> mPositionList = new ArrayList<PositionModel>(); // 位置数据集合
+            mMainService = binder.getService();
-    ArrayList<PositionTaskModel> mPositionTasksList = new ArrayList<PositionTaskModel>(); // 位置数据集合
+            isServiceBound = true;
+
+            LogUtils.d(TAG, "MainService绑定成功，开始同步数据");
+            // 从MainService同步初始数据（位置+任务）
+            syncDataFromMainService();
+            // 初始化Adapter（传入MainService实例，确保任务数据从服务获取）
+            initPositionAdapter();
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName name) {
+            LogUtils.w(TAG, "MainService断开连接，清空引用");
+            mMainService = null;
+            isServiceBound = false;
+        }
+    };
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_location);
 
-        // 绑定UI控件（Java 7显式强制转换）
+        // 初始化视图+本地缓存
-        tvLongitude = (TextView) findViewById(R.id.tv_longitude);
+        initView();
-        tvLatitude = (TextView) findViewById(R.id.tv_latitude);
+        mLocalPosCache = new ArrayList<PositionModel>();
-        fabPButton = (Button) findViewById(R.id.fab_p_button);
-        rvPositionList = (RecyclerView) findViewById(R.id.rv_position_list);
 
-        // 初始化核心逻辑：定位配置→悬浮按钮→列表Adapter→加载历史数据
+        // 绑定MainService（确保Activity启动时就拿到服务实例）
-        initLocationConfig();
+        bindMainService();
-        initFabPButton();
-        initRecyclerViewAndAdapter();
-        loadHistoryPositions();
-
-        // 检查并申请定位权限（权限通过后启动实时定位）
-        if (checkLocationPermissions()) {
-            startRealTimeLocation();
-        } else {
-            requestLocationPermissions();
-        }
     }
 
-
     /**
-     * 初始化定位配置（兼容Java 7，用LocationRequest.create()替代Builder）
+     * 初始化视图（RecyclerView）
      */
-    private void initLocationConfig() {
+    private void initView() {
-        // 初始化定位客户端
+        mRvPosition = (RecyclerView) findViewById(R.id.rv_position_list);
-        fusedLocationClient = LocationServices.getFusedLocationProviderClient(this);
+        // Java 7 显式设置布局管理器（LinearLayoutManager）
-
-        // 定位请求配置（高精度、1秒更新一次，适配旧版Google Play Services）
-        locationRequest = LocationRequest.create();
-        locationRequest.setInterval(1000); // 定位更新间隔（1秒）
-        locationRequest.setFastestInterval(500); // 最快更新间隔（500毫秒）
-        locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY); // 优先GPS高精度定位
-
-        // 位置变化监听器（实时更新UI + 同步位置给Adapter计算距离）
-        locationCallback = new LocationCallback() {
-            @Override
-            public void onLocationResult(@NonNull LocationResult locationResult) {
-                super.onLocationResult(locationResult);
-                currentLocation = locationResult.getLastLocation(); // 更新当前最新位置
-                if (currentLocation != null) {
-                    // 1. 更新页面经度、纬度显示
-                    double longitude = currentLocation.getLongitude();
-                    double latitude = currentLocation.getLatitude();
-                    tvLongitude.setText(String.format("当前经度：%.6f", longitude));
-                    tvLatitude.setText(String.format("当前纬度：%.6f", latitude));
-
-                    // 2. 同步当前位置给Adapter（用于计算列表项实时距离）
-                    if (positionAdapter != null) {
-                        // 创建仅含经纬度的PositionModel（memo空，isEnable无需关注）
-                        PositionModel currentGpsPos = new PositionModel();
-                        currentGpsPos.setLongitude(longitude);
-                        currentGpsPos.setLatitude(latitude);
-                        // 调用Adapter方法传入当前GPS位置
-                        positionAdapter.setCurrentGpsPosition(currentGpsPos);
-                    }
-                } else {
-                    // 位置为空（如GPS信号弱），显示等待提示
-                    tvLongitude.setText("当前经度：等待更新...");
-                    tvLatitude.setText("当前纬度：等待更新...");
-                }
-            }
-        };
-    }
-
-
-    /**
-     * 初始化悬浮按钮（点击弹出备注输入框，添加当前位置到列表）
-     */
-    private void initFabPButton() {
-        fabPButton.setOnClickListener(new View.OnClickListener() {
-				@Override
-				public void onClick(View v) {
-					showLocationRemarkDialog();
-				}
-			});
-    }
-
-
-    /**
-     * 初始化RecyclerView和Adapter（绑定实时距离计算逻辑）
-     */
-    private void initRecyclerViewAndAdapter() {
-        // 1. 配置RecyclerView布局管理器（垂直列表）
         LinearLayoutManager layoutManager = new LinearLayoutManager(this);
         layoutManager.setOrientation(LinearLayoutManager.VERTICAL);
-        rvPositionList.setLayoutManager(layoutManager);
+        mRvPosition.setLayoutManager(layoutManager);
-
-        // 2. 初始化Adapter（传入上下文和数据集合，兼容Java 7）
-		PositionModel.loadBeanList(this, this.mPositionList, PositionModel.class);
-		PositionTaskModel.loadBeanList(this, this.mPositionTasksList, PositionTaskModel.class);
-        positionAdapter = new PositionAdapter(this, mPositionList, mPositionTasksList);
-        rvPositionList.setAdapter(positionAdapter);
-
-        // 3. 设置Adapter删除监听（删除列表项并同步本地数据）
-        positionAdapter.setOnDeleteClickListener(new PositionAdapter.OnDeleteClickListener() {
-				@Override
-				public void onDeleteClick(int position) {
-					showDeleteConfirmDialog(position);
-				}
-			});
-
-        // 4. 设置Adapter保存监听（编辑备注后同步本地数据）
-        positionAdapter.setOnSavePositionClickListener(new PositionAdapter.OnSavePositionClickListener() {
-				@Override
-				public void onSavePositionClick() {
-					try {
-						PositionModel.saveBeanList(LocationActivity.this, mPositionList, PositionModel.class);
-						Toast.makeText(LocationActivity.this, "位置信息已保存", Toast.LENGTH_SHORT).show();
-					} catch (Exception e) {
-						e.printStackTrace();
-						Toast.makeText(LocationActivity.this, "数据保存失败", Toast.LENGTH_SHORT).show();
-					}
-				}
-			});
-			
-		positionAdapter.setOnSavePositionTaskClickListener(new PositionAdapter.OnSavePositionTaskClickListener() {
-				@Override
-				public void onSavePositionTaskClick() {
-					try {
-						PositionTaskModel.saveBeanList(LocationActivity.this, mPositionTasksList, PositionTaskModel.class);
-						Toast.makeText(LocationActivity.this, "任务信息已保存", Toast.LENGTH_SHORT).show();
-					} catch (Exception e) {
-						e.printStackTrace();
-						Toast.makeText(LocationActivity.this, "数据保存失败", Toast.LENGTH_SHORT).show();
-					}
-				}
-			});
     }
 
-
     /**
-     * 从本地加载历史位置数据（基于BaseBean的持久化逻辑）
+     * 绑定MainService（Java 7 显式Intent）
      */
-    private void loadHistoryPositions() {
+    private void bindMainService() {
-        try {
+        Intent serviceIntent = new Intent(this, MainService.class);
-            ArrayList<PositionModel> historyList = new ArrayList<PositionModel>();
+        // 绑定服务（BIND_AUTO_CREATE：服务不存在时自动创建）
-            // 调用PositionModel加载方法（读取本地保存的位置数据）
+        bindService(serviceIntent, mServiceConnection, BIND_AUTO_CREATE);
-            PositionModel.loadBeanList(LocationActivity.this, historyList, PositionModel.class);
+        LogUtils.d(TAG, "发起MainService绑定请求");
-            if (historyList != null && !historyList.isEmpty()) {
-                mPositionList.clear();
-                mPositionList.addAll(historyList);
-                positionAdapter.notifyDataSetChanged(); // 通知列表刷新
-            }
-        } catch (Exception e) {
-            e.printStackTrace(); // 首次启动无数据时忽略异常
-        }
     }
 
-
     /**
-     * 弹出位置备注输入对话框（添加当前位置到列表）
+     * 从MainService同步数据（位置+任务）
      */
-    private void showLocationRemarkDialog() {
+    private void syncDataFromMainService() {
-        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(LocationActivity.this);
+        if (!isServiceBound || mMainService == null) {
-        dialogBuilder.setTitle("当前位置备注");
+            LogUtils.w(TAG, "同步数据失败：MainService未绑定");
-
+            showToast("服务未就绪，无法加载数据");
-        // 创建输入框（配置提示文本和内边距）
-        final EditText remarkInput = new EditText(LocationActivity.this);
-        remarkInput.setHint("请输入备注（如：公司/家/学校）");
-        remarkInput.setInputType(InputType.TYPE_CLASS_TEXT);
-        remarkInput.setPadding(
-			dip2px(16),
-			dip2px(8),
-			dip2px(16),
-			dip2px(8)
-        );
-        dialogBuilder.setView(remarkInput);
-
-        // 确定按钮：添加位置到列表 + 保存本地
-        dialogBuilder.setPositiveButton("确定", new DialogInterface.OnClickListener() {
-				@Override
-				public void onClick(DialogInterface dialog, int which) {
-					String inputRemark = remarkInput.getText().toString().trim();
-					if (inputRemark.isEmpty()) {
-						Toast.makeText(LocationActivity.this, "未输入备注", Toast.LENGTH_SHORT).show();
-						return;
-					}
-
-					// 校验当前位置是否有效（避免无定位时添加空数据）
-					if (currentLocation == null) {
-						Toast.makeText(LocationActivity.this, "未获取到当前位置，请稍后再试", Toast.LENGTH_SHORT).show();
-						return;
-					}
-
-					// 添加位置到列表（isEnableRealPositionDistance默认false，需手动开启）
-					double longitude = currentLocation.getLongitude();
-					double latitude = currentLocation.getLatitude();
-					PositionModel newPosition = new PositionModel(
-					    PositionModel.genPositionId(),
-                        longitude,
-                        latitude,
-                        inputRemark,
-                        false // 默认不启用实时距离，用户可后续通过编辑开启
-					);
-					mPositionList.add(newPosition);
-
-					// 保存到本地 + 刷新列表
-					try {
-						PositionModel.saveBeanList(LocationActivity.this, mPositionList, PositionModel.class);
-						positionAdapter.notifyItemInserted(mPositionList.size() - 1); // 局部刷新（性能更优）
-						Toast.makeText(LocationActivity.this, "位置已添加", Toast.LENGTH_SHORT).show();
-					} catch (Exception e) {
-						e.printStackTrace();
-						Toast.makeText(LocationActivity.this, "位置保存失败", Toast.LENGTH_SHORT).show();
-					}
-					dialog.dismiss();
-				}
-			});
-
-        // 取消按钮：仅关闭对话框
-        dialogBuilder.setNegativeButton("取消", new DialogInterface.OnClickListener() {
-				@Override
-				public void onClick(DialogInterface dialog, int which) {
-					dialog.dismiss();
-				}
-			});
-
-        // 配置对话框（禁止外部点击关闭）
-        dialogBuilder.setCancelable(false);
-        AlertDialog remarkDialog = dialogBuilder.create();
-        remarkDialog.show();
-    }
-
-
-    /**
-     * 显示删除确认对话框（删除列表项）
-     */
-    private void showDeleteConfirmDialog(final int position) {
-        AlertDialog.Builder deleteDialogBuilder = new AlertDialog.Builder(this);
-        deleteDialogBuilder.setTitle("删除位置记录")
-			.setMessage("确定要删除这条位置吗？（删除后不可恢复）")
-			.setPositiveButton("确定", new DialogInterface.OnClickListener() {
-				@Override
-				public void onClick(DialogInterface dialog, int which) {
-					// 从列表移除 + 保存本地
-					positionAdapter.removePosition(position);
-					try {
-						PositionModel.saveBeanList(LocationActivity.this, mPositionList, PositionModel.class);
-						Toast.makeText(LocationActivity.this, "删除成功", Toast.LENGTH_SHORT).show();
-					} catch (Exception e) {
-						e.printStackTrace();
-						Toast.makeText(LocationActivity.this, "删除失败，请重试", Toast.LENGTH_SHORT).show();
-					}
-				}
-			})
-			.setNegativeButton("取消", new DialogInterface.OnClickListener() {
-				@Override
-				public void onClick(DialogInterface dialog, int which) {
-					dialog.dismiss();
-				}
-			})
-			.setCancelable(false);
-        deleteDialogBuilder.show();
-    }
-
-
-    /**
-     * 检查定位权限（仅精确定位权限，满足实时距离计算需求）
-     */
-    private boolean checkLocationPermissions() {
-        return ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
-			== PackageManager.PERMISSION_GRANTED;
-    }
-
-
-    /**
-     * 申请定位权限
-     */
-    private void requestLocationPermissions() {
-        String[] permissions = new String[]{Manifest.permission.ACCESS_FINE_LOCATION};
-        ActivityCompat.requestPermissions(
-			this,
-			permissions,
-			REQUEST_LOCATION_PERMISSIONS
-        );
-    }
-
-
-    /**
-     * 启动实时定位（获取当前位置 + 监听位置变化）
-     */
-    private void startRealTimeLocation() {
-        if (!checkLocationPermissions()) {
-            Toast.makeText(this, "定位权限未授予", Toast.LENGTH_SHORT).show();
             return;
         }
 
-        // 1. 先获取一次当前位置（初始化页面显示）
+        // 同步位置数据（从服务获取最新列表）
-        fusedLocationClient.getLastLocation()
+        ArrayList<PositionModel> servicePosList = mMainService.getPositionList();
-			.addOnSuccessListener(this, new OnSuccessListener<Location>() {
+        if (servicePosList != null && !servicePosList.isEmpty()) {
+            mLocalPosCache.clear();
+            mLocalPosCache.addAll(servicePosList);
+            LogUtils.d(TAG, "从MainService同步位置数据完成：数量=" + mLocalPosCache.size());
+        }
+
+        // 同步任务数据（无需本地缓存，Adapter直接从服务获取）
+        ArrayList<PositionTaskModel> serviceTaskList = mMainService.getAllTasks();
+        LogUtils.d(TAG, "从MainService同步任务数据完成：数量=" + serviceTaskList.size());
+    }
+
+    /**
+     * 初始化PositionAdapter（核心：传入MainService实例）
+     */
+    private void initPositionAdapter() {
+        if (mMainService == null) {
+            LogUtils.e(TAG, "初始化Adapter失败：MainService为空");
+            return;
+        }
+
+        // Java 7 显式初始化Adapter，传入上下文+本地位置缓存+MainService实例
+        mPositionAdapter = new PositionAdapter(this, mLocalPosCache, mMainService);
+
+        // 设置Adapter回调（处理位置删除/保存，最终同步到MainService）
+        mPositionAdapter.setOnDeleteClickListener(new PositionAdapter.OnDeleteClickListener() {
 				@Override
-				public void onSuccess(Location location) {
+				public void onDeleteClick(int position) {
-					if (location != null) {
+					// 删除逻辑：先删本地缓存，再调用MainService接口删服务数据
-						currentLocation = location;
+					if (position < 0 || position >= mLocalPosCache.size()) {
-						tvLongitude.setText(String.format("当前经度：%.6f", location.getLongitude()));
+						LogUtils.w(TAG, "删除位置失败：无效索引=" + position);
-						tvLatitude.setText(String.format("当前纬度：%.6f", location.getLatitude()));
+						return;
-					} else {
+					}
-						tvLongitude.setText("当前经度：等待更新...");
+					PositionModel deletePos = mLocalPosCache.get(position);
-						tvLatitude.setText("当前纬度：等待更新...");
+					if (deletePos != null && !deletePos.getPositionId().isEmpty()) {
+						// 1. 调用MainService接口删除服务端数据
+						mMainService.removePosition(deletePos.getPositionId());
+						// 2. 删除本地缓存数据
+						mLocalPosCache.remove(position);
+						// 3. 通知Adapter刷新
+						mPositionAdapter.notifyItemRemoved(position);
+						showToast("删除位置成功：" + deletePos.getMemo());
+						LogUtils.d(TAG, "删除位置完成：ID=" + deletePos.getPositionId() + "（已同步MainService）");
 					}
 				}
 			});
 
-        // 2. 注册位置监听器（实时更新位置）
+        mPositionAdapter.setOnSavePositionClickListener(new PositionAdapter.OnSavePositionClickListener() {
-        fusedLocationClient.requestLocationUpdates(
+				@Override
-			locationRequest,
+				public void onSavePositionClick(int position, PositionModel updatedPos) {
-			locationCallback,
+					// 保存逻辑：先更本地缓存，再调用MainService接口更新服务数据
-			getMainLooper() // 主线程更新UI，避免线程异常
+					if (!isServiceBound || mMainService == null) {
-        );
+						LogUtils.w(TAG, "保存位置失败：MainService未绑定");
+						showToast("服务未就绪，保存失败");
+						return;
+					}
+					if (position < 0 || position >= mLocalPosCache.size()) {
+						LogUtils.w(TAG, "保存位置失败：无效索引=" + position);
+						return;
+					}
+
+					// 1. 调用MainService接口更新服务端数据
+					mMainService.updatePosition(updatedPos);
+					// 2. 更新本地缓存数据
+					mLocalPosCache.set(position, updatedPos);
+					// 3. 通知Adapter刷新（可选，Adapter已本地同步）
+					mPositionAdapter.notifyItemChanged(position);
+					showToast("保存位置成功：" + updatedPos.getMemo());
+					LogUtils.d(TAG, "保存位置完成：ID=" + updatedPos.getPositionId() + "（已同步MainService）");
+				}
+			});
+
+        // 设置Adapter到RecyclerView
+        mRvPosition.setAdapter(mPositionAdapter);
+        LogUtils.d(TAG, "PositionAdapter初始化完成（已绑定MainService）");
     }
 
-
     /**
-     * 处理权限申请结果
+     * 显示Toast（Java 7 显式Toast.makeText）
      */
-    @Override
+    private void showToast(String content) {
-    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+        Toast.makeText(this, content, Toast.LENGTH_SHORT).show();
-        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
-        if (requestCode == REQUEST_LOCATION_PERMISSIONS) {
-            boolean isGranted = false;
-            for (int result : grantResults) {
-                if (result == PackageManager.PERMISSION_GRANTED) {
-                    isGranted = true;
-                    break;
-                }
-            }
-
-            if (isGranted) {
-                startRealTimeLocation(); // 权限通过，启动定位
-            } else {
-                // 权限拒绝，提示并显示无权限状态
-                Toast.makeText(this, "定位权限被拒绝，无法显示实时位置和距离", Toast.LENGTH_SHORT).show();
-                tvLongitude.setText("当前经度：无权限");
-                tvLatitude.setText("当前纬度：无权限");
-            }
-        }
     }
 
-
-    /**
-     * 活动销毁：停止定位 + 停止距离刷新定时器（避免内存泄漏）
-     */
     @Override
     protected void onDestroy() {
         super.onDestroy();
 
-        // 1. 停止定位监听（释放定位资源）
+        // 1. 释放Adapter资源（反注册服务监听，避免内存泄漏）
-        if (fusedLocationClient != null && locationCallback != null) {
+        if (mPositionAdapter != null) {
-            fusedLocationClient.removeLocationUpdates(locationCallback);
+            mPositionAdapter.release();
         }
 
-        // 2. 停止Adapter的距离刷新定时器（关键：避免Timer持有Context导致内存泄漏）
+        // 2. 解绑MainService（避免Activity销毁后服务仍被持有）
-        if (positionAdapter != null) {
+        if (isServiceBound) {
-            positionAdapter.stopTimer();
+            unbindService(mServiceConnection);
-        }
+            LogUtils.d(TAG, "MainService解绑完成");
-
-        // 3. 最后同步一次数据（确保所有修改保存）
-        try {
-            if (mPositionList != null && !mPositionList.isEmpty()) {
-                PositionModel.saveBeanList(this, mPositionList, PositionModel.class);
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
         }
     }
+	
+	public static class LocalBinder extends android.os.Binder {
+        // 持有 MainService 实例引用
+        private MainService mService;
 
+        // 构造时传入服务实例
+        public LocalBinder(MainService service) {
+            this.mService = service;
+        }
 
-    /**
+        // 对外提供获取服务实例的方法（供Activity调用）
-     * 辅助工具：dp转px（适配不同屏幕分辨率）
+        public MainService getService() {
-     */
+            return mService;
-    private int dip2px(float dpValue) {
+        }
-        final float scale = getResources().getDisplayMetrics().density;
-        return (int) (dpValue * scale + 0.5f); // +0.5f用于四舍五入，确保精度
     }
 }
 

positions/src/main/java/cc/winboll/studio/positions/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/models/AppConfigsModel.java

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

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

@@ -22,6 +22,8 @@ public class PositionModel extends BaseBean {
 	double latitude;
 	// 位置备注（空值时显示“无备注”）
 	String memo;
+	// 定位点与指定点实时距离长度
+	double realPositionDistance;
 	// 是否启用实时距离计算
 	boolean isEnableRealPositionDistance;
 	// 是否显示简单视图（true=简单视图，false=编辑视图）
@@ -45,6 +47,14 @@ public class PositionModel extends BaseBean {
 		this.isEnableRealPositionDistance = false;
 	}
 
+	public void setRealPositionDistance(double realPositionDistance) {
+		this.realPositionDistance = realPositionDistance;
+	}
+
+	public double getRealPositionDistance() {
+		return realPositionDistance;
+	}
+
 	// ---------------------- Getter/Setter（确保字段有效性） ----------------------
 	public void setPositionId(String positionId) {
 		this.positionId = (positionId == null || positionId.trim().isEmpty()) ? genPositionId() : positionId;

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

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

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

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

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

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

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

@@ -0,0 +1,185 @@
+package cc.winboll.studio.positions.utils;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
+ * @Date 2025/09/30 16:09
+ * @Describe NotificationUtils
+ */
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import androidx.core.app.NotificationCompat;
+import cc.winboll.studio.positions.R;
+import cc.winboll.studio.positions.activities.LocationActivity; // 引入你的前台服务类
+
+/**
+ * 通知栏工具类：专注于任务相关通知的显示与点击跳转 + 前台服务通知管理
+ * 核心功能：
+ * 1. 显示任务描述通知，点击后携带positionId/taskId跳转到LocationActivity
+ * 2. 创建前台服务通知（用于DistanceRefreshService保活，符合系统前台服务规范）
+ */
+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 FOREGROUND_SERVICE_CHANNEL_ID = "foreground_location_service_channel_02";
+	private static final String FOREGROUND_SERVICE_CHANNEL_NAME = "位置服务";
+	public static final int FOREGROUND_SERVICE_NOTIFICATION_ID = 10086; // 固定ID（前台服务通知无需动态生成）
+
+	// ---------------------- 原有功能：任务通知（不变） ----------------------
+	private static int getNotificationId(String taskId) {
+		return taskId.hashCode() & 0xFFFFFF;
+	}
+
+	public static void show(Context context, String taskId, String positionId, String taskDescription) {
+		if (context == null || taskId == null || positionId == null) {
+			return;
+		}
+
+		NotificationManager notificationManager = 
+			(NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+		if (notificationManager == null) {
+			return;
+		}
+
+		createNotificationChannel(notificationManager);
+
+		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);
+
+		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
+		);
+
+		Notification notification = new NotificationCompat.Builder(context, TASK_NOTIFICATION_CHANNEL_ID)
+			.setSmallIcon(R.mipmap.ic_launcher)
+			.setContentTitle("任务提醒")
+			.setContentText(taskDescription)
+			.setContentIntent(pendingIntent)
+			.setAutoCancel(true)
+			.setPriority(NotificationCompat.PRIORITY_DEFAULT)
+			.setDefaults(NotificationCompat.DEFAULT_SOUND)
+			.build();
+
+		notificationManager.notify(getNotificationId(taskId), notification);
+	}
+
+	private static void createNotificationChannel(NotificationManager notificationManager) {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+			// 原有：任务通知渠道
+			NotificationChannel taskChannel = new NotificationChannel(
+				TASK_NOTIFICATION_CHANNEL_ID,
+				TASK_NOTIFICATION_CHANNEL_NAME,
+				NotificationManager.IMPORTANCE_DEFAULT
+			);
+			taskChannel.setDescription("接收任务相关提醒，点击可查看任务详情");
+			taskChannel.enableVibration(true);
+			taskChannel.setVibrationPattern(new long[]{0, 300});
+
+			// 新增：前台服务通知渠道（重要性设为LOW，避免频繁打扰用户）
+			NotificationChannel foregroundChannel = new NotificationChannel(
+				FOREGROUND_SERVICE_CHANNEL_ID,
+				FOREGROUND_SERVICE_CHANNEL_NAME,
+				NotificationManager.IMPORTANCE_LOW // 仅通知栏显示，无提示音/震动，符合后台服务低打扰需求
+			);
+			foregroundChannel.setDescription("位置服务运行中，用于后台持续获取GPS数据，关闭会影响定位功能"); // 明确告知用户服务作用
+			foregroundChannel.enableVibration(false); // 前台服务通知不震动（避免打扰）
+			foregroundChannel.setSound(null, null); // 关闭提示音（低打扰）
+
+			// 注册两个渠道（任务+前台服务）
+			notificationManager.createNotificationChannel(taskChannel);
+			notificationManager.createNotificationChannel(foregroundChannel);
+		}
+	}
+
+	public static void cancel(Context context, String taskId) {
+		if (context == null || taskId == null) {
+			return;
+		}
+		NotificationManager notificationManager = 
+			(NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+		if (notificationManager != null) {
+			notificationManager.cancel(getNotificationId(taskId));
+		}
+	}
+
+	// ---------------------- 新增核心功能：创建前台服务通知（供DistanceRefreshService调用） ----------------------
+	/**
+	 * 创建前台服务通知（符合Android前台服务规范，用于启动/保活DistanceRefreshService）
+	 * @param context 服务上下文（直接传入DistanceRefreshService的this即可）
+	 * @param serviceStatus 服务状态文本（如“正在后台获取GPS位置...”，动态展示服务状态）
+	 * @return 可直接用于startForeground()的Notification对象
+	 */
+	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); // 确保前台服务渠道已注册
+		}
+
+		// 步骤2：构建“点击通知跳转至位置管理页”的Intent（用户点击通知可进入功能页）
+		Intent jumpIntent = new Intent(context, LocationActivity.class);
+		jumpIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP); // 避免创建重复页面
+
+		// 步骤3：创建PendingIntent（授权系统在用户点击时执行跳转）
+		PendingIntent pendingIntent = PendingIntent.getActivity(
+			context,
+			FOREGROUND_SERVICE_NOTIFICATION_ID, // 请求码与通知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
+		);
+
+		// 步骤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)
+			.build();
+	}
+
+	/**
+	 * （配套工具方法）更新前台服务通知的状态文本（如GPS获取进度、运行时长）
+	 * @param context 服务上下文
+	 * @param newServiceStatus 新的状态文本（如“已获取最新位置：北纬30.123°”）
+	 */
+	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) {
+			notificationManager.notify(FOREGROUND_SERVICE_NOTIFICATION_ID, updatedNotification);
+		}
+	}
+}
+

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

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

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

@@ -0,0 +1,34 @@
+package cc.winboll.studio.positions.utils;
+
+/**
+ * @Author ZhanGSKen<zhangsken@qq.com>
+ * @Date 2024/07/19 14:30:57
+ * @Describe 应用服务组件工具类
+ */
+import android.app.ActivityManager;
+import android.content.Context;
+import java.util.List;
+
+public class ServiceUtil {
+    public final static String TAG = "ServiceUtil";
+
+    public static boolean isServiceAlive(Context context, String szServiceName) {
+        // 获取Activity管理者对象
+        ActivityManager manager = (ActivityManager) context
+            .getSystemService(Context.ACTIVITY_SERVICE);
+        // 获取正在运行的服务（此处设置最多取1000个）
+        List<ActivityManager.RunningServiceInfo> runningServices = manager
+            .getRunningServices(1000);
+        if (runningServices.size() <= 0) {
+            return false;
+        }
+        // 遍历，若存在名字和传入的serviceName的一致则说明存在
+        for (ActivityManager.RunningServiceInfo runningServiceInfo : runningServices) {
+            if (runningServiceInfo.service.getClassName().equals(szServiceName)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

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

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

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

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

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

@@ -43,17 +43,17 @@
 			android:layout_height="wrap_content"
 			android:textSize="14sp"
 			android:textColor="#333333"
-			android:id="@+id/tv_edit_real_distance"/>
+			android:id="@+id/tv_edit_distance"/>
 
 		<RadioGroup
-			android:id="@+id/rg_real_distance_switch"
+			android:id="@+id/rg_distance_switch"
 			android:layout_width="wrap_content"
 			android:layout_height="wrap_content"
 			android:orientation="horizontal"
 			android:layout_marginLeft="8dp">
 
 			<RadioButton
-				android:id="@+id/rb_disable"
+				android:id="@+id/rb_distance_disable"
 				android:layout_width="wrap_content"
 				android:layout_height="wrap_content"
 				android:text="禁用"
@@ -61,7 +61,7 @@
 				android:checked="true"/>
 
 			<RadioButton
-				android:id="@+id/rb_enable"
+				android:id="@+id/rb_distance_enable"
 				android:layout_width="wrap_content"
 				android:layout_height="wrap_content"
 				android:text="启用"
@@ -109,7 +109,7 @@
 			android:layout_height="match_parent"/>
 
 		<Button
-			android:id="@+id/btn_edit_confirm"
+			android:id="@+id/btn_edit_save"
 			android:layout_width="wrap_content"
 			android:layout_height="32dp"
 			android:background="@drawable/btn_confirm_bg"
@@ -140,6 +140,14 @@
 				android:textSize="14sp"
 				android:textColor="#333333"/>
 
+			<TextView
+				android:id="@+id/tv_task_count"
+				android:layout_width="wrap_content"
+				android:layout_height="match_parent"
+				android:gravity="center_vertical"
+				android:textSize="14sp"
+				android:textColor="#333333"/>
+			
 			<View
 				android:layout_width="0dp"
 				android:layout_height="match_parent"

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

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="100dp"
+    android:gravity="center"
+    android:orientation="vertical">
+
+    <TextView
+        android:id="@+id/tv_empty_tip"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textColor="@color/colorGrayText"
+        android:textSize="16sp" />
+
+</LinearLayout>
+

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

@@ -29,7 +29,7 @@
         android:layout_marginTop="4dp"/>
 
     <TextView
-        android:id="@+id/tv_simple_real_distance"
+        android:id="@+id/tv_simple_distance"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:textSize="14sp"

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>