HarmonyOS开发：LBS社交与附近的人

核心要点：本文深入讲解HarmonyOS平台LBS社交与"附近的人"功能的完整技术实现，涵盖GeoHash空间索引、附近用户检索、实时距离计算、社交关系链构建、隐私保护与匿名化、地图可视化展示等核心能力，构建一个完整的LBS社交应用。

一、背景与动机

1.1 LBS社交的演进与价值

LBS（Location-Based Service）社交是移动互联网时代最具变革性的产品形态之一。从Foursquare的签到革命，到微信"附近的人"引爆社交裂变，再到探探基于位置的滑动匹配，LBS社交始终是连接虚拟与现实的桥梁。

HarmonyOS作为全场景分布式操作系统，其LBS社交具有独特优势：

• 多设备协同：手机发现附近的人，手表震动提醒，车机导航到对方位置
• 精准定位：融合GPS、Wi-Fi、蓝牙、基站等多源定位，室内外无缝切换
• 低功耗常驻：系统级位置服务优化，后台持续发现附近用户不显著耗电
• 隐私优先：从系统层面保障用户位置隐私，精细化权限控制

1.2 "附近的人"技术挑战

实现一个高质量的"附近的人"功能远非"查一下附近谁在"那么简单：

• 空间检索效率：百万级用户在线时，如何毫秒级返回附近用户？
• 实时性：用户移动后附近列表如何快速更新？
• 距离精度：不同场景下距离计算策略如何选择？
• 隐私安全：如何防止位置追踪、恶意围猎？
• 冷启动：新用户首次打开如何快速展示附近的人？
• 反作弊：如何识别虚拟定位刷附近的人？

1.3 本文目标

构建一个完整的「LBS社交——附近的人」应用，实现以下核心功能：

1. 基于GeoHash的附近用户高效检索
2. 实时距离计算与排序展示
3. 用户卡片式UI与地图双视图
4. 社交关系链：打招呼、好友申请
5. 隐私保护：距离模糊化、匿名模式、黑名单

二、核心原理

2.1 LBS社交整体架构

flowchart TB
    classDef client fill:#4ECDC4,stroke:#2C3E50,color:#fff,font-weight:bold
    classDef server fill:#FF6B6B,stroke:#2C3E50,color:#fff,font-weight:bold
    classDef algorithm fill:#45B7D1,stroke:#2C3E50,color:#fff,font-weight:bold
    classDef data fill:#96CEB4,stroke:#2C3E50,color:#fff,font-weight:bold
    classDef privacy fill:#DDA0DD,stroke:#2C3E50,color:#fff,font-weight:bold

    A[用户APP]:::client --> B[Location Kit]:::client
    B --> C[位置上报]:::data
    C --> D[GeoHash编码]:::algorithm
    D --> E[LBS社交服务器]:::server

    E --> F[空间索引查询]:::algorithm
    E --> G[距离计算引擎]:::algorithm
    E --> H[隐私过滤层]:::privacy
    E --> I[反作弊检测]:::privacy

    F --> J[附近用户列表]:::data
    G --> K[精确距离排序]:::data
    H --> L[匿名化处理]:::privacy
    I --> M[虚拟定位拦截]:::privacy

    J --> N[卡片视图]:::client
    K --> N
    J --> O[地图视图]:::client
    K --> O

    P[社交关系链]:::server --> Q[打招呼]:::data
    P --> R[好友申请]:::data
    P --> S[黑名单]:::privacy

    style A fill:#FFE66D,stroke:#2C3E50,color:#2C3E50
    style E fill:#FFE66D,stroke:#2C3E50,color:#2C3E50

2.2 GeoHash空间索引原理

GeoHash是LBS社交的核心算法，它将二维经纬度编码为一维字符串，实现高效的空间检索：

编码过程：

1. 将经度区间[-180, 180]和纬度区间[-90, 90]交替二分
2. 每次二分产生0或1，经纬度交替编码
3. 每5位一组，映射为Base32字符
4. 最终生成如wx4g0s的GeoHash字符串

核心特性：

• 前缀匹配：GeoHash前缀相同意味着距离相近（反之不一定成立）
• 邻近查询：通过计算当前GeoHash及8个邻居格子，实现范围查询
• 精度可控：GeoHash长度决定精度：6位≈610m，8位≈19m

GeoHash精度对照表：
┌─────────┬────────────┬──────────────┐
│ 长度    │ 纬度误差    │ 经度误差      │
├─────────┼────────────┼──────────────┤
│ 4位     │ ±20.5km    │ ±20.5km      │
│ 5位     │ ±2.28km    │ ±2.28km      │
│ 6位     │ ±0.61km    │ ±0.61km      │
│ 7位     │ ±76m       │ ±76m         │
│ 8位     │ ±19m       │ ±19m         │
└─────────┴────────────┴──────────────┘

2.3 距离计算算法

LBS社交中常用的两种距离计算方式：

Haversine公式（球面距离，精确）：

$$d = 2R \cdot \arcsin\sqrt{\sin^2\frac{\Delta\varphi}{2} + \cos\varphi_1 \cdot \cos\varphi_2 \cdot \sin^2\frac{\Delta\lambda}{2}}$$

简化平面近似（短距离场景，高效）：

$$d \approx R \cdot \sqrt{(\Delta\varphi)^2 + (\cos\bar\varphi \cdot \Delta\lambda)^2}$$

在"附近的人"场景中，通常距离在50km以内，两种算法差异小于0.5%，简化公式性能更优。

2.4 隐私保护策略

