更新记录

1.0.26（2026-11-11）

• 优化说明文档，补齐“作者系列 UTS 插件”清单及插件市场链接，便于按能力查找。

1.0.25（2026-11-03）

• 新增按“媒体、相册、处理、输出、管理”组织的双宿主演示 Tabs，支持进入指定相册、切换来源与时间筛选、填写自己的上传地址，并明确区分上传演练与实际上传。
• 修复示例加载末页覆盖已加载媒体、图片或视频续页切换为混合查询、查询与选择切换后旧回调覆盖新结果的问题。
• 修复普通监听参数、重复启动和离页后迟到监听释放，补齐预览、缓存清理与自检的请求归属；保存当前文件只使用已准备的原图或视频，基础自检始终只做上传演练。
• 修复 HarmonyOS 缓存清理的秒与毫秒及年龄语义，全部缓存清理同步覆盖插件专属持久游标；分页、缩略图和上传缺省参数与 Android、iOS 对齐。
• 修复示例页面和辅助模块使用相对引入路径的问题，统一通过 @/uni_modules/ 引用插件内文件，复制页面到其他目录时无需另行复制辅助代码。
• 整理使用说明和真实平台边界；本次 HarmonyOS 原生实现变更需要重新制作并安装匹配的自定义基座或 HAP。Android、iOS 本次仅更新示例与说明，无需因本轮改动重制原生基座。

1.0.24（2026-10-17）

• 修复微信和支付宝小程序编译时误加载 HarmonyOS 原生 ETS 文件，避免 HBuilderX 5.24 报 GalleryHarmonyTypes.ets 语法错误。
• 小程序继续返回明确的暂不支持错误，不改变 Android、iOS、HarmonyOS 的相册 API 和调用方式。

平台兼容性

uni-app(5.07)

uni-app x(5.07)

lizhao-gallery-pro

为 uni-app / uni-app x 提供用户授权范围内的系统相册图片、视频读取、缩略图、文件准备、上传、保存、元数据和变化查询。

功能特色

适合哪些场景

下载与导入

从基础到进阶

基础功能配置示例（简单示例）

用途：申请权限并读取第一批媒体；前置：已导入插件，App 使用包含本插件原生能力和权限声明的自定义基座或正式安装包。宿主：uni-app（Vue2/Vue3）；触发：在用户点击事件中调用 readFirstGalleryPage()，无需额外初始化接口。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function readFirstGalleryPage() {
  const capabilities = GalleryPro.getGalleryCapabilities()
  const nativePlatform = capabilities.platform === 'app-android' ||
    capabilities.platform === 'app-ios' || capabilities.platform === 'app-harmony'
  if (!nativePlatform) {
    console.log('当前平台不支持系统相册操作', capabilities.platform, capabilities.message)
    return
  }

  GalleryPro.requestGalleryPermission({
    // all 请求图片和视频范围；只需要图片时可使用 image。
    mediaType: 'all',
    // 兼容保留参数；当前不会据此扩大用户授予的系统访问范围。
    preferFullAccess: false,
    success(permission) {
      console.log('授权结果', permission.status, permission.mediaType, permission.platform)
      console.log('权限说明', permission.message)
      if (!permission.granted) {
        console.log('是否需要前往设置', permission.shouldOpenSettings)
        return
      }
      // HarmonyOS 的能力布尔值受当前授权影响，授权后重新读取。
      const authorizedCapabilities = GalleryPro.getGalleryCapabilities()
      if (!authorizedCapabilities.mixed) {
        console.log('当前读取能力尚未就绪', authorizedCapabilities.message)
        return
      }
      if (permission.limited) {
        console.log('本次只读取系统允许访问的部分媒体')
      }

      GalleryPro.getGalleryMedia({
        mediaType: 'all',
        pageSize: 30,               // 每页 30 条；可填写 1～200。
        pageToken: '',              // 首次查询不使用旧的下一页令牌。
        thumbnailMode: 'none',      // 最小流程先取列表，不等待缩略图。
        success(result) {
          console.log('查询结果', result.success, result.platform, result.mediaType)
          console.log('可见总数与说明', result.total, result.message)
          result.items.forEach(item => {
            console.log('媒体入口', item.id, item.mediaType, item.fileName)
          })
          console.log('下一页', result.hasMore, result.nextPageToken)
        },
        fail(error) {
          // 不把权限或读取失败显示成“相册为空”。
          console.log('读取失败', error.errSubject, error.errCode, error.errMsg)
        },
        complete(result) {
          // 这里表示本次列表动作结束，不代表整个相册已读完。
          console.log('列表动作结束', result)
        }
      })
    },
    fail(error) {
      console.log('申请权限失败', error.errCode, error.errMsg)
    },
    complete(result) {
      // 权限动作结束不等于嵌套的列表动作结束。
      console.log('权限动作结束', result)
    }
  })
}

高级示例

检查权限，按相册、时间和来源筛选

用途：读取最近七天指定来源的媒体；前置：已有相册读取授权。宿主：uni-app；触发：点击筛选按钮调用 readRecentCameraAlbum()，先取得真实相册 ID，再查询该相册。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

/** @param {import('@/uni_modules/lizhao-gallery-pro').GalleryMediaItem} item */
function printMediaItem(item) {
  // 尺寸是像素，size 是字节；视频时长和两个时间字段均为毫秒。
  console.log('身份与格式', item.id, item.mediaType, item.fileName, item.mimeType)
  console.log('尺寸、时长与大小', item.width, item.height, item.durationMs, item.size)
  console.log('创建与修改时间', item.createTime, item.modifiedTime)
  console.log('相册与来源', item.albumId, item.albumName, item.sourceType, item.sourceLabel)
  // 以下是列表原始返回值；资产标识不保证可直接渲染或上传。
  console.log('列表路径', item.originalPath, item.renderPath, item.uploadPath)
  console.log('缩略图与导出要求', item.thumbnailPath, item.requiresExport)
}

