1. 核心需求复述

你在鸿蒙 6 开发文物拍照复刻功能时，调用系统拍照 API 面临三大核心问题：一是拍照后对图片进行压缩 / 裁剪（用于 3D 纹理贴图），即便压缩质量设为 80%，文物纹饰等纹理细节仍丢失、画面模糊；二是轻量级穿戴设备调用手机端系统相机拍照后，跨设备传输图片时因手机默认 HEIC 格式、穿戴端仅识别 JPG 而提示 “文件格式不支持”；三是在aboutToAppear()生命周期中触发相机权限授权弹窗，偶发被系统拦截（弹窗不显示），导致拍照 API 调用直接失败。需要优化拍照和图片处理逻辑，保证纹理清晰度，适配跨设备图片传输格式，同时兼容相机权限的申请时机，避免授权弹窗被拦截。

2. 完整解决方案（可直接复用）

核心优化思路

• 图片处理层：放弃系统默认压缩 / 裁剪 API，采用自定义无损裁剪 + 细节优先的渐进式压缩，保留 3D 纹理所需的高频细节（如纹饰），压缩时优先保证分辨率和锐度；
• 跨设备格式层：拍照时强制指定 JPG 格式，跨设备传输前自动将 HEIC 格式转换为 JPG（基于鸿蒙原生编解码 API，保留细节）；
• 权限申请层：避开aboutToAppear生命周期，改用用户主动交互触发权限申请（如点击拍照按钮），补充权限状态监听和重试机制，避免弹窗被系统拦截。

步骤 1：自定义图片处理工具类（解决纹理细节丢失）

import { image, buffer, fileio } from '@ohos';
import { logger } from '@ohos/base';

// 图片处理工具类（适配3D纹理细节保留）
export class ImageProcessUtil {
  private static instance: ImageProcessUtil;
  // 3D纹理适配参数：保留足够分辨率，优先锐度
  private textureConfig = {
    targetWidth: 2048, // 纹理贴图推荐分辨率（保证细节）
    targetHeight: 2048,
    quality: 0.9, // 90%质量（平衡体积和细节）
    sharpenIntensity: 0.8 // 锐化强度（提升纹饰细节）
  };

  // 单例模式
  public static getInstance() {
    if (!this.instance) this.instance = new ImageProcessUtil();
    return this.instance;
  }

  // 自定义裁剪+压缩（保留纹理细节）
  async processImageForTexture(rawImagePath: string, outputPath: string): Promise<string> {
    try {
      // 步骤1：读取原始图片
      const file = await fileio.open(rawImagePath, fileio.OpenMode.READ_ONLY);
      const imageSource = image.createImageSource(file.fd);

      // 步骤2：自定义裁剪（基于纹理需求，居中裁剪为正方形）
      const cropParam: image.CropOptions = {
        x: 0,
        y: 0,
        width: this.textureConfig.targetWidth,
        height: this.textureConfig.targetHeight,
        // 居中裁剪：适配不同拍照比例
        cropRect: await this.getCenterCropRect(imageSource)
      };
      const croppedPixelMap = await imageSource.createPixelMap(cropParam);

      // 步骤3：锐化处理（提升纹饰细节）
      const sharpenedPixelMap = await this.sharpenPixelMap(croppedPixelMap);

      // 步骤4：细节优先的压缩（JPG格式，保留高频细节）
      const encodeParam: image.EncodeOptions = {
        format: image.ImageFormat.JPEG,
        quality: this.textureConfig.quality,
        // 关键：禁用色度子采样（避免细节丢失，默认4:2:0会丢失细节）
        subsampling: image.ImageSubsampling.NONE
      };
      await sharpenedPixelMap.encodeToFile(outputPath, encodeParam);

      // 释放资源
      croppedPixelMap.release();
      sharpenedPixelMap.release();
      fileio.close(file);

      logger.info(`图片处理完成，输出路径：${outputPath}`);
      return outputPath;
    } catch (e) {
      logger.error(`图片处理失败：${e.message}`);
      throw e;
    }
  }

  // 计算居中裁剪区域（适配不同拍照比例）
  private async getCenterCropRect(imageSource: image.ImageSource): Promise<image.Rect> {
    const imageInfo = await imageSource.getImageInfo();
    const shortEdge = Math.min(imageInfo.size.width, imageInfo.size.height);
    const x = (imageInfo.size.width - shortEdge) / 2;
    const y = (imageInfo.size.height - shortEdge) / 2;
    return { x, y, width: shortEdge, height: shortEdge };
  }