flowchart LR
    classDef input fill:#4ECDC4,stroke:#2C3E50,color:#fff,font-weight:bold
    classDef process fill:#45B7D1,stroke:#2C3E50,color:#fff,font-weight:bold
    classDef output fill:#96CEB4,stroke:#2C3E50,color:#fff,font-weight:bold
    classDef block fill:#FF6B6B,stroke:#2C3E50,color:#fff,font-weight:bold

    A[原始位置]:::input --> B{隐私策略}:::process

    B --> C[距离模糊化]:::process
    B --> D[位置偏移]:::process
    B --> E[匿名模式]:::process
    B --> F[完全隐藏]:::block

    C --> G[显示: 500m内/1km内/3km内]:::output
    D --> H[随机偏移200-500m]:::output
    E --> I[仅显示头像 不显示距离]:::output
    F --> J[不出现在附近列表]:::output

    style A fill:#FFE66D,stroke:#2C3E50,color:#2C3E50
    style B fill:#FFE66D,stroke:#2C3E50,color:#2C3E50

三、代码实战

3.1 GeoHash编码与附近用户检索

// GeoHashUtil.ets — GeoHash编码工具类
// 实现经纬度到GeoHash的编码转换，支持附近格子查询

const BASE32_CHARS: string = '0123456789bcdefghjkmnpqrstuvwxyz'
const BASE32_MAP: Record<string, number> = {}

// 初始化Base32映射表
for (let i = 0; i < BASE32_CHARS.length; i++) {
  BASE32_MAP[BASE32_CHARS[i]] = i
}

export class GeoHashUtil {
  /**
   * 将经纬度编码为GeoHash字符串
   * @param longitude 经度 [-180, 180]
   * @param latitude  纬度 [-90, 90]
   * @param precision 精度（字符长度），默认6位≈610m
   * @returns GeoHash字符串
   */
  static encode(longitude: number, latitude: number, precision: number = 6): string {
    let hash: string = ''
    let bitCount: number = 0
    let bitBuffer: number = 0
    let lonMin: number = -180, lonMax: number = 180
    let latMin: number = -90, latMax: number = 90
    let isLongitude: boolean = true // 交替编码：经度先行

    while (hash.length < precision) {
      if (isLongitude) {
        const mid: number = (lonMin + lonMax) / 2
        if (longitude >= mid) {
          bitBuffer = bitBuffer * 2 + 1
          lonMin = mid
        } else {
          bitBuffer = bitBuffer * 2
          lonMax = mid
        }
      } else {
        const mid: number = (latMin + latMax) / 2
        if (latitude >= mid) {
          bitBuffer = bitBuffer * 2 + 1
          latMin = mid
        } else {
          bitBuffer = bitBuffer * 2
          latMax = mid
        }
      }
      isLongitude = !isLongitude
      bitCount++

      // 每5位编码为一个Base32字符
      if (bitCount === 5) {
        hash += BASE32_CHARS[bitBuffer]
        bitCount = 0
        bitBuffer = 0
      }
    }
    return hash
  }

  /**
   * 获取当前GeoHash及8个相邻格子
   * 用于范围查询，解决边界问题
   * @param geoHash 中心GeoHash
   * @returns 包含自身及8邻居的数组
   */
  static getNeighbors(geoHash: string): string[] {
    const neighbors: string[] = []
    // 解码当前格子中心点
    const decoded = GeoHashUtil.decode(geoHash)
    const latStep = decoded.latError * 2
    const lonStep = decoded.lonError * 2

    // 遍历8个方向 + 自身
    for (let dlat = -1; dlat <= 1; dlat++) {
      for (let dlon = -1; dlon <= 1; dlon++) {
        if (dlat === 0 && dlon === 0) {
          neighbors.push(geoHash) // 自身
        } else {
          const nLat = decoded.latitude + dlat * latStep
          const nLon = decoded.longitude + dlon * lonStep
          neighbors.push(GeoHashUtil.encode(nLon, nLat, geoHash.length))
        }
      }
    }
    return neighbors
  }

  /**
   * 解码GeoHash为经纬度及误差范围
   * @param geoHash GeoHash字符串
   * @returns 解码结果
   */
  static decode(geoHash: string): {
    latitude: number, longitude: number,
    latError: number, lonError: number
  } {
    let lonMin: number = -180, lonMax: number = 180
    let latMin: number = -90, latMax: number = 90
    let isLongitude: boolean = true

    for (const ch of geoHash) {
      const bits: number = BASE32_MAP[ch] ?? 0
      for (let i = 4; i >= 0; i--) {
        const bit: number = (bits >> i) & 1
        if (isLongitude) {
          const mid: number = (lonMin + lonMax) / 2
          if (bit === 1) { lonMin = mid } else { lonMax = mid }
        } else {
          const mid: number = (latMin + latMax) / 2
          if (bit === 1) { latMin = mid } else { latMax = mid }
        }
        isLongitude = !isLongitude
      }
    }
    return {
      latitude: (latMin + latMax) / 2,
      longitude: (lonMin + lonMax) / 2,
      latError: (latMax - latMin) / 2,
      lonError: (lonMax - lonMin) / 2
    }
  }
}

3.2 附近用户检索服务

// NearbyUserService.ets — 附近用户检索与距离计算服务
import { geoLocationManager } from '@kit.LocationKit'
import { http } from '@kit.NetworkKit'
import { GeoHashUtil } from './GeoHashUtil'

// 附近用户数据模型
export interface NearbyUser {
  userId: string           // 用户ID
  nickname: string         // 昵称
  avatar: string           // 头像URL
  distance: number         // 距离（米）
  displayDistance: string   // 显示距离（模糊化后）
  geoHash: string          // GeoHash编码
  latitude: number         // 纬度
  longitude: number        // 经度
  lastActiveTime: number   // 最后活跃时间戳
  isOnline: boolean        // 是否在线
  signature: string        // 个性签名
  tags: string[]           // 兴趣标签
}

