From 37e1f65dc60acaf22d361839e313bbca867ba98f Mon Sep 17 00:00:00 2001
From: cwchen <1048842385@qq.com>
Date: Thu, 22 Jan 2026 09:32:33 +0800
Subject: [PATCH] =?UTF-8?q?=E5=9C=B0=E5=9B=BE=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/pages/projectSelect/index.vue |   20 +-
 src/static/map.html               | 1349 +++++++----------------------
 2 files changed, 328 insertions(+), 1041 deletions(-)

diff --git a/src/pages/projectSelect/index.vue b/src/pages/projectSelect/index.vue
index df6c4cc..32b359a 100644
--- a/src/pages/projectSelect/index.vue
+++ b/src/pages/projectSelect/index.vue
@@ -17,6 +17,7 @@ const webViewUrl = ref('')
 const webViewKey = ref(0) // 用于强制重新渲染 web-view
 const memberStore = useMemberStore()
 
+
 // 获取项目列表信息
 const getProjectList = async () => {
     const { data: res } = await getAllProjectListApi()
@@ -110,7 +111,22 @@ const handleWebViewMessage = (event) => {
                         projectId: projectInfo.proId,
                         token: memberStore.token,
                     },
-                    (result) => { },
+                    (result) => {
+                        console.log("收到原生回调:", result);
+
+                        // 增加非空判断
+                        if (!result) return;
+
+                        // 根据原生传回的 status 字段判断逻辑
+                        if (result.status === 'closed') {
+                            console.log("监听到三维模型关闭");
+                            uni.$u.toast('三维模型已关闭');
+                            // 在这里处理你需要的业务逻辑，比如刷新列表
+                        }
+                        else if (result.status === 'success') {
+                            // 处理保存成功的逻辑
+                        }
+                    },
                 )
             } else {
                 uni.$u.toast('该工程暂无模型数据')
@@ -139,6 +155,7 @@ const buildProjectInfo = (items) => {
     });
 };
 
+
 onLoad(() => {
     getProjectList().then(() => {
         if (projectList.value.length > 0) {
@@ -152,4 +169,5 @@ onLoad(() => {
         }
     })
 })
+
 </script>
diff --git a/src/static/map.html b/src/static/map.html
index 909744a..44adec7 100644
--- a/src/static/map.html
+++ b/src/static/map.html
@@ -32,7 +32,6 @@
             padding: 0;
             overflow: hidden;
             font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
-            /* 确保 body 背景色与地图底色一致，防止加载前的白屏 */
             background-color: #F5F3F0;
         }
 
@@ -40,32 +39,17 @@
             width: 100vw;
             height: 100vh;
             position: relative;
-
-            /* --- 核心修复代码 START --- */
-
-            /* 1. 设置背景色：使用百度地图默认的陆地颜色(#F5F3F0 或 #FCF9F2)
-               这样即使瓦片没加载出来，用户看到的也是地图的底色，而不是刺眼的白屏闪烁 */
             background-color: #F5F3F0;
-
-            /* 2. 开启硬件加速，减少渲染层重绘 */
             transform: translate3d(0, 0, 0);
             -webkit-transform: translate3d(0, 0, 0);
-
-            /* 3. 防止在某些 iOS 设备上出现灰色背景 */
             -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
-
-            /* --- 核心修复代码 END --- */
         }
 
-        /* 4. 针对 WebGL 生成的 Canvas 元素进行优化 */
         #map-container canvas {
-            /* 强制 GPU 合成 */
             will-change: transform;
-            /* 避免图片渲染时的锯齿和闪动 */
             image-rendering: -webkit-optimize-contrast;
         }
 
-        /* 去除百度地图的水印和logo */
         .BMap_cpyCtrl,
         .anchorBL {
             display: none !important;
@@ -90,7 +74,6 @@
             max-height: 80vh;
             margin: 5% 0 0 2%;
             background: rgba(30, 30, 30, 0.85);
-            /*稍微加深背景增加可读性*/
             border: 1px solid rgba(255, 255, 255, 0.1);
             border-radius: 8px;
             overflow-y: auto;
@@ -102,7 +85,6 @@
             color: #fff;
         }
 
-        /* 滚动条样式 */
         .model-preview-tree::-webkit-scrollbar {
             width: 6px;
         }
@@ -391,7 +373,7 @@
         /* 重置地图按钮 */
         .reset-map-btn {
             position: fixed;
-            bottom: 70px; /* 定位在定位按钮上方：20px + 32px + 18px间距 */
+            bottom: 70px;
             right: 20px;
             width: 32px;
             height: 32px;
@@ -416,7 +398,41 @@
             transform: scale(0.95);
         }
 
-        /* 地图 Label 样式 - 提取至 CSS */
+        /* 网络状态显示 */
+        .network-status {
+            position: fixed;
+            bottom: 20px;
+            left: 20px;
+            background-color: rgba(30, 30, 30, 0.7);
+            color: #fff;
+            padding: 8px 14px;
+            border-radius: 20px;
+            font-size: 13px;
+            font-weight: 500;
+            z-index: 999;
+            pointer-events: none;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            backdrop-filter: blur(5px);
+            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.2);
+            transition: all 0.3s;
+        }
+
+        .network-status-dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            background-color: #4cd964;
+            box-shadow: 0 0 5px #4cd964;
+        }
+
+        /* 断网状态下的样式 */
+        .network-status.offline .network-status-dot {
+            background-color: #ff3b30;
+            box-shadow: 0 0 5px #ff3b30;
+        }
+
         .map-project-label {
             color: #002db6 !important;
             background-color: transparent !important;
@@ -427,11 +443,9 @@
             font-size: 16px !important;
             font-weight: bold !important;
             text-shadow: 1px 1px 2px #fff, -1px -1px 2px #fff, 1px -1px 2px #fff, -1px 1px 2px #fff;
-            /* 增加描边效果提升可见度 */
             transform: translateX(-45%);
         }
 
-        /* 菜单样式 */
         .action-menu {
             background: rgba(255, 255, 255, 0.95);
             border-radius: 12px;
@@ -467,7 +481,6 @@
             font-size: 18px;
         }
 
-        /* 百度地图 InfoWindow 修正 */
         .BMap_bubble_title {
             display: none;
         }
@@ -486,7 +499,6 @@
             display: none;
         }
 
-        /* 隐藏自带关闭按钮 */
         .BMap_bubble_center {
             top: 0 !important;
         }
@@ -514,31 +526,30 @@
         <div class="model-preview-ar" id="ar-btn">AR</div>
     </div>
 
+    <div id="network-status" class="network-status">
+        <div class="network-status-dot"></div>
+        <span class="network-status-text">网络: 检查中...</span>
+    </div>
+
     <div class="reset-map-btn" id="reset-map-btn" title="重置地图"></div>
     <div class="location-center-btn" id="location-center-btn" title="回到当前位置"></div>
 </body>
 
 <script type="text/javascript">
-    /**
-     * 工具类：通用辅助函数
-     */
     const Utils = {
         parseUrlParams(queryString) {
             const params = {};
             const cleanQuery = queryString ? (queryString.startsWith('?') ? queryString.substring(1) : queryString) : '';
             if (!cleanQuery) return params;
-
             cleanQuery.split('&').forEach(pair => {
                 const [key, value] = pair.split('=');
                 if (key) params[decodeURIComponent(key)] = decodeURIComponent(value || '');
             });
             return params;
         },
-
         getUrlParams() {
             return this.parseUrlParams(window.location.search);
         },
-
         safeParseJSON(str, fallback = null) {
             if (!str) return fallback;
             try { return JSON.parse(decodeURIComponent(str)); }
@@ -546,35 +557,24 @@
         }
     };
 
-    /**
-     * 通信桥接类：处理与 UniApp/Parent 的消息发送
-     */
     const Bridge = {
         sendMessage(action, data = {}) {
             const message = { data: { action, ...data } };
             let sent = false;
-
-            // 1. UniApp Standard
             if (typeof uni !== 'undefined' && typeof uni.postMessage === 'function') {
                 uni.postMessage(message);
                 sent = true;
             }
-
-            // 2. Window Parent (Android/Web fallback)
             if (!sent && window.parent && window.parent !== window) {
                 window.parent.postMessage(message, '*');
                 sent = true;
             }
-
-            // 3. iOS Webkit
             if (!sent && window.webkit?.messageHandlers?.uni) {
                 window.webkit.messageHandlers.uni.postMessage(message);
                 sent = true;
             }
-
             return sent;
         },
-
         triggerPageReload(paramsToAppend) {
             try {
                 const currentParams = Utils.getUrlParams();
@@ -604,7 +604,6 @@
         getFullUrl(endpoint) {
             let base = this.baseUrl;
             if (!base.endsWith('/')) base += '/';
-            // 处理相对路径
             if (!base.startsWith('http')) {
                 base = `${window.location.protocol}//${window.location.host}${base.startsWith('/') ? '' : '/'}${base.replace(/^\//, '')}`;
             }
@@ -620,13 +619,12 @@
                     xhr.setRequestHeader('Authorization', this.token);
                     xhr.setRequestHeader('Token', this.token);
                 }
-
                 xhr.onreadystatechange = () => {
                     if (xhr.readyState === 4) {
                         if (xhr.status >= 200 && xhr.status < 300) {
                             const res = Utils.safeParseJSON(encodeURIComponent(xhr.responseText));
                             resolve(res?.code >= 200 && res?.code < 300 ? (res.data || []) : []);
-                    } else {
+                        } else {
                             resolve([]);
                         }
                     }
@@ -634,19 +632,57 @@
                 xhr.onerror = () => resolve([]);
                 xhr.send(JSON.stringify(data));
             });
+        },
+
+        /**
+         * 增强版网络检测：用心跳请求检测真实互联网连接
+         * 解决热点有连接但无网络的问题
+         */
+        checkInternetConnectivity() {
+            return new Promise((resolve) => {
+                // 如果浏览器已经认为离线，直接返回 false
+                if (!navigator.onLine) {
+                    resolve(false);
+                    return;
+                }
+
+                // 创建一个微小的请求来测试互联网
+                // 使用 favicon.ico 或一个极小的静态资源，加上时间戳防缓存
+                // 这里使用百度地图的一个极小图标，因为它本身就在白名单里，且速度快
+                const testImg = new Image();
+                const timeout = 3000; // 3秒超时
+                let timer = null;
+
+                testImg.onload = () => {
+                    clearTimeout(timer);
+                    resolve(true); // 加载成功，有网
+                };
+
+                testImg.onerror = () => {
+                    clearTimeout(timer);
+                    // 图片加载失败，尝试请求一下当前页面的HTML头部（同源策略允许）
+                    // 这是一个降级方案
+                    fetch(window.location.href, { method: 'HEAD', cache: 'no-cache' })
+                        .then(() => resolve(true))
+                        .catch(() => resolve(false));
+                };
+
+                // 设置超时
+                timer = setTimeout(() => {
+                    testImg.src = ''; // 停止请求
+                    resolve(false);
+                }, timeout);
+
+                // 发起请求：使用百度地图的一个静态资源，或者您服务器上的一个小文件
+                // 加上随机数防止缓存
+                testImg.src = 'https://api.map.baidu.com/images/blank.gif?t=' + Date.now();
+            });
         }
     };
 