export function readRecentCameraAlbum() {
  GalleryPro.checkGalleryPermission({
    mediaType: 'all',
    preferFullAccess: true, // 当前不改变系统授权范围；不能借此绕过 limited。
    success(permission) {
      if (!permission.granted) {
        console.log('请先授权', permission.status, permission.shouldOpenSettings)
        return
      }
      GalleryPro.getGalleryAlbums({
        mediaType: 'all',
        sourceType: 'camera',
        includeCoverThumbnail: false,
        success(groups) {
          if (groups.albums.length === 0) {
            console.log('当前授权范围内没有匹配相册')
            return
          }
          const album = groups.albums[0]
          // 同一轮分页须复用这组筛选值；改变筛选后从空 pageToken 重新开始。
          const endTime = Date.now()
          const startTime = endTime - 7 * 24 * 60 * 60 * 1000
          GalleryPro.getGalleryMedia({
            mediaType: 'all',
            pageSize: 30,
            pageToken: '',
            startTime: startTime,
            endTime: endTime,
            albumId: album.albumId,
            sourceType: 'camera',
            sortOrder: 'asc',       // 从较早的媒体开始；默认 desc。
            includeHidden: true,   // 只表达偏好，仍受系统可见范围限制。
            includeThumbnail: true,// 未设置 thumbnailMode 时等价于 sync。
            thumbnailWidth: 320,
            thumbnailHeight: 180,
            success(result) {
              result.items.forEach(printMediaItem)
              console.log('继续分页所需结果', result.hasMore, result.nextPageToken)
            },
            fail(error) {
              console.log('筛选失败', error.errCode, error.errMsg)
            },
            complete(result) {
              console.log('筛选结束', result)
            }
          })
        },
        fail(error) {
          console.log('相册分组失败', error.errCode, error.errMsg)
        },
        complete(result) {
          console.log('相册分组动作结束', result)
        }
      })
    },
    fail(error) {
      console.log('权限检查失败', error.errCode, error.errMsg)
    },
    complete(result) {
      console.log('权限检查动作结束', result)
    }
  })
}

先显示当前页，再分批补缩略图

用途：媒体列表先出现、图片随后补齐；前置：已有图片读取授权。宿主：uni-app；触发：在列表加载事件中调用 readProgressiveImages()。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function readProgressiveImages() {
  GalleryPro.getGalleryImages({
    pageSize: 30,
    includeThumbnail: false,       // 显式 thumbnailMode 优先于此兼容开关。
    thumbnailMode: 'progressive',  // none 不生成；sync 在列表返回前生成。
    thumbnailBatchSize: 4,         // 默认 4，每批允许 1～20 个。
    thumbnailWidth: 320,           // 请求物理像素尺寸，按实际显示区域选择。
    thumbnailHeight: 320,
    success(result) {
      console.log('先渲染当前页', result.items)
    },
    thumbnailProgress(event) {
      console.log('当前页处理量', event.current, event.total, event.done, event.message)
      event.items.forEach(thumbnail => {
        if (thumbnail.thumbnailPath !== '') {
          // 实际页面按 id 更新这一项，不替换为另一页的缩略图。
          console.log('补图', thumbnail.id, thumbnail.thumbnailPath)
        }
        console.log('实际尺寸与说明', thumbnail.width, thumbnail.height, thumbnail.message)
      })
    },
    fail(error) {
      console.log('列表读取失败', error.errCode, error.errMsg)
    },
    complete(result) {
      // 渐进模式在当前页缩略图处理结束后才 complete。
      // done 表示已处理完，不保证每个媒体都能生成缩略图。
      console.log('本页列表及渐进处理结束', result)
    }
  })
}

为选中媒体单独生成缩略图

用途：生成列表小图或 2:1 图片的预览缩略图；前置：参数 ids 来自当前授权列表，不使用自造 ID。宿主：uni-app；触发：选中媒体后调用 createSelectedThumbnails(ids)。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function createSelectedThumbnails(ids) {
  if (ids.length === 0) return
  GalleryPro.getGalleryThumbnails({
    ids: ids,
    width: 800,
    height: 400,
    // quality 只在 HarmonyOS 调节 JPEG 质量，范围 1～100，默认 85。
    // Android/iOS 当前使用各自固定编码质量，不读取此参数。
    quality: 85,
    success(result) {
      console.log('缩略图结果', result.success, result.message)
      result.items.forEach(item => {
        console.log(item.id, item.thumbnailPath, item.width, item.height, item.message)
      })
    },
    fail(error) {
      console.log('缩略图失败', error.errCode, error.errMsg)
    },
    complete(result) {
      console.log('缩略图动作结束', result)
    }
  })
}

按 ID 重新读取单个媒体

用途：打开详情前确认媒体仍可访问；前置：id 来自列表结果。宿主：uni-app；触发：点击列表项时调用 readSelectedMedia(id)。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function readSelectedMedia(id) {
  GalleryPro.getMediaById({
    id: id,
    includeThumbnail: true, // 默认 false；这里同时取小图供详情页占位。
    success(result) {
      console.log('单媒体结果', result.success, result.message)
      console.log('当前媒体', result.item.id, result.item.thumbnailPath)
    },
    fail(error) {
      // 媒体删除或授权范围变化后，旧 id 可能失效。
      console.log('媒体暂不可访问', error.errCode, error.errMsg)
    },
    complete(result) {
      console.log('单媒体动作结束', result)
    }
  })
}

一次准备预览、上传与 poster

用途：用户选中后再准备可用文件；前置：id 来自当前授权列表。宿主：uni-app；触发：调用 prepareSelectedMedia(id)，将结果赋给页面自己的数据。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function prepareSelectedMedia(id) {
  GalleryPro.prepareGalleryMedia({
    id: id,
    includePoster: true, // 默认 true；仅需上传时可关闭，见模块化示例。
    posterWidth: 640,    // 默认 320，单位像素。
    posterHeight: 360,
    success(result) {
      console.log('准备结果', result.success, result.id, result.mediaType, result.message)
      console.log('页面 image/video 的 src', result.renderPath)
      console.log('uni.uploadFile 的 filePath', result.uploadPath)
      console.log('image 占位或 video 的 poster', result.posterPath)
      console.log('文件字节数与导出缓存命中', result.size, result.cacheHit)
    },
    fail(error) {
      console.log('文件准备失败', error.errCode, error.errMsg)
    },
    complete(result) {
      console.log('文件准备结束', result)
    }
  })
}

按用途导出独立临时文件