// 隐私设置
export interface PrivacySettings {
  showDistance: boolean     // 是否显示精确距离
  distanceFuzzy: 'exact' | 'range' | 'hidden'  // 距离显示模式
  showOnMap: boolean       // 是否在地图上显示
  anonymousMode: boolean   // 匿名模式
  visibleRange: number     // 可见范围（米），0=不限
  positionOffset: boolean  // 位置随机偏移
}

// 搜索参数
export interface NearbySearchParams {
  radius: number           // 搜索半径（米）
  maxCount: number         // 最大返回数量
  genderFilter?: 'all' | 'male' | 'female'  // 性别过滤
  ageRange?: [number, number]  // 年龄范围
  onlineOnly: boolean      // 仅在线
}

export class NearbyUserService {
  private static instance: NearbyUserService
  private currentLocation: geoLocationManager.Location | null = null
  private currentGeoHash: string = ''
  private privacySettings: PrivacySettings = {
    showDistance: true,
    distanceFuzzy: 'range',
    showOnMap: true,
    anonymousMode: false,
    visibleRange: 5000,
    positionOffset: true
  }

  // 服务器基础地址
  private readonly BASE_URL = 'https://lbs-social.example.com/api'

  static getInstance(): NearbyUserService {
    if (!NearbyUserService.instance) {
      NearbyUserService.instance = new NearbyUserService()
    }
    return NearbyUserService.instance
  }

  /**
   * 更新当前位置并上报服务器
   * @param location 最新位置
   */
  async updateLocation(location: geoLocationManager.Location): Promise<void> {
    this.currentLocation = location

    // 应用隐私偏移
    let reportLat: number = location.latitude
    let reportLon: number = location.longitude

    if (this.privacySettings.positionOffset) {
      // 随机偏移200-500米，保护真实位置
      const offset: number = 200 + Math.random() * 300
      const angle: number = Math.random() * 2 * Math.PI
      // 1度纬度≈111km，1度经度≈111km×cos(纬度)
      reportLat += (offset * Math.cos(angle)) / 111000
      reportLon += (offset * Math.sin(angle)) / (111000 * Math.cos(reportLat * Math.PI / 180))
    }

    // 计算GeoHash（6位精度≈610m，适合"附近的人"场景）
    this.currentGeoHash = GeoHashUtil.encode(reportLon, reportLat, 6)

    // 上报位置到服务器
    await this.reportLocationToServer(reportLat, reportLon, this.currentGeoHash)
  }

  /**
   * 搜索附近用户
   * @param params 搜索参数
   * @returns 附近用户列表
   */
  async searchNearbyUsers(params: NearbySearchParams): Promise<NearbyUser[]> {
    if (!this.currentLocation) {
      throw new Error('当前位置未获取，请先更新位置')
    }

    // 计算需要查询的GeoHash格子
    const searchPrecision = this.getGeoHashPrecision(params.radius)
    const searchHash = GeoHashUtil.encode(
      this.currentLocation.longitude,
      this.currentLocation.latitude,
      searchPrecision
    )
    const neighborHashes = GeoHashUtil.getNeighbors(searchHash)

    // 构建服务端查询请求
    const request: http.HttpRequest = http.createHttp()
    const url = `${this.BASE_URL}/nearby/search`

    try {
      const response = await request.request(url, {
        method: http.RequestMethod.POST,
        header: { 'Content-Type': 'application/json' },
        extraData: JSON.stringify({
          geoHashes: neighborHashes,
          radius: params.radius,
          maxCount: params.maxCount,
          genderFilter: params.genderFilter ?? 'all',
          ageRange: params.ageRange ?? [18, 99],
          onlineOnly: params.onlineOnly,
          myLatitude: this.currentLocation.latitude,
          myLongitude: this.currentLocation.longitude,
          privacyMode: this.privacySettings.distanceFuzzy
        })
      })

      if (response.responseCode === 200) {
        const result = JSON.parse(response.result as string)
        const users: NearbyUser[] = result.data || []

        // 客户端二次距离过滤（防止GeoHash边界问题）
        return users.filter(user => {
          const dist = this.calculateDistance(
            this.currentLocation!.latitude,
            this.currentLocation!.longitude,
            user.latitude,
            user.longitude
          )
          user.distance = dist
          user.displayDistance = this.fuzzifyDistance(dist)
          return dist <= params.radius
        }).sort((a, b) => a.distance - b.distance)
      }
      return []
    } finally {
      request.destroy()
    }
  }

  /**
   * Haversine公式计算两点间球面距离
   * @param lat1 点1纬度
   * @param lon1 点1经度
   * @param lat2 点2纬度
   * @param lon2 点2经度
   * @returns 距离（米）
   */
  calculateDistance(lat1: number, lon1: number, lat2: number, lon2: number): number {
    const R = 6371000 // 地球平均半径（米）
    const dLat = (lat2 - lat1) * Math.PI / 180
    const dLon = (lon2 - lon1) * Math.PI / 180
    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
              Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
              Math.sin(dLon / 2) * Math.sin(dLon / 2)
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
    return R * c
  }

  /**
   * 距离模糊化处理——保护用户隐私
   * @param distance 精确距离（米）
   * @returns 模糊化后的显示文本
   */
  private fuzzifyDistance(distance: number): string {
    switch (this.privacySettings.distanceFuzzy) {
      case 'exact':
        // 精确显示
        if (distance < 100) {
          return `${Math.round(distance)}m`
        } else if (distance < 1000) {
          return `${(distance / 1000).toFixed(1)}km`
        }
        return `${Math.round(distance / 1000)}km`

      case 'range':
        // 区间模糊：500m内/1km内/3km内/5km内
        if (distance <= 500) return '500m内'
        if (distance <= 1000) return '1km内'
        if (distance <= 3000) return '3km内'
        return '5km内'

      case 'hidden':
        return ''

      default:
        return ''
    }
  }

