LocalMapManager提供了完整的离线地图下载、管理和状态监控功能。通过这个类，你可以轻松实现城市离线地图的下载、暂停、恢复、删除等操作。

import { LocalMapManager } from '@bdmap/map/src/main/ets/lbsmapsdk/feature/localmap/LocalMapManager';
import { LocalMapListener } from '@bdmap/map/src/main/ets/lbsmapsdk/feature/localmap/LocalMapListener';
import { LocalMapConstants } from '@bdmap/map/src/main/ets/lbsmapsdk/feature/localmap/constants/LocalMapConstants';

// 1. 获取单例实例
const localMapManager = LocalMapManager.getInstance();

// 2. 在地图初始化完成后初始化离线地图模块
// 注意：必须在MapController准备好后调用
const success = localMapManager.init(mapController);
if (success) {
  console.log('离线地图模块初始化成功');
}

// 创建事件监听器
const mapListener: LocalMapListener = {
  onGetLocalMapState: (type: number, param: number) => {
    console.log(`离线地图事件: type=${type}, param=${param}`);
    
    switch (type) {
      case LocalMapConstants.MESSAGE_START_DOWNLOAD:
        console.log('开始下载');
        break;
        
      case LocalMapConstants.MESSAGE_DOWNLOAD_PROGRESS:
        // 解析下载进度参数
        const cityId = param >> 8;      // 右移8位获取城市ID
        const progress = param & 0xFF;  // 取低8位获取进度
        console.log(`城市 ${cityId} 下载进度: ${progress}%`);
        break;
        
      case LocalMapConstants.MESSAGE_DOWNLOAD_FINISHED:
        console.log('下载完成');
        // 下载完成后建议导入地图
        localMapManager.importMap(true, false);
        break;
        
      case LocalMapConstants.MESSAGE_NETWORK_ERROR:
        console.log('网络错误，下载中断');
        break;
    }
  }
};

// 注册监听器
localMapManager.registerListener(mapListener);

// 获取热门城市（适合在首页展示）
async function loadHotCities() {
  try {
    const cities = await localMapManager.getHotCities();
    if (cities && cities.length > 0) {
      console.log(`获取到 ${cities.length} 个热门城市`);
      cities.forEach(city => {
        console.log(`${city.name} - 大小: ${formatSize(city.mapsize + city.searchsize)}`);
      });
    }
  } catch (error) {
    console.error('获取热门城市失败:', error);
  }
}

// 辅助函数：格式化文件大小
function formatSize(size: number): string {
  if (size < 1024 * 1024) {
    return `${Math.floor(size / 1024)}K`;
  } else if (size < 1024 * 1024 * 1024) {
    return `${(size / (1024 * 1024.0)).toFixed(1)}M`;
  } else {
    return `${(size / (1024 * 1024 * 1024.0)).toFixed(1)}G`;
  }
}

// 根据关键词搜索城市
function searchCities(keyword: string) {
  if (!keyword.trim()) {
    return [];
  }
  
  const results = localMapManager.getCitiesByName(keyword);
  if (results && results.length > 0) {
    console.log(`搜索"${keyword}"找到 ${results.length} 个城市`);
    return results;
  }
  
  console.log(`未找到包含"${keyword}"的城市`);
  return [];
}

// 获取用户所有下载记录
async function getUserDownloadList() {
  try {
    const resources = await localMapManager.getUserResources();
    if (resources && resources.length > 0) {
      // 分类整理下载记录
      const downloadingCities = resources.filter(city => 
        LocalMapResourceUtils.isDownloading(city) || 
        LocalMapResourceUtils.isWaiting(city) ||
        LocalMapResourceUtils.isStoped(city)
      );
      
      const downloadedCities = resources.filter(city => 
        LocalMapResourceUtils.isFinished(city)
      );
      
      console.log(`下载中: ${downloadingCities.length} 个城市`);
      console.log(`已完成: ${downloadedCities.length} 个城市`);
      
      return { downloadingCities, downloadedCities };
    }
  } catch (error) {
    console.error('获取下载记录失败:', error);
  }
  
  return { downloadingCities: [], downloadedCities: [] };
}

// 下载单个城市（带重复检查）
function downloadCity(
  city: LocalMapResource,
  downloadingList: LocalMapResource[],
  downloadedList: LocalMapResource[]
) {
  // 防重复下载检查
  const isAlreadyDownloaded = downloadedList.some(item => item.id === city.id);
  const isDownloading = downloadingList.some(item => item.id === city.id);
  
  if (isAlreadyDownloaded) {
    console.log(`${city.name} 已经下载完成，无需重复下载`);
    return false;
  }
  
  if (isDownloading) {
    console.log(`${city.name} 正在下载中，请勿重复操作`);
    return false;
  }
  
  // 开始下载
  const success = localMapManager.start(city.id);
  if (success) {
    console.log(`开始下载 ${city.name}`);
  } else {
    console.log(`下载失败 ${city.name}`);
  }
  
  return success;
}

// 暂停指定城市下载
function pauseCity(cityId: number) {
  const success = localMapManager.pause(cityId);
  if (success) {
    console.log(`已暂停城市 ${cityId} 的下载`);
  }
  return success;
}