  // 锐化处理（提升文物纹饰细节）
  private async sharpenPixelMap(pixelMap: image.PixelMap): Promise<image.PixelMap> {
    const sharpener = image.createImageSharpener(pixelMap);
    // 设置锐化参数：提升边缘对比度（纹饰属于边缘细节）
    sharpener.setSharpenParam({
      intensity: this.textureConfig.sharpenIntensity,
      radius: 1.0 // 锐化半径（避免过度模糊）
    });
    return await sharpener.sharpen();
  }

  // HEIC格式转换为JPG（跨设备适配）
  async convertHeicToJpg(heicPath: string, jpgOutputPath: string): Promise<string> {
    try {
      const file = await fileio.open(heicPath, fileio.OpenMode.READ_ONLY);
      const imageSource = image.createImageSource(file.fd);
      const pixelMap = await imageSource.createPixelMap();
      
      const encodeParam: image.EncodeOptions = {
        format: image.ImageFormat.JPEG,
        quality: this.textureConfig.quality,
        subsampling: image.ImageSubsampling.NONE
      };
      await pixelMap.encodeToFile(jpgOutputPath, encodeParam);
      
      pixelMap.release();
      fileio.close(file);
      logger.info(`HEIC转JPG完成，输出路径：${jpgOutputPath}`);
      return jpgOutputPath;
    } catch (e) {
      logger.error(`HEIC转JPG失败：${e.message}`);
      throw e;
    }
  }
}

步骤 2：跨设备拍照工具类（适配 HEIC/JPG 格式）

import { camera, distributedData, deviceInfo, fileio } from '@ohos';
import { ImageProcessUtil } from './ImageProcessUtil';

// 跨设备拍照工具类
export class CrossDeviceCameraUtil {
  private static instance: CrossDeviceCameraUtil;
  private imageProcessUtil = ImageProcessUtil.getInstance();
  private isWearable: boolean = false;

  // 单例模式
  public static getInstance() {
    if (!this.instance) this.instance = new CrossDeviceCameraUtil();
    return this.instance;
  }

  // 初始化：判断设备类型
  async init() {
    this.isWearable = (await deviceInfo.getDeviceType()) === 'liteWearable';
  }

  // 手机端：调用系统相机（强制JPG格式）
  async takePhotoOnPhone(savePath: string): Promise<string> {
    try {
      // 相机配置：强制输出JPG格式，高分辨率
      const cameraConfig: camera.CameraConfig = {
        outputFormat: camera.ImageFormat.JPEG, // 禁用默认HEIC
        resolution: { width: 4096, height: 4096 }, // 高分辨率保留细节
        quality: camera.ImageQuality.HIGH
      };
      // 调用系统相机拍照
      const photoPath = await camera.takePhoto(cameraConfig, savePath);
      logger.info(`手机拍照完成，路径：${photoPath}`);
      return photoPath;
    } catch (e) {
      logger.error(`手机拍照失败：${e.message}`);
      throw e;
    }
  }

  // 穿戴端：请求手机端拍照并接收图片（格式适配）
  async requestPhoneTakePhoto(phoneDeviceId: string): Promise<string> {
    if (!this.isWearable) {
      throw new Error('仅穿戴设备可调用此方法');
    }
    try {
      // 步骤1：向手机端发送拍照请求
      await distributedData.sendToDevice(phoneDeviceId, 'take_photo', {
        savePath: '/sdcard/museum/photo_temp'
      });

      // 步骤2：监听手机端返回的图片路径
      return new Promise((resolve, reject) => {
        const timeoutTimer = setTimeout(() => {
          reject(new Error('跨设备拍照超时'));
        }, 30000);

        distributedData.on('photo_result', async (data) => {
          clearTimeout(timeoutTimer);
          const { photoPath } = JSON.parse(data);
          
          // 步骤3：校验格式，HEIC自动转换为JPG
          let finalPath = photoPath;
          if (photoPath.endsWith('.heic') || photoPath.endsWith('.heif')) {
            finalPath = '/sdcard/museum/photo_converted.jpg';
            await this.imageProcessUtil.convertHeicToJpg(photoPath, finalPath);
          }
          
          // 步骤4：传输到穿戴端（仅JPG格式）
          await this.transferToWearable(finalPath);
          resolve(finalPath);
        });
      });
    } catch (e) {
      logger.error(`穿戴端请求拍照失败：${e.message}`);
      throw e;
    }
  }

