基本完成传感器陀螺仪启动，与接收器接收功能。

positions/build.properties

@@ -1,8 +1,8 @@
 #Created by .winboll/winboll_app_build.gradle
-#Tue Oct 28 20:03:59 HKT 2025
+#Tue Nov 04 12:54:59 GMT 2025
 stageCount=18
 libraryProject=
 baseVersion=15.0
 publishVersion=15.0.17
-buildCount=0
+buildCount=20
 baseBetaVersion=15.0.18

positions/src/main/AndroidManifest.xml

@@ -3,24 +3,24 @@
     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" />
-
-    <!-- 前台服务权限（可选，提升后台定位稳定性，避免服务被回收） -->
-    <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-permission android:name="android.permission.FOREGROUND_SERVICE"/>
+
+    <!-- 运行“location”类型的前台服务 -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION"/>
+
+    <!-- 拥有完全的网络访问权限 -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+
     <uses-feature
         android:name="android.hardware.location.gps"
         android:required="false"/>
@@ -59,22 +59,28 @@
             android:name="com.google.android.gms.version"
             android:value="@integer/google_play_services_version"/>
 
-        <service android:name=".services.MainService"/>
+        <service
+            android:name=".services.MainService"
+            android:exported="false"/>
 
-        <service android:name=".services.AssistantService"/>
+        <service
+            android:name=".services.AssistantService"
+            android:exported="false"/>
 
-        <service android:name=".services.DistanceRefreshService"/>
+        <service
+            android:name=".services.DistanceRefreshService"
+            android:exported="false"/>
 
+        <receiver android:name="cc.winboll.studio.positions.receivers.MotionStatusReceiver">
+
+            <intent-filter>
+
+                <action android:name="cc.winboll.studio.positions.receivers.MotionStatusReceiver"/>
+
+            </intent-filter>
+
+        </receiver>
 
-		<!-- 2. 注册运动状态Receiver -->
-		<receiver
-			android:name="cc.winboll.studio.positions.receivers.MotionStatusReceiver"
-			android:enabled="true"
-			android:exported="true">
-			<intent-filter>
-				<action android:name="cc.winboll.studio.positions.ACTION_MOTION_STATUS" />
-			</intent-filter>
-		</receiver>
     </application>
 
 </manifest>

positions/src/main/java/cc/winboll/studio/positions/receivers/MotionStatusReceiver.java

@@ -9,116 +9,353 @@ import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
 import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
 import android.text.TextUtils;
 import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.libappbase.ToastUtils;
 import cc.winboll.studio.positions.services.MainService;
 import cc.winboll.studio.positions.utils.ServiceUtil;
 
 /**
  * 运动状态监听Receiver
- * 功能：接收运动状态广播，控制GPS权限申请与GPS监听开关
+ * 功能：1.持续监听传感器（不关闭） 2.每5秒计算运动状态 3.按状态切换GPS模式（实时/30秒定时）
  */