-    /**
-     * 核心应用逻辑
-     */
     const App = {
         map: null,
-        overlays: {
-            markers: [],
-            models: [],
-            locationMarker: null
-        },
+        overlays: { markers: [], models: [], locationMarker: null },
         state: {
             projectInfo: [],
             currentClickedProject: null,
@@ -659,52 +695,38 @@
             watchOrientationId: null,
             watchLocationTimer: null,
             mapLoaded: false,
-            // 新增：网络状态处理相关
+            // 网络相关
             networkDebounceTimer: null,
-            isNetworkRecovering: false
+            isNetworkRecovering: false,
+            heartbeatTimer: null // 心跳检测定时器
         },
         locationIconCache: null,
         baiduGeolocation: null,
-        lastHeading: null, 
-        updateMarkerTimer: null, 
-        headingHistory: [], 
-        headingHistorySize: 5, 
-        lastOrientationUpdateTime: 0, 
-        headingOffset: 0, 
-        lastLocationTime: 0, 
-        lastLocationPoint: null, 
-        isMoving: false, 
+        lastHeading: null,
+        updateMarkerTimer: null,
+        headingHistory: [],
+        headingHistorySize: 5,
+        lastOrientationUpdateTime: 0,
+        headingOffset: 0,
+        lastLocationTime: 0,
+        lastLocationPoint: null,
+        isMoving: false,
         elements: {
-            panel: null,
-            tree: null,
-            closeBtn: null,
-            projectListContainer: null,
-            resetBtn: null
+            panel: null, tree: null, closeBtn: null, projectListContainer: null, resetBtn: null, networkStatus: null
         },
 
         init() {
             this.cacheElements();
             this.bindEvents();
-
             const params = Utils.getUrlParams();
-
-            // 初始化配置
             Network.init(params.apiBaseUrl, params.token);
-
-            // 解析数据
             this.state.projectInfo = Utils.safeParseJSON(params.projectInfo, []);
             this.state.currentClickedProject = Utils.safeParseJSON(params.clickedProject);
-
-            // 初始化地图（地图加载完成后再初始化定位功能）
             this.initMap(this.state.projectInfo);
-
-            // 渲染工程列表
             this.renderProjectList();
-
-            // 处理 URL Action
             this.handleUrlActions(params);
-
-            // 初始化网络监听优化
+            
+            // 重要：初始化增强版网络监听
             this.setupNetworkListeners();
         },
 
@@ -718,214 +740,187 @@
             this.elements.arBtn = document.getElementById('ar-btn');
             this.elements.locationCenterBtn = document.getElementById('location-center-btn');
             this.elements.resetBtn = document.getElementById('reset-map-btn');
+            this.elements.networkStatus = document.getElementById('network-status');
         },
 
         bindEvents() {
-            if (this.elements.closeBtn) {
-                this.elements.closeBtn.addEventListener('click', () => this.closePreview());
-            }
-
-            // AR 按钮
-            if (this.elements.arBtn) {
-                this.elements.arBtn.addEventListener('click', () => this.navigateToAR());
-            }
-
-            // 全选按钮
-            if (this.elements.selectAllBtn) {
-                this.elements.selectAllBtn.addEventListener('click', () => this.selectAllNodes());
-            }
-
-            // 全不选按钮
-            if (this.elements.deselectAllBtn) {
-                this.elements.deselectAllBtn.addEventListener('click', () => this.deselectAllNodes());
-            }
-
-            // 回到定位按钮
-            if (this.elements.locationCenterBtn) {
-                this.elements.locationCenterBtn.addEventListener('click', () => this.centerToLocation());
-            }
-
-            // 重置地图按钮
-            if (this.elements.resetBtn) {
-                this.elements.resetBtn.addEventListener('click', () => this.resetMap());
-            }
-
-            // 页面卸载时清理定位监听
+            if (this.elements.closeBtn) this.elements.closeBtn.addEventListener('click', () => this.closePreview());
+            if (this.elements.arBtn) this.elements.arBtn.addEventListener('click', () => this.navigateToAR());
+            if (this.elements.selectAllBtn) this.elements.selectAllBtn.addEventListener('click', () => this.selectAllNodes());
+            if (this.elements.deselectAllBtn) this.elements.deselectAllBtn.addEventListener('click', () => this.deselectAllNodes());
+            if (this.elements.locationCenterBtn) this.elements.locationCenterBtn.addEventListener('click', () => this.centerToLocation());
+            if (this.elements.resetBtn) this.elements.resetBtn.addEventListener('click', () => this.resetMap());
+            
             window.addEventListener('beforeunload', () => this.stopLocationTracking());
-
-            // 监听 postMessage
+            
             window.addEventListener('message', (e) => {
                 const data = e.data;
                 if (!data) return;
-
                 if (data.type === 'showModelPreview') {
                     this.showModelPreview(data.modelList, data.clickedProject);
                 } else if (data.action === 'modelDataResponse') {
                     this.drawModel(data.modelData || []);
                 }
             });
-
-            // 暴露全局方法供外部调用
             window.showModelPreview = this.showModelPreview.bind(this);
             window.showModelPreviewWithData = this.showModelPreview.bind(this);
             window.drawModel = this.drawModel.bind(this);
         },
 
         /**
-         * 优化后的网络状态监听：防抖处理，避免频繁闪烁
+         * 增强版网络状态监听：包含心跳检测
          */
         setupNetworkListeners() {
+            // 1. 先进行一次立即检测
+            this.performNetworkCheck();
+
+            // 2. 监听浏览器原生的 online/offline 事件（作为基础触发器）
             window.addEventListener('online', () => {
-                console.log('网络连接已恢复，等待稳定...');
-                
-                // 清除之前的定时器，防止在不稳定时频繁触发
-                if (this.state.networkDebounceTimer) {
-                    clearTimeout(this.state.networkDebounceTimer);
-                }
-                
-                // 设置防抖，等待2秒钟确认网络稳定后再刷新
-                this.state.networkDebounceTimer = setTimeout(() => {
-                    if (this.map && !this.state.isNetworkRecovering) {
-                        console.log('网络稳定，执行地图刷新');
-                        this.state.isNetworkRecovering = true;
-                        
-                        // 记录当前状态
-                        const zoom = this.map.getZoom();
-                        const center = this.map.getCenter();
-                        
-                        // 触发瓦片重载的轻微变动 (只变动一点点，减少视觉跳跃)
-                        // 使用 panBy(0,0) 有时无法触发瓦片重载，setZoom 是最暴力的有效方法
-                        // 这里使用极其微小的缩放变化，并快速还原
-                        this.map.setZoom(zoom + 0.000001);
-                        
-                        setTimeout(() => {
-                            this.map.setZoom(zoom);
-                            this.state.isNetworkRecovering = false;
-                        }, 200);
-                    }
-                }, 2000); // 2秒防抖时间
+                console.log('浏览器报告在线，正在验证真实连接...');
+                this.updateNetworkUIText('验证中...');
+                this.performNetworkCheck();
             });
-            
+
             window.addEventListener('offline', () => {
-                console.log('网络已断开');
-                // 如果在等待刷新期间断网，取消刷新
-                if (this.state.networkDebounceTimer) {
-                    clearTimeout(this.state.networkDebounceTimer);
-                    this.state.networkDebounceTimer = null;
-                }
+                console.log('浏览器报告离线');
+                this.updateNetworkUI(false);
             });
+
+            // 3. 开启心跳检测定时器 (每5秒检查一次)
+            // 这是解决“热点假连接”的关键
+            if (this.state.heartbeatTimer) clearInterval(this.state.heartbeatTimer);
+            this.state.heartbeatTimer = setInterval(() => {
+                this.performNetworkCheck();
+            }, 5000); 
         },
 
         /**
-         * 重置地图（解决网络差导致的黑屏/闪烁问题）
-         * 强制刷新当前页面
+         * 执行真实网络检查
          */
+        async performNetworkCheck() {
+            const isConnected = await Network.checkInternetConnectivity();
+            
+            // 获取当前显示的文本，判断是否还在“检查中”
+            const textSpan = this.elements.networkStatus?.querySelector('.network-status-text');
+            const isChecking = textSpan && textSpan.innerText.includes('检查中');
+            
+            // 获取当前样式状态 (是否有 offline 类)
+            // 注意：默认没有 offline 类，所以 isCurrentlyOnline 默认为 true
+            const isCurrentlyOnline = !this.elements.networkStatus?.classList.contains('offline');
+            
+            // 修复：除了状态改变外，如果还在“检查中”状态，也必须更新 UI
+            if (isConnected !== isCurrentlyOnline || isChecking) {
+                this.updateNetworkUI(isConnected);
+                
+                // 逻辑细化：只有在真正从“断网”恢复到“有网”时（且不是初始检查），才触发地图刷新
+                // 初始检查(isChecking=true)如果是在线的，通常不需要刷新地图
+                if (isConnected && !isCurrentlyOnline && !isChecking) {
+                    this.handleNetworkRecovered();
+                }
+            }
+        },
+
+        handleNetworkRecovered() {
+            console.log('真实网络连接已恢复，等待稳定...');
+            
+            if (this.state.networkDebounceTimer) {
+                clearTimeout(this.state.networkDebounceTimer);
+            }
+            
+            this.state.networkDebounceTimer = setTimeout(() => {
+                if (this.map && !this.state.isNetworkRecovering) {
+                    console.log('网络稳定，执行地图刷新');
+                    this.state.isNetworkRecovering = true;
+                    
+                    const zoom = this.map.getZoom();
+                    // 触发瓦片重载
+                    this.map.setZoom(zoom + 0.000001);
+                    
+                    setTimeout(() => {
+                        this.map.setZoom(zoom);
+                        this.state.isNetworkRecovering = false;
+                    }, 200);
+                }
+            }, 2000);
+        },
+
+        updateNetworkUI(isOnline) {
+            if (!this.elements.networkStatus) return;
+            const textSpan = this.elements.networkStatus.querySelector('.network-status-text');
+            
+            if (isOnline) {
+                this.elements.networkStatus.classList.remove('offline');
+                if (textSpan) textSpan.innerText = '网络: 正常';
+            } else {
+                this.elements.networkStatus.classList.add('offline');
+                if (textSpan) textSpan.innerText = '网络: 异常';
+            }
+        },
+
+        updateNetworkUIText(text) {
+             if (!this.elements.networkStatus) return;
+             const textSpan = this.elements.networkStatus.querySelector('.network-status-text');
+             if (textSpan) textSpan.innerText = `网络: ${text}`;
+        },
+
         resetMap() {
-            console.log('用户请求重置地图...');
-            // 在 WebGL 地图环境（特别是内嵌 WebView），如果因网络问题导致 Context 丢失或瓦片加载卡死，
-            // 简单的 destroy() 可能不够彻底，直接 location.reload() 是最稳妥的修复方式。
             window.location.reload();
         },
 
         initMap(projectInfo) {
             this.map = new BMapGL.Map('map-container', {
-                enableHighResolution: true, // 开启高清适配
-                backgroundColor: [245, 243, 240, 255] // [R, G, B, A] 显式设置 GL 引擎的清屏颜色，与CSS一致
+                enableHighResolution: true,
+                backgroundColor: [245, 243, 240, 255]
             })
             const center = projectInfo[0] ? new BMapGL.Point(projectInfo[0].lng, projectInfo[0].lat) : new BMapGL.Point(116.404, 39.915);
             this.map.centerAndZoom(center, 12);
             this.map.enableScrollWheelZoom(true);
-
-            // 等待地图加载完成
             this.map.addEventListener('tilesloaded', () => {
-                console.log('地图瓦片加载完成');
                 this.state.mapLoaded = true;
-
-                // 地图加载完成后，添加项目标记
                 projectInfo.forEach(p => this.addProjectMarker(p));
-
-                // 地图加载完成后，初始化定位跟踪
                 this.initLocationTracking();
             });
-
-            // 也监听地图初始化完成事件（备用）
             this.map.addEventListener('load', () => {
-                console.log('地图加载完成');
                 if (!this.state.mapLoaded) {
                     this.state.mapLoaded = true;
                     projectInfo.forEach(p => this.addProjectMarker(p));
                     this.initLocationTracking();
                 }
             });
-            
-            // 注意：原有的 window.addEventListener('online') 已移至 setupNetworkListeners 统一管理
         },
 
-        /**
-         * 初始化定位跟踪
-         */
         initLocationTracking() {
-            // ... (保持原有代码不变)
-            // 等待地图加载完成
             if (!this.map || !this.state.mapLoaded) {
-                console.log('等待地图加载完成...');
                 setTimeout(() => this.initLocationTracking(), 200);
                 return;
             }
-
-            console.log('地图已加载完成，开始初始化定位功能');
-
-            // 创建定位标记图标（带方向的箭头）
             this.createLocationIcon();
-
-            // 开始监听位置变化（异步获取位置，不会立即有位置信息）
             this.startWatchingPosition();
-
-            // 开始监听设备方向变化（使用设备方向传感器）
             this.startWatchingOrientation();
         },
         