  // 跨设备传输图片（仅JPG）
  private async transferToWearable(photoPath: string) {
    if (!photoPath.endsWith('.jpg') && !photoPath.endsWith('.jpeg')) {
      throw new Error('仅支持JPG格式传输');
    }
    // 读取图片数据
    const file = await fileio.open(photoPath, fileio.OpenMode.READ_ONLY);
    const bufferData = await fileio.read(file.fd, { length: fileio.SEEK_END });
    fileio.close(file);
    // 传输到穿戴端
    await distributedData.sendToLocalDevice('wearable_photo', bufferData);
  }
}

步骤 3：相机权限管理工具类（适配申请时机）

import { abilityAccessCtrl, promptAction } from '@ohos';

// 相机权限管理工具类（避免弹窗被拦截）
export class CameraPermissionUtil {
  private static instance: CameraPermissionUtil;
  private permissionManager = abilityAccessCtrl.createPermissionManager();
  private readonly CAMERA_PERM = 'ohos.permission.CAMERA';
  private readonly STORAGE_PERM = 'ohos.permission.WRITE_EXTERNAL_STORAGE'; // 保存图片需存储权限

  // 单例模式
  public static getInstance() {
    if (!this.instance) this.instance = new CameraPermissionUtil();
    return this.instance;
  }

  // 检查并申请相机+存储权限（用户交互触发，避开aboutToAppear）
  async checkAndRequestPermission(): Promise<boolean> {
    try {
      // 步骤1：检查权限状态
      const cameraStatus = await this.permissionManager.checkPermission(this.CAMERA_PERM);
      const storageStatus = await this.permissionManager.checkPermission(this.STORAGE_PERM);

      if (cameraStatus === abilityAccessCtrl.PermissionStatus.GRANTED && 
          storageStatus === abilityAccessCtrl.PermissionStatus.GRANTED) {
        return true;
      }

      // 步骤2：申请权限（用户主动触发，避免系统拦截）
      const result = await this.permissionManager.requestPermissions([
        this.CAMERA_PERM, this.STORAGE_PERM
      ]);

      // 步骤3：校验授权结果
      const cameraGranted = result.find(item => item.permissionName === this.CAMERA_PERM)?.grantStatus === 0;
      const storageGranted = result.find(item => item.permissionName === this.STORAGE_PERM)?.grantStatus === 0;
      
      if (!cameraGranted || !storageGranted) {
        // 授权失败：引导用户到设置页
        await this.showPermissionGuideDialog();
        return false;
      }
      return true;
    } catch (e) {
      logger.error(`权限申请失败：${e.message}`);
      return false;
    }
  }

  // 权限授权失败引导弹窗
  private async showPermissionGuideDialog() {
    await promptAction.showDialog({
      title: '权限申请失败',
      message: '拍照复刻功能需要相机和存储权限，请前往设置开启',
      buttons: [
        { text: '前往设置', action: () => this.openPermissionSetting() },
        { text: '取消', action: () => {} }
      ]
    });
  }

  // 打开应用权限设置页
  private async openPermissionSetting() {
    await abilityAccessCtrl.openPermissionSetting({
      bundleName: 'com.your.package.name', // 替换为应用包名
      permissionName: this.CAMERA_PERM
    });
  }

  // 监听权限状态变化（兜底：处理先拒后授场景）
  listenPermissionChange() {
    this.permissionManager.on('permissionChange', (perm, status) => {
      if (perm === this.CAMERA_PERM) {
        logger.info(`相机权限状态变化：${status}`);
      }
    });
  }
}

步骤 4：页面集成示例（完整拍照流程）

import { CrossDeviceCameraUtil } from './CrossDeviceCameraUtil';
import { CameraPermissionUtil } from './CameraPermissionUtil';
import { ImageProcessUtil } from './ImageProcessUtil';
import { deviceInfo } from '@ohos';

@Entry
@Component
struct MuseumCameraPage {
  private crossDeviceCameraUtil = CrossDeviceCameraUtil.getInstance();
  private cameraPermissionUtil = CameraPermissionUtil.getInstance();
  private imageProcessUtil = ImageProcessUtil.getInstance();
  @State photoPath: string = '';
  @State isWearable: boolean = false;