  /**
   * 根据搜索半径确定GeoHash精度
   * @param radius 搜索半径（米）
   * @returns GeoHash字符长度
   */
  private getGeoHashPrecision(radius: number): number {
    if (radius <= 100) return 8   // ±19m精度
    if (radius <= 500) return 7   // ±76m精度
    if (radius <= 2000) return 6  // ±610m精度
    if (radius <= 10000) return 5 // ±2.28km精度
    return 4                       // ±20.5km精度
  }

  /**
   * 上报位置到服务器
   */
  private async reportLocationToServer(
    latitude: number, longitude: number, geoHash: string
  ): Promise<void> {
    const request = http.createHttp()
    try {
      await request.request(`${this.BASE_URL}/location/report`, {
        method: http.RequestMethod.POST,
        header: { 'Content-Type': 'application/json' },
        extraData: JSON.stringify({
          latitude, longitude, geoHash,
          timestamp: Date.now(),
          visibleRange: this.privacySettings.visibleRange,
          anonymous: this.privacySettings.anonymousMode
        })
      })
    } finally {
      request.destroy()
    }
  }

  /**
   * 更新隐私设置
   */
  updatePrivacySettings(settings: Partial<PrivacySettings>): void {
    this.privacySettings = { ...this.privacySettings, ...settings }
  }

  /**
   * 获取当前隐私设置
   */
  getPrivacySettings(): PrivacySettings {
    return { ...this.privacySettings }
  }
}

3.3 附近的人主界面——卡片与地图双视图

// NearbyPeoplePage.ets — 附近的人主页面
// 支持卡片列表视图与地图视图双模式切换
import { geoLocationManager } from '@kit.LocationKit'
import { NearbyUserService, NearbyUser, NearbySearchParams, PrivacySettings } from './NearbyUserService'
import { GeoHashUtil } from './GeoHashUtil'

@Entry
@Component
struct NearbyPeoplePage {
  // 状态管理
  @State nearbyUsers: NearbyUser[] = []
  @State isLoading: boolean = false
  @State viewMode: 'card' | 'map' = 'card'
  @State searchRadius: number = 3000
  @State onlineOnly: boolean = true
  @State showPrivacySheet: boolean = false
  @State privacySettings: PrivacySettings = {
    showDistance: true, distanceFuzzy: 'range',
    showOnMap: true, anonymousMode: false,
    visibleRange: 5000, positionOffset: true
  }
  @State errorMessage: string = ''
  @State currentGeoHash: string = ''

  private userService: NearbyUserService = NearbyUserService.getInstance()
  private refreshInterval: number = -1

  aboutToAppear(): void {
    this.requestLocationAndSearch()
    // 每30秒自动刷新附近用户
    this.refreshInterval = setInterval(() => {
      this.searchNearby()
    }, 30000)
  }

  aboutToDisappear(): void {
    if (this.refreshInterval !== -1) {
      clearInterval(this.refreshInterval)
    }
  }

  /**
   * 请求定位权限并搜索附近用户
   */
  async requestLocationAndSearch(): Promise<void> {
    try {
      this.isLoading = true
      this.errorMessage = ''

      // 请求持续定位
      const locationChange = (location: geoLocationManager.Location): void => {
        this.userService.updateLocation(location)
        this.currentGeoHash = GeoHashUtil.encode(
          location.longitude, location.latitude, 6
        )
      }

      const requestInfo: geoLocationManager.ContinuousLocationRequest =
        geoLocationManager.createContinuousLocationRequest(
          geoLocationManager.LocationRequestPriority.FIRST_FIX,
          geoLocationManager.LocationRequestScenario.UNSET
        )
      geoLocationManager.on('locationChange', requestInfo, locationChange)

      // 首次搜索
      await this.searchNearby()
    } catch (error) {
      this.errorMessage = `定位失败: ${error.message}`
    } finally {
      this.isLoading = false
    }
  }

  /**
   * 执行附近用户搜索
   */
  async searchNearby(): Promise<void> {
    try {
      const params: NearbySearchParams = {
        radius: this.searchRadius,
        maxCount: 50,
        onlineOnly: this.onlineOnly
      }
      this.nearbyUsers = await this.userService.searchNearbyUsers(params)
    } catch (error) {
      this.errorMessage = `搜索失败: ${error.message}`
    }
  }

  build() {
    Navigation() {
      Column() {
        // 顶部状态栏
        this.TopStatusBar()

        // 视图切换标签
        this.ViewModeTabs()

        // 内容区域
        if (this.errorMessage) {
          this.ErrorView()
        } else if (this.isLoading) {
          this.LoadingView()
        } else if (this.viewMode === 'card') {
          this.CardListView()
        } else {
          this.MapView()
        }
      }
      .width('100%')
      .height('100%')
      .backgroundColor('#0D1117')
    }
    .title('附近的人')
    .titleMode(NavigationTitleMode.Mini)
    .backgroundColor('#0D1117')
    .bindSheet($$this.showPrivacySheet, this.PrivacySheet(), {
      height: '70%', dragBar: true, showClose: true
    })
  }

  // ===== 顶部状态栏 =====
  @Builder
  TopStatusBar() {
    Row() {
      // 当前GeoHash指示
      Text(`📍 ${this.currentGeoHash || '定位中...'}`)
        .fontSize(12)
        .fontColor('#8B949E')
        .fontFamily('monospace')

      Blank()

      // 在线人数
      Text(`${this.nearbyUsers.filter(u => u.isOnline).length}人在线`)
        .fontSize(12)
        .fontColor('#58A6FF')

      // 隐私设置按钮
      Button() {
        Text('🛡️')
          .fontSize(18)
      }
      .width(36)
      .height(36)
      .backgroundColor('#21262D')
      .borderRadius(18)
      .onClick(() => { this.showPrivacySheet = true })
    }
    .width('100%')
    .padding({ left: 16, right: 16, top: 8, bottom: 8 })
  }