-public class MotionStatusReceiver extends BroadcastReceiver {
+public class MotionStatusReceiver extends BroadcastReceiver implements SensorEventListener {
-	public static final String TAG = "MotionStatusReceiver";
+    public static final String TAG = "MotionStatusReceiver";
 
-	// 运动状态广播Action（需与运动状态发送方保持一致，如传感器服务）
+    // 广播Action
-	public static final String ACTION_MOTION_STATUS = "cc.winboll.studio.positions.ACTION_MOTION_STATUS";
+    public static final String ACTION_MOTION_STATUS_RECEIVER = "cc.winboll.studio.positions.receivers.MotionStatusReceiver";
-	// 运动状态Extra键：0=静止/低运动，1=行走/高运动
+    public static final String EXTRA_SENSORS_ENABLE = "EXTRA_SENSORS_ENABLE";
-	public static final String EXTRA_MOTION_STATUS = "EXTRA_MOTION_STATUS";
+	// 传感器启动状态标志位
-	// 静止时GPS定时获取间隔（单位：分钟，可配置）
+	boolean mIsSensorsEnable = false;
-	public static final long GPS_STATIC_INTERVAL = 1;
+    // 运动状态常量
+    private static final int MOTION_STATUS_STATIC = 0; // 静止/低运动
+    private static final int MOTION_STATUS_WALKING = 1; // 行走/高速运动
+    // 配置参数（按需求调整）
+    private static final float ACCELEROMETER_THRESHOLD = 0.8f; // 加速度阈值
+    private static final float GYROSCOPE_THRESHOLD = 0.5f; // 陀螺仪阈值
+    private static final long STATUS_CALC_INTERVAL = 5000; // 运动状态计算间隔（5秒）
+    private static final long GPS_STATIC_INTERVAL = 30; // 静止时GPS间隔（30秒）
+    // 核心对象
+    private volatile SensorManager mSensorManager;
+    private Sensor mAccelerometer;
+    private Sensor mGyroscope;
+    private volatile boolean mIsSensorListening = false; // 传感器是否持续监听
+    private int mCurrentMotionStatus = MOTION_STATUS_STATIC; // 当前运动状态
+    private Handler mMainHandler; // 主线程Handler（用于定时计算）
+    private Context mBroadcastContext; // 广播上下文
+    // 传感器数据缓存（用于5秒内数据汇总，避免单次波动误判）
+    private float mAccelMax = 0f; // 5秒内加速度最大值
+    private float mGyroMax = 0f; // 5秒内陀螺仪最大值
 
-	@Override
+    @Override
-	public void onReceive(Context context, Intent intent) {
+    public void onReceive(Context context, Intent intent) {
-		if (context == null || intent == null || !TextUtils.equals(intent.getAction(), ACTION_MOTION_STATUS)) {
-			LogUtils.w(TAG, "无效广播：Action不匹配或上下文为空");
-			return;
-		}
 
-		// 1. 获取运动状态（0=静止/低运动，1=行走/高运动）
+        LogUtils.d(TAG, "===== 接收器启动：onReceive() 开始执行 =====");
-		int motionStatus = intent.getIntExtra(EXTRA_MOTION_STATUS, 0);
+        this.mBroadcastContext = context;
-		LogUtils.d(TAG, "接收运动状态：" + (motionStatus == 1 ? "行走中" : "静止/低运动"));
+        mMainHandler = new Handler(Looper.getMainLooper());
 
-		// 2. 绑定并获取MainService实例（确保服务已启动）
+		if (TextUtils.equals(intent.getAction(), ACTION_MOTION_STATUS_RECEIVER)) {
-		MainService mainService = getMainService(context);
+			boolean isSettingEnable = intent.getBooleanExtra(EXTRA_SENSORS_ENABLE, false);
-		if (mainService == null) {
+			if (mIsSensorsEnable == false && isSettingEnable == true) {
-			LogUtils.e(TAG, "MainService未启动，无法控制GPS状态");
+				mIsSensorsEnable = true;
-			return;
+				// 1. 初始化传感器（必执行）
-		}
+				initSensors();
+				
 
-		// 3. 根据运动状态处理GPS逻辑
+				if (mAccelerometer == null || mGyroscope == null) {
-		if (motionStatus == 1) {
+					LogUtils.e(TAG, "设备缺少加速度/陀螺仪，无法持续监听");
-			// 3.1 行走中：申请GPS权限（若未授予）+ 开启持续GPS监听
+					cleanResources(false); // 传感器不可用才清理
-			handleWalkingStatus(mainService, context);
+					return;
-		} else {
+				}
-			// 3.2 静止/低运动：关闭持续GPS监听 + 启动定时GPS获取
-			handleStaticStatus(mainService);
-		}
-	}
 
-	/**
+				// 2. 校验参数
-	 * 处理行走状态：申请GPS权限+开启持续GPS监听
+				if (context == null || intent == null) {
-	 */
+					LogUtils.d(TAG, "onReceive()：无效参数，终止处理");
-	private void handleWalkingStatus(MainService mainService, Context context) {
+					cleanResources(false);
-		// 检查GPS权限（Android 6.0+动态权限）
+					return;
-		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && 
+				}
-			context.checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) 
+				LogUtils.d(TAG, "onReceive()：接收到广播Action=" + intent.getAction());
-			!= PackageManager.PERMISSION_GRANTED) {
-			// 发送权限申请广播（由Activity接收并发起申请，Receiver无法直接申请权限）
-			Intent permissionIntent = new Intent("cc.winboll.studio.positions.ACTION_REQUEST_GPS_PERMISSION");
-			permissionIntent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
-			context.sendBroadcast(permissionIntent);
-			LogUtils.d(TAG, "行走中：GPS权限未授予，已发送权限申请广播");
-			return;
-		}
 
-		// 权限已授予：开启持续GPS监听（调用MainService原有方法）
+				// 3. 启动持续传感器监听（核心：不关闭，重复调用无影响）
-		if (!mainService.isGpsListening()) { // 需在MainService中新增isGpsListening()方法
+				startSensorListening();
-			mainService.startGpsLocation();
-			LogUtils.d(TAG, "行走中：已开启持续GPS监听");
-		}
 
-		// 停止静止时的GPS定时任务（避免重复获取）
+				// 4. 启动5秒定时计算运动状态（核心：持续触发状态判断）
-		mainService.stopGpsStaticTimer();
+				startStatusCalcTimer();
-	}
-
-	/**
-	 * 处理静止状态：关闭持续GPS监听+启动定时GPS获取
-	 */
-	private void handleStaticStatus(MainService mainService) {
-		// 关闭持续GPS监听（避免耗电）
-		if (mainService.isGpsListening()) {
-			mainService.stopGpsLocation();
-			LogUtils.d(TAG, "静止中：已关闭持续GPS监听");
-		}
-
-		// 启动定时GPS获取（获取一次后关闭，间隔GPS_STATIC_INTERVAL分钟）
-		mainService.startGpsStaticTimer(GPS_STATIC_INTERVAL);
-	}
-
-	/**
-	 * 获取MainService实例（通过绑定服务或单例，确保线程安全）
-	 */
-	private MainService getMainService(Context context) {
-		// 方式1：若MainService单例有效，直接获取（推荐）
-		MainService singleton = MainService.getInstance(context);
-		if (singleton != null && singleton.isServiceRunning()) {
-			return singleton;
-		}
-
-		// 方式2：若单例无效，尝试绑定服务（备用，需处理绑定回调）
-		if (!ServiceUtil.isServiceAlive(context, MainService.class.getName())) {
-			// 启动服务（若未运行）
-			context.startService(new Intent(context, MainService.class));
-			// 等待服务启动（短延时，实际项目建议用ServiceConnection异步绑定）
-			try {
-				Thread.sleep(500);
-			} catch (InterruptedException e) {
-				Thread.currentThread().interrupt();
 			}
 		}
-		return MainService.getInstance(context);
+		
-	}
+
+        // 5. 处理外部广播触发（可选，保留外部控制能力）
+//        if (TextUtils.equals(intent.getAction(), ACTION_MOTION_STATUS_RECEIVER)) {
+//		 int motionStatus = intent.getIntExtra(EXTRA_MOTION_STATUS, MOTION_STATUS_STATIC);
+//		 String statusDesc = motionStatus == MOTION_STATUS_WALKING ? "高速运动" : "静止/低运动";
+//		 LogUtils.d(TAG, "外部广播触发，强制设置运动状态：" + statusDesc);
+//		 mCurrentMotionStatus = motionStatus;
+//		 handleMotionStatus(mCurrentMotionStatus); // 立即执行GPS切换
+//		 }
+    }
+
+    /**
+     * 初始化传感器（持续监听，复用实例）
+     */
+    private void initSensors() {
+        LogUtils.d(TAG, "initSensors()：初始化传感器");
+        if (mSensorManager != null || mBroadcastContext == null) return;
+
+        mSensorManager = (SensorManager) mBroadcastContext.getSystemService(Context.SENSOR_SERVICE);
+        if (mSensorManager == null) {
+            LogUtils.e(TAG, "设备不支持传感器服务");
+            return;
+        }
+        // 获取传感器实例（持续复用，不销毁）
+        mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
+        mGyroscope = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
+
+        LogUtils.d(TAG, "传感器初始化结果：加速度=" + (mAccelerometer != null) + "，陀螺仪=" + (mGyroscope != null));
+    }
+
+    /**
+     * 启动传感器持续监听（核心：不关闭，注册一次一直生效）
+     */
+    private void startSensorListening() {
+        if (mSensorManager == null || mAccelerometer == null || mGyroscope == null) return;
+
+        if (!mIsSensorListening) {
+            // 注册传感器监听（持续生效，直到服务销毁才注销）
+            mSensorManager.registerListener(
+                this,
+                mAccelerometer,
+                SensorManager.SENSOR_DELAY_NORMAL, // 正常延迟，平衡性能与精度
+                mMainHandler
+            );
+            mSensorManager.registerListener(
+                this,
+                mGyroscope,
+                SensorManager.SENSOR_DELAY_NORMAL,
+                mMainHandler
+            );
+            mIsSensorListening = true;
+            LogUtils.d(TAG, "startSensorListening()：传感器持续监听已启动（不关闭）");
+        }
+    }
+
+    /**
+     * 启动5秒定时计算运动状态（核心：周期性汇总传感器数据）
+     */
+    private void startStatusCalcTimer() {
+        if (mMainHandler == null) return;
+
+        // 移除旧任务（避免重复注册）
+        mMainHandler.removeCallbacks(mStatusCalcRunnable);
+        // 启动定时任务（每5秒执行一次）
+        mMainHandler.postDelayed(mStatusCalcRunnable, STATUS_CALC_INTERVAL);
+        LogUtils.d(TAG, "startStatusCalcTimer()：5秒运动状态计算定时器已启动");
+    }
+
+    /**
+     * 运动状态计算任务（5秒执行一次）
+     */
+    private final Runnable mStatusCalcRunnable = new Runnable() {
+        @Override
+        public void run() {
+            // 1. 基于5秒内缓存的最大传感器数据判断状态
+            boolean isHighMotion = (mAccelMax > ACCELEROMETER_THRESHOLD) && (mGyroMax > GYROSCOPE_THRESHOLD);
+            int newMotionStatus = isHighMotion ? MOTION_STATUS_WALKING : MOTION_STATUS_STATIC;
+
+            // 2. 状态变化时才处理（避免频繁切换GPS）
+            if (newMotionStatus != mCurrentMotionStatus) {
+                mCurrentMotionStatus = newMotionStatus;
+                String statusDesc = isHighMotion ? "高速运动" : "静止/低运动";
+                LogUtils.d(TAG, "运动状态更新（5秒计算）：" + statusDesc 
+						   + "（加速度最大值=" + mAccelMax + "，陀螺仪最大值=" + mGyroMax + "）");
+                handleMotionStatus(newMotionStatus); // 切换GPS模式
+            } else {
+                LogUtils.d(TAG, "运动状态无变化（5秒计算）：" + (isHighMotion ? "高速运动" : "静止/低运动"));
+            }
+
+            // 3. 重置传感器数据缓存，准备下一个5秒周期
+            mAccelMax = 0f;
+            mGyroMax = 0f;
+
+            // 4. 循环执行定时任务（核心：持续计算）
+            mMainHandler.postDelayed(this, STATUS_CALC_INTERVAL);
+        }
+    };
+
+    /**
+     * 传感器数据变化回调（核心：实时缓存最大数据）
+     */
+    @Override
+    public void onSensorChanged(SensorEvent event) {
+        if (event == null) return;
+
+        // 实时缓存5秒内的最大传感器数据（避免单次波动误判）
+        switch (event.sensor.getType()) {
+            case Sensor.TYPE_ACCELEROMETER:
+                float accelTotal = Math.abs(event.values[0]) + Math.abs(event.values[1]) + Math.abs(event.values[2]);
+                if (accelTotal > mAccelMax) mAccelMax = accelTotal; // 缓存最大值
+                LogUtils.d(TAG, "加速度传感器实时数据：合值=" + accelTotal + "（当前5秒最大值=" + mAccelMax + "）");
+                break;
+            case Sensor.TYPE_GYROSCOPE:
+                float gyroTotal = Math.abs(event.values[0]) + Math.abs(event.values[1]) + Math.abs(event.values[2]);
+                if (gyroTotal > mGyroMax) mGyroMax = gyroTotal; // 缓存最大值
+                LogUtils.d(TAG, "陀螺仪实时数据：合值=" + gyroTotal + "（当前5秒最大值=" + mGyroMax + "）");
+                break;
+        }
+    }
+
+    /**
+     * 处理运动状态（核心：按状态切换GPS模式）
+     */
+    private void handleMotionStatus(int motionStatus) {
+        LogUtils.d(TAG, "handleMotionStatus()：开始处理运动状态，切换GPS模式");
+        if (mBroadcastContext == null) {
+            LogUtils.w(TAG, "上下文为空，无法处理GPS");
+            return;
+        }
+
+        MainService mainService = getMainService();
+        if (mainService == null) {
+            LogUtils.e(TAG, "MainService未启动，GPS控制失败");
+            return;
+        }
+
+        if (motionStatus == MOTION_STATUS_WALKING) {
+            // 高速运动：启动GPS实时更新（2秒/1米）
+            handleHighMotionGPS(mainService);
+        } else {
+            // 静止/低运动：启动GPS30秒定时更新
+            handleStaticGPS(mainService);
+        }
+    }
+
+    /**
+     * 高速运动GPS处理：实时更新
+     */
+    private void handleHighMotionGPS(MainService mainService) {
+        // 动态权限判断（Android 6.0+）
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M &&
+            mBroadcastContext.checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION)
+            != PackageManager.PERMISSION_GRANTED) {
+            sendPermissionRequestBroadcast();
+            return;
+        }
+
+        // 启动实时GPS（已启动则不重复操作）
+        if (!mainService.isGpsListening()) {
+            mainService.startGpsLocation(); // 实时更新（2秒/1米）
+            mainService.stopGpsStaticTimer(); // 停止定时GPS
+            LogUtils.d(TAG, "高速运动：已启动GPS实时更新");
+        }
+    }
+
+    /**
+     * 静止/低运动GPS处理：30秒定时更新
+     */
+    private void handleStaticGPS(MainService mainService) {
+        // 停止实时GPS（已停止则不重复操作）
+        if (mainService.isGpsListening()) {
+            mainService.stopGpsLocation(); // 停止实时更新
+            LogUtils.d(TAG, "静止/低运动：已停止GPS实时更新");
+        }
+
+        // 启动30秒定时GPS（已启动则不重复操作）
+        mainService.startGpsStaticTimer(GPS_STATIC_INTERVAL); // 30秒一次
+        LogUtils.d(TAG, "静止/低运动：已启动GPS30秒定时更新");
+    }
+
+    /**
+     * 获取MainService实例（复用逻辑）
+     */
+    private MainService getMainService() {
+        if (mBroadcastContext == null) return null;
+
+        // 优先获取单例
+        MainService singleton = MainService.getInstance(mBroadcastContext);
+        if (singleton != null && singleton.isServiceRunning()) {
+            return singleton;
+        }
+
+        // 启动服务并重试
+        if (!ServiceUtil.isServiceAlive(mBroadcastContext, MainService.class.getName())) {
+            mBroadcastContext.startService(new Intent(mBroadcastContext, MainService.class));
+            try {
+                Thread.sleep(500); // 等待服务启动
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+        }
+        return MainService.getInstance(mBroadcastContext);
+    }
+
+    /**
+     * 发送GPS权限申请广播（Receiver无法直接申请）
+     */
+    private void sendPermissionRequestBroadcast() {
+        Intent permissionIntent = new Intent("cc.winboll.studio.positions.ACTION_REQUEST_GPS_PERMISSION");
+        permissionIntent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
+        mBroadcastContext.sendBroadcast(permissionIntent);
+        LogUtils.d(TAG, "GPS权限缺失，已发送申请广播");
+    }
+
+    /**
+     * 资源清理（核心：传感器不关闭，仅清理Handler和上下文）
+     * @param isForceStopSensor 是否强制停止传感器（仅服务销毁时传true）
+     */
+    private void cleanResources(boolean isForceStopSensor) {
+        // 1. 停止定时计算任务
+        if (mMainHandler != null) {
+            mMainHandler.removeCallbacksAndMessages(null);
+            mMainHandler = null;
+            LogUtils.d(TAG, "cleanResources()：已停止运动状态计算定时器");
+        }
+
+        // 2. 强制停止传感器（仅当外部触发销毁时执行，正常情况不关闭）
+        if (isForceStopSensor && mSensorManager != null && mIsSensorListening) {
+            mSensorManager.unregisterListener(this);
+            mIsSensorListening = false;
+            LogUtils.d(TAG, "cleanResources()：已强制停止传感器监听");
+        }
+
+        // 3. 置空上下文（避免内存泄漏）
+        mBroadcastContext = null;
+    }
+
+    /**
+     * 传感器精度变化回调（日志监控）
+     */
+    @Override
+    public void onAccuracyChanged(Sensor sensor, int accuracy) {
+        String sensorType = sensor.getType() == Sensor.TYPE_ACCELEROMETER ? "加速度" : "陀螺仪";
+        String accuracyDesc = getAccuracyDesc(accuracy);
+        LogUtils.d(TAG, sensorType + "传感器精度变化：" + accuracyDesc);
+    }
+
+    /**
+     * 传感器精度描述转换
+     */
+    private String getAccuracyDesc(int accuracy) {
+        switch (accuracy) {
+            case SensorManager.SENSOR_STATUS_ACCURACY_HIGH: return "高";
+            case SensorManager.SENSOR_STATUS_ACCURACY_MEDIUM: return "中";
+            case SensorManager.SENSOR_STATUS_ACCURACY_LOW: return "低";
+            case SensorManager.SENSOR_STATUS_UNRELIABLE: return "不可靠";
+            default: return "未知";
+        }
+    }
+
+    /**
+     * 补充：Receiver销毁时强制清理（需在MainService注销时调用）
+     */
+    public void forceCleanResources() {
+        cleanResources(true); // 强制停止传感器
+    }
 }
 

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

