图片压缩并保存方法，有人知道吗？

import image from '@ohos.multimedia.image'; 
import fs from '@ohos.file.fs'; 
import axios from '@ohos/axios'; 
import fileuri from "@ohos.file.fileuri"; 
//压缩图片接口 
interface CompressImageOption { 
  imagePath: string, //应用沙箱路径 
  limitLength: number, 
  lossy?: boolean, 
  success: Function 
  fail?: Function 
  complete?: Function 
  
} 
//访问图片链接返回的数据类型 
interface ResponseType { 
  data: ArrayBuffer 
} 
@Entry 
@Component 
export default struct demo { 
  @State imageUrl: image.PixelMap = null 
  @State uri:string='' 
  build() { 
    Column() { 
      //图片展示 
      Image(this.imageUrl) 
        .width('100%') 
        .height(200) 
      Image($r('app.media.icon')) 
        .width('100') 
        .height(200) 
      Image(this.uri) 
        .width('100') 
        .height(200) 
      Button('压缩图片') 
        .onClick(async () => { 
          this.compressImage({ 
            imagePath: 'https://j5.dfcfw.com/imagesystem/material_imgs/1698131145895686.png', 
            limitLength: 0, 
            success: async (path: string) => { 
              console.log('shishuang compresspath', path) 
              const file: fs.File = fs.openSync(path, fs.OpenMode.READ_WRITE); 
              const fd: number = file?.fd; 
              // fd为已获得的文件描述符 
              const imageSource: image.ImageSource = image.createImageSource(fd); 
              this.uri = fileuri.getUriFromPath(path) 
              console.info('shishuang  uri '+this.uri) 
              console.info('shishuang fd'+fd) 
              let decodingOptions: image.DecodingOptions = { 
                editable: true, 
                desiredPixelFormat: 3, 
              } 
              // const color = new ArrayBuffer(96);  //96为需要创建的像素buffer大小，取值为：height * width *4 
              // let bufferArr = new Uint8Array(color); 
              // let opts = { editable: true, pixelFormat: 3, size: { height: 4, width: 6 } } 
              // // 创建pixelMap并进行简单的旋转和缩放 
              // let options = { 
              //   alphaType: 0, // 透明度 
              //   editable: false, // 是否可编辑 
              //   pixelFormat: 3, // 像素格式 
              //   scaleMode: 1, // 缩略值 
              //   size: { height: 100, width: 100 } 
              // } // 创建图片大小 
              imageSource.createPixelMap(decodingOptions) 
                .then((pixelMap) => { 
                  //展示图片 
                  this.imageUrl = pixelMap 
                }) 
                .catch((err: object) => { 
                  console.log('shishuang  err', JSON.stringify(err)) 
                }) 
  
            }, 
            fail: ((err: object) => { 
              console.log('压缩失败', JSON.stringify(err)) 
            }), 
            complete: (() => { 
              console.log('压缩结束') 
            }), 
          }) 
        }) 
        .margin({ top: 20 }) 
    } 
  } 
  /** 
   * 压缩图片 
   * @param CompressImageOption 
   * @returns Promise<void> 
   */ 
  async compressImage(params: CompressImageOption): Promise<void> { 
    params.lossy = params.lossy || true //默认开启有损压缩 
    console.info('shishuang1') 
  
    try { 
      console.info('shishuang2') 
      const imagePackerApi: image.ImagePacker = image.createImagePacker(); 
      //获取图片数据 
      const imageData: ResponseType = await axios({ 
        url: params.imagePath, 
        method: 'get', 
      }) //获取网络图片数据 
      console.log('byteLength', imageData.data.byteLength) 
      //创建ImageSource实例 
      const imageSource: image.ImageSource = image.createImageSource(imageData.data); 
      //设置quality参数 无损 quality = 100，有损 quality = 80 
      let quality: number = 0 
      if (params.lossy) { 
        quality = 80 
      } else { 
        quality = 100 
      } 
      //设置编码输出流和编码参数 format为图像的编码格式,当前仅支持jpeg、webp 和 png，选用WebP，因为压缩率更高；quality为图像质量，范围从0-100，100为最佳质量 
      let packOpts: image.PackingOption = { 
        format: "image/png", 
        quality: quality, 
        bufferSize: params.limitLength 
      } 
      //压缩图片 
      imagePackerApi.packing(imageSource, packOpts) 
        .then((data: ArrayBuffer) => { 
          console.info('shishuang packLength', data.byteLength) 
          const path: string = this.writeFile(data, 'png') 
          if (params?.success) params.success(path) 
        }) 
        .catch((err: object) => { 
          console.info('shishuang4') 
  
          if (params?.fail) params.fail(err) 
        }) 
        .finally(() => { 
          console.info('shishuang5') 
  
          if (params?.complete) params.complete() 
        }) 
    } catch (err) { 
      console.info('shishuang3') 
  
      if (params?.fail) params.fail(err) 
      if (params?.complete) params.complete() 
    } 
  } 
  /** 
   * 将数据写入文件 
   * 
   * @param content 压缩数据 
   * @param type 压缩图片的类型 
   * @return path 压缩图片的存储路径 
   */ 
  writeFile(content: ArrayBuffer | string, type: string): string { 
    let context: Context | undefined = getContext('context'); //获取context 
    const path: string = context.filesDir + '/' + 'tt_compress_image' //设定存储路径 
  
    if (!this.existFolder(path)) { 
      this.createFolder(path, true) 
    } 
  
    let tempPath = path + '/' + `${new Date().getTime()}` + '.' + type 
    console.log('tempPath', tempPath) 
    this.writeDataToFile(tempPath, content) //将压缩后的数据进行保存 
    return tempPath 
  } 
  /** 
   * 判断文件夹是否存在 
   * 
   * @param path 文件夹绝对路径 
   */ 
  existFolder(path: string): boolean { 
    try { 
      let stat = fs.statSync(path) 
      return stat.isDirectory() 
    } catch (e) { 
      // console.error("FileUtils folder exist e " + e) 
      return false 
    } 
  } 
  /** 
   * 创建文件夹 
   * 
   * @param path 文件夹绝对路径，只有是权限范围内的路径，可以生成 
   * @param recursive 
   */ 
  createFolder(path: string, recursive?: boolean) { 
    if (recursive) { 
      if (!this.existFolder(path)) { 
        let lastInterval = path.lastIndexOf('/') 
        if (lastInterval == 0) { 
          return 
        } 
        let newPath = path.substring(0, lastInterval) 
        this.createFolder(newPath, true) 
        if (!this.existFolder(path)) { 
          fs.mkdirSync(path) 
        } 
      } 
    } else { 
      if (!this.existFolder(path)) { 
        fs.mkdirSync(path) 
      } 
    } 
  } 
  //将数据写入文件 
  writeDataToFile(path: string, content: ArrayBuffer | string) { 
    let fd = fs.openSync(path, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE).fd 
    fs.truncateSync(fd) 
    fs.writeSync(fd, content) 
    fs.fsyncSync(fd) 
    fs.closeSync(fd) 
  } 
}