  // ===== 视图切换 =====
  @Builder
  ViewModeTabs() {
    Row() {
      ForEach([
        { mode: 'card' as const, label: '📋 卡片' },
        { mode: 'map' as const, label: '🗺️ 地图' }
      ], (item: { mode: 'card' | 'map', label: string }) => {
        Text(item.label)
          .fontSize(14)
          .fontColor(this.viewMode === item.mode ? '#FFFFFF' : '#8B949E')
          .fontWeight(this.viewMode === item.mode ? FontWeight.Bold : FontWeight.Normal)
          .padding({ left: 16, right: 16, top: 8, bottom: 8 })
          .borderRadius(8)
          .backgroundColor(this.viewMode === item.mode ? '#21262D' : 'transparent')
          .onClick(() => { this.viewMode = item.mode })
      })
    }
    .width('100%')
    .padding({ left: 16, right: 16, top: 4, bottom: 4 })
  }

  // ===== 卡片列表视图 =====
  @Builder
  CardListView() {
    List({ space: 12 }) {
      ForEach(this.nearbyUsers, (user: NearbyUser) => {
        ListItem() {
          this.UserCard(user)
        }
      }, (user: NearbyUser) => user.userId)

      // 底部搜索范围调节
      ListItem() {
        this.RadiusSlider()
      }
    }
    .width('100%')
    .layoutWeight(1)
    .padding({ left: 16, right: 16, top: 8 })
  }

  // ===== 用户卡片 =====
  @Builder
  UserCard(user: NearbyUser) {
    Row() {
      // 头像
      Image(user.avatar)
        .width(56)
        .height(56)
        .borderRadius(28)
        .borderWidth(2)
        .borderColor(user.isOnline ? '#3FB950' : '#30363D')
        .alt('https://via.placeholder.com/56')

      // 用户信息
      Column() {
        Row() {
          Text(user.nickname)
            .fontSize(16)
            .fontColor('#E6EDF3')
            .fontWeight(FontWeight.Medium)

          if (user.isOnline) {
            Text('在线')
              .fontSize(10)
              .fontColor('#3FB950')
              .backgroundColor('#1A3FB950')
              .borderRadius(4)
              .padding({ left: 4, right: 4, top: 1, bottom: 1 })
              .margin({ left: 8 })
          }
        }

        Text(user.signature)
          .fontSize(12)
          .fontColor('#8B949E')
          .maxLines(1)
          .textOverflow({ overflow: TextOverflow.Ellipsis })
          .margin({ top: 4 })

        // 兴趣标签
        Row() {
          ForEach(user.tags.slice(0, 3), (tag: string) => {
            Text(`#${tag}`)
              .fontSize(10)
              .fontColor('#58A6FF')
              .backgroundColor('#1A58A6FF')
              .borderRadius(4)
              .padding({ left: 6, right: 6, top: 2, bottom: 2 })
              .margin({ right: 4 })
          })
        }
        .margin({ top: 6 })
      }
      .layoutWeight(1)
      .alignItems(HorizontalAlign.Start)
      .margin({ left: 12 })

      // 距离与操作
      Column() {
        Text(user.displayDistance)
          .fontSize(14)
          .fontColor('#F0883E')
          .fontWeight(FontWeight.Medium)

        Button('打招呼')
          .fontSize(12)
          .fontColor('#FFFFFF')
          .backgroundColor('#238636')
          .borderRadius(14)
          .height(28)
          .padding({ left: 12, right: 12 })
          .margin({ top: 8 })
          .onClick(() => this.sendGreeting(user.userId))
      }
      .alignItems(HorizontalAlign.End)
    }
    .width('100%')
    .padding(14)
    .backgroundColor('#161B22')
    .borderRadius(12)
    .border({ width: 1, color: '#30363D' })
  }

  // ===== 地图视图 =====
  @Builder
  MapView() {
    Stack() {
      // 此处集成Map Kit组件
      // 实际项目中使用 mapComponent 组件
      Column() {
        Text('🗺️ 地图视图')
          .fontSize(18)
          .fontColor('#E6EDF3')
        Text(`展示 ${this.nearbyUsers.length} 个附近用户`)
          .fontSize(14)
          .fontColor('#8B949E')
          .margin({ top: 8 })
      }
      .width('100%')
      .height('100%')
      .justifyContent(FlexAlign.Center)
      .backgroundColor('#0D1117')

      // 地图上的用户数量浮层
      Row() {
        Text(`${this.nearbyUsers.length} 人附近`)
          .fontSize(12)
          .fontColor('#FFFFFF')
          .backgroundColor('#CC238636')
          .borderRadius(16)
          .padding({ left: 12, right: 12, top: 6, bottom: 6 })
      }
      .width('100%')
      .padding(16)
      .alignItems(VerticalAlign.Bottom)
    }
    .layoutWeight(1)
  }

  // ===== 搜索半径滑块 =====
  @Builder
  RadiusSlider() {
    Column() {
      Row() {
        Text('搜索范围')
          .fontSize(14)
          .fontColor('#8B949E')
        Blank()
        Text(this.formatRadius(this.searchRadius))
          .fontSize(14)
          .fontColor('#58A6FF')
      }
      .width('100%')

      Slider({
        value: this.searchRadius,
        min: 500,
        max: 10000,
        step: 500
      })
        .width('100%')
        .trackColor('#30363D')
        .selectedColor('#58A6FF')
        .showSteps(true)
        .onChange((value: number) => {
          this.searchRadius = value
          this.searchNearby()
        })
    }
    .width('100%')
    .padding(16)
    .backgroundColor('#161B22')
    .borderRadius(12)
  }