// 恢复指定城市下载
function resumeCity(cityId: number) {
  const success = localMapManager.resume(cityId);
  if (success) {
    console.log(`已恢复城市 ${cityId} 的下载`);
  }
  return success;
}

// 批量暂停所有下载
function pauseAllDownloads() {
  const success = localMapManager.pauseAll(0); // 0表示批量暂停
  if (success) {
    console.log('已暂停所有下载任务');
  }
  return success;
}

// 批量恢复所有下载
function resumeAllDownloads() {
  const success = localMapManager.resumeAll(0); // 0表示下载
  if (success) {
    console.log('已恢复所有下载任务');
  }
  return success;
}

// 删除指定城市
function deleteCity(cityId: number) {
  const success = localMapManager.delete(cityId);
  if (success) {
    console.log(`已删除城市 ${cityId}`);
  }
  return success;
}

// 删除所有下载任务
function deleteAllCities() {
  const success = localMapManager.deleteAll();
  if (success) {
    console.log('已删除所有城市离线地图');
  }
  return success;
}

import { LocalMapResourceUtils } from '@bdmap/map/src/main/ets/lbsmapsdk/feature/localmap/utils/LocalMapResourceUtils';

function getCityStatus(city: LocalMapResource): string {
  if (LocalMapResourceUtils.isWaiting(city)) {
    return '等待下载';
  } else if (LocalMapResourceUtils.isDownloading(city)) {
    return `下载中 ${city.downloadProgress}%`;
  } else if (LocalMapResourceUtils.isStoped(city)) {
    return '已暂停';
  } else if (LocalMapResourceUtils.isFinished(city)) {
    return '下载完成';
  } else if (LocalMapResourceUtils.isNeedUpdate(city)) {
    return '需要更新';
  } else {
    return '未下载';
  }
}

// 检查是否可以执行特定操作
function canResumeDownload(city: LocalMapResource): boolean {
  return LocalMapResourceUtils.isCanResume(city);
}

function needsUpdate(city: LocalMapResource): boolean {
  return LocalMapResourceUtils.isNeedUpdate(city);
}

// 推荐的状态刷新策略
class OfflineMapManager {
  private refreshTimer: number = -1;
  
  // 启动定时刷新（仅在有下载任务时）
  startAutoRefresh(downloadingCities: LocalMapResource[]) {
    if (this.refreshTimer !== -1) {
      clearInterval(this.refreshTimer);
    }
    
    this.refreshTimer = setInterval(async () => {
      if (downloadingCities.length > 0) {
        await this.refreshUserResources();
      }
    }, 2000); // 每2秒刷新一次
  }
  
  // 停止自动刷新
  stopAutoRefresh() {
    if (this.refreshTimer !== -1) {
      clearInterval(this.refreshTimer);
      this.refreshTimer = -1;
    }
  }
  
  // 刷新用户资源
  async refreshUserResources() {
    const { downloadingCities, downloadedCities } = await getUserDownloadList();
    // 更新UI状态
    // ...
  }
}

// 导入离线地图包
function importOfflineMap() {
  // 参数1: 是否删除导入失败的包
  // 参数2: 是否离线导入
  const success = localMapManager.importMap(true, false);
  if (success) {
    console.log('开始导入离线地图');
  }
  return success;
}

// 更新指定城市
function updateCity(cityId: number) {
  const success = localMapManager.update(cityId);
  if (success) {
    console.log(`开始更新城市 ${cityId}`);
  }
  return success;
}

// 批量更新所有城市
function updateAllCities() {
  const success = localMapManager.updateAll();
  if (success) {
    console.log('开始更新所有城市');
  }
  return success;
}

// 在WiFi环境下自动下载路网信息（提升路况加载速度）
function autoDownloadRoadNetwork(cityId: number) {
  const result = localMapManager.autoDownloadRoadNetworkViaWifi(cityId);
  if (result > 0) {
    console.log(`城市 ${cityId} 路网信息下载请求已提交`);
  }
  return result;
}

// 组件销毁时的清理工作
function cleanup() {
  // 1. 移除事件监听器
  localMapManager.removeListener(mapListener);
  
  // 2. 销毁离线地图模块
  localMapManager.destroy();
  
  // 3. 清理定时器
  if (refreshTimer !== -1) {
    clearInterval(refreshTimer);
  }
  
  console.log('离线地图资源已清理');
}

// 错误：地图未准备好就初始化
const manager = LocalMapManager.getInstance();
manager.init(null); // 会返回false

// 正确：等待地图初始化完成
MapComponent({
  onReady: (err, map: MapController) => {
    if (map) {
      const success = manager.init(map);
      // 现在可以安全使用离线地图功能
    }
  }
});

// 推荐做法：在组件生命周期中管理监听器
aboutToAppear() {
  localMapManager.registerListener(this.mapListener);
}

aboutToDisappear() {
  localMapManager.removeListener(this.mapListener);
  localMapManager.destroy();
}

// 正确处理异步方法
async function loadCities() {
  try {
    const cities = await localMapManager.getHotCities();
    // 处理结果
  } catch (error) {
    console.error('加载失败:', error);
    // 错误处理
  }
}