-        /**
-         * 创建定位标记图标（使用 real_postion.png）
-         */
         createLocationIcon() {
-            // 直接使用静态图片作为定位图标
             this.locationIconUrl = './image/real_postion.png';
         },
 
-        /**
-         * 开始监听位置变化
-         */
         startWatchingPosition() {
-            // 只使用百度地图SDK定位
             if (typeof BMapGL !== 'undefined' && BMapGL.Geolocation) {
-                console.log('使用百度地图SDK辅助定位API');
                 this.startBaiduGeolocation();
             } else {
-                console.error('百度地图定位API不可用，请检查BMapGL.Geolocation是否已加载');
+                console.error('百度地图定位API不可用');
             }
         },
 
-        /**
-         * 使用百度地图定位（返回BD09坐标，无需转换）- 开启SDK辅助定位
-         */
         startBaiduGeolocation() {
-            // 确保地图已加载完成
             if (!this.map || !this.state.mapLoaded) {
-                console.warn('地图未加载完成，延迟启动百度定位');
                 setTimeout(() => this.startBaiduGeolocation(), 500);
                 return;
             }
-
             const geolocation = new BMapGL.Geolocation();
-            // 开启SDK辅助定位，提高定位精度
             geolocation.enableSDKLocation();
 
-            console.log('已开启百度地图SDK辅助定位');
-
-            // 计算两点之间的距离（米）- 供多个函数使用
             const calculateDistance = (lng1, lat1, lng2, lat2) => {
-                const R = 6371000; // 地球半径（米）
+                const R = 6371000;
                 const dLat = (lat2 - lat1) * Math.PI / 180;
                 const dLng = (lng2 - lng1) * Math.PI / 180;
                 const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
@@ -935,247 +930,123 @@
                 return R * c;
             };
 
-            // 先快速获取位置（使用较短的超时时间，优先显示位置）
             let isFirstLocation = true;
-
             const getQuickPosition = () => {
                 geolocation.getCurrentPosition((result) => {
                     const status = geolocation.getStatus();
-                    console.log('百度地图定位状态:', status, '结果:', result);
-
-                    // 百度地图定位成功状态码是0
                     if (status === 0 && result && result.point) {
                         const point = result.point;
                         const accuracy = result.accuracy || 999;
-
-                        // 验证坐标有效性
                         if (point.lng && point.lat && !isNaN(point.lng) && !isNaN(point.lat) &&
                             Math.abs(point.lng) <= 180 && Math.abs(point.lat) <= 90) {
-
-                            // 如果是第一次获取位置，立即显示（不管精度如何）
                             if (isFirstLocation) {
-                                console.log('首次定位成功 - 经度:', point.lng, '纬度:', point.lat, '精度:', accuracy, '米');
-                                this.state.currentLocation = {
-                                    lng: point.lng,
-                                    lat: point.lat,
-                                    accuracy: accuracy
-                                };
-
-                                // 方向由设备方向传感器提供，不在这里设置
+                                this.state.currentLocation = { lng: point.lng, lat: point.lat, accuracy: accuracy };
                                 this.updateLocationMarker();
                                 isFirstLocation = false;
-
-                                // 如果精度较差，继续获取更精确的位置（后台优化）
-                                if (accuracy > 50) {
-                                    console.log('精度较差，后台继续优化定位...');
-                                    setTimeout(() => getPrecisePosition(), 1000);
-                                }
+                                if (accuracy > 50) setTimeout(() => getPrecisePosition(), 1000);
                             }
                         }
-                    } else {
-                        console.warn('快速定位失败，状态:', status);
                     }
-                }, {
-                    enableHighAccuracy: false, // 先使用快速定位（网络定位）
-                    timeout: 5000 // 5秒超时，快速获取位置
-                });
+                }, { enableHighAccuracy: false, timeout: 5000 });
             };
 
-            // 获取精确位置（GPS定位）
             const getPrecisePosition = () => {
                 geolocation.getCurrentPosition((result) => {
                     const status = geolocation.getStatus();
-
                     if (status === 0 && result && result.point) {
                         const point = result.point;
                         const accuracy = result.accuracy || 999;
-
-                        // 验证坐标有效性
                         if (point.lng && point.lat && !isNaN(point.lng) && !isNaN(point.lat) &&
                             Math.abs(point.lng) <= 180 && Math.abs(point.lat) <= 90) {
-
                             let shouldUpdate = false;
-
                             if (!this.state.currentLocation) {
                                 shouldUpdate = true;
                             } else {
-                                // 计算位置变化距离
                                 const distance = calculateDistance(
-                                    this.state.currentLocation.lng,
-                                    this.state.currentLocation.lat,
-                                    point.lng,
-                                    point.lat
+                                    this.state.currentLocation.lng, this.state.currentLocation.lat,
+                                    point.lng, point.lat
                                 );
-
-                                // 位置变化超过0.3米就更新(极高灵敏度)，或者精度提升超过5米
-                                if (distance > 0.3 ||
-                                    (accuracy < this.state.currentLocation.accuracy - 5) ||
-                                    (accuracy < 50 && this.state.currentLocation.accuracy >= 50)) {
+                                if (distance > 0.3 || (accuracy < this.state.currentLocation.accuracy - 5) || (accuracy < 50 && this.state.currentLocation.accuracy >= 50)) {
                                     shouldUpdate = true;
                                 }
                             }
-
                             if (shouldUpdate) {
-                                // 检测移动状态（通过位置变化速度）
                                 const now = Date.now();
                                 if (this.lastLocationTime > 0 && this.lastLocationPoint && this.state.currentLocation) {
-                                    const distance = calculateDistance(
-                                        this.state.currentLocation.lng,
-                                        this.state.currentLocation.lat,
-                                        point.lng,
-                                        point.lat
-                                    );
-                                    const timeDiff = (now - this.lastLocationTime) / 1000; // 秒
+                                    const distance = calculateDistance(this.state.currentLocation.lng, this.state.currentLocation.lat, point.lng, point.lat);
+                                    const timeDiff = (now - this.lastLocationTime) / 1000;
                                     if (timeDiff > 0) {
-                                        const speed = distance / timeDiff; // 米/秒
-                                        // 如果速度超过0.05米/秒(极低阈值)，认为在移动
+                                        const speed = distance / timeDiff;
                                         this.isMoving = speed > 0.05;
                                     }
                                 }
-
                                 this.lastLocationTime = now;
                                 this.lastLocationPoint = { lng: point.lng, lat: point.lat };
-
-                                console.log('精确位置更新 - 经度:', point.lng, '纬度:', point.lat, '精度:', accuracy, '米',
-                                    this.isMoving ? '(移动中)' : '(静止)');
-                                this.state.currentLocation = {
-                                    lng: point.lng,
-                                    lat: point.lat,
-                                    accuracy: accuracy
-                                };
-
-                                // 方向由设备方向传感器提供，不在这里更新
+                                this.state.currentLocation = { lng: point.lng, lat: point.lat, accuracy: accuracy };
                                 this.updateLocationMarker();
                             }
                         }
                     }
-                }, {
-                    enableHighAccuracy: true, // 使用GPS精确定位
-                    timeout: 20000 // 20秒超时(给GPS足够时间)
-                });
+                }, { enableHighAccuracy: true, timeout: 20000 });
             };
 
-            // 先快速获取位置
             getQuickPosition();
 
-            // 持续监听位置变化（使用定时器定期获取，改为每5秒更新一次）
             this.state.watchLocationTimer = setInterval(() => {
                 geolocation.getCurrentPosition((result) => {
                     const status = geolocation.getStatus();
                     if (status === 0 && result && result.point) {
                         const point = result.point;
                         const accuracy = result.accuracy || 999;
-
-                        // 验证坐标有效性
-                        if (point.lng && point.lat && !isNaN(point.lng) && !isNaN(point.lat) &&
-                            Math.abs(point.lng) <= 180 && Math.abs(point.lat) <= 90) {
-
+                        if (point.lng && point.lat && !isNaN(point.lng) && !isNaN(point.lat) && Math.abs(point.lng) <= 180 && Math.abs(point.lat) <= 90) {
                             let shouldUpdate = false;
-
                             if (!this.state.currentLocation) {
-                                // 如果没有当前位置，直接更新
                                 shouldUpdate = true;
                             } else {
-                                // 计算位置变化距离
-                                const distance = calculateDistance(
-                                    this.state.currentLocation.lng,
-                                    this.state.currentLocation.lat,
-                                    point.lng,
-                                    point.lat
-                                );
-
-                                // 位置变化超过0.3米就更新(极高灵敏度)，或者精度提升超过5米
-                                if (distance > 0.3 ||
-                                    (accuracy < this.state.currentLocation.accuracy - 5) ||
-                                    (accuracy < 50 && this.state.currentLocation.accuracy >= 50)) {
+                                const distance = calculateDistance(this.state.currentLocation.lng, this.state.currentLocation.lat, point.lng, point.lat);
+                                if (distance > 0.3 || (accuracy < this.state.currentLocation.accuracy - 5) || (accuracy < 50 && this.state.currentLocation.accuracy >= 50)) {
                                     shouldUpdate = true;
                                 }
                             }
-
-                            // 强制每3秒更新一次，即使位置变化不大
                             const now = Date.now();
                             if (!this.lastForceUpdateTime) this.lastForceUpdateTime = 0;
                             if ((now - this.lastForceUpdateTime) > 3000) {
                                 shouldUpdate = true;
                                 this.lastForceUpdateTime = now;
-                                console.log('⚠️ 强制位置更新(3秒周期)');
                             }
-
                             if (shouldUpdate) {
                                 const oldLocation = this.state.currentLocation;
-                                const distance = oldLocation ? calculateDistance(
-                                    oldLocation.lng, oldLocation.lat, point.lng, point.lat
-                                ) : 0;
-
-                                // 检测移动状态（通过位置变化速度）
+                                const distance = oldLocation ? calculateDistance(oldLocation.lng, oldLocation.lat, point.lng, point.lat) : 0;
                                 if (this.lastLocationTime > 0 && this.lastLocationPoint) {
-                                    const timeDiff = (now - this.lastLocationTime) / 1000; // 秒
+                                    const timeDiff = (now - this.lastLocationTime) / 1000;
                                     if (timeDiff > 0) {
-                                        const speed = distance / timeDiff; // 米/秒
-                                        // 如果速度超过0.05米/秒(极低阈值)，认为在移动
+                                        const speed = distance / timeDiff;
                                         this.isMoving = speed > 0.05;
                                     }
                                 }
-
                                 this.lastLocationTime = now;
                                 this.lastLocationPoint = { lng: point.lng, lat: point.lat };
-
-                                console.log('位置更新 - 经度:', point.lng, '纬度:', point.lat,
-                                    '精度:', accuracy, '米',
-                                    oldLocation ? `移动距离: ${distance.toFixed(2)}米` : '',
-                                    this.isMoving ? '(移动中)' : '(静止)');
-
-                                this.state.currentLocation = {
-                                    lng: point.lng,
-                                    lat: point.lat,
-                                    accuracy: accuracy
-                                };
-
-                                // 方向由设备方向传感器实时提供，不在这里更新
+                                this.state.currentLocation = { lng: point.lng, lat: point.lat, accuracy: accuracy };
                                 this.updateLocationMarker();
                             }
                         }
                     }
-                }, {
-                    enableHighAccuracy: true, // 使用GPS精确定位
-                    timeout: 15000 // 15秒超时(给GPS足够时间)
-                });
-            }, 3000); // 每5秒更新一次位置
-
-            // 保存geolocation实例，以便后续使用
+                }, { enableHighAccuracy: true, timeout: 15000 });
+            }, 3000);
             this.baiduGeolocation = geolocation;
         },
 