  // ===== 隐私设置底部弹窗 =====
  @Builder
  PrivacySheet() {
    Column() {
      Text('🛡️ 隐私设置')
        .fontSize(20)
        .fontColor('#E6EDF3')
        .fontWeight(FontWeight.Bold)
        .margin({ bottom: 20 })

      // 距离显示模式
      Column() {
        Text('距离显示')
          .fontSize(14)
          .fontColor('#8B949E')
          .margin({ bottom: 8 })

        Row() {
          ForEach([
            { mode: 'exact' as const, label: '精确' },
            { mode: 'range' as const, label: '区间' },
            { mode: 'hidden' as const, label: '隐藏' }
          ], (item: { mode: 'exact' | 'range' | 'hidden', label: string }) => {
            Button(item.label)
              .fontSize(13)
              .fontColor(this.privacySettings.distanceFuzzy === item.mode ? '#FFFFFF' : '#8B949E')
              .backgroundColor(this.privacySettings.distanceFuzzy === item.mode ? '#238636' : '#21262D')
              .borderRadius(8)
              .height(36)
              .layoutWeight(1)
              .onClick(() => {
                this.privacySettings.distanceFuzzy = item.mode
                this.userService.updatePrivacySettings({ distanceFuzzy: item.mode })
              })
          })
        }
      }
      .width('100%')
      .margin({ bottom: 20 })

      // 匿名模式开关
      Row() {
        Column() {
          Text('匿名模式')
            .fontSize(14)
            .fontColor('#E6EDF3')
          Text('仅显示头像，不显示昵称和距离')
            .fontSize(12)
            .fontColor('#8B949E')
            .margin({ top: 2 })
        }
        .alignItems(HorizontalAlign.Start)
        .layoutWeight(1)

        Toggle({ type: ToggleType.Switch, isOn: this.privacySettings.anonymousMode })
          .selectedColor('#238636')
          .onChange((isOn: boolean) => {
            this.privacySettings.anonymousMode = isOn
            this.userService.updatePrivacySettings({ anonymousMode: isOn })
          })
      }
      .width('100%')
      .margin({ bottom: 16 })

      // 位置偏移开关
      Row() {
        Column() {
          Text('位置偏移')
            .fontSize(14)
            .fontColor('#E6EDF3')
          Text('上报位置随机偏移200-500米')
            .fontSize(12)
            .fontColor('#8B949E')
            .margin({ top: 2 })
        }
        .alignItems(HorizontalAlign.Start)
        .layoutWeight(1)

        Toggle({ type: ToggleType.Switch, isOn: this.privacySettings.positionOffset })
          .selectedColor('#238636')
          .onChange((isOn: boolean) => {
            this.privacySettings.positionOffset = isOn
            this.userService.updatePrivacySettings({ positionOffset: isOn })
          })
      }
      .width('100%')
      .margin({ bottom: 16 })

      // 可见范围
      Column() {
        Row() {
          Text('可见范围')
            .fontSize(14)
            .fontColor('#8B949E')
          Blank()
          Text(this.formatRadius(this.privacySettings.visibleRange))
            .fontSize(14)
            .fontColor('#58A6FF')
        }
        Slider({
          value: this.privacySettings.visibleRange,
          min: 500,
          max: 10000,
          step: 500
        })
          .width('100%')
          .trackColor('#30363D')
          .selectedColor('#58A6FF')
          .onChange((value: number) => {
            this.privacySettings.visibleRange = value
            this.userService.updatePrivacySettings({ visibleRange: value })
          })
      }
      .width('100%')
    }
    .padding(20)
    .backgroundColor('#0D1117')
  }

  // ===== 加载视图 =====
  @Builder
  LoadingView() {
    Column() {
      LoadingProgress()
        .width(48)
        .height(48)
        .color('#58A6FF')
      Text('正在搜索附近的人...')
        .fontSize(14)
        .fontColor('#8B949E')
        .margin({ top: 16 })
    }
    .width('100%')
    .layoutWeight(1)
    .justifyContent(FlexAlign.Center)
  }

  // ===== 错误视图 =====
  @Builder
  ErrorView() {
    Column() {
      Text('⚠️')
        .fontSize(48)
      Text(this.errorMessage)
        .fontSize(14)
        .fontColor('#F85149')
        .margin({ top: 12 })
      Button('重试')
        .fontSize(14)
        .fontColor('#FFFFFF')
        .backgroundColor('#238636')
        .borderRadius(8)
        .margin({ top: 16 })
        .onClick(() => this.requestLocationAndSearch())
    }
    .width('100%')
    .layoutWeight(1)
    .justifyContent(FlexAlign.Center)
  }

  // ===== 工具方法 =====
  private formatRadius(meters: number): string {
    return meters >= 1000 ? `${meters / 1000}km` : `${meters}m`
  }

  /**
   * 发送打招呼消息
   */
  private sendGreeting(userId: string): void {
    // 实际项目中调用IM SDK发送消息
    console.info(`[LBS社交] 向用户 ${userId} 发送打招呼`)
  }
}

3.4 社交关系链与打招呼

// SocialRelationService.ets — 社交关系链管理服务
import { http } from '@kit.NetworkKit'
import { notificationManager } from '@kit.NotificationKit'

// 关系类型
export type RelationType = 'stranger' | 'acquaintance' | 'friend' | 'blocked'

// 社交关系
export interface SocialRelation {
  targetUserId: string
  relationType: RelationType
  greetingCount: number       // 打招呼次数
  lastGreetingTime: number    // 最后打招呼时间
  isMutual: boolean           // 是否互相关注
  note: string                // 好友备注
}