用途：详情、编辑或业务上传需要普通文件；前置：id 来自列表。宿主：uni-app；触发：调用 exportSelectedOriginal(id)，从真实媒体信息取得文件名。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function exportSelectedOriginal(id) {
  GalleryPro.getMediaById({
    id: id,
    includeThumbnail: false,
    success(media) {
      GalleryPro.exportMediaToTempFile({
        id: media.item.id,
        // render / upload / original 表达用途，均返回同一文件的两种可用路径。
        exportType: 'original',
        // 可填写自己的文件名；这里沿用媒体名，不把文件名当作目标目录。
        fileName: media.item.fileName,
        success(result) {
          console.log('导出结果', result.success, result.id, result.message)
          console.log('预览与上传路径', result.renderPath, result.uploadPath)
          console.log('字节数与缓存命中', result.size, result.cacheHit)
        },
        fail(error) {
          console.log('导出失败', error.errCode, error.errMsg)
        },
        complete(result) {
          console.log('导出动作结束', result)
        }
      })
    },
    fail(error) {
      console.log('读取媒体信息失败', error.errCode, error.errMsg)
    },
    complete(result) {
      console.log('媒体信息动作结束', result)
    }
  })
}

快速显示相册，按需补封面

用途：相册侧栏先显示名称和数量；前置：已获相册读取授权。宿主：uni-app；触发：调用 readAlbumFolders()，下面只为第一个非空相册补封面，实际页面可按可见范围分批处理。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function readAlbumFolders() {
  GalleryPro.getGalleryAlbums({
    mediaType: 'all',
    sourceType: 'all',
    includeCoverThumbnail: false, // 默认快速模式，不等待全部封面。
    success(result) {
      console.log('相册结果', result.success, result.message)
      result.albums.forEach(album => {
        console.log('相册', album.albumId, album.albumName, album.sourceType)
        console.log('数量', album.count, album.imageCount, album.videoCount)
        console.log('封面', album.coverThumbnailPath)
        console.log('最新媒体', album.latestMediaId, album.latestMediaType)
        console.log('最新文件与时间', album.latestFileName, album.latestCreateTime)
      })
      const album = result.albums.find(item => item.latestMediaId !== '')
      if (album == null) return

      GalleryPro.getGalleryThumbnails({
        ids: [album.latestMediaId],
        width: 180,
        height: 180,
        success(thumbnails) {
          thumbnails.items.forEach(item => {
            if (item.id === album.latestMediaId) {
              album.coverThumbnailPath = item.thumbnailPath
            }
          })
          console.log('此相册的封面', album.albumId, album.coverThumbnailPath)
        },
        fail(error) {
          // 补封面失败不隐藏已经取得的文件夹。
          console.log('封面暂不可用', error.errCode, error.errMsg)
        },
        complete(result) {
          console.log('本批封面处理结束', result)
        }
      })
    },
    fail(error) {
      console.log('相册读取失败', error.errCode, error.errMsg)
    },
    complete(result) {
      console.log('相册分组动作结束', result)
    }
  })
}

校验上传路径，或发送到自己的业务接口

用途：先导出，再按所选模式处理；前置：ids 来自列表，真实上传地址由应用提供。宿主：uni-app；触发：checkSelectedUploadPaths(ids) 只校验，uploadSelectedMedia(ids, url) 才发送网络请求。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

function submitGalleryMedia(ids, url, dryRun) {
  if (ids.length === 0) return
  if (!dryRun && url.trim() === '') {
    console.log('请填写自己业务服务器的 HTTPS 上传地址')
    return
  }
  GalleryPro.uploadGalleryMedia({
    ids: ids,
    url: url,                     // dryRun 为 true 时可为空。
    dryRun: dryRun,
    name: 'file',                 // 文件表单字段名须与服务端约定一致。
    formData: { scene: 'feedback' }, // 附加业务字段，不在页面保存服务端 Secret。
    concurrency: 2,               // 默认 1，允许 1～4。
    retryCount: 1,                // 默认 0，允许 0～5 次额外重试。
    timeoutMs: 120000,            // 单文件请求超时，单位毫秒。
    progress(event) {
      // 阶段可能为 export、upload、dryRun、complete。
      console.log('阶段', event.stage, event.current, event.total)
      console.log('进度百分比与说明', event.progress, event.message)
    },
    success(result) {
      console.log('批次结果', result.success, result.successCount, result.failCount, result.message)
      result.items.forEach(item => {
        console.log('输入位置与媒体', item.index, item.id, item.success, item.message)
        // HTTP 成功仍需由业务检查 responseText 中的应用层结果。
        console.log('HTTP 结果', item.statusCode, item.responseText)
        if (item.renderPath != null) console.log('可预览路径', item.renderPath)
        if (item.uploadPath != null) console.log('可上传路径', item.uploadPath)
        if (item.size != null) console.log('文件字节数', item.size)
      })
    },
    fail(error) {
      console.log('上传任务失败', error.errCode, error.errMsg)
    },
    complete(result) {
      console.log('上传或路径校验结束', result)
    }
  })
}

export function checkSelectedUploadPaths(ids) {
  // 不发起网络请求，成功只说明导出链路可用。
  submitGalleryMedia(ids, '', true)
}

export function uploadSelectedMedia(ids, url) {
  // url 使用应用自己的配置，不能把演示域名当成真实接口。
  submitGalleryMedia(ids, url, false)
}

保存本地图片、视频并检查逐项结果

用途：把业务生成或下载的文件归档到相册；前置：paths 是实际可读的绝对路径或 file:// 路径。宿主：uni-app；触发：用户确认保存后调用 saveGeneratedMedia(paths)。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function saveGeneratedMedia(paths) {
  if (paths.length === 0) return
  GalleryPro.saveMediaToGallery({
    paths: paths,                  // 不传网络地址、content URI 或虚构示例路径。
    albumName: '工单附件',          // 可替换为自己的相册名；空字符串使用系统默认相册。
    duplicatePolicy: 'skip',        // 默认 allow；skip 只跳过当前可见且能确认的重复项。
    progress(event) {
      console.log('处理进度', event.current, event.total, event.progress)
      console.log('当前汇总', event.successCount, event.failCount)
      console.log('当前输入与说明', event.currentPath, event.message)
    },
    success(result) {
      // 至少一项成功或跳过时可进入 success，仍须检查 failCount。
      console.log('批次状态', result.success, result.message)
      console.log('保存或跳过/失败/跳过', result.successCount, result.failCount, result.skippedCount)
      result.items.forEach(item => {
        console.log('输入', item.index, item.sourcePath, item.mediaType)
        console.log('结果', item.success, item.skipped, item.mediaId, item.albumName, item.message)
        if (item.errCode != null) console.log('单项错误码', item.errCode)
      })
    },
    fail(error) {
      console.log('保存任务失败', error.errCode, error.errMsg)
    },
    complete(result) {
      console.log('保存流程结束', result)
    }
  })
}