-        /**
-         * 使用逆地理编码验证位置（用于调试）
-         */
-        verifyLocationWithGeocoder(lng, lat) {
-            if (!this.map) return;
-
-            const geocoder = new BMapGL.Geocoder();
-            const point = new BMapGL.Point(lng, lat);
-
-            geocoder.getLocation(point, (result) => {
-                if (result && result.address) {
-                    console.log('位置验证 - 地址:', result.address);
-                }
-            });
+        wgs84ToBd09(wgs_lng, wgs_lat, callback) {
+            this.wgs84ToBd09WebAPI(wgs_lng, wgs_lat, callback);
         },
 
-        /**
-         * GCJ02坐标转BD09坐标（百度坐标）
-         */
-        gcj02ToBd09(gcj_lng, gcj_lat, callback) {
+        wgs84ToBd09WebAPI(wgs_lng, wgs_lat, callback) {
             const ak = 'iqyZkSZPurf61MhFV7hesbDukHdMBEEb';
-            // 使用6位小数精度（百度API推荐精度）
-            const coords = `${Number(gcj_lng).toFixed(6)},${Number(gcj_lat).toFixed(6)}`;
-            const url = `https://api.map.baidu.com/geoconv/v1/?coords=${coords}&from=3&to=5&ak=${ak}`;
-
-            console.log('GCJ02转BD09 - 输入:', gcj_lng, gcj_lat);
-
+            const coords = `${Number(wgs_lng).toFixed(6)},${Number(wgs_lat).toFixed(6)}`;
+            const url = `https://api.map.baidu.com/geoconv/v1/?coords=${coords}&from=1&to=5&ak=${ak}`;
             const xhr = new XMLHttpRequest();
             xhr.open('GET', url, true);
-            xhr.timeout = 10000; // 10秒超时
+            xhr.timeout = 10000;
             xhr.onreadystatechange = () => {
                 if (xhr.readyState === 4) {
                     if (xhr.status === 200) {
@@ -1183,148 +1054,34 @@
                             const response = JSON.parse(xhr.responseText);
                             if (response.status === 0 && response.result && response.result.length > 0) {
                                 const point = response.result[0];
-                                const result = {
-                                    lng: Number(point.x),
-                                    lat: Number(point.y)
-                                };
-                                console.log('GCJ02转BD09成功:', result.lng, result.lat);
+                                const result = { lng: Number(point.x), lat: Number(point.y) };
                                 if (callback) callback(result);
                                 return;
                             }
-                        } catch (e) {
-                            console.error('GCJ02转BD09解析失败:', e);
-                        }
+                        } catch (e) { console.error('Web API解析失败:', e); }
                     }
-                    // API失败，使用算法转换
-                    console.warn('GCJ02转BD09 API失败，使用算法转换');
-                    const result = this.gcj02ToBd09Fallback(gcj_lng, gcj_lat);
-                    if (callback) callback(result);
-                }
-            };
-            xhr.onerror = () => {
-                console.warn('GCJ02转BD09网络错误，使用算法转换');
-                const result = this.gcj02ToBd09Fallback(gcj_lng, gcj_lat);
-                if (callback) callback(result);
-            };
-            xhr.ontimeout = () => {
-                console.warn('GCJ02转BD09超时，使用算法转换');
-                const result = this.gcj02ToBd09Fallback(gcj_lng, gcj_lat);
-                if (callback) callback(result);
-            };
-            xhr.send();
-        },
-
-        /**
-         * GCJ02转BD09算法
-         */
-        gcj02ToBd09Fallback(gcj_lng, gcj_lat) {
-            const x_PI = 3.14159265358979324 * 3000.0 / 180.0;
-            let z = Math.sqrt(gcj_lng * gcj_lng + gcj_lat * gcj_lat) + 0.00002 * Math.sin(gcj_lat * x_PI);
-            let theta = Math.atan2(gcj_lat, gcj_lng) + 0.000003 * Math.cos(gcj_lng * x_PI);
-            let bd_lng = z * Math.cos(theta) + 0.0065;
-            let bd_lat = z * Math.sin(theta) + 0.006;
-            return { lng: bd_lng, lat: bd_lat };
-        },
-
-        /**
-         * WGS84坐标转BD09坐标（优先使用百度地图Web API，最准确）
-         */
-        wgs84ToBd09(wgs_lng, wgs_lat, callback) {
-            // 优先使用Web API（最准确）
-            this.wgs84ToBd09WebAPI(wgs_lng, wgs_lat, callback);
-        },
-
-        /**
-         * 使用百度地图Web服务API进行坐标转换
-         */
-        wgs84ToBd09WebAPI(wgs_lng, wgs_lat, callback) {
-            const ak = 'iqyZkSZPurf61MhFV7hesbDukHdMBEEb'; // 百度地图AK
-            // 使用6位小数精度（百度API推荐精度）
-            const coords = `${Number(wgs_lng).toFixed(6)},${Number(wgs_lat).toFixed(6)}`;
-            const url = `https://api.map.baidu.com/geoconv/v1/?coords=${coords}&from=1&to=5&ak=${ak}`;
-
-            console.log('调用坐标转换API - WGS84:', wgs_lng, wgs_lat, 'URL:', url);
-
-            const xhr = new XMLHttpRequest();
-            xhr.open('GET', url, true);
-            xhr.timeout = 10000; // 10秒超时
-            xhr.onreadystatechange = () => {
-                if (xhr.readyState === 4) {
-                    if (xhr.status === 200) {
-                        try {
-                            const responseText = xhr.responseText;
-                            console.log('坐标转换API原始响应:', responseText);
-                            const response = JSON.parse(responseText);
-
-                            if (response.status === 0 && response.result && response.result.length > 0) {
-                                const point = response.result[0];
-                                // 百度API返回：x=经度，y=纬度
-                                const result = {
-                                    lng: Number(point.x),
-                                    lat: Number(point.y)
-                                };
-
-                                // 验证转换结果的有效性
-                                if (isNaN(result.lng) || isNaN(result.lat) ||
-                                    result.lng === 0 || result.lat === 0 ||
-                                    Math.abs(result.lng) > 180 || Math.abs(result.lat) > 90) {
-                                    console.error('坐标转换结果无效:', result, '原始响应:', response);
-                                    const fallback = this.wgs84ToBd09Fallback(wgs_lng, wgs_lat);
-                                    console.warn('使用备用算法:', fallback);
-                                    if (callback) callback(fallback);
-                                    return;
-                                }
-
-                                // 计算偏移距离（用于调试）
-                                const offsetLng = result.lng - wgs_lng;
-                                const offsetLat = result.lat - wgs_lat;
-                                console.log('Web API转换成功 - WGS84:', wgs_lng, wgs_lat, '-> BD09:', result.lng, result.lat);
-                                console.log('坐标偏移:', '经度:', offsetLng.toFixed(6), '纬度:', offsetLat.toFixed(6));
-
-                                if (callback) callback(result);
-                                return;
-                            } else {
-                                console.error('Web API返回错误 - 状态码:', response.status, '错误信息:', response.message || JSON.stringify(response));
-                            }
-                        } catch (e) {
-                            console.error('Web API解析失败:', e, '响应文本:', xhr.responseText);
-                        }
-                    } else {
-                        console.error('Web API请求失败 - HTTP状态码:', xhr.status, '响应:', xhr.responseText);
-                    }
-                    // API调用失败，使用备用算法
-                    console.warn('坐标转换API失败，使用备用算法');
                     const result = this.wgs84ToBd09Fallback(wgs_lng, wgs_lat);
-                    console.log('备用算法转换结果 - WGS84:', wgs_lng, wgs_lat, '-> BD09:', result.lng, result.lat);
                     if (callback) callback(result);
                 }
             };
             xhr.onerror = () => {
-                console.error('Web API网络错误');
                 const result = this.wgs84ToBd09Fallback(wgs_lng, wgs_lat);
                 if (callback) callback(result);
             };
             xhr.ontimeout = () => {
-                console.error('Web API请求超时');
                 const result = this.wgs84ToBd09Fallback(wgs_lng, wgs_lat);
                 if (callback) callback(result);
             };
             xhr.send();
         },
 
-        /**
-         * WGS84转BD09算法（精确版，针对中国地区优化）
-         */
         wgs84ToBd09Fallback(wgs_lng, wgs_lat) {
             const x_PI = 3.14159265358979324 * 3000.0 / 180.0;
             const PI = 3.1415926535897932384626;
             const a = 6378245.0;
             const ee = 0.00669342162296594323;
-
             let x = Number(wgs_lng);
             let y = Number(wgs_lat);
-
-            // WGS84转GCJ02（火星坐标）- 使用精确算法
             let dlat = this.transformLat(x - 105.0, y - 35.0);
             let dlng = this.transformLng(x - 105.0, y - 35.0);
             let radlat = y / 180.0 * PI;
@@ -1335,13 +1092,10 @@
             dlng = (dlng * 180.0) / (a / sqrtmagic * Math.cos(radlat) * PI);
             let mglat = y + dlat;
             let mglng = x + dlng;
-
-            // GCJ02转BD09（百度坐标）- 使用精确算法
             let z = Math.sqrt(mglng * mglng + mglat * mglat) + 0.00002 * Math.sin(mglat * x_PI);
             let theta = Math.atan2(mglat, mglng) + 0.000003 * Math.cos(mglng * x_PI);
             let bd_lng = z * Math.cos(theta) + 0.0065;
             let bd_lat = z * Math.sin(theta) + 0.006;
-
             return { lng: bd_lng, lat: bd_lat };
         },
 
@@ -1361,306 +1115,136 @@
             return ret;
         },
 
-        /**
-         * 更新位置
-         */
-        updateLocation(position) {
-            const coords = position.coords || position;
-            const { latitude, longitude, heading, accuracy } = coords;
-
-            if (!latitude || !longitude) {
-                console.warn('位置信息无效:', { latitude, longitude });
-                return;
-            }
-
-            console.log('收到位置更新 - WGS84:', longitude, latitude, '精度:', accuracy, '方向:', heading);
-
-            // 将WGS84坐标转换为百度BD09坐标（使用官方API）
-            this.wgs84ToBd09(longitude, latitude, (bd09) => {
-                if (!bd09) {
-                    // 如果转换失败，使用备用算法
-                    console.warn('坐标转换返回空，使用备用算法');
-                    bd09 = this.wgs84ToBd09Fallback(longitude, latitude);
-                }
-
-                console.log('坐标转换完成 - BD09:', bd09.lng, bd09.lat);
-
-                // 保存转换后的百度坐标
-                this.state.currentLocation = {
-                    lat: bd09.lat,
-                    lng: bd09.lng,
-                    accuracy: accuracy || 0
-                };
-
-                // 如果有方向信息，更新方向
-                if (heading !== null && heading !== undefined && !isNaN(heading)) {
-                    const oldHeading = this.state.currentHeading;
-                    this.state.currentHeading = heading;
-                    if (Math.abs(heading - oldHeading) > 1) {
-                        console.log('方向更新（来自GPS）:', heading);
-                    }
-                }
-
-                // 更新地图上的标记
-                this.updateLocationMarker();
-            });
-        },
-
-        /**
-         * 更新定位标记（实时更新，优先更新位置）
-         */
         updateLocationMarker() {
-            // 确保地图已加载完成
-            if (!this.map || !this.state.mapLoaded) {
-                    return;
-                }
-                
-            // 如果没有位置信息，静默返回
-            if (!this.state.currentLocation) {
-                    return;
-                }
-                
-            // 如果已经有待处理的更新，取消它，重新调度（确保使用最新数据）
-            if (this.updateMarkerTimer) {
-                cancelAnimationFrame(this.updateMarkerTimer);
-            }
-
-            // 使用requestAnimationFrame实现平滑更新，保持实时性
-            // 对于位置更新，立即执行；对于方向更新，异步执行
+            if (!this.map || !this.state.mapLoaded || !this.state.currentLocation) return;
+            if (this.updateMarkerTimer) cancelAnimationFrame(this.updateMarkerTimer);
             this.updateMarkerTimer = requestAnimationFrame(() => {
                 this.updateMarkerTimer = null;
                 this._doUpdateLocationMarker();
             });
         },
 