// 打招呼消息
export interface GreetingMessage {
  fromUserId: string
  toUserId: string
  content: string
  timestamp: number
  locationShared: boolean     // 是否附带位置
  latitude?: number
  longitude?: number
}

export class SocialRelationService {
  private static instance: SocialRelationService
  private readonly BASE_URL = 'https://lbs-social.example.com/api/social'

  // 本地缓存关系数据
  private relations: Map<string, SocialRelation> = new Map()

  // 打招呼冷却时间（毫秒），防止骚扰
  private readonly GREETING_COOLDOWN = 60000 // 1分钟

  static getInstance(): SocialRelationService {
    if (!SocialRelationService.instance) {
      SocialRelationService.instance = new SocialRelationService()
    }
    return SocialRelationService.instance
  }

  /**
   * 发送打招呼
   * @param toUserId 目标用户ID
   * @param content 打招呼内容
   * @param shareLocation 是否分享位置
   */
  async sendGreeting(
    toUserId: string,
    content: string,
    shareLocation: boolean = false
  ): Promise<boolean> {
    // 检查是否被拉黑
    const relation = this.relations.get(toUserId)
    if (relation?.relationType === 'blocked') {
      console.warn('[LBS社交] 无法向已拉黑用户发送招呼')
      return false
    }

    // 检查冷却时间
    if (relation && relation.lastGreetingTime > 0) {
      const elapsed = Date.now() - relation.lastGreetingTime
      if (elapsed < this.GREETING_COOLDOWN) {
        const remaining = Math.ceil((this.GREETING_COOLDOWN - elapsed) / 1000)
        console.warn(`[LBS社交] 打招呼冷却中，还需等待${remaining}秒`)
        return false
      }
    }

    // 构建消息
    const message: GreetingMessage = {
      fromUserId: 'current_user_id', // 实际项目中从账户系统获取
      toUserId,
      content,
      timestamp: Date.now(),
      locationShared: shareLocation
    }

    // 发送到服务器
    const request = http.createHttp()
    try {
      const response = await request.request(`${this.BASE_URL}/greeting/send`, {
        method: http.RequestMethod.POST,
        header: { 'Content-Type': 'application/json' },
        extraData: JSON.stringify(message)
      })

      if (response.responseCode === 200) {
        // 更新本地关系缓存
        this.updateLocalRelation(toUserId, {
          greetingCount: (relation?.greetingCount ?? 0) + 1,
          lastGreetingTime: Date.now()
        })
        return true
      }
      return false
    } finally {
      request.destroy()
    }
  }

  /**
   * 发送好友申请
   * @param toUserId 目标用户ID
   * @param message 申请消息
   */
  async sendFriendRequest(toUserId: string, message: string): Promise<boolean> {
    const request = http.createHttp()
    try {
      const response = await request.request(`${this.BASE_URL}/friend/request`, {
        method: http.RequestMethod.POST,
        header: { 'Content-Type': 'application/json' },
        extraData: JSON.stringify({
          toUserId,
          message,
          source: 'nearby',  // 来源：附近的人
          timestamp: Date.now()
        })
      })
      return response.responseCode === 200
    } finally {
      request.destroy()
    }
  }

  /**
   * 拉黑用户
   * @param userId 被拉黑用户ID
   */
  async blockUser(userId: string): Promise<boolean> {
    const request = http.createHttp()
    try {
      const response = await request.request(`${this.BASE_URL}/block`, {
        method: http.RequestMethod.POST,
        header: { 'Content-Type': 'application/json' },
        extraData: JSON.stringify({ targetUserId: userId })
      })

      if (response.responseCode === 200) {
        this.updateLocalRelation(userId, { relationType: 'blocked' })
        return true
      }
      return false
    } finally {
      request.destroy()
    }
  }

  /**
   * 获取与某用户的关系
   */
  getRelation(userId: string): SocialRelation | undefined {
    return this.relations.get(userId)
  }

  /**
   * 更新本地关系缓存
   */
  private updateLocalRelation(
    userId: string,
    updates: Partial<SocialRelation>
  ): void {
    const existing = this.relations.get(userId) ?? {
      targetUserId: userId,
      relationType: 'stranger' as RelationType,
      greetingCount: 0,
      lastGreetingTime: 0,
      isMutual: false,
      note: ''
    }
    this.relations.set(userId, { ...existing, ...updates })
  }
}

四、踩坑与注意事项

4.1 GeoHash边界问题

问题：两个用户物理距离很近，但分属不同GeoHash格子，导致搜索不到。

解决方案：始终查询当前格子及8个邻居格子（共9个），确保边界覆盖。

// ❌ 错误：只查当前格子
const users = await queryByGeoHash(currentGeoHash)

// ✅ 正确：查当前格子 + 8个邻居
const neighborHashes = GeoHashUtil.getNeighbors(currentGeoHash)
const users = await queryByGeoHashes(neighborHashes)

4.2 位置上报频率与电量

问题：高频位置上报导致电量快速消耗。

策略：

• 静止时降低上报频率（5分钟一次）
• 移动时动态调整（移动速度越快，上报越频繁）
• 使用LocationRequestScenario.NAVIGATION场景自动优化

// 根据移动速度动态调整上报间隔
function getOptimalInterval(speed: number): number {
  if (speed < 1) return 300000       // 静止：5分钟
  if (speed < 5) return 60000        // 步行：1分钟
  if (speed < 20) return 30000       // 骑行：30秒
  return 10000                        // 驾车：10秒
}

4.3 虚拟定位反作弊

问题：用户使用虚拟定位软件伪造位置，在"附近的人"中刷排名。

检测策略：

1. 位置跳变检测：两次上报位置距离超过合理移动速度
2. 定位源验证：检查locationSource是否为系统可信源
3. 多源交叉验证：对比GPS、Wi-Fi、基站定位结果
4. 设备指纹：检测模拟器、Root、Hook框架