读取 EXIF、视频参数和显式开启的位置

用途：按选中 ID 展示详情；前置：ids 为 1～100 个不重复 ID，位置开关应由用户知情操作触发。宿主：uni-app；触发：默认调用 readMetadataWithoutLocation(ids)，用户确认读取位置后调用 readMetadataWithLocation(ids)。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function readSelectedMetadata(ids, includeLocation = false) {
  GalleryPro.getGalleryMetadata({
    ids: ids,
    includeExif: true,             // 默认 true；只读视频参数可关闭，见模块化示例。
    includeLocation: includeLocation, // 默认 false；开启后仍受系统权限和媒体内容限制。
    useCache: true,                // 仅复用非敏感缓存，位置不会进入插件缓存。
    progress(event) {
      console.log('元数据进度', event.current, event.total, event.successCount, event.failCount)
      console.log('当前媒体', event.currentId)
    },
    success(result) {
      // 批次完成后逐项读取；所有项目读取失败也可能正常返回汇总。
      console.log('汇总', result.success, result.successCount, result.failCount, result.message)
      result.items.forEach(item => {
        console.log('身份与结果', item.id, item.success, item.mediaType, item.message)
        console.log('像素、时长、方向', item.width, item.height, item.durationMs, item.orientation)
        console.log('拍摄时间、相机和镜头', item.captureTime, item.cameraMake, item.cameraModel, item.lensModel)
        console.log('可选曝光参数', item.iso, item.exposureTime, item.aperture)
        console.log('可选焦距（毫米）', item.focalLength, item.focalLength35mm)
        console.log('视频参数', item.videoCodec, item.videoBitrate, item.videoFrameRate)
        console.log('位置可用性与缓存', item.locationAvailable, item.fromCache)
        if (item.errCode != null) {
          // 9070032 可与 success=true 同时存在，表示非敏感缓存异常。
          console.log('单项诊断码', item.errCode)
        }
        if (item.location != null) {
          // 示例只检查范围，不把真实经纬度写进日志。
          const location = item.location
          const validCoordinate = Number.isFinite(location.latitude) &&
            Number.isFinite(location.longitude) &&
            Math.abs(location.latitude) <= 90 && Math.abs(location.longitude) <= 180
          const hasAltitude = location.altitude != null
          console.log('本次返回有效坐标/海拔字段', validCoordinate, hasAltitude)
        }
      })
    },
    fail(error) {
      console.log('元数据任务无法启动', error.errCode, error.errMsg)
    },
    complete(result) {
      console.log('元数据批次结束', result)
    }
  })
}

export function readMetadataWithoutLocation(ids) {
  readSelectedMetadata(ids, false)
}

export function readMetadataWithLocation(ids) {
  // 仅绑定到用户明确选择读取位置的操作，不在页面加载时自动执行。
  readSelectedMetadata(ids, true)
}

进阶示例

分页读取可访问图片，并筛选 2:1 全景图

用途：按页筛选当前授权范围内的图片；前置：已获图片读取授权。宿主：uni-app；触发：调用 startPanoramaRead()，页面离开时调用 stopPanoramaRead()，阻止迟到结果更新本轮数据。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

let panoramaRequestVersion = 0
let panoramaImages = []

export function stopPanoramaRead() {
  // 只作业务侧失效处理，不会取消插件已经开始的原生查询。
  panoramaRequestVersion += 1
}

export function startPanoramaRead() {
  const version = ++panoramaRequestVersion
  panoramaImages = []

  function readPage(pageToken) {
    if (version !== panoramaRequestVersion) return
    GalleryPro.getGalleryImages({
      pageSize: 100,
      pageToken: pageToken,
      sortOrder: 'desc',
      thumbnailMode: 'none',
      success(result) {
        if (version !== panoramaRequestVersion) return
        result.items.forEach(item => {
          if (item.width <= 0 || item.height <= 0) return
          const ratio = item.width / item.height
          // 1.95～2.05 为像素误差容差；不限制 JPG/PNG 等编码。
          if (ratio >= 1.95 && ratio <= 2.05) panoramaImages.push(item)
        })
        if (result.hasMore) {
          if (result.nextPageToken === '' || result.nextPageToken === pageToken) {
            console.log('下一页令牌无效，停止本轮读取')
            return
          }
          readPage(result.nextPageToken)
          return
        }
        console.log('本轮筛选结束', panoramaImages.length, panoramaImages)
      },
      fail(error) {
        if (version === panoramaRequestVersion) {
          console.log('分页读取失败', error.errCode, error.errMsg)
        }
      },
      complete(result) {
        if (version === panoramaRequestVersion) console.log('当前分页动作结束', result)
      }
    })
  }

  readPage('')
}

监听变化并保留监听器归属

用途：相册变化后提示页面刷新；前置：读取权限有效。宿主：uni-app；触发：页面进入时调用 startLiveGalleryObserver()，页面卸载时调用 stopLiveGalleryObserver()。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

let liveObserverId = ''
let observerVersion = 0
let observerStarting = false
const pendingStopIds = new Set()

function stopOwnedObserver(id) {
  pendingStopIds.add(id)
  GalleryPro.stopGalleryChangeObserver({
    observerId: id,
    success(result) {
      console.log('停止结果', result.observerId, result.stopped, result.message)
      if (result.stopped) {
        pendingStopIds.delete(result.observerId)
        if (liveObserverId === result.observerId) liveObserverId = ''
      }
    },
    fail(error) {
      // 保留待清理 ID，调用 retryGalleryObserverCleanup 可重试。
      console.log('停止监听失败', id, error.errCode, error.errMsg)
    },
    complete(result) {
      console.log('本次停止动作结束', result)
    }
  })
}

