From 5f0f22e62a6c19de0c9156b7fcda2590a32d40e0 Mon Sep 17 00:00:00 2001
From: BAKEYi <16298417+bakeyi@user.noreply.gitee.com>
Date: Wed, 1 Apr 2026 14:43:14 +0800
Subject: [PATCH] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E6=90=9C=E7=B4=A2=E5=9C=B0?=
 =?UTF-8?q?=E5=9D=80=E9=A1=B5=E9=9D=A2=EF=BC=88=E6=89=8B=E8=89=BA=E4=BA=BA?=
 =?UTF-8?q?=E6=90=AC=E5=95=86=E5=AE=B6=EF=BC=89?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 pages/address/search.vue | 2291 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 2291 insertions(+)
 create mode 100644 pages/address/search.vue

diff --git a/pages/address/search.vue b/pages/address/search.vue
new file mode 100644
index 0000000..e598e88
--- /dev/null
+++ b/pages/address/search.vue
@@ -0,0 +1,2291 @@
+<template>
+    <view class="search-address-page">
+        <!-- 自定义导航栏 -->
+        <custom-navbar title="搜索地址" :showBack="true" backgroundColor="#FFFFFF"></custom-navbar>
+
+        <!-- 城市选择-->
+        <view class="search-container" v-if="isSelectCity">
+            <text class="search-container-text" @click="goSelectCity">{{ city.name }}</text>
+            <image src="https://mrrplus.oss-cn-beijing.aliyuncs.com/wxstaic/images/Fill.jpg" mode="aspectFit" class="text-img"></image>
+        </view>
+
+        <!-- 地图容器 -->
+        <view class="map-container" :style="{ height: mapHeight + 'rpx' }">
+            <map
+                v-if="mapVisible"
+                :key="mapRenderKey"
+                id="map"
+                class="map"
+                :latitude="latitude"
+                :longitude="longitude"
+                scale="19"
+                @tap="onMapTap"
+                @regionchange="changeMap"
+            ></map>
+
+            <image
+                v-if="showMapSnapshot"
+                class="map-snapshot"
+                :src="mapSnapshotUrl"
+                mode="aspectFill"
+                @load="onSnapshotLoad"
+                @error="onSnapshotError"
+            ></image>
+
+            <cover-view v-if="mapVisible" class="center-marker">
+                <cover-image
+                    src="https://mrrplus.oss-cn-beijing.aliyuncs.com/photo/system/04007cab-3047-42b0-baab-44df344a92d2"
+                    class="center-marker-img"
+                ></cover-image>
+            </cover-view>
+        </view>
+
+        <!-- 底部编辑区域 -->
+        <view class="bottom-edit-section">
+            <!-- 地址识别输入行 -->
+            <view class="address-input-row">
+                <textarea class="raw-address-input" v-model="rawAddress" placeholder="粘贴文本到此处，将自动识别地址信息。" placeholder-style="color: #C6C9CC; font-size: 14px;" :maxlength="200" :adjust-position="true" />
+                <view class="action-buttons">
+                    <view class="action-btn paste-btn" @click="hasRawContent ? clearRawAddress() : onPaste()">
+                        <text class="btn-text" :style="{ color: '#333333' }">{{ hasRawContent ? '一键清空' : '粘贴' }}</text>
+                    </view>
+                    <view class="action-btn smart-btn" :class="{ 'smart-btn-active': hasRawContent }" @click="onSmartRecognize">
+                        <text class="btn-text" :style="{ color: hasRawContent ? '#E8101E' : '#999999' }">{{ smartBtnText }}</text>
+                    </view>
+                </view>
+            </view>
+
+            <!-- 地址信息栏 -->
+            <view class="address-info-panel">
+                <view class="info-row" @click="selectRegion">
+                    <text class="row-label">所在地区</text>
+                    <view class="row-content">
+                        <text :class="currentRegion ? 'content-text' : 'placeholder'">{{ currentRegion || "请选择"}}</text>
+                        <image src="https://mrrplus.oss-cn-beijing.aliyuncs.com/photo/system/71c63001-a104-49ad-a90d-30d2ade73f4d.png" mode="aspectFit" class="arrow-icon"></image>
+                    </view>
+                </view>
+                <view class="line"></view>
+                <view class="info-row">
+                    <text class="row-label">详细地址</text>
+                    <input type="text" class="detail-input" v-model="detailAddress" @input="onDetailInput" placeholder="请填写详细地址" placeholder-style="color: #999999; font-size: 14px;" :adjust-position="true" />
+                </view>
+                <view class="line"></view>
+            </view>
+
+            <!-- 确认按钮 -->
+            <view class="confirm-btn" @click="onConfirm"><text class="con-btn-text">确认</text></view>
+        </view>
+
+        <!-- 地区选择弹窗（用户端） -->
+		<view class="popup" :class="{ show: showRegionPicker }">
+			<view class="popup-mask" @click="closeRegionPicker"></view>
+			<view class="popup-content">
+				<view class="popup-header">
+					<text class="popup-title">选择所在地区</text>
+					<text class="popup-close" @click="closeRegionPicker">×</text>
+				</view>
+				<view class="region-body">
+					<picker-view
+						@change="onRegionChange"
+						class="picker-scroll"
+						:indicator-style="indicatorStyle"
+						:value="regionPickerValue"
+					>
+						<picker-view-column>
+							<view
+								class="picker-item"
+								v-for="(item, index) in regionProvinceList"
+								:key="index"
+							>{{ item.province }}</view>
+						</picker-view-column>
+						<picker-view-column>
+							<view
+								class="picker-item"
+								v-for="(item, index) in regionCityList"
+								:key="index"
+							>{{ item.city }}</view>
+						</picker-view-column>
+						<picker-view-column>
+							<view
+								class="picker-item"
+								v-for="(item, index) in regionDistrictList"
+								:key="index"
+							>{{ item.area }}</view>
+						</picker-view-column>
+					</picker-view>
+				</view>
+				<view class="popup-footer">
+					<view class="popup-btn cancel" @click="closeRegionPicker">
+						<text class="btn-text">取消</text>
+					</view>
+					<view class="popup-btn confirm" @click="confirmRegion">
+						<text class="btn-text">确定</text>
+					</view>
+				</view>
+			</view>
+		</view>
+    </view>
+</template>
+
+<script>
+    import request from '@/utils/request'
+    import ChinaCitys from './data/ChinaCitys.json'
+    import store from '@/store'
+    import { setVersion } from '@/utils/version.js'
+
+    export default {
+        data() {
+            return {
+                mapVisible: true,
+                showMapSnapshot: false,
+                mapSnapshotUrl: '',
+                mapRenderKey: 0,
+                mapMoveTimer: null,
+                mapProgrammaticUntil: 0,
+                mapGuardTimer: null,
+                mapReverseTimer: null,
+                popupRestoreTimer: null,
+                reverseGeocodeRequestId: 0,
+                dependencyInitLock: false,
+                dependencyInitTimer: null,
+                blankPageInitLock: false,
+
+                // 地图与定位相关
+                systemInfo: {},
+                latitude: 0,
+                longitude: 0,
+                newLatitude: 0,
+                newLongitude: 0,
+                mapHeight: 670,
+                city: {
+                    center: '',
+                    name: ''
+                },
+                isSelectCity: false,
+                searchCity: uni.getStorageSync('searchCity'),
+                source: '',
+                recognizeMapMoving: false,
+                recognizeMapMoveTimer: null,
+
+                // 编辑区数据
+                manualDetail: '',
+                isManualDetail: false,
+                currentProvince: '',
+                currentCity: '',
+                currentDistrict: '',
+                currentDetail: '',
+                selectedProvinceCode: '',
+                selectedCityCode: '',
+                selectedDistrictCode: '',
+                rawAddress: '',
+                hasRawContent: false,
+                smartBtnText: '智能识别',
+                hasDetailContent: false,
+                currentRegion: '',
+                detailAddress: '',
+
+                // 首次进入且上页没有详细地址时，禁止自动回填详细地址
+                suppressInitDetailFill: false,
+                ignoreRegionChangeOnce: false, // 忽略一次程序触发的地图变化
+
+                // 地区选择弹窗数据
+                showRegionPicker: false,
+                regionProvinceList: [],
+                regionCityList: [],
+                regionDistrictList: [],
+                regionPickerValue: [0, 0, 0],
+
+                indicatorStyle: 'height: 68rpx;',
+                userSelectedRegion: false,
+
+                // 高德地图 key
+                amapKey: '30b7eb1a1b2f88edc085b9b3ee9a2188'
+            }
+        },
+
+        watch: {
+            rawAddress(newVal) {
+                this.hasRawContent = (newVal || '').trim().length > 0
+                this.smartBtnText = '智能识别'
+            },
+            detailAddress(newVal) {
+                this.hasDetailContent = (newVal || '').trim().length > 0
+            }
+        },
+
+        onLoad(options) {
+    console.log('ChinaCitys 数据:', ChinaCitys)
+    console.log('ChinaCitys 长度:', ChinaCitys?.length)
+
+    this.systemInfo = uni.getSystemInfoSync()
+    this.source = options.source || ''
+    this.mapHeight = 670
+
+    const incomingAddress = options.address ? decodeURIComponent(options.address) : ''
+    const hasDependency = !!options.dependency
+    const hasLocation = !!(options.longitude && options.latitude)
+    const skipAutoLocate = String(options.skip_auto_locate || '') === '1'
+    const initCurrentLocation = String(options.init_current_location || '') === '1'
+    const silentLocate = String(options.silent_locate || '') === '1'
+
+    // 1. 有传入地区：优先按传入地区初始化，禁止首屏地图自动反写
+    if (hasDependency) {
+        const regions = decodeURIComponent(options.dependency).split('-')
+        console.log('传入地区信息:', regions)
+
+        this.currentProvince = regions[0] || ''
+        this.currentCity = regions[1] || ''
+        this.currentDistrict = regions[2] || ''
+
+        let regionText = ''
+        if (this.currentProvince) regionText += this.currentProvince
+        if (this.currentCity && this.currentCity !== this.currentProvince) regionText += this.currentCity
+        if (this.currentDistrict) regionText += this.currentDistrict
+        this.currentRegion = regionText
+
+        if (incomingAddress) {
+            this.detailAddress = incomingAddress
+            this.manualDetail = incomingAddress
+            this.currentDetail = incomingAddress
+            this.isManualDetail = true
+            this.suppressInitDetailFill = false
+        } else {
+            this.detailAddress = ''
+            this.manualDetail = ''
+            this.currentDetail = ''
+            this.isManualDetail = false
+            this.suppressInitDetailFill = true
+        }
+
+        // 关键：锁住首次地图初始化阶段，避免首屏被旧地图中心点反写
+        this.startDependencyInitLock()
+
+        // 有经纬度：只用于地图定位，不再 reverseGeocode 覆盖所在地区
+        if (hasLocation) {
+            this.applyMapLocation(options.longitude, options.latitude, true)
+            return
+        }
+
+        // 没经纬度：用地区中心定位地图
+        const dependencyCode = options.dependency_code
+
+        ;(async () => {
+            let center = null
+
+            if (dependencyCode && regions[2]) {
+                center = await this.getDistrictCenter(regions[2], dependencyCode)
+            }
+
+            if (!center && regions[2]) {
+                center = await this.getDistrictCenter(regions[2])
+            }
+            if (!center && regions[1] && regions[1] !== regions[0]) {
+                center = await this.getDistrictCenter(regions[1])
+            }
+            if (!center && regions[0]) {
+                center = await this.getDistrictCenter(regions[0])
+            }
+
+            if (center) {
+                const locationRes = center.split(',')
+                if (locationRes.length >= 2) {
+                    this.updateMapCenter(
+                        parseFloat(locationRes[0]),
+                        parseFloat(locationRes[1]),
+                        true
+                    )
+                }
+            } else if (!skipAutoLocate) {
+                // 走当前位置时，不再锁
+                this.clearDependencyInitLock()
+                this.getCurrentLocation()
+            } else {
+                this.clearDependencyInitLock()
+            }
+        })()
+
+        return
+    }
+
+    // 2. 只有经纬度，没有地区
+    if (hasLocation) {
+        this.applyMapLocation(options.longitude, options.latitude, true)
+
+        if (incomingAddress) {
+            this.detailAddress = incomingAddress
+            this.manualDetail = incomingAddress
+            this.currentDetail = incomingAddress
+            this.isManualDetail = true
+            this.suppressInitDetailFill = false
+        } else {
+            this.detailAddress = ''
+            this.manualDetail = ''
+            this.currentDetail = ''
+            this.isManualDetail = false
+            this.suppressInitDetailFill = true
+        }
+
+        this.reverseGeocode(parseFloat(options.longitude), parseFloat(options.latitude))
+        return
+    }
+
+    // 3. 从城市选择页进入
+    if (options.city) {
+        const city = JSON.parse(decodeURIComponent(options.city))
+        this.city = city
+        this.ignoreRegionChangeOnce = true
+        this.getNowLocation(city.center)
+        this.isSelectCity = true
+        return
+    }
+
+    // 4. 仅标记城市选择模式
+    if (options.isSelectCity) {
+        this.isSelectCity = true
+        this.getCurrentLocation()
+        return
+    }
+
+    // 5. 手艺人信息页首次进入且详细地址为空：按当前定位初始化
+    if (initCurrentLocation) {
+        this.blankPageInitLock = false
+        this.getCurrentLocation(silentLocate, true)
+        return
+    }
+
+    // 6. 空白进入且明确要求不自动定位：
+    // 不仅不调用当前位置，还要锁住首屏地图默认中心点触发的regionchange反写
+    if (skipAutoLocate && !hasDependency && !hasLocation) {
+        this.blankPageInitLock = true
+        this.currentProvince = ''
+        this.currentCity = ''
+        this.currentDistrict = ''
+        this.currentRegion = ''
+        this.detailAddress = ''
+        this.manualDetail = ''
+        this.currentDetail = ''
+        this.isManualDetail = false
+        this.suppressInitDetailFill = true
+        return
+    }
+
+    // 7. 默认当前位置
+    if (!skipAutoLocate) {
+        this.blankPageInitLock = false
+        this.getCurrentLocation(silentLocate, false)
+    }
+},
+
+        onShow() {
+            // 只有城市选择模式下，才允许 searchCity 缓存更新地图
+            if (!this.isSelectCity) return
+
+            const searchCity = uni.getStorageSync('searchCity')
+            if (searchCity && this.city.name !== searchCity.name) {
+                this.city = searchCity
+                this.searchCity = searchCity
+                this.ignoreRegionChangeOnce = true
+                this.getNowLocation(searchCity.center)
+            }
+        },
+
+        methods: {
+
+            startDependencyInitLock(duration = 800) {
+                this.dependencyInitLock = true
+
+                if (this.dependencyInitTimer) {
+                    clearTimeout(this.dependencyInitTimer)
+                }
+
+                this.dependencyInitTimer = setTimeout(() => {
+                    this.dependencyInitLock = false
+                    this.dependencyInitTimer = null
+                }, duration)
+            },
+
+            clearDependencyInitLock() {
+                this.dependencyInitLock = false
+
+                if (this.dependencyInitTimer) {
+                    clearTimeout(this.dependencyInitTimer)
+                    this.dependencyInitTimer = null
+                }
+            },
+
+            clearBlankPageInitLock() {
+                this.blankPageInitLock = false
+            },
+
+            isUserGestureMapEvent(causedBy) {
+                return ['gesture', 'drag', 'scale'].includes(String(causedBy || '').toLowerCase())
+            },
+
+            applyMapLocation(longitude, latitude, noReverse = true) {
+                const lng = Number(longitude)
+                const lat = Number(latitude)
+
+                if (!Number.isFinite(lng) || !Number.isFinite(lat)) return
+
+                // 程序主动改中心时，给一个更短的保护时间
+                // 避免真机上用户刚进页面第一次拖动也被吞掉
+                this.ignoreRegionChangeOnce = true
+                this.mapProgrammaticUntil = Date.now() + 280
+
+                this.longitude = lng
+                this.latitude = lat
+                this.newLongitude = lng
+                this.newLatitude = lat
+
+                if (this.mapGuardTimer) {
+                    clearTimeout(this.mapGuardTimer)
+                }
+                this.mapGuardTimer = setTimeout(() => {
+                    this.ignoreRegionChangeOnce = false
+                    this.mapGuardTimer = null
+                }, 320)
+
+                if (this.mapReverseTimer) {
+                    clearTimeout(this.mapReverseTimer)
+                    this.mapReverseTimer = null
+                }
+
+                if (!noReverse) {
+                    this.mapReverseTimer = setTimeout(() => {
+                        this.reverseGeocode(lng, lat)
+                        this.mapReverseTimer = null
+                    }, 220)
+                }
+            },
+            // 直辖市处理
+            normalizeCityName(province, city) {
+                let cityName = ''
+
+                if (Array.isArray(city)) {
+                    cityName = city[0] || ''
+                } else {
+                    cityName = city || ''
+                }
+
+                const fallbackCities = [
+                    '北京市',
+                    '上海市',
+                    '天津市',
+                    '重庆市',
+                    '香港特别行政区',
+                    '澳门特别行政区'
+                ]
+
+                if (!cityName && fallbackCities.includes(province)) {
+                    cityName = province
+                }
+
+                return cityName
+            },
+
+            buildMapSnapshotUrl() {
+                const lng = Number(this.longitude || this.newLongitude || 0).toFixed(6)
+                const lat = Number(this.latitude || this.newLatitude || 0).toFixed(6)
+                return `https://restapi.amap.com/v3/staticmap?location=${lng},${lat}&zoom=17&size=750*500&scale=2&markers=mid,0xE8101E,A:${lng},${lat}&key=${this.amapKey}`
+            },
+
+            onSnapshotLoad() {
+                console.log('地图加载成功:', this.mapSnapshotUrl)
+            },
+
+            onSnapshotError(e) {
+                console.log('地图加载失败:', e, this.mapSnapshotUrl)
+                uni.showToast({
+                    title: '地图加载失败',
+                    icon: 'none'
+                })
+            },
+
+            findRegionIndexByCode(baseData, provinceCode, cityCode, areaCode) {
+                const result = { provinceIndex: -1, cityIndex: -1, areaIndex: -1 }
+                const targetProvinceCode = (provinceCode || '').slice(0, 6)
+                const targetCityCode = (cityCode || '').slice(0, 6)
+                const targetAreaCode = (areaCode || '').slice(0, 6)
+                if (!targetProvinceCode || !targetCityCode || !targetAreaCode) return result
+
+                for (let pIdx = 0; pIdx < baseData.length; pIdx++) {
+                    const provinceItem = baseData[pIdx]
+                    const currentProvinceCode = (provinceItem.code || '').slice(0, 6)
+                    if (currentProvinceCode === targetProvinceCode) {
+                        result.provinceIndex = pIdx
+                        const citys = provinceItem.citys || []
+                        for (let cIdx = 0; cIdx < citys.length; cIdx++) {
+                            const cityItem = citys[cIdx]
+                            const currentCityCode = (cityItem.code || '').slice(0, 6)
+                            if (currentCityCode === targetCityCode) {
+                                result.cityIndex = cIdx
+                                const areas = cityItem.areas || []
+                                for (let aIdx = 0; aIdx < areas.length; aIdx++) {
+                                    const areaItem = areas[aIdx]
+                                    const currentAreaCode = (areaItem.code || '').slice(0, 6)
+                                    if (currentAreaCode === targetAreaCode) {
+                                        result.areaIndex = aIdx
+                                        return result
+                                    }
+                                }
+                                return result
+                            }
+                        }
+                        return result
+                    }
+                }
+                return result
+            },
+
+            convert(item) {
+                const data = {
+                    key: this.amapKey,
+                    locations: `${item.longitude},${item.latitude}`,
+                    coordsys: 'gps'
+                }
+                return new Promise((resolve) => {
+                    uni.request({
+                        url: 'https://restapi.amap.com/v3/assistant/coordinate/convert',
+                        method: 'GET',
+                        data,
+                        success(res) {
+                            resolve(res.data)
+                        }
+                    })
+                })
+            },
+
+            getLocation(silent = false) {
+                return new Promise((resolve, reject) => {
+                    const handleFail = (err) => {
+                        if (!silent) {
+                            uni.showToast({ title: '获取位置失败', icon: 'none' })
+                        }
+                        reject(err)
+                    }
+
+                    if (this.$store?.state?.version?.DeviceBrand === 'ios') {
+                        uni.getLocation({
+                            type: 'wgs84',
+                            isHighAccuracy: true,
+                            success: async (res) => {
+                                try {
+                                    const convert = await this.convert(res)
+                                    const locations = String(convert?.locations || '').split(',')
+
+                                    if (locations.length >= 2) {
+                                        res.longitude = Number(locations[0])
+                                        res.latitude = Number(locations[1])
+                                    }
+
+                                    resolve(res)
+                                } catch (error) {
+                                    handleFail(error)
+                                }
+                            },
+                            fail: handleFail
+                        })
+                    } else {
+                        uni.getLocation({
+                            type: 'gcj02',
+                            geocode: true,
+                            success: (res) => resolve(res),
+                            fail: handleFail
+                        })
+                    }
+                })
+            },
+
+            async getCurrentLocation(silent = false, lockInit = false) {
+                this.blankPageInitLock = false
+
+                try {
+                    const locationRes = await this.getLocation(silent)
+
+                    if (lockInit) {
+                        // 首次进入搜索地址页、且需要按当前定位初始化时，锁住地图初始化阶段
+                        this.startDependencyInitLock(1200)
+                        this.userSelectedRegion = false
+                        this.isManualDetail = false
+                        this.suppressInitDetailFill = false
+                    }
+
+                    this.updateMapCenter(locationRes.longitude, locationRes.latitude, false)
+                } catch (error) {
+                    // 静默定位失败时，保持页面为空，等用户自己操作
+                    if (silent) {
+                        this.latitude = 0
+                        this.longitude = 0
+                        this.newLatitude = 0
+                        this.newLongitude = 0
+
+                        this.currentProvince = ''
+                        this.currentCity = ''
+                        this.currentDistrict = ''
+                        this.currentRegion = ''
+                        this.detailAddress = ''
+                        this.manualDetail = ''
+                        this.currentDetail = ''
+                        this.isManualDetail = false
+
+                        // 关键补丁：
+                        // 未授权/静默定位失败后，立刻进入空白锁定模式，
+                        // 防止地图默认中心点再把“北京市西城区”反写回来
+                        this.blankPageInitLock = true
+                        this.suppressInitDetailFill = true
+                    }
+
+                    console.log('定位失败', error)
+                }
+            },
+
+            getNowLocation(center) {
+                if (!center) return
+                const locationRes = center.split(',')
+                if (locationRes.length < 2) return
+
+                this.updateMapCenter(
+                    parseFloat(locationRes[0]),
+                    parseFloat(locationRes[1]),
+                    false
+                )
+            },
+
+            normalizeAdcode6(code) {
+                    return String(code || '').slice(0, 6)
+                },
+
+                validateLocationWithDependency(longitude, latitude, dependencyCode) {
+                    return new Promise((resolve) => {
+                        const targetCode = this.normalizeAdcode6(dependencyCode)
+
+                        if (!targetCode || !longitude || !latitude) {
+                            resolve(true)
+                            return
+                        }
+
+                        uni.request({
+                            url: 'https://restapi.amap.com/v3/geocode/regeo',
+                            method: 'GET',
+                            data: {
+                                key: this.amapKey,
+                                location: `${longitude},${latitude}`,
+                                extensions: 'base'
+                            },
+                            success: (res) => {
+                                const adcode = this.normalizeAdcode6(
+                                    res?.data?.regeocode?.addressComponent?.adcode || ''
+                                )
+
+                                // 取不到adcode时不拦，避免误杀正常流程
+                                if (!adcode) {
+                                    resolve(true)
+                                    return
+                                }
+
+                                resolve(adcode === targetCode)
+                            },
+                            fail: () => {
+                                // 校验失败时不拦，避免把正常功能带坏
+                                resolve(true)
+                            }
+                        })
+                    })
+                },
+
+                async locateByDependencyCenter(regions, dependencyCode, skipAutoLocate) {
+                    let center = null
+
+                    if (dependencyCode && regions[2]) {
+                        center = await this.getDistrictCenter(regions[2], dependencyCode)
+                    }
+
+                    if (!center && regions[2]) {
+                        center = await this.getDistrictCenter(regions[2])
+                    }
+                    if (!center && regions[1] && regions[1] !== regions[0]) {
+                        center = await this.getDistrictCenter(regions[1])
+                    }
+                    if (!center && regions[0]) {
+                        center = await this.getDistrictCenter(regions[0])
+                    }
+
+                    if (center) {
+                        const locationRes = center.split(',')
+                        if (locationRes.length >= 2) {
+                            this.updateMapCenter(
+                                parseFloat(locationRes[0]),
+                                parseFloat(locationRes[1]),
+                                true
+                            )
+                        }
+                    } else if (!skipAutoLocate) {
+                        this.getCurrentLocation()
+                    }
+                },
+
+            // 逆地理编码
+            reverseGeocode(lng, lat) {
+                const requestId = ++this.reverseGeocodeRequestId
+                const targetLng = parseFloat(lng)
+                const targetLat = parseFloat(lat)
+
+                if (!Number.isFinite(targetLng) || !Number.isFinite(targetLat)) return
+
+                uni.request({
+                    url: 'https://restapi.amap.com/v3/geocode/regeo',
+                    data: {
+                        key: this.amapKey,
+                        location: `${targetLng},${targetLat}`,
+                        extensions: 'base'
+                    },
+                    success: (res) => {
+                        // 只认最后一次逆地理编码，避免旧请求把新位置覆盖掉
+                        if (requestId !== this.reverseGeocodeRequestId) return
+
+                        if (res.data.status === '1' && res.data.regeocode) {
+                            if (this.recognizeMapMoving) return
+
+                            const regeo = res.data.regeocode
+                            const formatted = regeo.formatted_address || ''
+                            const addrComp = regeo.addressComponent || {}
+
+                            const provinceName = addrComp.province || ''
+                            const cityName = this.normalizeCityName(provinceName, addrComp.city)
+                            const districtName = addrComp.district || ''
+
+                            let region = ''
+                            if (provinceName) region += provinceName
+                            if (cityName && cityName !== provinceName) region += cityName
+                            if (districtName) region += districtName
+
+                            if (!this.userSelectedRegion) {
+                                this.currentRegion = region || formatted
+                                this.currentProvince = provinceName
+                                this.currentCity = cityName
+                                this.currentDistrict = districtName
+
+                                const adcode = addrComp.adcode || ''
+                                if (adcode.length >= 6) {
+                                    this.selectedDistrictCode = adcode
+                                    this.selectedCityCode = adcode.substring(0, 4) + '00'
+                                    this.selectedProvinceCode = adcode.substring(0, 2) + '0000'
+                                }
+                            }
+
+                            let detail = ''
+                            if (region && formatted.startsWith(region)) {
+                                detail = formatted.substring(region.length).trim()
+                            } else {
+                                detail = formatted.trim()
+                            }
+
+                            // 首次进入且上页没传详细地址：保持空
+                            if (this.suppressInitDetailFill) {
+                                this.suppressInitDetailFill = false
+                                return
+                            }
+
+                            if (!this.isManualDetail) {
+                                this.detailAddress = detail || formatted
+                                this.manualDetail = this.detailAddress
+                                this.currentDetail = this.detailAddress
+                            }
+                        }
+                    },
+                    fail: (err) => {
+                        if (requestId !== this.reverseGeocodeRequestId) return
+                        console.error('逆地理编码失败:', err)
+                    }
+                })
+            },
+
+            // 地图点击：点击后立即更新地区和详细地址
+            onMapTap(e) {
+                this.clearDependencyInitLock()
+                this.clearBlankPageInitLock()
+
+                this.userSelectedRegion = false
+                this.isManualDetail = false
+                this.suppressInitDetailFill = false
+
+                const tapLat = Number(e?.detail?.latitude)
+                const tapLng = Number(e?.detail?.longitude)
+
+                if (Number.isFinite(tapLat) && Number.isFinite(tapLng)) {
+                    this.latitude = tapLat
+                    this.longitude = tapLng
+                    this.newLatitude = tapLat
+                    this.newLongitude = tapLng
+                    this.reverseGeocode(tapLng, tapLat)
+                    return
+                }
+
+                const mapCtx = uni.createMapContext('map', this)
+                mapCtx.getCenterLocation({
+                    success: (res) => {
+                        this.latitude = res.latitude
+                        this.longitude = res.longitude
+                        this.newLatitude = res.latitude
+                        this.newLongitude = res.longitude
+                        this.reverseGeocode(res.longitude, res.latitude)
+                    },
+                    fail: (err) => {
+                        console.error('点击地图获取中心点失败', err)
+                    }
+                })
+            },
+
+            syncCenterFromMap() {
+                if (this.dependencyInitLock) return
+                if (this.blankPageInitLock) return
+
+                const mapCtx = uni.createMapContext('map', this)
+
+                mapCtx.getCenterLocation({
+                    success: (res) => {
+                        if (
+                            !res ||
+                            !Number.isFinite(Number(res.longitude)) ||
+                            !Number.isFinite(Number(res.latitude))
+                        ) {
+                            return
+                        }
+
+                        this.userSelectedRegion = false
+                        this.isManualDetail = false
+                        this.suppressInitDetailFill = false
+
+                        this.latitude = Number(res.latitude)
+                        this.longitude = Number(res.longitude)
+                        this.newLatitude = Number(res.latitude)
+                        this.newLongitude = Number(res.longitude)
+
+                        this.reverseGeocode(this.longitude, this.latitude)
+                    },
+                    fail: (err) => {
+                        console.error('syncCenterFromMap失败', err)
+                    }
+                })
+            },
+
+            // 地图拖动结束：用getCenterLocation拿中心点，然后更新地区和详细地址
+            changeMap(e) {
+                if (this.showRegionPicker || !this.mapVisible) return
+                if (this.recognizeMapMoving) return
+                if (this.dependencyInitLock) return
+
+                const eventType = e?.detail?.type || e?.type || ''
+                const causedBy = e?.detail?.causedBy || e?.causedBy || ''
+
+                if (this.blankPageInitLock) {
+                    if (this.isUserGestureMapEvent(causedBy)) {
+                        this.clearBlankPageInitLock()
+                    } else {
+                        return
+                    }
+                }
+
+                // 只跳过明确的 begin
+                if (eventType === 'begin') return
+
+                if (Date.now() < this.mapProgrammaticUntil) {
+                    return
+                }
+
+                const isProgrammaticEvent = causedBy && causedBy !== 'gesture'
+
+                if (isProgrammaticEvent && this.ignoreRegionChangeOnce) {
+                    this.ignoreRegionChangeOnce = false
+                    return
+                }
+
+                if (this.mapMoveTimer) {
+                    clearTimeout(this.mapMoveTimer)
+                }
+
+                const delay = eventType === 'end' ? 80 : 260
+
+                this.mapMoveTimer = setTimeout(() => {
+                    this.syncCenterFromMap()
+
+                    setTimeout(() => {
+                        this.syncCenterFromMap()
+                    }, 180)
+
+                    this.mapMoveTimer = null
+                }, delay)
+            },
+
+            // 城市选择
+            goSelectCity() {
+                uni.navigateTo({
+                    url: '/subPackages/address/selectCity'
+                })
+            },
+
+            // 底部编辑区方法
+            clearRawAddress() {
+                this.rawAddress = ''
+                uni.showToast({ title: '已清空', icon: 'none' })
+            },
+
+            onDetailInput(e) {
+                const val = e.detail.value || ''
+                this.detailAddress = val
+                this.manualDetail = val
+                this.currentDetail = val
+                this.isManualDetail = val.trim().length > 0
+            },
+
+            onPaste() {
+                uni.getClipboardData({
+                    success: (res) => {
+                        if (res.data) {
+                            this.rawAddress = res.data
+                            uni.showToast({ title: '已粘贴', icon: 'none' })
+                        }
+                    }
+                })
+            },
+
+            sanitizeRawAddress(raw) {
+                let text = (raw || '')
+                    .replace(/[\r\n\t]+/g, ' ')
+                    .replace(/　/g, ' ')
+                    .replace(/\s+/g, ' ')
+                    .trim()
+
+                const addressMatch = text.match(/地址[:：]\s*(.*)/)
+                if (addressMatch && addressMatch[1]) {
+                    text = addressMatch[1].trim()
+                }
+
+                text = text
+                    .replace(/(收货人|联系人|姓名)[:：]\s*[\u4e00-\u9fa5A-Za-z·]{1,20}/g, '')
+                    .replace(/(电话|手机)[:：]?\s*1[3-9]\d{9}/g, '')
+                    .replace(/1[3-9]\d{9}/g, '')
+                    .replace(/[，,；;]+/g, ' ')
+                    .replace(/\s+/g, ' ')
+                    .trim()
+
+                return text
+            },
+
+            escapeRegExp(str) {
+                return (str || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+            },
+
+            getNetworkTypeSafe() {
+                return new Promise((resolve) => {
+                    uni.getNetworkType({
+                        success: (res) => resolve(res.networkType || 'unknown'),
+                        fail: () => resolve('unknown')
+                    })
+                })
+            },
+
+            async ensureRecognizeNetworkAvailable() {
+                const networkType = await this.getNetworkTypeSafe()
+
+                if (networkType === 'none') {
+                    this.showRecognizeNetworkError()
+                    return false
+                }
+
+                return true
+            },
+
+            showRecognizeNetworkError() {
+                uni.showToast({
+                    title: '网络异常，无法进行地址识别与地图定位，请检查网络后重试',
+                    icon: 'none',
+                    duration: 3500
+                })
+            },
+
+            isLikelyNetworkError(error) {
+                const msg = String(
+                    error?.errMsg ||
+                    error?.message ||
+                    error ||
+                    ''
+                ).toLowerCase()
+
+                return (
+                    msg.includes('network') ||
+                    msg.includes('timeout') ||
+                    msg.includes('request:fail') ||
+                    msg.includes('fail')
+                )
+            },
+
+            hasStrongAddressFeature(text) {
+                return /(\d|号|栋|幢|单元|室|楼|层|座|路|街|巷|道|村|镇|乡|里|弄|园|苑|小区|大厦|广场|市场|学校|医院|公寓|酒店|中心|胡同)/.test(text || '')
+            },
+
+            containsObviousInvalidNoise(text) {
+                return /(价格|价钱|多少钱|举报|投诉|建议|咨询|测试|示例|比如|比方|假设|无效|乱填)/i.test(text || '')
+            },
+
+            isLikelyInvalidRecognizedDetail(text) {
+                const value = String(text || '').trim()
+                if (!value) return true
+
+                const hasChinese = /[\u4e00-\u9fa5]/.test(value)
+                const hasDigit = /\d/.test(value)
+                const hasAddressUnit = this.hasStrongAddressFeature(value)
+                const longPureLetters = /\b[A-Za-z]{4,}\b/.test(value) && !/[A-Za-z]\d|\d[A-Za-z]/.test(value)
+
+                if (this.containsObviousInvalidNoise(value) && !hasAddressUnit && !hasDigit) {
+                    return true
+                }
+
+                if (longPureLetters && !hasAddressUnit && !hasDigit) {
+                    return true
+                }
+
+                if (!hasChinese && !hasDigit && !hasAddressUnit) {
+                    return true
+                }
+
+                return false
+            },
+
+            isPreciseGeocodeLevel(level) {
+                return [
+                    '门牌号',
+                    '兴趣点',
+                    '道路',
+                    '道路交叉口',
+                    '乡镇',
+                    '村庄',
+                    '村级地名'
+                ].includes(String(level || '').trim())
+            },
+
+            validateRecognizedDetail(detailText, geo) {
+                const cleaned = String(detailText || '').trim()
+
+                if (!cleaned) {
+                    return {
+                        valid: false,
+                        cleaned: '',
+                        reason: 'empty'
+                    }
+                }
+
+                if (this.isLikelyInvalidRecognizedDetail(cleaned)) {
+                    return {
+                        valid: false,
+                        cleaned: '',
+                        reason: 'invalid_text'
+                    }
+                }
+
+                if (!geo) {
+                    return {
+                        valid: false,
+                        cleaned: '',
+                        reason: 'geocode_failed'
+                    }
+                }
+
+                if (!this.isPreciseGeocodeLevel(geo.level) && !this.hasStrongAddressFeature(cleaned)) {
+                    return {
+                        valid: false,
+                        cleaned: '',
+                        reason: 'low_precision'
+                    }
+                }
+
+                return {
+                    valid: true,
+                    cleaned,
+                    reason: ''
+                }
+            },
+
+            cleanRecognizedDetail(detail, province, city, district, town) {
+                let text = (detail || '').trim()
+
+                const parts = [province, city, district, town]
+                    .filter(Boolean)
+                    .map(item => this.escapeRegExp(item))
+
+                if (parts.length) {
+                    const reg = new RegExp(`^(${parts.join('|')})+`)
+                    text = text.replace(reg, '')
+                }
+
+                text = text
+                    .replace(/(收货人|联系人|姓名)[:：].*$/g, '')
+                    .replace(/(电话|手机)[:：]?\s*1[3-9]\d{9}.*$/g, '')
+                    .replace(/备注[:：].*$/g, '')
+                    .replace(/1[3-9]\d{9}/g, '')
+                    .replace(/[（(][^）)]*[）)]/g, '')
+                    .replace(/^[，,；;、\s]+/, '')
+                    .replace(/\s+/g, ' ')
+                    .trim()
+
+                return text
+            },
+
+            buildRecognizedDetail(townName, detail) {
+                const town = (townName || '').trim()
+                const detailText = (detail || '').trim()
+
+                if (town && detailText) {
+                    return detailText.startsWith(town) ? detailText : `${town}${detailText}`
+                }
+
+                return detailText || town
+            },
+
+            buildExactRecognizedDetail(hit, sanitizedText, province, city, district) {
+                const directDetail = (
+                    hit?.detail ||
+                    hit?.address ||
+                    hit?.addr ||
+                    hit?.full_address_detail ||
+                    hit?.address_detail ||
+                    ''
+                ).trim()
+
+                // 接口已经给了明确详细地址，就直接用，不再清洗、不再删镇街
+                if (directDetail) {
+                    return directDetail
+                }
+
+                // 接口没单独给详细地址时，再从原始识别文本里扣掉省市区，保留后面的完整内容
+                let text = (sanitizedText || '').trim()
+                const prefix = [
+                    province || '',
+                    city && city !== province ? city : '',
+                    district || ''
+                ].join('')
+
+                if (prefix && text.startsWith(prefix)) {
+                    text = text.slice(prefix.length).trim()
+                }
+
+                return text
+            },
+
+            getRecognizeLevel(hit, detailText, rawText) {
+                const province = (hit?.province_name || '').trim()
+                const city = (hit?.city_name || '').trim()
+                const district = (hit?.county_name || '').trim()
+
+                if (/火星市|月球|银河|测试地址/.test(rawText || '')) {
+                    return 'low'
+                }
+
+                if (!province || (!city && !district)) {
+                    return 'low'
+                }
+
+                if (!detailText || detailText.length < 4) {
+                    return 'medium'
+                }
+
+                return 'high'
+            },
+
+            // 垃圾文本拦截
+            shouldOnlyToastForGarbageRecognize(rawText, hit, detailText, detailRejected = false) {
+                const input = String(rawText || '').trim()
+                if (!input) return true
+
+                const province = (hit?.province_name || '').trim()
+                const city = (hit?.city_name || '').trim()
+                const district = (hit?.county_name || '').trim()
+
+                const hasFullRegion = !!(province && (city || district))
+                if (!hasFullRegion) return false
+
+                const hasAddressFeature = this.hasStrongAddressFeature(input)
+                const hasRegionKeyword = /(省|市|区|县|旗|镇|乡|村|街道)/.test(input)
+                const hasLongLetterChunk = /[A-Za-z]{2,}/.test(input)
+                const hasInvalidNoise = this.containsObviousInvalidNoise(input)
+
+                // 像“付i啊不符合可不vi了哈女本办法本办法v就看不上”这种，
+                // 既不像正常地址，又夹杂明显乱码/字母串，同时还没有有效详细地址时，只提示不回填
+                if (!hasAddressFeature && !hasRegionKeyword && !detailText) {
+                    if (hasLongLetterChunk || hasInvalidNoise || detailRejected) {
+                        return true
+                    }
+                }
+
+                return false
+            },
+
+            getRecognizeToast(level, removedNoise, geocodeOk, hit, detailText, detailRejected = false) {
+                const province = (hit?.province_name || '').trim()
+                const city = (hit?.city_name || '').trim()
+                const district = (hit?.county_name || '').trim()
+
+                const hasRegion = !!(province || city || district)
+                const hasFullRegion = !!(province && (city || district))
+                const hasDetail = !!(detailText && detailText.trim())
+
+                if (detailRejected && hasFullRegion && !hasDetail) {
+                    return {
+                        type: 'modal',
+                        title: '已识别到地区，详细地址未自动填入',
+                        content: '已识别到省市区，但检测到详细地址中包含无效或不完整内容，系统未自动填入详细地址，请手动补充。'
+                    }
+                }
+
+                if (level === 'low') {
+                    if (!hasRegion) {
+                        return {
+                            type: 'modal',
+                            title: '已识别，但未匹配到有效地区',
+                            content: '未查找到明确的省市区信息，请手动选择所在地区，并检查输入内容是否包含错别字、备注或无效地址。'
+                        }
+                    }
+
+                    if (hasRegion && !hasFullRegion) {
+                        return {
+                            type: 'modal',
+                            title: '已识别到部分地区信息',
+                            content: '当前仅识别到部分地区，未能完整匹配到市区县，请手动补全所在地区并核对详细地址。'
+                        }
+                    }
+
+                    if (hasFullRegion && !hasDetail) {
+                        return {
+                            type: 'modal',
+                            title: '已识别到地区，但详细地址不完整',
+                            content: '已识别到省市区，但未能准确提取详细地址，请补充门牌号、楼栋号等信息。'
+                        }
+                    }
+
+                    return {
+                        type: 'modal',
+                        title: '已识别，但结果不够准确',
+                        content: '当前地址已部分识别，请核对所在地区和详细地址，必要时请手动修正。'
+                    }
+                }
+
+                if (level === 'medium') {
+                    if (!hasDetail) {
+                        return {
+                            type: 'toast',
+                            title: removedNoise ? '已识别到地区，请补充详细地址' : '已识别到地区，请补充详细地址'
+                        }
+                    }
+
+                    if (!geocodeOk) {
+                        return {
+                            type: 'toast',
+                            title: removedNoise ? '已识别，但未查到地图位置' : '已识别，但未查到对应地图位置'
+                        }
+                    }
+
+                    return {
+                        type: 'toast',
+                        title: removedNoise ? '已识别到部分地址' : '已识别到部分地址，请核对'
+                    }
+                }
+
+                if (!geocodeOk) {
+                    return {
+                        type: 'toast',
+                        title: removedNoise ? '已识别，但未查到地图位置' : '已识别，请核对地址和地图位置'
+                    }
+                }
+
+                return {
+                    type: 'toast',
+                    title: removedNoise ? '识别成功' : '识别成功，请核对'
+                }
+            },
+
+            parseStreetStd(streetStd = '') {
+                const parsed = {}
+
+                String(streetStd)
+                    .split(/\t+/)
+                    .forEach(item => {
+                        const index = item.indexOf('=')
+                        if (index === -1) return
+
+                        const key = item.slice(0, index).trim().toLowerCase()
+                        const value = item.slice(index + 1).trim()
+
+                        if (key) {
+                            parsed[key] = value
+                        }
+                    })
+
+                return {
+                    province_name: (parsed.prov || parsed.province || '').trim(),
+                    city_name: (parsed.city || '').trim(),
+                    county_name: (parsed.district || parsed.county || parsed.area || '').trim(),
+                    town_name: (parsed.town || parsed.street || '').trim(),
+                    detail: (parsed.detail || parsed.address || parsed.addr || '').trim(),
+                    address: (parsed.address || parsed.detail || parsed.addr || '').trim(),
+                    province_code: (parsed.province_code || parsed.prov_code || '').trim(),
+                    city_code: (parsed.city_code || '').trim(),
+                    county_code: (parsed.county_code || parsed.district_code || parsed.area_code || '').trim()
+                }
+            },
+
+            normalizeRecognizeHit(res) {
+                if (!res || (res.code !== 200 && res.code !== 0)) return null
+
+                // 旧格式1：data 是数组
+                if (Array.isArray(res.data) && res.data.length) {
+                    return res.data[0]
+                }
+
+                // 旧格式2：data.data 是数组
+                if (Array.isArray(res?.data?.data) && res.data.data.length) {
+                    return res.data.data[0]
+                }
+
+                // 旧格式3：result 是数组
+                if (Array.isArray(res.result) && res.result.length) {
+                    return res.result[0]
+                }
+
+                // 新格式：data 本身就是对象，且直接带这些字段
+                if (
+                    res.data &&
+                    typeof res.data === 'object' &&
+                    (
+                        res.data.province_name ||
+                        res.data.city_name ||
+                        res.data.county_name ||
+                        res.data.detail ||
+                        res.data.address
+                    )
+                ) {
+                    return res.data
+                }
+
+                // 新格式：data.street.street_std
+                if (res?.data?.street && typeof res.data.street === 'object') {
+                    const street = res.data.street
+                    const stdParsed = this.parseStreetStd(street.street_std || '')
+
+                    return {
+                        province_name: (street.province_name || street.province || stdParsed.province_name || '').trim(),
+                        city_name: (street.city_name || street.city || stdParsed.city_name || '').trim(),
+                        county_name: (street.county_name || street.district || street.county || stdParsed.county_name || '').trim(),
+                        town_name: (street.town_name || street.town || street.street_name || stdParsed.town_name || '').trim(),
+                        detail: (street.detail || street.address || stdParsed.detail || stdParsed.address || '').trim(),
+                        address: (street.address || street.detail || stdParsed.address || stdParsed.detail || '').trim(),
+                        province_code: (street.province_code || stdParsed.province_code || '').trim(),
+                        city_code: (street.city_code || stdParsed.city_code || '').trim(),
+                        county_code: (street.county_code || street.district_code || stdParsed.county_code || '').trim()
+                    }
+                }
+
+                return null
+            },
+
+            getRecognizeApiUrl() {
+                const app = typeof getApp === 'function' ? getApp() : null
+
+                const baseUrl =
+                    app?.globalData?.url ||
+                    app?.globalData?.baseUrl ||
+                    app?.globalData?.apiBaseUrl ||
+                    'https://api.mrrwlkj.top'
+
+                return `${String(baseUrl).replace(/\/+$/, '')}/api/recognize/address`
+            },
+
+            buildMultipartFormData(fields = {}) {
+                const boundary = '----UniFormBoundary' + Date.now()
+                let body = ''
+
+                Object.keys(fields).forEach((key) => {
+                    const value = fields[key] == null ? '' : String(fields[key])
+                    body += `--${boundary}\r\n`
+                    body += `Content-Disposition: form-data; name="${key}"\r\n\r\n`
+                    body += `${value}\r\n`
+                })
+
+                body += `--${boundary}--\r\n`
+
+                return {
+                    boundary,
+                    body
+                }
+            },
+
+            requestRecognizeAddress(rawText) {
+                return request.post('/api/recognize/address', {
+                    text: rawText
+                })
+            },
+
+            geocodeRecognizedAddress(address) {
+                return new Promise((resolve) => {
+                    if (!address) {
+                        resolve({
+                            ok: true,
+                            data: null,
+                            error: null
+                        })
+                        return
+                    }
+
+                    uni.request({
+                        url: 'https://restapi.amap.com/v3/geocode/geo',
+                        method: 'GET',
+                        data: {
+                            key: this.amapKey,
+                            address,
+                            output: 'JSON'
+                        },
+                        success: (res) => {
+                            if (res.data.status === '1' && res.data.geocodes?.length > 0) {
+                                resolve({
+                                    ok: true,
+                                    data: res.data.geocodes[0],
+                                    error: null
+                                })
+                            } else {
+                                resolve({
+                                    ok: true,
+                                    data: null,
+                                    error: null
+                                })
+                            }
+                        },
+                        fail: (error) => resolve({
+                            ok: false,
+                            data: null,
+                            error
+                        })
+                    })
+                })
+            },
+
+            async onSmartRecognize() {
+                this.clearBlankPageInitLock()
+                this.userSelectedRegion = false
+                this.isManualDetail = false
+                this.suppressInitDetailFill = false
+
+                if (!this.hasRawContent) {
+                    uni.showToast({ title: '请先粘贴或输入地址', icon: 'none' })
+                    return
+                }
+
+                const originalRawText = (this.rawAddress || '').trim()
+                if (!originalRawText) {
+                    uni.showToast({ title: '请先粘贴或输入地址', icon: 'none' })
+                    return
+                }
+
+                const hasNetwork = await this.ensureRecognizeNetworkAvailable()
+                if (!hasNetwork) {
+                    return
+                }
+
+                const sanitizedText = this.sanitizeRawAddress(originalRawText)
+                const removedNoise = sanitizedText !== originalRawText
+
+                if (!sanitizedText) {
+                    uni.showToast({ title: '未提取到有效地址', icon: 'none' })
+                    return
+                }
+
+                uni.showLoading({ title: '识别中...' })
+
+                try {
+                    const res = await this.requestRecognizeAddress(sanitizedText)
+                    console.log('智能识别接口返回:', res)
+
+                    const hit = this.normalizeRecognizeHit(res)
+
+                    if (!res || (res.code !== 0 && res.code !== 200) || !hit) {
+                        uni.hideLoading()
+                        uni.showToast({
+                            title: res?.msg || '地址解析失败',
+                            icon: 'none'
+                        })
+                        return
+                    }
+
+                    console.log('智能识别标准化结果:', hit)
+
+                    const province = (hit.province_name || '').trim()
+                    const city = (hit.city_name || '').trim()
+                    const district = (hit.county_name || '').trim()
+                    const town = (hit.town_name || '').trim()
+
+                    let regionText = ''
+                    if (province) regionText += province
+                    if (city && city !== province) regionText += city
+                    if (district) regionText += district
+
+                    if (!regionText) {
+                        uni.hideLoading()
+                        const tip = this.getRecognizeToast('low', removedNoise, false, hit, '', false)
+                        if (tip.type === 'modal') {
+                            uni.showModal({
+                                title: tip.title,
+                                content: tip.content,
+                                showCancel: false
+                            })
+                        } else {
+                            uni.showToast({
+                                title: tip.title,
+                                icon: 'none'
+                            })
+                        }
+                        return
+                    }
+
+                    const detailCandidate = this.cleanRecognizedDetail(
+                        this.buildExactRecognizedDetail(
+                            hit,
+                            sanitizedText,
+                            province,
+                            city,
+                            district
+                        ),
+                        province,
+                        city,
+                        district,
+                        town
+                    )
+
+                    const fullAddress = `${regionText}${detailCandidate}`.trim()
+                    console.log('用于定位的完整地址:', fullAddress)
+
+                    let geocodeOk = false
+                    let geo = null
+                    let detailRejected = false
+                    let detailText = ''
+
+                    const fullGeoResult = await this.geocodeRecognizedAddress(fullAddress)
+
+                    if (!fullGeoResult.ok) {
+                        uni.hideLoading()
+                        this.showRecognizeNetworkError()
+                        return
+                    }
+
+                    geo = fullGeoResult.data
+
+                    const detailDecision = this.validateRecognizedDetail(detailCandidate, geo)
+                    detailRejected = !detailDecision.valid && !!detailCandidate
+                    detailText = detailDecision.valid ? detailDecision.cleaned : ''
+
+                    // ====== 回填到页面下方的位置 ======
+                    this.currentProvince = province
+                    this.currentCity = city
+                    this.currentDistrict = district
+                    this.currentRegion = regionText
+
+                    this.selectedProvinceCode = hit.province_code || ''
+                    this.selectedCityCode = hit.city_code || ''
+                    this.selectedDistrictCode = hit.county_code || ''
+
+                    this.detailAddress = detailText
+                    this.manualDetail = detailText
+                    this.currentDetail = detailText
+                    this.isManualDetail = !!detailText
+                    // =================================
+
+                    // 如果详细地址被判定为无效，则退回到仅用省市区定位，避免把脏文本带进详情页
+                    if (!detailText) {
+                        const regionGeoResult = await this.geocodeRecognizedAddress(regionText)
+
+                        if (!regionGeoResult.ok) {
+                            uni.hideLoading()
+                            this.showRecognizeNetworkError()
+                            return
+                        }
+
+                        geo = regionGeoResult.data
+                    }
+
+                    if (geo) {
+                        const location = geo.location
+                        const adcode = geo.adcode || ''
+
+                        if (adcode.length >= 6) {
+                            this.selectedDistrictCode = adcode
+                            this.selectedCityCode = adcode.substring(0, 4) + '00'
+                            this.selectedProvinceCode = adcode.substring(0, 2) + '0000'
+                        }
+
+                        if (location) {
+                            const [lng, lat] = location.split(',')
+
+                            this.longitude = parseFloat(lng)
+                            this.latitude = parseFloat(lat)
+                            this.newLongitude = this.longitude
+                            this.newLatitude = this.latitude
+
+                            // 智能识别后这次地图自动移动，只允许移动地图，不允许回头覆盖识别结果
+                            this.recognizeMapMoving = true
+                            if (this.recognizeMapMoveTimer) {
+                                clearTimeout(this.recognizeMapMoveTimer)
+                            }
+
+                            this.updateMapCenter(this.longitude, this.latitude, true)
+                            geocodeOk = true
+
+                            this.recognizeMapMoveTimer = setTimeout(() => {
+                                this.recognizeMapMoving = false
+                                this.recognizeMapMoveTimer = null
+                            }, 1500)
+                        }
+                    }
+
+                    const level = this.getRecognizeLevel(hit, detailText, sanitizedText)
+
+                    this.smartBtnText = '已识别'
+                    uni.hideLoading()
+
+                    const tip = this.getRecognizeToast(level, removedNoise, geocodeOk, hit, detailText, detailRejected)
+                    if (tip.type === 'modal') {
+                        uni.showModal({
+                            title: tip.title,
+                            content: tip.content,
+                            showCancel: false
+                        })
+                    } else {
+                        uni.showToast({
+                            title: tip.title,
+                            icon: 'none'
+                        })
+                    }
+                } catch (error) {
+                    console.error('智能识别失败:', error)
+                    uni.hideLoading()
+
+                    if (this.isLikelyNetworkError(error)) {
+                        this.showRecognizeNetworkError()
+                        return
+                    }
+
+                    uni.showToast({
+                        title: '识别失败，请稍后重试',
+                        icon: 'none'
+                    })
+                }
+            },
+
+            // 更新地图中心
+            updateMapCenter(longitude, latitude, noReverse = false) {
+                const lng = parseFloat(longitude)
+                const lat = parseFloat(latitude)
+
+                if (!Number.isFinite(lng) || !Number.isFinite(lat)) return
+
+                this.applyMapLocation(lng, lat, noReverse)
+            },
+
+            // 地区选择弹窗
+            selectRegion() {
+                this.openRegionPicker()
+            },
+
+            openRegionPicker() {
+                this.regionProvinceList = ChinaCitys || []
+
+                let provinceIndex = 0
+                let cityIndex = 0
+                let areaIndex = 0
+
+                if (this.selectedProvinceCode && this.selectedCityCode && this.selectedDistrictCode) {
+                    const idx = this.findRegionIndexByCode(
+                        ChinaCitys,
+                        this.selectedProvinceCode,
+                        this.selectedCityCode,
+                        this.selectedDistrictCode
+                    )
+                    provinceIndex = idx.provinceIndex >= 0 ? idx.provinceIndex : 0
+                    cityIndex = idx.cityIndex >= 0 ? idx.cityIndex : 0
+                    areaIndex = idx.areaIndex >= 0 ? idx.areaIndex : 0
+                }
+
+                this.regionCityList = this.regionProvinceList[provinceIndex]?.citys || []
+                this.regionDistrictList = this.regionCityList[cityIndex]?.areas || []
+                this.regionPickerValue = [provinceIndex, cityIndex, areaIndex]
+
+                if (this.mapMoveTimer) {
+                    clearTimeout(this.mapMoveTimer)
+                    this.mapMoveTimer = null
+                }
+
+                this.mapSnapshotUrl = this.buildMapSnapshotUrl()
+                this.showMapSnapshot = true
+                this.mapVisible = false
+                this.showRegionPicker = true
+            },
+
+            closeRegionPicker() {
+                this.showRegionPicker = false
+
+                if (this.popupRestoreTimer) {
+                    clearTimeout(this.popupRestoreTimer)
+                }
+
+                this.popupRestoreTimer = setTimeout(() => {
+                    this.showMapSnapshot = false
+                    this.mapSnapshotUrl = ''
+
+                    // 恢复地图时做一次保护，避免重建后的 regionchange 抢状态
+                    this.ignoreRegionChangeOnce = true
+                    this.mapProgrammaticUntil = Date.now() + 500
+
+                    if (this.mapGuardTimer) {
+                        clearTimeout(this.mapGuardTimer)
+                    }
+                    this.mapGuardTimer = setTimeout(() => {
+                        this.ignoreRegionChangeOnce = false
+                        this.mapGuardTimer = null
+                    }, 550)
+
+                    this.mapVisible = true
+                    this.mapRenderKey += 1
+                    this.popupRestoreTimer = null
+                }, 300)
+            },
+
+            onRegionChange(e) {
+                const val = e.detail.value
+                this.regionPickerValue = val
+
+                const provinceIdx = val[0]
+                const cityIdx = val[1] || 0
+
+                if (this.regionProvinceList.length > provinceIdx) {
+                    this.regionCityList = this.regionProvinceList[provinceIdx].citys || []
+                    const maxCityIdx = this.regionCityList.length - 1
+                    const adjustedCityIdx = Math.min(cityIdx, maxCityIdx)
+
+                    if (adjustedCityIdx !== cityIdx) {
+                        this.regionPickerValue = [provinceIdx, adjustedCityIdx, 0]
+                    }
+
+                    if (this.regionCityList.length > adjustedCityIdx) {
+                        this.regionDistrictList = this.regionCityList[adjustedCityIdx].areas || []
+                        const areaIdx = val[2] || 0
+                        const maxAreaIdx = this.regionDistrictList.length - 1
+                        if (areaIdx > maxAreaIdx) {
+                            this.regionPickerValue = [provinceIdx, adjustedCityIdx, 0]
+                        }
+                    } else {
+                        this.regionDistrictList = []
+                        this.regionPickerValue = [provinceIdx, 0, 0]
+                    }
+                } else {
+                    this.regionCityList = []
+                    this.regionDistrictList = []
+                    this.regionPickerValue = [0, 0, 0]
+                }
+            },
+
+            async confirmRegion() {
+                this.clearBlankPageInitLock()
+                const [provinceIdx, cityIdx, districtIdx] = this.regionPickerValue
+                const provinceItem = this.regionProvinceList[provinceIdx]
+                const cityItem = this.regionCityList[cityIdx]
+                const districtItem = this.regionDistrictList[districtIdx]
+
+                if (!provinceItem || !cityItem || !districtItem) {
+                    uni.showToast({ title: '选择无效', icon: 'none' })
+                    return
+                }
+
+                this.userSelectedRegion = true
+
+                const regionStr = provinceItem.province + cityItem.city + districtItem.area
+                this.currentProvince = provinceItem.province
+                this.currentCity = cityItem.city
+                this.currentDistrict = districtItem.area
+                this.currentRegion = regionStr
+
+                this.selectedProvinceCode = provinceItem.code
+                this.selectedCityCode = cityItem.code
+                this.selectedDistrictCode = districtItem.code
+
+                // 选地区后只定位到地区中心，详细地址保持空
+                this.isManualDetail = false
+                this.suppressInitDetailFill = true
+                this.detailAddress = ''
+                this.manualDetail = ''
+                this.currentDetail = ''
+
+                const shortCode = districtItem.code ? districtItem.code.toString().slice(0, 6) : ''
+                this.startDependencyInitLock()
+                const center = await this.getDistrictCenter(districtItem.area, shortCode)
+
+                if (center) {
+                    const [lng, lat] = center.split(',')
+                    this.updateMapCenter(parseFloat(lng), parseFloat(lat), true)
+                } else {
+                    uni.showToast({ title: '无法定位该地区，请手动拖动地图', icon: 'none' })
+                }
+
+                this.closeRegionPicker()
+            },
+
+            // 获取地区中心点
+            getDistrictCenter(keyword, adcode = '', subdistrict = 0) {
+                return new Promise((resolve) => {
+                    const params = {
+                        key: this.amapKey,
+                        subdistrict,
+                        extensions: 'all'
+                    }
+
+                    const queryAdcode = () => {
+                        if (!adcode) return Promise.resolve(null)
+
+                        return new Promise((resolveInner) => {
+                            uni.request({
+                                url: 'https://restapi.amap.com/v3/config/district',
+                                method: 'GET',
+                                data: {
+                                    ...params,
+                                    keywords: adcode.slice(0, 6)
+                                },
+                                success: (res) => {
+                                    if (res.data.status === '1' && res.data.districts && res.data.districts.length > 0) {
+                                        const district = res.data.districts[0]
+                                        if (district.center) {
+                                            resolveInner(district.center)
+                                            return
+                                        }
+                                    }
+                                    resolveInner(null)
+                                },
+                                fail: () => resolveInner(null)
+                            })
+                        })
+                    }
+
+                    const queryKeyword = () => {
+                        return new Promise((resolveInner) => {
+                            uni.request({
+                                url: 'https://restapi.amap.com/v3/config/district',
+                                method: 'GET',
+                                data: {
+                                    ...params,
+                                    keywords: keyword
+                                },
+                                success: (res) => {
+                                    if (res.data.status === '1' && res.data.districts && res.data.districts.length > 0) {
+                                        const district = res.data.districts[0]
+                                        if (district.center) {
+                                            resolveInner(district.center)
+                                            return
+                                        }
+                                    }
+                                    resolveInner(null)
+                                },
+                                fail: () => resolveInner(null)
+                            })
+                        })
+                    }
+
+                    queryAdcode().then(center => {
+                        if (center) {
+                            resolve(center)
+                        } else {
+                            queryKeyword().then(resolve)
+                        }
+                    })
+                })
+            },
+
+            // 确认返回
+            onConfirm() {
+                const fullAddress = (this.currentRegion + (this.detailAddress ? ' ' + this.detailAddress : '')).trim()
+
+                const addressItem = {
+                    name: fullAddress,
+                    address: this.detailAddress,
+                    location: `${this.longitude},${this.latitude}`,
+                    pname: this.currentProvince,
+                    cityname: this.currentCity,
+                    adname: this.currentDistrict,
+                    province: this.currentProvince,
+                    city: this.currentCity,
+                    district: this.currentDistrict,
+                    provinceCode: this.selectedProvinceCode,
+                    cityCode: this.selectedCityCode,
+                    districtCode: this.selectedDistrictCode,
+                    source: this.source
+                }
+
+                const pages = getCurrentPages()
+                const prevPage = pages[pages.length - 2]
+                const currentPage = pages[pages.length - 1]
+                const source = this.source || currentPage.options.source
+
+                if (source === 'syr_info') {
+                    uni.$emit('address-selected-for-syr', addressItem)
+                    uni.setStorageSync('syr_selected_address', addressItem)
+                } else if (source === 'sj_info') {
+                    uni.$emit('address-selected-for-sj', addressItem)
+                    uni.setStorageSync('sj_selected_address', addressItem)
+                    if (getApp().globalData) getApp().globalData.selectedAddress = addressItem
+                } else if (prevPage) {
+                    if (prevPage.$vm && typeof prevPage.$vm.editAddress === 'function') {
+                        prevPage.$vm.editAddress(addressItem)
+                    } else {
+                        uni.$emit('address-selected', addressItem)
+                    }
+                } else {
+                    uni.$emit('address-selected', addressItem)
+                }
+
+                uni.navigateBack()
+            }
+        }
+    }
+</script>
+
+<style scoped lang="less">
+    .search-address-page {
+        flex: 1;
+        height: 100vh;
+        overflow: hidden;
+        display: flex;
+        flex-direction: column;
+        background-color: #FFFFFF;
+    }
+
+    /* 城市选择 */
+    .search-container {
+        background-color: #FFFFFF;
+        display: flex;
+        flex-direction: row;
+        align-items: center;
+        padding: 32rpx 30rpx 20rpx 30rpx;
+
+        .search-container-text {
+            font-family: PingFangSC, PingFang SC;
+            font-weight: 500;
+            font-size: 32rpx;
+            color: #333333;
+            line-height: 45rpx;
+        }
+
+        .text-img {
+            width: 20rpx;
+            height: 12rpx;
+            margin-left: 8rpx;
+            margin-right: 26rpx;
+        }
+    }
+
+    /* 地图区域 */
+    .map-container {
+        width: 750rpx;
+        position: relative;
+        overflow: hidden;
+    }
+
+    .map {
+        width: 750rpx;
+        height: 100%;
+    }
+
+    .map-snapshot {
+        position: absolute;
+        left: 0;
+        top: 0;
+        width: 750rpx;
+        height: 100%;
+        display: block;
+        z-index: 2;
+        background: #f5f5f5;
+    }
+
+    .center-marker {
+        position: absolute;
+        left: 375rpx;
+        transform: translateX(-50%);
+        top: 250rpx;
+        width: 42rpx;
+        height: 69rpx;
+        z-index: 3;
+
+        .center-marker-img {
+            width: 42rpx;
+        }
+    }
+
+    .map-snapshot {
+        width: 750rpx;
+        height: 100%;
+        display: block;
+    }
+
+    /* 底部编辑区域（用户端样式） */
+    .bottom-edit-section {
+        background-color: #FFFFFF;
+        padding: 20rpx 20rpx 0 20rpx;
+        flex: 1;
+        display: flex;
+        flex-direction: column;
+    }
+
+    .address-input-row {
+        // width: 702rpx;
+        display: flex;
+        flex-direction: column;
+        background-color: #F5F5F5;
+        border-radius: 20rpx;
+        padding: 16rpx 24rpx;
+        margin-bottom: 30rpx;
+    }
+
+    .raw-address-input {
+        width: 100%;
+        height: 120rpx;
+        font-size: 14px;
+        color: #333333;
+        background-color: transparent;
+        border-width: 0;
+        padding: 0;
+        margin: 0;
+    }
+
+    .action-buttons {
+        display: flex;
+        flex-direction: row;
+        justify-content: flex-end;
+        margin-top: 0rpx;
+    }
+
+    .action-btn {
+        margin-left: 16rpx;
+        padding: 7rpx 20rpx;
+        font-size: 24rpx;
+        border-radius: 11rpx;
+        border-width: 1rpx;
+        border-style: solid;
+        background-color: transparent;
+        align-items: center;
+        justify-content: center;
+    }
+
+    .action-btn:first-child {
+        margin-left: 0;
+    }
+
+    .btn-text {
+        font-size: 24rpx;
+        font-weight: 400;
+        line-height: 33rpx;
+    }
+
+    .paste-btn {
+        border-color: #C6C9CC;
+        color: #333333;
+    }
+
+    .smart-btn {
+        border-color: #C6C9CC;
+        color: #999999;
+    }
+
+    .smart-btn.smart-btn-active {
+        border-color: #E8101E;
+        color: #E8101E;
+    }
+
+    .address-info-panel {
+        background-color: #FFFFFF;
+        border-radius: 16rpx;
+        margin-bottom: 40rpx;
+    }
+
+    .info-row {
+        display: flex;
+        flex-direction: row;
+        align-items: center;
+        justify-content: space-between;
+        padding: 30rpx 0;
+    }
+
+    .line {
+        border-bottom: 1rpx solid #F0F0F0;
+        width: 540rpx;
+        margin-left: 150rpx;
+    }
+
+    .row-label {
+        font-size: 28rpx;
+        color: #333333;
+        font-weight: 500;
+        width: 160rpx;
+    }
+
+    .row-content {
+        flex: 1;
+        display: flex;
+        flex-direction: row;
+        align-items: center;
+        justify-content: flex-start;
+    }
+
+    .content-text {
+        font-size: 28rpx;
+        color: #333333;
+        margin-right: 12rpx;
+        flex: 1;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+    }
+
+    .placeholder {
+        color: #999999;
+        font-size: 28rpx;
+    }
+
+    .arrow-icon {
+        width: 14rpx;
+        height: 26rpx;
+        position: absolute;
+        right: 60rpx;
+    }
+
+    .detail-input {
+        flex: 1;
+        font-size: 28rpx;
+        color: #333333;
+        padding: 0;
+        border-width: 0;
+        background-color: transparent;
+        height: 60rpx;
+    }
+
+    .confirm-btn {
+        background-color: #E8101E;
+        border-radius: 49rpx;
+        height: 98rpx;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-size: 32rpx;
+        color: #FFFFFF;
+        margin-top: 40rpx;
+    }
+
+    .con-btn-text {
+        font-size: 32rpx;
+        color: #FFFFFF;
+    }
+
+    /* 弹窗基础 */
+	.popup {
+		position: fixed;
+		left: 0;
+		right: 0;
+		bottom: 0;
+		z-index: 9999;
+		visibility: hidden;
+		opacity: 0;
+		transition: all 0.3s ease;
+	}
+	.popup.show {
+		visibility: visible !important;
+		opacity: 1 !important;
+	}
+	.popup-mask {
+		position: fixed;
+		top: 0;
+		left: 0;
+		right: 0;
+		bottom: 0;
+		background-color: rgba(0, 0, 0, 0.5);
+	}
+	.popup-content {
+		position: relative;
+		background-color: #ffffff;
+		border-radius: 24rpx 24rpx 0 0;
+		padding: 32rpx;
+		transform: translateY(100%);
+		transition: transform 0.3s ease;
+		max-height: 70vh;
+	}
+	.popup.show .popup-content {
+		transform: translateY(0);
+	}
+	.popup-header {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		margin-bottom: 20rpx;
+		padding: 0 0 20rpx 0;
+		border-bottom: 1rpx solid #F0F0F0;
+	}
+	.popup-title {
+		font-size: 32rpx;
+		font-weight: 500;
+		color: #333;
+	}
+	.popup-close {
+		font-size: 40rpx;
+		color: #999;
+		padding: 10rpx;
+	}
+	.region-body {
+		height: 400rpx;
+		overflow: hidden;
+	}
+	.picker-scroll {
+		height: 400rpx;
+	}
+	.picker-item {
+		height: 68rpx;
+		line-height: 68rpx;
+		text-align: center;
+		font-size: 28rpx;
+		color: #333;
+	}
+	.popup-footer {
+		display: flex;
+		margin-top: 30rpx;
+		padding-top: 20rpx;
+		border-top: 1rpx solid #F0F0F0;
+	}
+	.popup-btn {
+		flex: 1;
+		height: 88rpx;
+		border-radius: 44rpx;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		margin: 0 16rpx;
+	}
+	.popup-btn.cancel {
+		background-color: #f5f5f5;
+	}
+	.popup-btn.confirm {
+		background: #e8101e;
+	}
+	.popup-btn .btn-text {
+		font-size: 32rpx;
+		font-weight: 500;
+	}
+	.popup-btn.cancel .btn-text {
+		color: #666666;
+	}
+	.popup-btn.confirm .btn-text {
+		color: #ffffff;
+	}
+	/* 指示器样式（沿用原有） */
+	.indicatorStyle {
+		height: 68rpx;
+	}
+</style>