// 位置跳变检测
function isLocationSpoofed(
  prevLocation: geoLocationManager.Location,
  currentLocation: geoLocationManager.Location
): boolean {
  const timeDiff = (currentLocation.timestamp - prevLocation.timestamp) / 1000 // 秒
  const distDiff = calculateDistance(
    prevLocation.latitude, prevLocation.longitude,
    currentLocation.latitude, currentLocation.longitude
  )
  // 合理最大速度：高铁350km/h ≈ 97m/s，加50%容差
  const maxReasonableSpeed = 150 // m/s
  const actualSpeed = distDiff / timeDiff

  return actualSpeed > maxReasonableSpeed
}

4.4 隐私合规要点

4.5 性能优化清单

• 服务端：GeoHash前缀索引 + Redis缓存热点区域用户列表
• 客户端：分页加载，首屏20人，滚动加载更多
• 增量更新：位置变化较小时只更新距离排序，不全量刷新
• 预加载：打开页面前后台预热位置和GeoHash
• 去抖动：搜索半径滑块拖动时300ms去抖，避免频繁请求

五、HarmonyOS 6适配

5.1 分布式位置服务

HarmonyOS 6增强了分布式位置能力，支持跨设备位置协同：

// HarmonyOS 6：跨设备位置协同
// 手机发现附近的人，手表接收提醒
import { distributedDeviceManager } from '@kit.DistributedServiceKit'

// 监听分布式设备连接
const deviceManager = distributedDeviceManager.createDeviceManager('com.example.lbs')

deviceManager.on('deviceStateChange', (data) => {
  if (data.action === distributedDeviceManager.DeviceStateChange.AVAILABLE) {
    // 新设备上线，同步附近的人数据
    syncNearbyDataToDevice(data.device.id)
  }
})

// 将附近用户数据推送到手表
async function syncNearbyDataToDevice(deviceId: string): Promise<void> {
  const nearbySummary = {
    totalCount: nearbyUsers.length,
    onlineCount: nearbyUsers.filter(u => u.isOnline).length,
    nearestDistance: nearbyUsers[0]?.displayDistance ?? '无'
  }
  // 通过分布式数据同步到手表
  await distributedDataObject.setSessionId(deviceId)
  distributedDataObject.nearbySummary = JSON.stringify(nearbySummary)
}

5.2 后台位置常驻优化

HarmonyOS 6对后台位置服务进行了长续航优化：

// HarmonyOS 6：后台位置常驻（Low Power模式）
import { backgroundTaskManager } from '@kit.BackgroundTasksKit'

// 申请长时任务，保证后台持续定位
const bgMode: backgroundTaskManager.BackgroundMode =
  backgroundTaskManager.BackgroundMode.LOCATION

backgroundTaskManager.requestEnableBackgroundTask({
  bgMode,
  wantAgent: wantAgentObj
})

// 使用低功耗定位场景
const lowPowerRequest: geoLocationManager.ContinuousLocationRequest =
  geoLocationManager.createContinuousLocationRequest(
    geoLocationManager.LocationRequestPriority.LOW_POWER,  // 低功耗优先
    geoLocationManager.LocationRequestScenario.UNSET
  )

// 设置位置变化阈值，减少无效上报
lowPowerRequest.locationChangeThreshold = 50 // 移动50米才触发回调

5.3 AI辅助社交匹配

HarmonyOS 6的MindSpore Lite端侧AI能力，可实现本地化社交匹配：

// HarmonyOS 6：端侧AI兴趣匹配
import { common } from '@kit.AbilityKit'

// 基于用户画像的附近人排序优化
// 将兴趣标签转为向量，计算余弦相似度
function calculateInterestSimilarity(myTags: string[], otherTags: string[]): number {
  const allTags = [...new Set([...myTags, ...otherTags])]
  const myVector = allTags.map(tag => myTags.includes(tag) ? 1 : 0)
  const otherVector = allTags.map(tag => otherTags.includes(tag) ? 1 : 0)

  const dotProduct = myVector.reduce((sum, v, i) => sum + v * otherVector[i], 0)
  const myMagnitude = Math.sqrt(myVector.reduce((sum, v) => sum + v * v, 0))
  const otherMagnitude = Math.sqrt(otherVector.reduce((sum, v) => sum + v * v, 0))

  if (myMagnitude === 0 || otherMagnitude === 0) return 0
  return dotProduct / (myMagnitude * otherMagnitude)
}

六、总结

6.1 技术架构回顾

本文构建了一个完整的LBS社交"附近的人"应用，核心技术栈如下：

6.2 关键设计决策

1. GeoHash精度选择：6位（≈610m）是"附近的人"最佳平衡点，太粗会返回过多无关用户，太细会增加格子数量
2. 距离模糊化：默认使用区间模式（500m内/1km内/3km内），兼顾社交体验和隐私保护
3. 位置偏移：上报位置随机偏移200-500米，在保证附近检索有效性的同时保护真实位置
4. 冷却机制：打招呼1分钟冷却，防止骚扰和刷屏

6.3 扩展方向

• 兴趣匹配排序：结合用户画像，优先展示兴趣相近的附近用户
• 轨迹交叉发现：分析历史轨迹，发现"经常擦肩而过"的人
• 场景化推荐：咖啡厅推荐咖啡爱好者，健身房推荐运动达人
• 群组发现：附近3人以上同兴趣自动推荐加入群聊
• AR实景社交：通过相机叠加附近用户信息，增强现实社交体验

📌 一句话总结：LBS社交的核心是GeoHash空间索引+Haversine距离计算+隐私保护三驾马车，技术实现不难，难的是在社交体验与隐私安全之间找到最佳平衡点。