export function startLiveGalleryObserver() {
  if (observerStarting || liveObserverId !== '') return
  observerStarting = true
  const version = ++observerVersion
  GalleryPro.startGalleryChangeObserver({
    mediaType: 'all',       // 需要刷新的业务范围，不是原生变化的精确媒体类型。
    debounceMs: 500,        // 默认 300 毫秒，允许 0～5000。
    includeChanges: true,  // 默认 false；开启后才尝试返回精确变化。
    maxChanges: 2000,      // 允许 1～10000；超限需重建全量基线。
    change(event) {
      if (version !== observerVersion) return
      console.log('事件归属', event.observerId, event.mediaType)
      console.log('事件原因、时间和合并数', event.reason, event.changedAt, event.mergedCount)
      console.log('事件说明', event.message)
      if (event.permissionStatus != null) console.log('授权范围变化', event.permissionStatus)
      console.log('旧/新事件游标', event.cursor, event.nextCursor)
      if (event.resetRequired === true || event.detailsAvailable !== true) {
        console.log('重新读取页面数据', event.resetRequired, event.resetReason)
        return
      }
      console.log('本次精确变化数', event.changeCount)
      console.log('新增', event.addedIds)
      console.log('删除', event.removedIds)
      console.log('修改', event.updatedIds)
      // 页面实际完成更新后再更新自己的状态；不把观察事件当成服务端同步完成。
    },
    success(result) {
      console.log('注册结果', result.observerId, result.platform, result.message)
      if (version !== observerVersion) {
        // 注册回调迟到时，只停止这次回调返回的监听器。
        stopOwnedObserver(result.observerId)
        return
      }
      liveObserverId = result.observerId
    },
    fail(error) {
      if (version === observerVersion) console.log('注册失败', error.errCode, error.errMsg)
    },
    complete(result) {
      if (version === observerVersion) observerStarting = false
      // complete 只代表注册动作结束；change 可在之后持续触发。
      console.log('注册动作结束', result)
    }
  })
}

export function stopLiveGalleryObserver() {
  observerVersion += 1
  observerStarting = false
  if (liveObserverId !== '') stopOwnedObserver(liveObserverId)
}

export function retryGalleryObserverCleanup() {
  Array.from(pendingStopIds).forEach(id => stopOwnedObserver(id))
}

查询持久化增量，业务完成后再推进游标

用途：跨页面、跨启动保留变化查询基线；前置：已有读取权限，存储键由应用按账号隔离。宿主：uni-app；触发：调用 readPersistentGalleryChanges()，应用确认真实业务完成后才调用 confirmGalleryChangesApplied()。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

const cursorStorageKey = 'gallery-change-cursor'
let pendingChanges = null
let changesRequestVersion = 0

export function readPersistentGalleryChanges() {
  const version = ++changesRequestVersion
  pendingChanges = null
  const stored = uni.getStorageSync(cursorStorageKey)
  const cursor = typeof stored === 'string' ? stored : ''
  GalleryPro.getGalleryChanges({
    cursor: cursor,          // 空字符串建立初始基线；后续使用原样保存的游标。
    mediaType: 'all',        // 更换媒体范围可能触发 filterChanged。
    maxChanges: 2000,
    success(result) {
      if (version !== changesRequestVersion) return
      pendingChanges = result
      console.log('增量结果', result.success, result.message)
      console.log('初始/重建', result.isInitial, result.resetRequired, result.resetReason)
      console.log('数量与创建时间', result.changeCount, result.currentTotal, result.createdAt)
      console.log('待确认的新游标', result.nextCursor)
      if (result.isInitial || result.resetRequired) {
        console.log('先执行自己的全量业务流程，本段代码不自动确认基线')
        return
      }
      console.log('待处理新增', result.addedIds)
      console.log('待处理删除', result.removedIds)
      console.log('待处理修改', result.updatedIds)
      // 此处只读取变化，不声称文件已上传或服务端已同步。
    },
    fail(error) {
      if (version === changesRequestVersion) console.log('增量读取失败，保留旧游标', error.errCode, error.errMsg)
    },
    complete(result) {
      if (version === changesRequestVersion) console.log('本次增量查询结束', result)
    }
  })
}

export function confirmGalleryChangesApplied(nextCursor, fullSyncCompleted = false) {
  // 仅在应用自己的同步/更新流程真实成功后调用。
  // fullSyncCompleted 必须来自真实全量结果，不能为消除提示固定填写 true。
  if (pendingChanges == null || pendingChanges.nextCursor !== nextCursor) return
  if ((pendingChanges.isInitial || pendingChanges.resetRequired) && !fullSyncCompleted) return
  uni.setStorageSync(cursorStorageKey, nextCursor)
  pendingChanges = null
}

export function removeStoredGalleryCursor() {
  const stored = uni.getStorageSync(cursorStorageKey)
  if (typeof stored !== 'string' || stored === '') return
  GalleryPro.clearGalleryChangeCursor({
    cursor: stored,
    success(result) {
      console.log('清理结果', result.success, result.cursor, result.removed, result.message)
      // 不移除并发业务刚写入的新游标；removed=false 可表示原游标已不存在。
      if (result.success && uni.getStorageSync(cursorStorageKey) === stored) {
        uni.removeStorageSync(cursorStorageKey)
      }
    },
    fail(error) {
      console.log('清理游标失败', error.errCode, error.errMsg)
    },
    complete(result) {
      console.log('游标清理动作结束', result)
    }
  })
}

判断平台能力并按缓存年龄清理

用途：显示适用入口、清理较旧缓存；前置：清理前确认页面和上传任务不再依赖这些缓存路径。宿主：uni-app；触发：调用 inspectGalleryCapabilities()，需要清理时单独调用 clearOldGalleryThumbnails()。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function inspectGalleryCapabilities() {
  const result = GalleryPro.getGalleryCapabilities()
  console.log('平台与说明', result.platform, result.message)
  console.log('列表能力', result.images, result.videos, result.mixed)
  console.log('查询能力', result.pagination, result.timeRange, result.sourceClassification)
  console.log('文件能力', result.thumbnails, result.exportTempFile, result.upload, result.saveMedia)
  console.log('元数据能力', result.metadata, result.exif, result.locationMetadata)
  console.log('变化能力', result.changeObserver, result.incrementalChanges, result.persistentChangeCursor)
  console.log('原生安装包提示', result.customBaseRecommended)
  // 能力为 true 不替代权限检查；HarmonyOS 的 false 也可能只是尚未授权。
  // 保留原生平台的授权入口，授权后再次读取能力。
  return result
}