-        /**
-         * 实际执行更新定位标记（实时更新位置和方向）
-         */
         _doUpdateLocationMarker() {
             const { lng, lat } = this.state.currentLocation;
             const point = new BMapGL.Point(lng, lat);
-
-            // 如果标记已存在，直接更新（避免删除重建）
             if (this.overlays.locationMarker) {
                 try {
-                    // 优先更新位置（立即执行，不等待方向更新）
                     if (typeof this.overlays.locationMarker.setPosition === 'function') {
-                        // 直接更新位置，实时跟随移动（不检查距离，每次都更新以确保平滑）
                         this.overlays.locationMarker.setPosition(point);
                     } else {
-                        // 如果不支持setPosition，检查位置是否变化（降低阈值，提高灵敏度）
                         const currentPoint = this.overlays.locationMarker.getPosition();
-                        // 极低坐标变化阈值0.0000005(约0.05米)，实时更新位置
-                        if (!currentPoint ||
-                            Math.abs(currentPoint.lng - lng) > 0.0000005 ||
-                            Math.abs(currentPoint.lat - lat) > 0.0000005) {
-                            // 位置变化，需要更新（但尽量不删除重建）
+                        if (!currentPoint || Math.abs(currentPoint.lng - lng) > 0.0000005 || Math.abs(currentPoint.lat - lat) > 0.0000005) {
                             const currentIcon = this.overlays.locationMarker.getIcon();
                             this.map.removeOverlay(this.overlays.locationMarker);
                             this.overlays.locationMarker = new BMapGL.Marker(point, { icon: currentIcon });
                             this.map.addOverlay(this.overlays.locationMarker);
                         }
                     }
-
-                    // 实时更新方向（使用角度差值计算，考虑0-360度边界）
-                    // 移动时1.5度，静止时0.3度，极高灵敏度
                     const headingThreshold = this.isMoving ? 1.5 : 0.3;
                     const headingChanged = !this.lastHeading || Math.abs(this.angleDifference(this.state.currentHeading, this.lastHeading)) >= headingThreshold;
-
                     if (headingChanged) {
                         const oldHeading = this.lastHeading;
                         this.lastHeading = this.state.currentHeading;
-
-                        // 异步更新图标（使用requestAnimationFrame确保平滑，不阻塞位置更新）
                         requestAnimationFrame(() => {
                             this.createRotatedLocationIcon(this.state.currentHeading).then((icon) => {
                                 if (this.overlays.locationMarker) {
-                                    // 优先使用setIcon更新（不删除重建）
                                     if (typeof this.overlays.locationMarker.setIcon === 'function') {
                                         this.overlays.locationMarker.setIcon(icon);
                                     } else {
-                                        // 如果不支持setIcon，需要重新创建（但保持位置）
                                         const currentPoint = this.overlays.locationMarker.getPosition() || point;
                                         this.map.removeOverlay(this.overlays.locationMarker);
                                         this.overlays.locationMarker = new BMapGL.Marker(currentPoint, { icon });
                                         this.map.addOverlay(this.overlays.locationMarker);
                                     }
                                 }
-                            }).catch((error) => {
-                                console.error('更新定位图标失败:', error);
-                                // 恢复旧的方向值
-                                this.lastHeading = oldHeading;
-                            });
+                            }).catch(() => { this.lastHeading = oldHeading; });
                         });
                     }
                 } catch (e) {
-                    // 如果更新失败，重新创建标记
-                    console.warn('更新标记失败，重新创建:', e);
-                    try {
-                        this.map.removeOverlay(this.overlays.locationMarker);
-                    } catch (e2) {
-                        // 忽略移除错误
-                    }
+                    try { this.map.removeOverlay(this.overlays.locationMarker); } catch (e2) {}
                     this.overlays.locationMarker = null;
                     this._createNewMarker(point);
                 }
             } else {
-                // 标记不存在，创建新标记
                 this._createNewMarker(point);
             }
         },
 
-        /**
-         * 创建新的定位标记
-         */
         _createNewMarker(point) {
             this.createRotatedLocationIcon(this.state.currentHeading).then((icon) => {
                 this.overlays.locationMarker = new BMapGL.Marker(point, { icon });
                 this.map.addOverlay(this.overlays.locationMarker);
                 this.lastHeading = this.state.currentHeading;
-            }).catch((error) => {
-                console.error('创建定位图标失败:', error);
             });
         },
 
-        /**
-         * 回到平板当前位置
-         */
         centerToLocation() {
-            if (!this.map || !this.state.mapLoaded) {
-                console.warn('地图未加载完成');
-                return;
-            }
-
-            // 如果有当前位置，直接定位
+            if (!this.map || !this.state.mapLoaded) return;
             if (this.state.currentLocation) {
                 const { lng, lat } = this.state.currentLocation;
                 const point = new BMapGL.Point(lng, lat);
-                this.map.centerAndZoom(point, 18); // 使用较大的缩放级别以便看清当前位置
+                this.map.centerAndZoom(point, 18);
                 return;
             }
-
-            // 如果没有当前位置，提示用户等待定位
-            console.warn('当前位置尚未获取，请等待定位完成');
             alert('正在获取当前位置，请稍候...');
         },
 
-        /**
-         * 创建旋转后的定位图标（使用 real_postion.png）
-         */
         createRotatedLocationIcon(heading) {
-            // 如果图片已缓存，直接使用（返回Promise以保持接口一致性）
             if (this.locationIconCache && this.locationIconCache.img && this.locationIconCache.img.complete) {
                 return Promise.resolve(this.drawRotatedIcon(this.locationIconCache.img, heading));
             }
-
-            // 创建图片对象
             const img = new Image();
             img.crossOrigin = 'anonymous';
-
-            // 使用 Promise 等待图片加载
             return new Promise((resolve) => {
                 img.onload = () => {
-                    // 缓存图片
                     this.locationIconCache = { img: img };
                     const icon = this.drawRotatedIcon(img, heading);
                     resolve(icon);
                 };
-
                 img.onerror = () => {
-                    // 如果图片加载失败，使用默认图标（不旋转）
-                    console.warn('real_postion.png 加载失败，使用默认图标');
                     const iconSize = 30;
                     const defaultIcon = new BMapGL.Icon('./image/real_postion.png', new BMapGL.Size(iconSize, iconSize), {
                         anchor: new BMapGL.Size(iconSize / 2, iconSize / 2)
                     });
                     resolve(defaultIcon);
                 };
-
-                // 加载图片
                 img.src = './image/real_postion.png';
             });
         },
 
-        /**
-         * 在Canvas上绘制旋转后的图标
-         */
         drawRotatedIcon(img, heading) {
-            // 获取图片原始尺寸
             const imgWidth = img.naturalWidth || img.width || 30;
             const imgHeight = img.naturalHeight || img.height || 30;
-
-            // 计算缩放比例，保持宽高比，最大尺寸为30
             const maxSize = 30;
             const scale = Math.min(maxSize / imgWidth, maxSize / imgHeight);
             const displayWidth = imgWidth * scale;
             const displayHeight = imgHeight * scale;
-
-            // Canvas尺寸需要足够大以容纳旋转后的图片（对角线长度）
             const canvasSize = Math.ceil(Math.max(displayWidth, displayHeight) * Math.sqrt(2));
             const canvas = document.createElement('canvas');
             canvas.width = canvasSize;
             canvas.height = canvasSize;
             const ctx = canvas.getContext('2d');
-
-            // 设置高质量渲染
             ctx.imageSmoothingEnabled = true;
             ctx.imageSmoothingQuality = 'high';
-
-            // 保存上下文
             ctx.save();
-
-            // 移动到中心点
             ctx.translate(canvasSize / 2, canvasSize / 2);
-
-            // 旋转画布（heading是相对于正北的角度，需要转换为相对于画布的角度）
-            // 百度地图中，heading是相对于正北的角度（0-360），顺时针为正
-            // 画布坐标系：0度向右，90度向下，180度向左，270度向上
-            // 地图坐标系：0度正北，90度正东，180度正南，270度正西
-            // 转换公式：画布角度 = 90度 - 地图角度（因为画布的0度对应地图的90度）
-
-            // 应用方向偏移量（用于校正方向偏差）
             const adjustedHeading = this.normalizeHeading(heading + (this.headingOffset || 0));
-
-            // 转换为画布旋转角度
-            // 标准转换：画布的0度（向右）对应地图的90度（正东）
-            // 所以：画布角度 = 90度 - 地图角度
             let rotation = (90 - adjustedHeading) * Math.PI / 180;
-
-            // 如果方向仍然不对，可以尝试以下方案（取消注释）：
-            // 方案1：反转180度
-            // rotation = (270 - adjustedHeading) * Math.PI / 180;
-            // 方案2：直接使用heading（如果图标本身已经指向正确方向）
-            // rotation = -adjustedHeading * Math.PI / 180;
-
             ctx.rotate(rotation);
-
-            // 绘制图片（居中，保持原始宽高比）
             ctx.drawImage(img, -displayWidth / 2, -displayHeight / 2, displayWidth, displayHeight);
-
-            // 恢复上下文
             ctx.restore();
-
-            // 转换为图片URL
             const iconUrl = canvas.toDataURL();
             return new BMapGL.Icon(iconUrl, new BMapGL.Size(canvasSize, canvasSize), {
                 anchor: new BMapGL.Size(canvasSize / 2, canvasSize / 2)
             });
         },
 
-        /**
-         * 平滑方向角度（处理0-360度边界问题）
-         */
         normalizeHeading(heading) {
-            // 确保角度在0-360范围内
             while (heading < 0) heading += 360;
             while (heading >= 360) heading -= 360;
             return heading;
         },
 
-        /**
-         * 计算两个角度之间的最短差值（考虑0-360度边界）
-         */
         angleDifference(a, b) {
             let diff = a - b;
             if (diff > 180) diff -= 360;
@@ -1668,121 +1252,55 @@
             return diff;
         },
 
-        /**
-         * 移动平均滤波（减少抖动）
-         * 移动时使用更强的平滑，静止时使用较弱的平滑
-         */
         smoothHeading(rawHeading) {
-            // 初始化历史记录数组和大小（如果不存在）
-            if (!this.headingHistory) {
-                this.headingHistory = [];
-            }
-
-            // 根据移动状态动态调整历史记录大小
-            // 移动时使用更多样本进行更强的平滑，静止时使用中等平滑保持稳定
+            if (!this.headingHistory) this.headingHistory = [];
             const targetHistorySize = this.isMoving ? 15 : 7;
-            if (!this.headingHistorySize) {
-                this.headingHistorySize = targetHistorySize;
-                    } else {
-                // 动态调整历史记录大小
-                this.headingHistorySize = targetHistorySize;
-            }
-
-            // 添加到历史记录
+            this.headingHistorySize = targetHistorySize;
             this.headingHistory.push(rawHeading);
-            if (this.headingHistory.length > this.headingHistorySize) {
-                this.headingHistory.shift();
-            }
-
-            // 如果历史记录不足，直接返回原始值
-            const minHistorySize = this.isMoving ? 7 : 4; // 移动时需要更多样本，静止时也稍微增加样本数
-            if (this.headingHistory.length < minHistorySize) {
-                return rawHeading;
-            }
-
-            // 处理0-360度边界问题：计算相对于第一个值的差值
+            if (this.headingHistory.length > this.headingHistorySize) this.headingHistory.shift();
+            const minHistorySize = this.isMoving ? 7 : 4;
+            if (this.headingHistory.length < minHistorySize) return rawHeading;
             const baseHeading = this.headingHistory[0];
             const normalizedHistory = this.headingHistory.map(h => {
                 let diff = this.angleDifference(h, baseHeading);
                 return baseHeading + diff;
             });
-
-            // 计算平均值
             const sum = normalizedHistory.reduce((a, b) => a + b, 0);
             const avg = sum / normalizedHistory.length;
-
             return this.normalizeHeading(avg);
         },
 