  async aboutToAppear() {
    // 初始化工具类
    await this.crossDeviceCameraUtil.init();
    this.isWearable = (await deviceInfo.getDeviceType()) === 'liteWearable';
    // 监听权限变化
    this.cameraPermissionUtil.listenPermissionChange();
  }

  // 拍照按钮点击事件（用户交互触发，避开aboutToAppear）
  async onTakePhotoClick() {
    try {
      // 步骤1：检查并申请权限（用户交互触发，避免弹窗被拦截）
      const hasPerm = await this.cameraPermissionUtil.checkAndRequestPermission();
      if (!hasPerm) return;

      // 步骤2：差异化拍照逻辑
      let rawPhotoPath = '';
      if (this.isWearable) {
        // 穿戴端：请求手机端拍照（替换为实际手机设备ID）
        rawPhotoPath = await this.crossDeviceCameraUtil.requestPhoneTakePhoto('phone_device_id');
      } else {
        // 手机端：直接拍照（强制JPG）
        rawPhotoPath = await this.crossDeviceCameraUtil.takePhotoOnPhone('/sdcard/museum/photo_raw.jpg');
      }

      // 步骤3：处理图片（裁剪+压缩，保留纹理细节）
      const processedPath = await this.imageProcessUtil.processImageForTexture(
        rawPhotoPath,
        '/sdcard/museum/photo_texture.jpg'
      );
      this.photoPath = processedPath;
      logger.info(`纹理图片处理完成：${processedPath}`);

      // 步骤4：将处理后的图片用于3D纹理贴图（略）
    } catch (e) {
      logger.error(`拍照流程失败：${e.message}`);
    }
  }

  build() {
    Column() {
      // 拍照按钮（用户交互触发权限申请+拍照）
      Button('文物拍照复刻')
        .onClick(() => this.onTakePhotoClick())
        .margin({ top: 20 });

      // 预览处理后的图片
      if (this.photoPath) {
        Image(this.photoPath)
          .width('80%')
          .height('60%')
          .margin({ top: 20 })
          .objectFit(ImageFit.Contain);
      }
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center);
  }
}

关键优化点解释

1. 纹理细节保留优化：
   • 禁用系统默认的 HEIC 格式（压缩率高但丢失细节），拍照时强制指定 JPG 格式；
   • 压缩时设置subsampling: ImageSubsampling.NONE（禁用色度子采样，默认 4:2:0 会丢失高频细节），质量设为 90% 平衡体积和细节；
   • 增加锐化处理，提升文物纹饰等边缘细节的对比度，适配 3D 纹理贴图需求；
   • 裁剪采用居中正方形裁剪，保证纹理贴图的比例适配。
2. 跨设备格式适配：
   • 手机端拍照强制输出 JPG，从源头避免 HEIC 格式问题；
   • 跨设备传输前增加格式校验，若为 HEIC 则通过鸿蒙原生编解码 API 转换为 JPG（保留细节）；
   • 穿戴端仅接收 JPG 格式图片，传输前做格式校验，避免 “文件格式不支持” 错误。
3. 权限申请时机优化：
   • 完全避开aboutToAppear生命周期，改用 “点击拍照按钮”（用户主动交互）触发权限申请，避免系统拦截弹窗；
   • 权限申请失败时引导用户到设置页开启，补充权限状态监听，处理先拒后授的场景；
   • 申请权限时同时申请相机 + 存储权限（拍照后保存图片需要），避免分步申请导致的拦截。

3. 总结

1. 纹理细节保留：拍照强制 JPG 格式，压缩时禁用色度子采样、增加锐化处理，裁剪采用居中正方形，保证 3D 纹理所需的纹饰细节；
2. 跨设备格式适配：手机端拍照指定 JPG，传输前校验格式，HEIC 自动转换为 JPG，穿戴端仅接收 JPG 格式；
3. 权限申请适配：避开aboutToAppear，通过用户主动交互触发权限申请，补充权限监听和设置引导，避免弹窗被系统拦截；
4. 核心避坑：鸿蒙 6 系统相机默认输出 HEIC 格式，需手动指定 JPEG；权限申请若在组件初始化阶段（aboutToAppear）触发，极易被系统拦截，必须绑定