export function clearOldGalleryThumbnails() {
  GalleryPro.clearGalleryCache({
    cacheType: 'thumbnail',
    // 缓存年龄，单位毫秒；这里清理至少已存放 7 天的缩略图，不传时间戳。
    olderThanMs: 7 * 24 * 60 * 60 * 1000,
    success(result) {
      console.log('清理结果', result.success, result.cacheType, result.message)
      console.log('文件数与释放字节数', result.removedCount, result.releasedBytes)
    },
    fail(error) {
      console.log('缓存清理失败', error.errCode, error.errMsg)
    },
    complete(result) {
      console.log('缓存清理动作结束', result)
    }
  })
}

完整示例

下面两段各自构成可复制的最小页面：点击后申请授权、读取第一项、准备预览，并在页面退出时停止变化监听；不需要上传地址或虚构媒体 ID。更完整的操作页面分别为 uni_modules/lizhao-gallery-pro/example/uniapp/galleryPro.vue 和 uni_modules/lizhao-gallery-pro/example/uniappx/index.uvue。

uni-app：选项式页面

前置：App 安装包已包含本插件及所需权限；宿主：uni-app Vue2/Vue3。触发：点击按钮；清理：onUnload 先使请求失效，再停止本页监听，迟到的注册结果只清理自己的 ID。

<template>
  <view>
    <button :disabled="busy" @click="loadMedia">读取并预览第一项</button>
    <text>{{ message }}</text>
    <image v-if="previewPath !== '' && mediaType === 'image'"
      :src="previewPath" mode="aspectFit" />
    <video v-if="previewPath !== '' && mediaType === 'video'"
      :src="previewPath" :poster="posterPath" controls />
  </view>
</template>

<script>
import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export default {
  data() {
    return {
      alive: false, busy: false, requestVersion: 0, observerId: '',
      previewPath: '', posterPath: '', mediaType: 'image', message: ''
    }
  },
  onLoad() {
    this.alive = true
  },
  onUnload() {
    this.alive = false
    this.requestVersion += 1
    const id = this.observerId
    this.observerId = ''
    if (id !== '') this.stopOwnedObserver(id)
  },
  methods: {
    isCurrent(version) {
      return this.alive && this.requestVersion === version
    },
    stopOwnedObserver(id) {
      GalleryPro.stopGalleryChangeObserver({
        observerId: id,
        fail: error => console.log('停止监听失败', id, error.errCode, error.errMsg),
        complete: result => console.log('停止动作结束', result)
      })
    },
    watchGallery(version) {
      if (!GalleryPro.getGalleryCapabilities().changeObserver) return
      GalleryPro.startGalleryChangeObserver({
        mediaType: 'all',
        debounceMs: 300,
        includeChanges: false,
        change: event => {
          if (this.isCurrent(version)) this.message = '相册已变化，可再次读取：' + event.message
        },
        success: result => {
          if (!this.isCurrent(version)) {
            this.stopOwnedObserver(result.observerId)
            return
          }
          this.observerId = result.observerId
        },
        fail: error => console.log('监听注册失败', error.errCode, error.errMsg),
        complete: result => console.log('注册动作结束', result)
      })
    },
    readAndPrepare(version) {
      GalleryPro.getGalleryMedia({
        mediaType: 'all',
        pageSize: 1,
        thumbnailMode: 'none',
        success: result => {
          if (!this.isCurrent(version)) return
          if (result.items.length === 0) {
            this.message = '当前授权范围内没有媒体'
            this.busy = false
            return
          }
          GalleryPro.prepareGalleryMedia({
            id: result.items[0].id,
            includePoster: true,
            posterWidth: 320,
            posterHeight: 320,
            success: prepared => {
              if (!this.isCurrent(version)) return
              this.previewPath = prepared.renderPath
              this.posterPath = prepared.posterPath
              this.mediaType = prepared.mediaType
              this.message = prepared.message
            },
            fail: error => {
              if (this.isCurrent(version)) this.message = error.errMsg
            },
            complete: result => {
              // 外层列表的 complete 可能早于文件准备结束，忙碌状态在这里释放。
              if (this.isCurrent(version)) this.busy = false
              console.log('准备动作结束', result)
            }
          })
        },
        fail: error => {
          if (!this.isCurrent(version)) return
          this.message = error.errMsg
          this.busy = false
        },
        complete: result => console.log('列表动作结束', result)
      })
    },
    loadMedia() {
      if (this.busy || !this.alive) return
      const capabilities = GalleryPro.getGalleryCapabilities()
      const nativePlatform = capabilities.platform === 'app-android' ||
        capabilities.platform === 'app-ios' || capabilities.platform === 'app-harmony'
      if (!nativePlatform) {
        this.message = capabilities.message
        return
      }
      const version = ++this.requestVersion
      const oldObserverId = this.observerId
      this.observerId = ''
      if (oldObserverId !== '') this.stopOwnedObserver(oldObserverId)
      this.busy = true
      this.previewPath = ''
      this.posterPath = ''
      this.message = '正在读取'
      GalleryPro.requestGalleryPermission({
        mediaType: 'all',
        success: permission => {
          if (!this.isCurrent(version)) return
          if (!permission.granted) {
            this.message = permission.message
            this.busy = false
            return
          }
          const authorizedCapabilities = GalleryPro.getGalleryCapabilities()
          if (!authorizedCapabilities.mixed || !authorizedCapabilities.exportTempFile) {
            this.message = authorizedCapabilities.message
            this.busy = false
            return
          }
          this.watchGallery(version)
          this.readAndPrepare(version)
        },
        fail: error => {
          if (!this.isCurrent(version)) return
          this.message = error.errMsg
          this.busy = false
        },
        complete: result => console.log('权限动作结束', result)
      })
    }
  }
}
</script>