@@ -9,6 +9,7 @@ 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;
@@ -24,6 +25,7 @@ import cc.winboll.studio.libappbase.LogUtils;
 import cc.winboll.studio.libappbase.ToastUtils;
 import cc.winboll.studio.positions.models.PositionModel;
 import cc.winboll.studio.positions.models.PositionTaskModel;
+import cc.winboll.studio.positions.receivers.MotionStatusReceiver;
 import cc.winboll.studio.positions.utils.AppConfigsUtil;
 import cc.winboll.studio.positions.utils.DistanceCalculatorUtil;
 import cc.winboll.studio.positions.utils.NotificationUtil;
@@ -43,10 +45,7 @@ public class MainService extends Service {
     public static final String EXTRA_IS_SETTING_TO_ENABLE = "EXTRA_IS_SETTING_TO_ENABLE";
 
     // ---------------------- 定时器相关变量 ----------------------
-    private ScheduledExecutorService taskCheckTimer; // 任务校验定时器
+    // 静止时GPS定时任务变量（Java 7 显式声明）
-    private static final long TASK_CHECK_INTERVAL = 1; // 定时间隔（1分钟）
-    private static final long TASK_CHECK_INIT_DELAY = 1; // 初始延迟（1分钟）
-    // 新增：静止时GPS定时任务变量（Java 7 显式声明）
     private ScheduledExecutorService gpsStaticTimer; // 静止时GPS定时获取线程池
     private volatile boolean isGpsListening = false;  // GPS是否处于持续监听状态
     private static final long GPS_STATIC_DURATION = 3; // 静止时GPS单次获取超时时间（秒）
@@ -92,47 +91,15 @@ public class MainService extends Service {
     private static volatile MainService sInstance;
     private static Context sAppContext;
 
+    // 核心：运动状态Receiver（动态注册/注销，Java 7 显式声明）
+    private MotionStatusReceiver mMotionStatusReceiver;
+    private IntentFilter mMotionStatusFilter;
+
 
     // =========================================================================
-    // 定时器初始化方法（任务校验+静止GPS定时）
+    // 静止GPS定时任务方法（Java 7 语法）
     // =========================================================================
-    /*private void initTaskCheckTimer() {
+    // 启动静止时GPS定时获取
-        // 先销毁旧定时器（避免重复创建）
-        if (taskCheckTimer != null && !taskCheckTimer.isShutdown()) {
-            taskCheckTimer.shutdown();
-        }
-
-        // 创建单线程定时器（任务串行执行）
-        taskCheckTimer = Executors.newSingleThreadScheduledExecutor();
-        taskCheckTimer.scheduleAtFixedRate(new Runnable() {
-				@Override
-				public void run() {
-					LogUtils.d(TAG, "定时任务触发：开始校验任务（间隔1分钟）");
-					DistanceCalculatorUtil.getInstance(MainService.this).checkAllTaskTriggerCondition(MainService._mCurrentGpsPosition);
-				}
-			}, TASK_CHECK_INIT_DELAY, TASK_CHECK_INTERVAL, TimeUnit.MINUTES);
-
-        LogUtils.d(TAG, "任务校验定时器已启动（间隔：" + TASK_CHECK_INTERVAL + "分钟）");
-    }*/
-
-    /*private void destroyTaskCheckTimer() {
-        if (taskCheckTimer != null && !taskCheckTimer.isShutdown()) {
-            taskCheckTimer.shutdown(); // 优雅关闭
-            try {
-                if (!taskCheckTimer.awaitTermination(1, TimeUnit.SECONDS)) {
-                    taskCheckTimer.shutdownNow(); // 强制关闭
-                }
-            } catch (InterruptedException e) {
-                taskCheckTimer.shutdownNow();
-                Thread.currentThread().interrupt(); // 恢复中断状态
-            } finally {
-                taskCheckTimer = null;
-                LogUtils.d(TAG, "任务校验定时器已销毁");
-            }
-        }
-    }*/
-
-    // 新增：启动静止时GPS定时获取（Java 7 语法，无Lambda）
     public void startGpsStaticTimer(long interval) {
         // 先销毁旧定时器（避免重复创建）
         stopGpsStaticTimer();
@@ -150,7 +117,7 @@ public class MainService extends Service {
         LogUtils.d(TAG, "静止时GPS定时任务已启动（间隔：" + interval + "分钟）");
     }
 
-    // 新增：停止静止时GPS定时任务
+    // 停止静止时GPS定时任务
     public void stopGpsStaticTimer() {
         if (gpsStaticTimer != null && !gpsStaticTimer.isShutdown()) {
             gpsStaticTimer.shutdown();
@@ -168,7 +135,7 @@ public class MainService extends Service {
         }
     }
 
-    // 新增：单次GPS获取（获取后关闭监听，Java 7 匿名内部类）
+    // 单次GPS获取（获取后关闭监听，Java 7 匿名内部类）
     private void startSingleGpsRetrieve() {
         if (!checkGpsReady()) {
             LogUtils.w(TAG, "单次GPS获取：GPS未就绪，跳过");
@@ -379,7 +346,7 @@ public class MainService extends Service {
 
 
     // =========================================================================
-    // 原有基础方法（Java 7 语法适配）
+    // 服务基础方法（核心调整：动态注册/注销MotionStatusReceiver）
     // =========================================================================
     public static synchronized MainService getInstance(Context context) {
         if (sInstance == null) {
@@ -418,15 +385,19 @@ public class MainService extends Service {
             mMyServiceConnection = new MyServiceConnection();
         }
 
+        // 初始化GPS监听（仅初始化，不启动）
+        //initGpsLocationListener();
+
         if (mAppConfigsUtil.isEnableMainService(true)) {
             run(); // 启动服务核心逻辑
         }
     }
 
+    // 服务核心运行方法（调整：启动服务时仅注册Receiver，不启动GPS）
     public void run() {
         if (mAppConfigsUtil.isEnableMainService(true)) {
             if (!_mIsServiceRunning) {
-				_mIsServiceRunning = true;
+                _mIsServiceRunning = true;
                 wakeupAndBindAssistant(); // 唤醒并绑定辅助服务
 
                 // 启动前台服务
@@ -435,25 +406,70 @@ public class MainService extends Service {
                 startForeground(NotificationUtil.FOREGROUND_SERVICE_NOTIFICATION_ID,
 								NotificationUtil.createForegroundServiceNotification(this, initialStatus));
 
-                // 初始化GPS相关
+                // 初始化LocationManager（仅初始化，不启动GPS）
                 mLocationManager = (LocationManager) sInstance.getApplicationContext().getSystemService(Context.LOCATION_SERVICE);
-                initGpsLocationListener();
-                startGpsLocation();
 
                 // 加载本地数据
                 PositionModel.loadBeanList(MainService.this, mPositionList, PositionModel.class);
                 PositionTaskModel.loadBeanList(MainService.this, mAllTasks, PositionTaskModel.class);
 
+				// 初始化运动状态Receiver（动态注册准备）
+				initMotionStatusReceiver();
+
+                // 动态注册MotionStatusReceiver（核心：交给Receiver控制GPS）
+                registerMotionStatusReceiver();
+				
+				Intent triggerIntent = new Intent(MotionStatusReceiver.ACTION_MOTION_STATUS_RECEIVER);
+				triggerIntent.putExtra(MotionStatusReceiver.EXTRA_SENSORS_ENABLE, true);
+				sendBroadcast(triggerIntent);
+				LogUtils.d(TAG, "已发送自主触发广播，唤醒MotionStatusReceiver");
+
                 // 提示与日志
                 ToastUtils.show(initialStatus);
                 LogUtils.i(TAG, initialStatus);
-
-                // 启动任务校验定时器
-                //initTaskCheckTimer();
             }
         }
     }
 
+    // 初始化运动状态Receiver和IntentFilter
+    private void initMotionStatusReceiver() {
+		LogUtils.d(TAG, "initMotionStatusReceiver()");
+        mMotionStatusReceiver = new MotionStatusReceiver();
+        mMotionStatusFilter = new IntentFilter();
+        mMotionStatusFilter.addAction(MotionStatusReceiver.ACTION_MOTION_STATUS_RECEIVER);
+    }
+
+    // 动态注册MotionStatusReceiver
+    private void registerMotionStatusReceiver() {
+		LogUtils.d(TAG, "registerMotionStatusReceiver()");
+        if (mMotionStatusReceiver != null && mMotionStatusFilter != null) {
+            try {
+                registerReceiver(mMotionStatusReceiver, mMotionStatusFilter);
+                LogUtils.d(TAG, "MotionStatusReceiver 动态注册成功");
+            } catch (Exception e) {
+                LogUtils.e(TAG, "MotionStatusReceiver 注册失败：" + e.getMessage());
+            }
+        }
+    }
+
+	//
+	// 动态注销MotionStatusReceiver
+	//
+	private void unregisterMotionStatusReceiver() {
+		if (mMotionStatusReceiver != null) {
+			try {
+				unregisterReceiver(mMotionStatusReceiver);
+				mMotionStatusReceiver.forceCleanResources(); // 新增：强制清理传感器
+				LogUtils.d(TAG, "MotionStatusReceiver 注销并强制清理传感器");
+			} catch (Exception e) {
+				LogUtils.e(TAG, "MotionStatusReceiver 注销失败：" + e.getMessage());
+			} finally {
+				mMotionStatusReceiver = null;
+				mMotionStatusFilter = null;
+			}
+		}
+	}
+
     public boolean isServiceRunning() {
         return _mIsServiceRunning;
     }
@@ -463,8 +479,12 @@ public class MainService extends Service {
         super.onDestroy();
         sInstance = null;
 
-        // 清理资源
+        // 核心清理：1.注销MotionStatusReceiver 2.关闭GPS 3.停止定时任务
-        stopGpsLocation();
+        unregisterMotionStatusReceiver(); // 注销Receiver，避免内存泄漏
+        stopGpsLocation(); // 强制关闭GPS监听
+        stopGpsStaticTimer(); // 停止静止时GPS定时任务
+
+        // 其他资源清理
         clearAllData();
         stopForeground(true);
 
@@ -474,9 +494,7 @@ public class MainService extends Service {
             mTaskListeners.clear();
         }
 
-        // 销毁所有定时器与线程池
+        // 销毁线程池
-        //destroyTaskCheckTimer();
-        stopGpsStaticTimer(); // 新增：销毁静止时GPS定时任务
         if (distanceExecutor != null && !distanceExecutor.isShutdown()) {
             distanceExecutor.shutdown();
         }
@@ -484,8 +502,9 @@ public class MainService extends Service {
         // 重置状态变量
         _mIsServiceRunning = false;
         isGpsEnabled = false;
-        isGpsListening = false; // 新增：重置GPS监听状态
+        isGpsListening = false;
         mLocationManager = null;
+        LogUtils.d(TAG, "MainService 销毁完成，所有资源已清理");
     }
 
 
@@ -500,7 +519,7 @@ public class MainService extends Service {
         return _mCurrentGpsPosition;
     }
 
-    // 新增：判断GPS是否处于持续监听状态（给Receiver调用）
+    // 对外提供：判断GPS是否处于持续监听状态（给MotionStatusReceiver调用）
     public boolean isGpsListening() {
         return isGpsListening;
     }
@@ -606,10 +625,10 @@ public class MainService extends Service {
         }
         // 格式化通知内容
         final String gpsStatus = String.format(
-			"GPS位置：北纬%.4f° 东经%.4f° | 可见位置：%d个",
+            "GPS位置：北纬%.4f° 东经%.4f° | 可见位置：%d个",
-			_mCurrentGpsPosition.getLatitude(),
+            _mCurrentGpsPosition.getLatitude(),
-			_mCurrentGpsPosition.getLongitude(),
+            _mCurrentGpsPosition.getLongitude(),
-			mVisiblePositionIds.size()
+            mVisiblePositionIds.size()
         );
         // 主线程切换
         if (Looper.myLooper() == Looper.getMainLooper()) {
@@ -634,7 +653,7 @@ public class MainService extends Service {
         if (intent != null) {
             isSettingToEnable = intent.getBooleanExtra(EXTRA_IS_SETTING_TO_ENABLE, false);
             if (isSettingToEnable) {
-                run(); // 重启服务核心逻辑
+                run(); // 重启服务核心逻辑（重新注册Receiver）
             }
         }
 
@@ -669,13 +688,14 @@ public class MainService extends Service {
 
 
     // =========================================================================
-    // GPS相关核心方法（Java 7 语法，匿名内部类实现）
+    // GPS相关核心方法（Java 7 语法，仅保留Receiver调用的启动/停止逻辑）
     // =========================================================================
     public MainService() {
         distanceExecutor = Executors.newSingleThreadScheduledExecutor();
         initGpsLocationListener();
     }
 
+    // 初始化GPS监听（仅创建Listener，不注册）
     private void initGpsLocationListener() {
         LogUtils.d(TAG, "initGpsLocationListener");
         mGpsLocationListener = new LocationListener() {
@@ -725,8 +745,8 @@ public class MainService extends Service {
                     String statusDesc = "GPS已开启（用户手动打开）";
                     LogUtils.d(TAG, statusDesc);
                     notifyAllGpsStatusListeners(statusDesc);
-                    updateNotificationGpsStatus("GPS已开启，正在获取位置...");
+                    updateNotificationGpsStatus("GPS已开启，等待Receiver控制启动...");
-                    startGpsLocation();
+                    // 不主动启动GPS，由Receiver根据运动状态控制
                 }
             }
 
@@ -734,7 +754,7 @@ public class MainService extends Service {
             public void onProviderDisabled(String provider) {
                 if (provider.equals(LocationManager.GPS_PROVIDER)) {
                     isGpsEnabled = false;
-                    isGpsListening = false; // 新增：GPS禁用时重置监听状态
+                    isGpsListening = false;
                     _mCurrentGpsPosition = null;
                     String statusDesc = "GPS已关闭（用户手动关闭）";
                     LogUtils.w(TAG, statusDesc);
@@ -746,10 +766,11 @@ public class MainService extends Service {
         };
     }
 
+    // GPS就绪检查（给Receiver调用的GPS操作做前置判断）
     private boolean checkGpsReady() {
         // 检查定位权限
         isGpsPermissionGranted = checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION)
-			== PackageManager.PERMISSION_GRANTED;
+            == PackageManager.PERMISSION_GRANTED;
 
         // 初始化LocationManager
         if (mLocationManager == null) {
@@ -781,22 +802,23 @@ public class MainService extends Service {
         return true;
     }
 
+    // 启动GPS持续监听（仅Receiver可调用）
     public void startGpsLocation() {
-        if (!checkGpsReady()) {
+        if (!checkGpsReady() || isGpsListening) {
             return;
         }
 
         try {
             // 注册GPS位置更新
             mLocationManager.requestLocationUpdates(
-				LocationManager.GPS_PROVIDER,
+                LocationManager.GPS_PROVIDER,
-				GPS_UPDATE_INTERVAL,
+                GPS_UPDATE_INTERVAL,
-				GPS_UPDATE_DISTANCE,
+                GPS_UPDATE_DISTANCE,
-				mGpsLocationListener,
+                mGpsLocationListener,
-				Looper.getMainLooper()
+                Looper.getMainLooper()
             );
 
-            // 新增：标记GPS进入持续监听状态
+            // 标记GPS进入持续监听状态
             isGpsListening = true;
 
             // 获取最后已知GPS位置
@@ -820,17 +842,18 @@ public class MainService extends Service {
             LogUtils.e(TAG, error);
             notifyAllGpsStatusListeners(error);
             isGpsPermissionGranted = false;
-            isGpsListening = false; // 新增：异常时重置监听状态
+            isGpsListening = false;
             updateNotificationGpsStatus("定位权限异常，无法获取GPS");
         } catch (Exception e) {
             String error = "启动GPS失败：" + e.getMessage();
             LogUtils.e(TAG, error);
             notifyAllGpsStatusListeners(error);
-            isGpsListening = false; // 新增：异常时重置监听状态
+            isGpsListening = false;
             updateNotificationGpsStatus("GPS启动失败，尝试重试...");
         }
     }
 
+    // 停止GPS持续监听（仅Receiver可调用）
     public void stopGpsLocation() {
         // 校验参数：避免空指针+权限未授予时调用
         if (mLocationManager != null && mGpsLocationListener != null && isGpsPermissionGranted) {
@@ -839,12 +862,12 @@ public class MainService extends Service {
                 String tip = "GPS定位已停止（移除监听器）";
                 LogUtils.d(TAG, tip);
                 notifyAllGpsStatusListeners(tip);
-                isGpsListening = false; // 新增：停止监听时重置状态
+                isGpsListening = false;
             } catch (Exception e) {
                 String error = "停止GPS失败：" + e.getMessage();
                 LogUtils.e(TAG, error);
                 notifyAllGpsStatusListeners(error);
-                isGpsListening = false; // 新增：异常时重置状态
+                isGpsListening = false;
             }
         }
     }
@@ -857,12 +880,12 @@ public class MainService extends Service {
 
         // 格式化通知内容
         final String triggerContent = String.format(
-			"任务触发：%s\n位置：%s\n当前距离：%.1f米（条件：%s%d米）",
+            "任务触发：%s\n位置：%s\n当前距离：%.1f米（条件：%s%d米）",
-			task.getTaskDescription(),
+            task.getTaskDescription(),
-			bindPos.getMemo(),
+            bindPos.getMemo(),
-			currentDistance,
+            currentDistance,
-			task.isGreaterThan() ? ">" : "<",
+            task.isGreaterThan() ? ">" : "<",
-			task.getDiscussDistance()
+            task.getDiscussDistance()
         );
 
         // 更新前台通知
@@ -887,7 +910,7 @@ public class MainService extends Service {
     // 更新前台通知的GPS状态
     void updateNotificationGpsStatus(final String statusText) {
         if (_mIsServiceRunning) {
-			// 主线程判断+切换
+            // 主线程判断+切换（Java7匿名内部类）
             if (Looper.myLooper() == Looper.getMainLooper()) {
                 NotificationUtil.updateForegroundServiceStatus(this, statusText);
             } else {
@@ -903,7 +926,7 @@ public class MainService extends Service {
 
 
     // =========================================================================
-    // GPS监听通知相关方法（Java 7 语法）
+    // GPS监听通知相关方法（Java7语法，给外部监听者回调）
     // =========================================================================
     public void notifyAllGpsListeners(PositionModel currentGpsPos) {
         if (currentGpsPos == null || mGpsListeners.isEmpty()) {
@@ -946,7 +969,7 @@ public class MainService extends Service {
                 WeakReference<GpsUpdateListener> ref = iter.next();
                 final GpsUpdateListener listener = ref.get();
                 if (listener != null) {
-                    // 主线程切换，避免UI异常
+                    // 主线程切换，避免UI异常（Java7匿名Runnable）
                     if (Looper.myLooper() == Looper.getMainLooper()) {
                         listener.onGpsStatusChanged(status);
                     } else {
@@ -999,7 +1022,7 @@ public class MainService extends Service {
 
 
     // =========================================================================
-    // LocalBinder 定义（与Activity绑定用，Java 7 内部类）
+    // LocalBinder 定义（与Activity绑定用，Java7内部类）
     // =========================================================================
     public class LocalBinder extends android.os.Binder {
         private MainService mService;
@@ -1015,3 +1038,4 @@ public class MainService extends Service {
 }
 
 
+