-        /**
-         * 从四元数计算方向角（heading）- 修正版本
-         */
         quaternionToHeading(qx, qy, qz, qw) {
-            // 四元数到欧拉角转换（提取heading/azimuth）
-            // 使用标准公式计算Z轴旋转角度（heading）
-            // 注意：四元数顺序可能是 [w, x, y, z] 或 [x, y, z, w]，需要根据实际情况调整
-            // 这里假设是 [x, y, z, w] 格式
-
-            // 方法1：使用标准四元数到欧拉角转换公式（ZYX顺序）
-            // 计算heading（azimuth/yaw）- 绕Z轴旋转
             const siny_cosp = 2 * (qw * qz + qx * qy);
             const cosy_cosp = 1 - 2 * (qy * qy + qz * qz);
             let heading = Math.atan2(siny_cosp, cosy_cosp) * 180 / Math.PI;
-
-            // 转换为0-360度范围
             heading = this.normalizeHeading(heading);
-
-            // 如果方向反了，可以添加180度校正
-            // heading = (heading + 180) % 360;
-
             return heading;
         },
 
-        /**
-         * 开始监听设备方向变化（优化：优先使用旋转矢量传感器）
-         */
         startWatchingOrientation() {
-            // 绑定方法，确保在事件监听器中能正确访问 this
             this.handleOrientation = this.handleOrientation.bind(this);
             this.handleMotion = this.handleMotion.bind(this);
             this.updateHeadingIfChanged = this.updateHeadingIfChanged.bind(this);
-
-            // 初始化方向历史记录
             this.headingHistory = [];
             this.lastOrientationUpdateTime = 0;
-
-            console.log('开始监听设备方向（优先使用旋转矢量传感器）...');
-
-            // 1. 优先尝试使用旋转矢量传感器（通过DeviceOrientationEvent的quaternion）
             if (window.DeviceOrientationEvent) {
-                // 检查是否支持quaternion（旋转矢量传感器）
                 const testEvent = new DeviceOrientationEvent('test', {});
                 if (typeof DeviceOrientationEvent !== 'undefined' && typeof DeviceOrientationEvent.requestPermission === 'function') {
-                    // iOS 13+ 需要请求权限
-                    console.log('请求设备方向权限（尝试使用旋转矢量传感器）...');
                     DeviceOrientationEvent.requestPermission()
                         .then(response => {
                             if (response === 'granted') {
-                                console.log('设备方向权限已授予，监听旋转矢量传感器');
                                 window.addEventListener('deviceorientation', this.handleOrientation, { passive: false });
                             } else {
-                                console.warn('设备方向权限被拒绝，尝试传统传感器');
                                 this.fallbackToTraditionalSensor();
                             }
                         })
-                        .catch(error => {
-                            console.error('请求设备方向权限失败:', error);
-                            this.fallbackToTraditionalSensor();
-                        });
+                        .catch(error => { this.fallbackToTraditionalSensor(); });
                 } else {
-                    // 其他设备直接监听
-                    console.log('直接监听设备方向事件（尝试旋转矢量传感器）');
                     window.addEventListener('deviceorientation', this.handleOrientation, { passive: false });
                 }
             } else {
-                // 2. 尝试使用DeviceMotionEvent（可能包含旋转矢量数据）
                 if (window.DeviceMotionEvent) {
-                    console.log('尝试使用DeviceMotionEvent（旋转矢量传感器）');
                     if (typeof DeviceMotionEvent !== 'undefined' && typeof DeviceMotionEvent.requestPermission === 'function') {
                         DeviceMotionEvent.requestPermission()
                             .then(response => {
@@ -1797,29 +1315,18 @@
                         window.addEventListener('devicemotion', this.handleMotion, { passive: false });
                     }
                 } else {
-                    // 3. 降级到传统传感器
-                    console.log('旋转矢量传感器不可用，使用传统传感器');
                     this.fallbackToTraditionalSensor();
                 }
             }
         },
 
-        /**
-         * 处理DeviceMotion事件（可能包含旋转矢量数据）
-         */
         handleMotion(event) {
             const now = Date.now();
-            if (now - this.lastOrientationUpdateTime < 50) {
-                return;
-            }
+            if (now - this.lastOrientationUpdateTime < 50) return;
             this.lastOrientationUpdateTime = now;
-
-            // 检查是否有旋转速率数据（融合传感器）
             if (event.rotationRate) {
-                const { alpha, beta, gamma } = event.rotationRate;
+                const { alpha } = event.rotationRate;
                 if (alpha !== null && alpha !== undefined && !isNaN(alpha)) {
-                    // 使用旋转速率计算方向（需要积分，这里简化处理）
-                    // 实际应用中，旋转矢量传感器通常通过DeviceOrientationEvent的quaternion提供
                     const rawHeading = this.normalizeHeading(alpha);
                     const smoothedHeading = this.smoothHeading(rawHeading);
                     this.updateHeadingIfChanged(smoothedHeading);
@@ -1827,12 +1334,7 @@
             }
         },
 
-        /**
-         * 降级到传统传感器
-         */
         fallbackToTraditionalSensor() {
-            console.log('使用传统方向传感器（DeviceOrientationEvent alpha）');
-            // 使用传统的DeviceOrientationEvent（如果没有quaternion）
             if (window.DeviceOrientationEvent) {
                 if (typeof DeviceOrientationEvent !== 'undefined' && typeof DeviceOrientationEvent.requestPermission === 'function') {
                     DeviceOrientationEvent.requestPermission()
@@ -1852,19 +1354,12 @@
             }
         },
 
-        /**
-         * 更新方向（如果变化足够大）
-         */
         updateHeadingIfChanged(newHeading) {
             const oldHeading = this.state.currentHeading;
             const diff = Math.abs(this.angleDifference(newHeading, oldHeading));
-
-            // 阈值加大：移动时 3°，静止时 1°，进一步抑制小抖动
             const threshold = this.isMoving ? 3 : 1;
-
             if (diff >= threshold || oldHeading === 0) {
                 this.state.currentHeading = newHeading;
-
                 if (this.state.currentLocation) {
                     requestAnimationFrame(() => {
                         this.updateLocationMarker();
@@ -1873,23 +1368,16 @@
             }
         },
 
-        /**
-         * 降级到Compass API（uni-app）
-         */
         fallbackToCompassAPI() {
             if (typeof plus !== 'undefined' && plus.compass) {
                 this.state.watchOrientationId = plus.compass.watchHeading(
                     (heading) => {
                         const rawHeading = heading.magneticHeading;
-                        // 使用平滑滤波处理Compass数据
                         const smoothedHeading = this.smoothHeading(rawHeading);
                         const oldHeading = this.state.currentHeading;
                         const diff = Math.abs(this.angleDifference(smoothedHeading, oldHeading));
-
-                        // 只有当方向变化超过1度时才更新
                         if (diff >= 1 || oldHeading === 0) {
                             this.state.currentHeading = smoothedHeading;
-                            // 只有在有位置信息时才更新标记
                             if (this.state.currentLocation) {
                                 requestAnimationFrame(() => {
                                     this.updateLocationMarker();
@@ -1898,157 +1386,77 @@
                         }
                     },
                     (error) => console.error('获取方向失败:', error),
-                    { frequency: 100 } // 100ms更新一次
+                    { frequency: 100 }
                 );
-            } else {
-                console.warn('设备方向功能完全不可用');
             }
         },
 
-        /**
-         * 处理设备方向变化（优化：优先使用旋转矢量传感器）
-         */
         handleOrientation(event) {
             const now = Date.now();
-            // 节流：限制更新频率到每20ms一次(50Hz)，极高响应速度
-            if (now - this.lastOrientationUpdateTime < 20) {
-                return;
-            }
+            if (now - this.lastOrientationUpdateTime < 20) return;
             this.lastOrientationUpdateTime = now;
-
             let rawHeading = null;
-
-            // 1. 优先使用旋转矢量传感器（四元数数据）- 最稳定
             if (event.quaternion && Array.isArray(event.quaternion) && event.quaternion.length >= 4) {
-                // 旋转矢量传感器提供的四元数数据 [x, y, z, w]
                 const [qx, qy, qz, qw] = event.quaternion;
                 rawHeading = this.quaternionToHeading(qx, qy, qz, qw);
-                console.log('使用旋转矢量传感器（四元数）:', rawHeading.toFixed(1), '度');
             }
-            // 2. 检查是否有quaternion属性（某些浏览器可能以对象形式提供）
             else if (event.quaternion && typeof event.quaternion === 'object') {
                 const q = event.quaternion;
                 if (q.x !== undefined && q.y !== undefined && q.z !== undefined && q.w !== undefined) {
                     rawHeading = this.quaternionToHeading(q.x, q.y, q.z, q.w);
-                    console.log('使用旋转矢量传感器（四元数对象）:', rawHeading.toFixed(1), '度');
                 }
             }
-            // 3. 降级到传统传感器（alpha）
             else if (event.alpha !== null && event.alpha !== undefined && !isNaN(event.alpha)) {
-                // event.alpha 是绕Z轴旋转的角度（0-360度）
-                // 在某些设备上，alpha是逆时针的，需要转换为顺时针
-                // 根据设备类型调整：Android通常需要反转，iOS可能不需要
-                // 先尝试不反转
                 rawHeading = event.alpha;
-
-                // 如果方向反了，可以尝试反转（取消下面的注释）：
-                // rawHeading = (360 - event.alpha) % 360;
-
-                // 或者使用headingOffset来校正（更灵活）
-                // this.headingOffset = 180; // 在初始化时设置
             }
-            // 4. iOS Safari 使用 webkitCompassHeading
             else if (event.webkitCompassHeading !== null && event.webkitCompassHeading !== undefined) {
                 rawHeading = event.webkitCompassHeading;
             }
-            // 5. 某些平板设备使用 absolute 模式
             else if (event.absolute !== undefined && event.absolute && event.alpha !== null) {
                 rawHeading = (360 - event.alpha) % 360;
             }
-
             if (rawHeading !== null && !isNaN(rawHeading)) {
-                // 使用移动平均滤波平滑方向数据（减少抖动）
                 const smoothedHeading = this.smoothHeading(rawHeading);
-
-                // 更新方向（如果变化足够大）
                 this.updateHeadingIfChanged(smoothedHeading);
             }
         },
 
-        /**
-         * 处理定位错误
-         */
-        handleLocationError(error) {
-            let message = '定位失败: ';
-            switch (error.code) {
-                case error.PERMISSION_DENIED:
-                    message += '用户拒绝了定位请求';
-                    break;
-                case error.POSITION_UNAVAILABLE:
-                    message += '位置信息不可用';
-                    break;
-                case error.TIMEOUT:
-                    message += '定位请求超时';
-                    break;
-                default:
-                    message += '未知错误';
-                    break;
-            }
-            console.warn(message);
-        },
-
-        /**
-         * 停止定位跟踪
-         */
         stopLocationTracking() {
-            // 停止定位定时器（包括uni-app和百度地图）
             if (this.state.watchLocationTimer !== null) {
                 clearInterval(this.state.watchLocationTimer);
                 this.state.watchLocationTimer = null;
             }
-            
-            // 清理网络防抖定时器
             if (this.state.networkDebounceTimer) {
                 clearTimeout(this.state.networkDebounceTimer);
                 this.state.networkDebounceTimer = null;
             }
+            // 清理心跳检测定时器
+            if (this.state.heartbeatTimer) {
+                clearInterval(this.state.heartbeatTimer);
+                this.state.heartbeatTimer = null;
+            }
 
-            // 清理更新标记的定时器
             if (this.updateMarkerTimer !== null) {
                 cancelAnimationFrame(this.updateMarkerTimer);
                 this.updateMarkerTimer = null;
             }
-
-            // 清理百度地图定位实例
-            if (this.baiduGeolocation) {
-                this.baiduGeolocation = null;
-            }
-
-            // 停止位置监听
+            if (this.baiduGeolocation) this.baiduGeolocation = null;
             if (this.state.watchPositionId !== null) {
-                if (navigator.geolocation) {
-                    navigator.geolocation.clearWatch(this.state.watchPositionId);
-                } else if (typeof plus !== 'undefined' && plus.geolocation) {
-                    plus.geolocation.clearWatch(this.state.watchPositionId);
-                }
+                if (navigator.geolocation) navigator.geolocation.clearWatch(this.state.watchPositionId);
+                else if (typeof plus !== 'undefined' && plus.geolocation) plus.geolocation.clearWatch(this.state.watchPositionId);
                 this.state.watchPositionId = null;
             }
-
-            // 停止方向监听
             if (typeof plus !== 'undefined' && plus.compass && this.state.watchOrientationId !== null) {
                 plus.compass.clearWatch(this.state.watchOrientationId);
                 this.state.watchOrientationId = null;
             }
-
-            // 移除方向事件监听（包括旋转矢量传感器和传统传感器）
-            if (this.handleOrientation) {
-                window.removeEventListener('deviceorientation', this.handleOrientation);
-            }
-            if (this.handleMotion) {
-                window.removeEventListener('devicemotion', this.handleMotion);
-            }
-
-            // 清理方向历史记录
-            if (this.headingHistory) {
-                this.headingHistory = [];
-            }
-            // 重置移动状态相关变量
+            if (this.handleOrientation) window.removeEventListener('deviceorientation', this.handleOrientation);
+            if (this.handleMotion) window.removeEventListener('devicemotion', this.handleMotion);
+            this.headingHistory = [];
             this.isMoving = false;
             this.lastLocationTime = 0;
             this.lastLocationPoint = null;
             this.lastOrientationUpdateTime = 0;
-
-            // 移除定位标记
             if (this.overlays.locationMarker && this.map) {
                 this.map.removeOverlay(this.overlays.locationMarker);
                 this.overlays.locationMarker = null;
@@ -2057,11 +1465,9 @@
 
         addProjectMarker(info) {
             if (!info.lng || !info.lat) return;
-
             const pt = new BMapGL.Point(info.lng, info.lat);
             const icon = new BMapGL.Icon('./image/location.png', new BMapGL.Size(36, 36), { anchor: new BMapGL.Size(12, 24) });
             const marker = new BMapGL.Marker(pt, { icon });
-
             const label = new BMapGL.Label(`${info.proName} (${info.declination})`, { position: pt, offset: new BMapGL.Size(0, 0) });
             label.setStyle({
                 color: '#002db6',
@@ -2075,11 +1481,9 @@
                 transform: 'translateX(-45%)',
                 display: 'block'
             });
-
             this.map.addOverlay(marker);
             this.map.addOverlay(label);
             this.overlays.markers.push({ marker, label });
-
             marker.addEventListener('click', () => {
                 this.state.currentClickedProject = info;
                 this.openActionMenu(pt, info);
@@ -2088,65 +1492,43 @@
 
         renderProjectList() {
             if (!this.elements.projectListContainer) return;
-
             const projectInfo = this.state.projectInfo || [];
             if (projectInfo.length === 0) {
                 this.elements.projectListContainer.innerHTML = '<div style="color:#aaa;text-align:center;padding:20px;">暂无工程数据</div>';
                 return;
             }
-            
             const fragment = document.createDocumentFragment();
             projectInfo.forEach((project, index) => {
                 const projectId = project.id || `project-${index}`;
                 const itemDiv = document.createElement('div');
                 itemDiv.className = 'project-list-item';
                 itemDiv.dataset.projectId = projectId;
-
-                // 单选框
                 const radio = document.createElement('input');
                 radio.type = 'radio';
                 radio.name = 'project-radio';
                 radio.className = 'project-list-radio';
                 radio.checked = this.state.selectedProjectId === projectId;
-
-                // 工程名称标签
                 const label = document.createElement('span');
                 label.className = 'project-list-label';
                 label.textContent = `${project.proName || '未命名工程'} (${project.declination || ''})`;
-
-                // 进入按钮
                 const enterBtn = document.createElement('button');
                 enterBtn.className = 'project-list-enter-btn';
                 enterBtn.textContent = '预览';
-                // 只有选中时才显示进入按钮
                 enterBtn.style.display = radio.checked ? 'block' : 'none';
-
                 itemDiv.appendChild(radio);
                 itemDiv.appendChild(label);
                 itemDiv.appendChild(enterBtn);
-
-                // 点击工程项：选中单选框并定位
                 itemDiv.addEventListener('click', (e) => {
-                    // 如果点击的是按钮，不触发定位
                     if (e.target === enterBtn) return;
-
-                    // 选中单选框
-                    const projectId = project.id || `project-${index}`;
                     radio.checked = true;
                     this.state.selectedProjectId = projectId;
-
-                    // 更新所有单选框状态和进入按钮显示状态
                     this.updateProjectRadioStates();
                     this.updateEnterButtonsVisibility();
-
-                    // 定位到该工程坐标
                     if (project.lng && project.lat) {
                         const point = new BMapGL.Point(project.lng, project.lat);
                         this.map.centerAndZoom(point, 15);
                     }
                 });
-
-                // 单选框变化事件
                 radio.addEventListener('change', () => {
                     if (radio.checked) {
                         this.state.selectedProjectId = projectId;
@@ -2154,19 +1536,13 @@
                         this.updateEnterButtonsVisibility();
                     }
                 });
-
-                // 点击跳转按钮 - 直接进入模型预览
                 enterBtn.addEventListener('click', (e) => {
                     e.stopPropagation();
-                    // 设置当前点击的工程
                     this.state.currentClickedProject = project;
-                    // 直接触发模型预览
                     this.triggerPreview(project);
                 });
-
                 fragment.appendChild(itemDiv);
             });
-
             this.elements.projectListContainer.innerHTML = '';
             this.elements.projectListContainer.appendChild(fragment);
         },
@@ -2197,33 +1573,22 @@
                     <div class="action-menu-item" data-action="preview"><span>🗺️</span>模型预览</div>
                     <div class="action-menu-item" data-action="survey"><span>📋</span>勘察</div>
                 </div>`;
-
             const infoWindow = new BMapGL.InfoWindow(content, {
                 width: 140, height: 100, title: '', enableMessage: false, offset: new BMapGL.Size(0, -20), enableAutoPan: true
             });
             this.map.openInfoWindow(infoWindow, point);
-
-            // 绑定菜单事件 (延迟绑定确保 DOM 存在)
             setTimeout(() => {
                 const menu = document.querySelector('.action-menu');
                 if (!menu) return;
-
                 const handleAction = (e) => {
                     const item = e.target.closest('.action-menu-item');
                     if (!item) return;
                     e.stopPropagation();
-
                     const action = item.dataset.action;
                     this.map.closeInfoWindow();
-
-                    if (action === 'survey') {
-                        Bridge.sendMessage('navigateToProject', { projectInfo: info });
-                    } else if (action === 'preview') {
-                        this.triggerPreview(info);
-                    }
+                    if (action === 'survey') Bridge.sendMessage('navigateToProject', { projectInfo: info });
+                    else if (action === 'preview') this.triggerPreview(info);
                 };
-
-                // 处理触摸/点击冲突
                 let lastTouchTime = 0;
                 menu.addEventListener('touchend', (e) => {
                     lastTouchTime = Date.now();
@@ -2237,9 +1602,7 @@
 
         handleUrlActions(params) {
             const { action, modelList, modelData, clickedProject } = params;
-
             if (action === 'modelPreview' && clickedProject) {
-                // 等待 Bridge Ready
                 setTimeout(() => Bridge.sendMessage('modelPreview', { projectInfo: Utils.safeParseJSON(clickedProject) }), 500);
             }
             else if (action === 'showPreview' && modelList) {
@@ -2252,9 +1615,8 @@
 
         triggerPreview(info) {
             if (!Bridge.sendMessage('modelPreview', { projectInfo: info })) {
-                // 如果消息发送失败，使用 URL 刷新降级方案
                 Bridge.triggerPageReload({
-                    projectInfo: Utils.getUrlParams().projectInfo || '', // 保持原有项目列表
+                    projectInfo: Utils.getUrlParams().projectInfo || '',
                     clickedProject: JSON.stringify(info),
                     action: 'modelPreview',
                     apiBaseUrl: Network.baseUrl,
@@ -2263,22 +1625,14 @@
             }
         },
 
-        /**
-         * 预览模块
-         */
         showModelPreview(models, clickedProject) {
             if (clickedProject) this.state.currentClickedProject = clickedProject;
             if (!this.map) return setTimeout(() => this.showModelPreview(models, clickedProject), 200);
-
             this.state.modelList = models || [];
             this.state.checkedNodeIds = [];
-            this.clearMap(true); // 清除标记和模型
-            this.clearModels();  // 清除模型缓存
-
-            // 构建树数据
+            this.clearMap(true);
+            this.clearModels();
             const treeData = this.buildTreeData(this.state.modelList);
-
-            // 渲染树
             this.elements.tree.innerHTML = '';
             if (treeData.length === 0) {
                 this.elements.tree.innerHTML = '<div style="color:#aaa;text-align:center;padding:20px;">暂无数据</div>';
@@ -2286,36 +1640,25 @@
                 const fragment = document.createDocumentFragment();
                 treeData.forEach(node => this.renderTreeNode(node, fragment, 0));
                 this.elements.tree.appendChild(fragment);
-
-                // 默认全选
                 this.selectAllNodes();
             }
-
             this.elements.panel.style.display = 'flex';
         },
 
         navigateToAR() {
-            // 跳转到勘察逻辑
             const projectInfo = this.state.currentClickedProject;
-            if (projectInfo) {
-                Bridge.sendMessage('navigateToProject', { projectInfo: projectInfo });
-            } else {
-                console.warn('没有选中的工程信息，无法跳转到勘察页面');
-            }
+            if (projectInfo) Bridge.sendMessage('navigateToProject', { projectInfo: projectInfo });
+            else console.warn('没有选中的工程信息');
         },
 
         closePreview() {
             this.elements.panel.style.display = 'none';
             this.clearModels();
             this.state.checkedNodeIds = [];
-
-            // 恢复 Marker
             this.overlays.markers.forEach(o => {
                 this.map.addOverlay(o.marker);
                 this.map.addOverlay(o.label);
             });
-
-            // 回到视角
             if (this.state.currentClickedProject) {
                 const p = this.state.currentClickedProject;
                 this.map.centerAndZoom(new BMapGL.Point(p.lng, p.lat), 12);
@@ -2337,18 +1680,11 @@
             this.overlays.models = [];
         },
 
-        /**
-         * 树形结构处理
-         */
         buildTreeData(list) {
-            // 检查是否已是树形
             const isTree = list.some(i => i.children?.length > 0);
             if (isTree) return this.processNodes(list);
-
-            // 构建树
             const idMap = new Set(list.map(i => i.id));
             const roots = list.filter(i => i.nodelevel == '2' && !idMap.has(i.parentId));
-
             const findChildren = (parent) => {
                 const children = list.filter(i => i.parentId == parent.id);
                 return children.map(child => ({
@@ -2358,7 +1694,6 @@
                     children: findChildren(child)
                 }));
             };
-
             return roots.map(root => ({
                 ...root,
                 expanded: true,
@@ -2377,75 +1712,62 @@
         },
 
         renderTreeNode(node, container, level) {
-                    const nodeDiv = document.createElement('div');
-                    nodeDiv.className = 'tree-node';
+            const nodeDiv = document.createElement('div');
+            nodeDiv.className = 'tree-node';
             nodeDiv.style.paddingLeft = (level * 20) + 'px';
-                    
-                    const itemDiv = document.createElement('div');
-                    itemDiv.className = 'tree-node-item';
-                    
-            const hasChildren = node.children && node.children.length > 0;
-
-            // 展开图标
-            if (hasChildren) {
+            const itemDiv = document.createElement('div');
+            itemDiv.className = 'tree-node-item';
+            if (node.children && node.children.length > 0) {
                 const icon = document.createElement('span');
                 icon.className = 'tree-expand-icon';
                 icon.textContent = node.expanded ? '▼' : '▶';
                 itemDiv.appendChild(icon);
-
-                icon.addEventListener('click', (e) => {
+                icon.onclick = (e) => {
                     e.stopPropagation();
                     node.expanded = !node.expanded;
                     icon.textContent = node.expanded ? '▼' : '▶';
-                    const childContainer = nodeDiv.querySelector('.tree-children');
-                    if (childContainer) {
-                        childContainer.classList.toggle('expanded', node.expanded);
-                    }
-                });
+                    nodeDiv.querySelector('.tree-children').style.display = node.expanded ? 'block' : 'none';
+                };
             } else {
-                // 占位
-                const spacer = document.createElement('span');
-                spacer.style.width = '24px';
-                itemDiv.appendChild(spacer);
+                const sp = document.createElement('span');
+                sp.style.width = '24px';
+                itemDiv.appendChild(sp);
             }
-
-            // 复选框
-                    const checkbox = document.createElement('input');
-                    checkbox.type = 'checkbox';
-                    checkbox.className = 'tree-node-checkbox';
-            checkbox.dataset.id = node.id; // 添加data-id用于全选/全不选时更新UI
+            const checkbox = document.createElement('input');
+            checkbox.type = 'checkbox';
+            checkbox.className = 'tree-node-checkbox';
+            checkbox.dataset.id = node.id;
             checkbox.checked = this.state.checkedNodeIds.includes(node.id);
-            checkbox.addEventListener('change', (e) => this.handleCheck(node, e.target.checked));
+            checkbox.addEventListener('change', (e) => {
+                this.handleCheck(node, e.target.checked);
+                const allBoxes = this.elements.tree.querySelectorAll('.tree-node-checkbox');
+                allBoxes.forEach(box => {
+                    box.checked = this.state.checkedNodeIds.includes(box.dataset.id);
+                });
+            });
             itemDiv.appendChild(checkbox);
-                    
-            // 文本
-                    const label = document.createElement('span');
-                    label.className = 'tree-node-label';
-            label.textContent = node.nodeName || node.name || `Node ${node.id}`;
-                    itemDiv.appendChild(label);
-
-                    nodeDiv.appendChild(itemDiv);
-
-            // 子容器
-            if (hasChildren) {
-                const childrenDiv = document.createElement('div');
-                childrenDiv.className = `tree-children ${node.expanded ? 'expanded' : ''}`;
-                node.children.forEach(child => this.renderTreeNode(child, childrenDiv, level + 1));
-                nodeDiv.appendChild(childrenDiv);
+            const label = document.createElement('span');
+            label.className = 'tree-node-label';
+            label.innerText = node.nodeName || node.name || node.id;
+            itemDiv.appendChild(label);
+            nodeDiv.appendChild(itemDiv);
+            if (node.children && node.children.length > 0) {
+                const childContainer = document.createElement('div');
+                childContainer.className = 'tree-children';
+                childContainer.style.display = node.expanded ? 'block' : 'none';
+                node.children.forEach(c => this.renderTreeNode(c, childContainer, level + 1));
+                nodeDiv.appendChild(childContainer);
             }
-
             container.appendChild(nodeDiv);
         },
 
         handleCheck(node, isChecked) {
-            // 获取所有子ID
             const getAllIds = (n) => {
                 let ids = [n.id];
                 if (n.children) n.children.forEach(c => ids = ids.concat(getAllIds(c)));
                 return ids;
             };
             const targetIds = getAllIds(node);
-
             if (isChecked) {
                 targetIds.forEach(id => {
                     if (!this.state.checkedNodeIds.includes(id)) this.state.checkedNodeIds.push(id);
@@ -2453,63 +1775,38 @@
             } else {
                 this.state.checkedNodeIds = this.state.checkedNodeIds.filter(id => !targetIds.includes(id));
             }
-
-            // 更新 UI 状态
-            const allCheckboxes = this.elements.tree.querySelectorAll('input[type="checkbox"]');
-            // 这里为了简化，重新渲染或者手动查找 DOM 比较繁琐，因为没有 React/Vue 绑定。
-            // 简单遍历更新 DOM 是最高效的。
-            // 但因为 renderTreeNode 没有把 id 绑在 DOM 上，我们需要一种机制。
-            // 重新调用 updateCheckboxes
             this.syncCheckboxUI(node, isChecked);
-
-            // 触发数据加载 (防抖建议加上，这里直接调用)
             this.loadBatchData();
         },
 
-        // 获取所有节点ID（递归）
         getAllNodeIds(nodes) {
             let ids = [];
             nodes.forEach(node => {
                 ids.push(node.id);
-                if (node.children && node.children.length > 0) {
-                    ids = ids.concat(this.getAllNodeIds(node.children));
-                }
+                if (node.children && node.children.length > 0) ids = ids.concat(this.getAllNodeIds(node.children));
             });
             return ids;
         },
 
-        // 全选
         selectAllNodes() {
             const treeData = this.buildTreeData(this.state.modelList);
             const allIds = this.getAllNodeIds(treeData);
-            this.state.checkedNodeIds = [...new Set(allIds)]; // 去重
-
-            // 更新所有复选框UI
+            this.state.checkedNodeIds = [...new Set(allIds)];
             this.updateAllCheckboxes();
-
-            // 触发数据加载
             this.loadBatchData();
         },
 
-        // 全不选
         deselectAllNodes() {
             this.state.checkedNodeIds = [];
-
-            // 更新所有复选框UI
             this.updateAllCheckboxes();
-
-            // 清除模型
             this.clearModels();
         },
 
-        // 更新所有复选框状态
         updateAllCheckboxes() {
             const checkboxes = this.elements.tree.querySelectorAll('input[type="checkbox"]');
             checkboxes.forEach(checkbox => {
-                // 从checkbox的data-id获取节点ID
                 const nodeId = checkbox.dataset.id;
                 if (nodeId !== undefined) {
-                    // 确保ID类型一致（都转为字符串或数字进行比较）
                     const idStr = String(nodeId);
                     const checkedIdsStr = this.state.checkedNodeIds.map(id => String(id));
                     checkbox.checked = checkedIdsStr.includes(idStr);
@@ -2518,36 +1815,35 @@
         },
 
         syncCheckboxUI(rootNode, checked) {
-
             const checkboxes = this.elements.tree.querySelectorAll('.tree-node-checkbox');
             checkboxes.forEach(cb => {
+                const nodeId = cb.dataset.id;
+                if (nodeId && this.state.checkedNodeIds.includes(nodeId)) {
+                    cb.checked = true;
+                } else {
+                    cb.checked = false;
+                }
             });
         },
 
         async loadBatchData() {
             this.clearModels();
             if (this.state.checkedNodeIds.length === 0) return;
-
-            // 批量请求
             const promises = this.state.checkedNodeIds.map(id => Network.post('model/openView', { id }));
             const results = await Promise.all(promises);
             const flatData = results.flat();
-
             if (flatData.length > 0) this.drawModel(flatData);
         },
 
         drawModel(dataList) {
             this.clearModels();
             if (!dataList?.length) return;
-
             const newOverlays = [];
             const allPoints = [];
-
             dataList.forEach(item => {
                 try {
                     const geometry = Utils.safeParseJSON(item.geometry);
                     if (!geometry) return;
-
                     switch (item.entityType) {
                         case 'LWPOLYLINE':
                             geometry.segments?.forEach(seg => {
@@ -2555,32 +1851,24 @@
                                     this.createPolyline([seg.start, seg.end], newOverlays, allPoints, 'red');
                                 } else if (seg.type === 'arc') {
                                     if (seg.start_point && seg.end_point && seg.center) {
-                                        this.createPolyline([seg.start_point, seg.end_point], newOverlays, allPoints, 'red'); // 简化圆弧为线
+                                        this.createPolyline([seg.start_point, seg.end_point], newOverlays, allPoints, 'red');
                                     } else if (seg.center && seg.radius) {
                                         this.createCircle(seg.center, seg.radius, newOverlays, allPoints);
                                     }
                                 }
                             });
                             break;
-
                         case 'LINE':
                             this.createPolyline([geometry.start, geometry.end], newOverlays, allPoints, 'red');
                             break;
-
                         case 'CIRCLE':
-                            if (geometry.center) {
-                                this.createCircle(geometry.center, geometry.radius, newOverlays, allPoints, 'blue');
-                            }
+                            if (geometry.center) this.createCircle(geometry.center, geometry.radius, newOverlays, allPoints, 'blue');
                             break;
-
                         default:
-                            // 处理 Polygon 或其他点集
                             if (geometry.points?.length > 0) {
                                 const pts = geometry.points.map(p => new BMapGL.Point(p[0], p[1]));
                                 pts.forEach(p => allPoints.push(p));
-
                                 if (pts.length === 2) {
-                                    // 箭头或线
                                     const line = new BMapGL.Polyline(pts, { strokeColor: 'green', strokeWeight: 2 });
                                     this.map.addOverlay(line);
                                     newOverlays.push(line);
@@ -2591,14 +1879,9 @@
                                 }
                             }
                     }
-                } catch (e) {
-                    console.warn('Draw Entity Error', item, e);
-                }
+                } catch (e) { console.warn('Draw Entity Error', item, e); }
             });
-
             this.overlays.models = newOverlays;
-
-            // 自动缩放
             if (allPoints.length > 0) {
                 this.map.setViewport(allPoints, { margins: [50, 50, 50, 50] });
             }
@@ -2621,18 +1904,13 @@
         }
     };
 
-    // 补丁：重写 renderTreeNode 以支持 UI 联动
     const _originalRender = App.renderTreeNode;
     App.renderTreeNode = function (node, container, level) {
-
         const nodeDiv = document.createElement('div');
         nodeDiv.className = 'tree-node';
         nodeDiv.style.paddingLeft = (level * 20) + 'px';
-
         const itemDiv = document.createElement('div');
         itemDiv.className = 'tree-node-item';
-
-        // ... (Expand Icon Logic same as above) ...
         if (node.children && node.children.length > 0) {
             const icon = document.createElement('span');
             icon.className = 'tree-expand-icon';
@@ -2649,31 +1927,24 @@
             sp.style.width = '24px';
             itemDiv.appendChild(sp);
         }
-
         const checkbox = document.createElement('input');
         checkbox.type = 'checkbox';
         checkbox.className = 'tree-node-checkbox';
-        checkbox.dataset.id = node.id; // 关键：添加 ID 用于反查
+        checkbox.dataset.id = node.id;
         checkbox.checked = this.state.checkedNodeIds.includes(node.id);
-
         checkbox.addEventListener('change', (e) => {
             this.handleCheck(node, e.target.checked);
-            // 更新所有 DOM 状态
             const allBoxes = this.elements.tree.querySelectorAll('.tree-node-checkbox');
             allBoxes.forEach(box => {
                 box.checked = this.state.checkedNodeIds.includes(box.dataset.id);
             });
         });
-
         itemDiv.appendChild(checkbox);
-
         const label = document.createElement('span');
         label.className = 'tree-node-label';
         label.innerText = node.nodeName || node.name || node.id;
         itemDiv.appendChild(label);
-
         nodeDiv.appendChild(itemDiv);
-
         if (node.children && node.children.length > 0) {
             const childContainer = document.createElement('div');
             childContainer.className = 'tree-children';
@@ -2684,11 +1955,9 @@
         container.appendChild(nodeDiv);
     };
 
-    // 启动应用
     document.addEventListener('UniAppJSBridgeReady', function () {
         App.init();
     });
-    // 兼容普通浏览器测试
     if (!window.UniAppJSBridgeReady && !navigator.userAgent.includes('uni-app')) {
         window.onload = () => App.init();
     }