uni-app x：组合式 UTS 页面

前置、触发和退出顺序与上例一致；宿主：uni-app x。类型与方法均从插件根入口导入，函数先声明后调用；此处没有上传、保存或清空缓存等额外操作。

<template>
  <view>
    <button :disabled="busy" @click="loadMedia">读取并预览第一项</button>
    <text>{{ message }}</text>
    <image v-if="previewPath !== '' && mediaType === 'image'"
      :src="previewPath" mode="aspectFit" />
    <video v-if="previewPath !== '' && mediaType === 'video'"
      :src="previewPath" :poster="posterPath" controls />
  </view>
</template>

<script setup lang="uts">
import { ref } from 'vue'
import { onLoad, onUnload } from '@dcloudio/uni-app'
import {
  getGalleryCapabilities, requestGalleryPermission, getGalleryMedia,
  prepareGalleryMedia, startGalleryChangeObserver, stopGalleryChangeObserver,
  type GalleryPermissionResult, type GalleryQueryResult, type GalleryPrepareResult,
  type GalleryChangeEvent, type GalleryChangeObserverStartResult, type GalleryFail
} from '@/uni_modules/lizhao-gallery-pro'

const busy = ref(false)
const previewPath = ref('')
const posterPath = ref('')
const mediaType = ref('image')
const message = ref('')
let alive = false
let requestVersion = 0
let observerId = ''

function isCurrent(version: number): boolean {
  return alive && requestVersion == version
}

function stopOwnedObserver(id: string): void {
  stopGalleryChangeObserver({
    observerId: id,
    fail: (error: GalleryFail): void => {
      console.log('停止监听失败', id, error.errCode, error.errMsg)
    },
    complete: (result: any): void => { console.log('停止动作结束', result) }
  })
}

function watchGallery(version: number): void {
  if (!getGalleryCapabilities().changeObserver) return
  startGalleryChangeObserver({
    mediaType: 'all',
    debounceMs: 300,
    includeChanges: false,
    change: (event: GalleryChangeEvent): void => {
      if (isCurrent(version)) message.value = '相册已变化，可再次读取：' + event.message
    },
    success: (result: GalleryChangeObserverStartResult): void => {
      if (!isCurrent(version)) {
        stopOwnedObserver(result.observerId)
        return
      }
      observerId = result.observerId
    },
    fail: (error: GalleryFail): void => {
      console.log('监听注册失败', error.errCode, error.errMsg)
    },
    complete: (result: any): void => { console.log('注册动作结束', result) }
  })
}

function readAndPrepare(version: number): void {
  getGalleryMedia({
    mediaType: 'all',
    pageSize: 1,
    thumbnailMode: 'none',
    success: (result: GalleryQueryResult): void => {
      if (!isCurrent(version)) return
      if (result.items.length == 0) {
        message.value = '当前授权范围内没有媒体'
        busy.value = false
        return
      }
      prepareGalleryMedia({
        id: result.items[0].id,
        includePoster: true,
        posterWidth: 320,
        posterHeight: 320,
        success: (prepared: GalleryPrepareResult): void => {
          if (!isCurrent(version)) return
          previewPath.value = prepared.renderPath
          posterPath.value = prepared.posterPath
          mediaType.value = prepared.mediaType
          message.value = prepared.message
        },
        fail: (error: GalleryFail): void => {
          if (isCurrent(version)) message.value = error.errMsg
        },
        complete: (result: any): void => {
          if (isCurrent(version)) busy.value = false
          console.log('准备动作结束', result)
        }
      })
    },
    fail: (error: GalleryFail): void => {
      if (!isCurrent(version)) return
      message.value = error.errMsg
      busy.value = false
    },
    complete: (result: any): void => { console.log('列表动作结束', result) }
  })
}

function loadMedia(): void {
  if (busy.value || !alive) return
  const capabilities = getGalleryCapabilities()
  const nativePlatform = capabilities.platform == 'app-android' ||
    capabilities.platform == 'app-ios' || capabilities.platform == 'app-harmony'
  if (!nativePlatform) {
    message.value = capabilities.message
    return
  }
  const version = ++requestVersion
  const oldObserverId = observerId
  observerId = ''
  if (oldObserverId != '') stopOwnedObserver(oldObserverId)
  busy.value = true
  previewPath.value = ''
  posterPath.value = ''
  message.value = '正在读取'
  requestGalleryPermission({
    mediaType: 'all',
    success: (permission: GalleryPermissionResult): void => {
      if (!isCurrent(version)) return
      if (!permission.granted) {
        message.value = permission.message
        busy.value = false
        return
      }
      const authorizedCapabilities = getGalleryCapabilities()
      if (!authorizedCapabilities.mixed || !authorizedCapabilities.exportTempFile) {
        message.value = authorizedCapabilities.message
        busy.value = false
        return
      }
      watchGallery(version)
      readAndPrepare(version)
    },
    fail: (error: GalleryFail): void => {
      if (!isCurrent(version)) return
      message.value = error.errMsg
      busy.value = false
    },
    complete: (result: any): void => { console.log('权限动作结束', result) }
  })
}

onLoad((): void => { alive = true })
onUnload((): void => {
  alive = false
  requestVersion += 1
  const id = observerId
  observerId = ''
  if (id != '') stopOwnedObserver(id)
})
</script>

模块化示例

媒体：只读取视频列表

用途：为视频素材页读取一页数据；前置：视频读取授权。宿主：uni-app；触发：视频页签首次加载调用 readGalleryVideoPage()，后续分页仍使用结果中的令牌。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function readGalleryVideoPage() {
  GalleryPro.getGalleryVideos({
    mediaType: 'video', // 专用视频方法会固定为 video，不受其他 mediaType 值改变。
    pageSize: 30,
    pageToken: '',
    thumbnailMode: 'sync',
    thumbnailWidth: 320,
    thumbnailHeight: 180,
    success(result) {
      result.items.forEach(item => console.log('视频', item.id, item.durationMs, item.thumbnailPath))
      console.log('分页', result.hasMore, result.nextPageToken)
    },
    fail(error) { console.log('视频读取失败', error.errCode, error.errMsg) },
    complete(result) { console.log('视频列表动作结束', result) }
  })
}

相册：读取截图文件夹并等待封面

用途：一次取得截图相册和封面；前置：读取授权，页面可以接受等待封面。宿主：uni-app；触发：调用 readScreenshotAlbums()，首屏需要更快出现文件夹时用前文快速模式。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function readScreenshotAlbums() {
  GalleryPro.getGalleryAlbums({
    mediaType: 'image',
    sourceType: 'screenshot',
    includeCoverThumbnail: true, // 显式等待封面处理，可能慢于默认 false。
    success(result) {
      result.albums.forEach(album => console.log(album.albumName, album.count, album.coverThumbnailPath))
    },
    fail(error) { console.log('截图相册读取失败', error.errCode, error.errMsg) },
    complete(result) { console.log('截图相册动作结束', result) }
  })
}

处理：重新读取视频参数

用途：读取视频参数而不读取 EXIF 或位置；前置：videoId 来自视频列表。宿主：uni-app；触发：打开视频详情后调用 readFreshVideoMetadata(videoId)。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function readFreshVideoMetadata(videoId) {
  GalleryPro.getGalleryMetadata({
    ids: [videoId],
    includeExif: false,
    includeLocation: false,
    useCache: false, // 需要重新读取时关闭非敏感缓存复用。
    success(result) {
      result.items.forEach(item => console.log(item.success, item.videoCodec, item.videoBitrate, item.videoFrameRate))
    },
    fail(error) { console.log('视频参数读取失败', error.errCode, error.errMsg) },
    complete(result) { console.log('视频参数动作结束', result) }
  })
}

输出：只准备可用文件，再保存到默认相册

用途：明确要求保存一份副本时使用；前置：id 来自列表且用户已确认保存。宿主：uni-app；触发：调用 saveSelectedMediaCopy(id)，这里实际保存准备结果中的本地文件，不使用占位路径。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function saveSelectedMediaCopy(id) {
  GalleryPro.prepareGalleryMedia({
    id: id,
    includePoster: false, // 不生成页面不需要的 poster。
    success(prepared) {
      GalleryPro.saveMediaToGallery({
        paths: [prepared.uploadPath],
        albumName: '',
        duplicatePolicy: 'allow', // 明确保留本次副本，不执行可见重复项跳过。
        success(result) { console.log('保存副本结果', result.success, result.items) },
        fail(error) { console.log('保存副本失败', error.errCode, error.errMsg) },
        complete(result) { console.log('保存副本动作结束', result) }
      })
    },
    fail(error) { console.log('准备副本失败', error.errCode, error.errMsg) },
    complete(result) { console.log('副本准备动作结束', result) }
  })
}

管理：清理全部非敏感元数据缓存

用途：让下次详情页重新读取非敏感字段；前置：没有依赖本次缓存清理结果的并发任务。宿主：uni-app；触发：调用 clearGalleryMetadataCache()，不会删除系统相册原文件。

import * as GalleryPro from '@/uni_modules/lizhao-gallery-pro'

export function clearGalleryMetadataCache() {
  GalleryPro.clearGalleryCache({
    cacheType: 'metadata',
    olderThanMs: 0, // 默认 0；清理该类型全部缓存，不按年龄筛选。
    success(result) { console.log('清理文件数与字节数', result.removedCount, result.releasedBytes) },
    fail(error) { console.log('元数据缓存清理失败', error.errCode, error.errMsg) },
    complete(result) { console.log('元数据缓存清理动作结束', result) }
  })
}

API 用途速查

公共回调与结果判定

下列公共参数适用于除同步 getGalleryCapabilities() 以外的异步方法；回调的具体结果类型见各组输出表。完整传入和读取方式可见基础示例及各功能示例。

输入参数

以下各表均同时支持上方公共回调；同名参数的示例链接指向实际赋值或调用代码。

权限：GalleryPermissionOptions

列表：GalleryQueryOptions

缩略图：GalleryThumbnailOptions

单媒体：GalleryMediaByIdOptions

导出：GalleryExportOptions

文件准备：GalleryPrepareOptions

上传：GalleryUploadOptions

保存：GallerySaveOptions

相册分组：GalleryAlbumsOptions

元数据：GalleryMetadataOptions

变化监听：GalleryChangeObserverOptions

停止监听：GalleryChangeObserverStopOptions

增量查询：GalleryChangesOptions

游标清理：GalleryClearChangeCursorOptions

缓存清理：GalleryClearCacheOptions

返回字段与事件

权限结果：GalleryPermissionResult

读取示例：基础授权。

列表与单媒体：GalleryQueryResult / GalleryMediaByIdResult

读取示例：基础结果、逐项字段、按 ID 查询。

缩略图：GalleryThumbnailResult / GalleryThumbnailProgress / GalleryThumbnailItem

读取示例：渐进结果、独立缩略图。

文件准备与导出：GalleryPrepareResult / GalleryExportResult

读取示例：准备结果、导出结果。

上传：GalleryUploadProgress / GalleryUploadResult / GalleryUploadItemResult

读取示例：上传与路径校验。

保存：GallerySaveProgress / GallerySaveResult / GallerySaveItemResult

读取示例：批量保存。

相册：GalleryAlbumsResult / GalleryAlbumItem

读取示例：相册结果及补封面。

元数据：GalleryMetadataProgress / GalleryMetadataResult / GalleryMetadataItem / GalleryMediaLocation

读取示例：元数据与位置读取。

监听：GalleryChangeObserverStartResult / GalleryChangeObserverStopResult / GalleryChangeEvent

读取示例：监听归属及清理。

增量与游标：GalleryChangesResult / GalleryClearChangeCursorResult

读取示例：查询、确认和清理游标。

缓存与能力：GalleryClearCacheResult / GalleryCapabilities

读取示例：能力分支与缓存清理。

错误码说明

错误对象的 errSubject 为 lizhao-gallery-pro，读取方式见基础失败处理。批量结果还应检查单项状态；上传单项没有 errCode，使用 statusCode / responseText / message 判断。

示例与平台接入

注意事项

微信：l-z-1-8-7-1512-5421（使用时去掉连字符）。

作者系列 UTS 插件

以下为作者已发布的 UTS 插件，可按能力方向查找。