@ohos.multimedia.image (图片处理)

本模块提供图片处理效果，包括通过属性创建PixelMap、读取图像像素数据、读取区域内的图片数据等。

说明：

本模块首批接口从API version 6开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。

导入模块

import image from '@ohos.multimedia.image';

image.createPixelMap⁸⁺

createPixelMap(colors: ArrayBuffer, options: InitializationOptions): Promise<PixelMap>

通过属性创建PixelMap，默认采用BGRA_8888格式处理数据，通过Promise返回结果。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    const color: ArrayBuffer = new ArrayBuffer(96); // 96为需要创建的像素buffer大小，取值为：height * width *4
    let opts: image.InitializationOptions = { editable: true, pixelFormat: 3, size: { height: 4, width: 6 } }
    image.createPixelMap(color, opts).then((pixelMap: image.PixelMap) => {
        console.info('Succeeded in creating pixelmap.');
    }).catch((error: BusinessError) => {
        console.error('Failed to create pixelmap.');
    })
}

image.createPixelMap⁸⁺

createPixelMap(colors: ArrayBuffer, options: InitializationOptions, callback: AsyncCallback<PixelMap>): void

通过属性创建PixelMap，默认采用BGRA_8888格式处理数据，通过回调函数返回结果。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    const color: ArrayBuffer = new ArrayBuffer(96); // 96为需要创建的像素buffer大小，取值为：height * width *4
    let opts: image.InitializationOptions = { editable: true, pixelFormat: 3, size: { height: 4, width: 6 } }
    image.createPixelMap(color, opts, (error: BusinessError, pixelMap: image.PixelMap) => {
        if(error) {
            console.error('Failed to create pixelmap.');
            return;
        } else {
            console.info('Succeeded in creating pixelmap.');
        }
    })
}

image.createPixelMapFromParcel¹¹⁺

createPixelMapFromParcel(sequence: rpc.MessageSequence): PixelMap

从MessageSequence中获取PixelMap。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import image from '@ohos.multimedia.image';
import rpc from '@ohos.rpc';
import { BusinessError } from '@ohos.base';

class MySequence implements rpc.Parcelable {
    pixel_map: image.PixelMap;
    constructor(conPixelmap: image.PixelMap) {
        this.pixel_map = conPixelmap;
    }
    marshalling(messageSequence: rpc.MessageSequence) {
        this.pixel_map.marshalling(messageSequence);
        return true;
    }
    unmarshalling(messageSequence: rpc.MessageSequence) {
        try {
            this.pixel_map = image.createPixelMapFromParcel(messageSequence);
        } catch(e) {
            let error = e as BusinessError;
            console.error(`createPixelMapFromParcel error: ${error}`);
            return false;
        }
      return true;
    }
}
async function Demo() {
   const color: ArrayBuffer = new ArrayBuffer(96);
   let bufferArr: Uint8Array = new Uint8Array(color);
   for (let i = 0; i < bufferArr.length; i++) {
      bufferArr[i] = 0x80;
   }
   let opts: image.InitializationOptions = {
      editable: true,
      pixelFormat: 4,
      size: { height: 4, width: 6 },
      alphaType: 3
   }
   let pixelMap: image.PixelMap | undefined = undefined;
   image.createPixelMap(color, opts).then((srcPixelMap: image.PixelMap) => {
      pixelMap = srcPixelMap;
   })
   if (pixelMap != undefined) {
     // 序列化
     let parcelable: MySequence = new MySequence(pixelMap);
     let data: rpc.MessageSequence = rpc.MessageSequence.create();
     data.writeParcelable(parcelable);

     // 反序列化 rpc获取到data
     let ret: MySequence = new MySequence(pixelMap);
     data.readParcelable(ret);

     // 获取到pixelmap
     let unmarshPixelmap = ret.pixel_map;
   }
}

image.createPixelMapFromSurface¹¹⁺

从Surface id创建一个pixelmap对象

createPixelMapFromSurface(surfaceId: string, region: Region): Promise<PixelMap>

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import { BusinessError } from '@ohos.base';

async function Demo(surfaceId: string) {
    let region: image.Region = { x: 0, y: 0, size: { height: 100, width: 100 } };
    image.createPixelMapFromSurface(surfaceId, region).then(() => {
        console.info('Succeeded in creating pixelmap from Surface');
    }).catch((error: BusinessError) => {
        console.error('Failed to create pixelmap');
    });
} 

PixelMap⁷⁺

图像像素类，用于读取或写入图像数据以及获取图像信息。在调用PixelMap的方法前，需要先通过createPixelMap创建一个PixelMap实例。目前pixelmap序列化大小最大128MB，超过会送显失败。大小计算方式为(宽*高*每像素占用字节数)。

从API version 11开始，PixelMap支持通过worker跨线程调用。当PixelMap通过Worker跨线程后，原线程的PixelMap的所有接口均不能调用，否则将报错501 服务器不具备完成请求的功能。

在调用PixelMap的方法前，需要先通过image.createPixelMap构建一个PixelMap对象。

属性

系统能力： SystemCapability.Multimedia.Image.Core

readPixelsToBuffer⁷⁺

readPixelsToBuffer(dst: ArrayBuffer): Promise<void>

读取图像像素数据，结果写入ArrayBuffer里，使用Promise形式返回。指定BGRA_8888格式创建pixelmap，读取的像素数据与原数据保持一致。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    const readBuffer: ArrayBuffer = new ArrayBuffer(96); // 96为需要创建的像素buffer大小，取值为：height * width *4
    if (pixelMap != undefined) {
        pixelMap.readPixelsToBuffer(readBuffer).then(() => {
            console.info('Succeeded in reading image pixel data.'); // 符合条件则进入 
        }).catch((error: BusinessError) => {
            console.error('Failed to read image pixel data.'); // 不符合条件则进入
        })
    }
}

readPixelsToBuffer⁷⁺

readPixelsToBuffer(dst: ArrayBuffer, callback: AsyncCallback<void>): void

读取图像像素数据，结果写入ArrayBuffer里，使用callback形式返回。指定BGRA_8888格式创建pixelmap，读取的像素数据与原数据保持一致。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    const readBuffer: ArrayBuffer = new ArrayBuffer(96); // 96为需要创建的像素buffer大小，取值为：height * width *4
    if (pixelMap != undefined) {
        pixelMap.readPixelsToBuffer(readBuffer, (err: BusinessError, res: void) => {
            if(err) {
                console.error('Failed to read image pixel data.');  //不符合条件则进入
                return;
            } else {
                console.info('Succeeded in reading image pixel data.');  //符合条件则进入
            }
        })
    }
}

readPixels⁷⁺

readPixels(area: PositionArea): Promise<void>

读取区域内的图片数据，使用Promise形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    const area: image.PositionArea = {
        pixels: new ArrayBuffer(8),
        offset: 0,
        stride: 8,
        region: { size: { height: 1, width: 2 }, x: 0, y: 0 }
    };
    if (pixelMap != undefined) {
        pixelMap.readPixels(area).then(() => {
            console.info('Succeeded in reading the image data in the area.'); //符合条件则进入
        }).catch((error: BusinessError) => {
            console.error('Failed to read the image data in the area.'); //不符合条件则进入
        })
    }
}

readPixels⁷⁺

readPixels(area: PositionArea, callback: AsyncCallback<void>): void

读取区域内的图片数据，使用callback形式返回读取结果。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    const area: image.PositionArea = {
        pixels: new ArrayBuffer(8),
        offset: 0,
        stride: 8,
        region: { size: { height: 1, width: 2 }, x: 0, y: 0 }
    };
    if (pixelMap != undefined) {
        pixelMap.readPixels(area, (err: BusinessError) => {
            if (err != undefined) {
                console.error('Failed to read pixelmap from the specified area.');
                return;
            } else {
                console.info('Succeeded to read pixelmap from the specified area.');
            }
        })
    }
}

writePixels⁷⁺

writePixels(area: PositionArea): Promise<void>

将PixelMap写入指定区域内，使用Promise形式返回写入结果。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    const area: image.PositionArea = {
        pixels: new ArrayBuffer(8),
        offset: 0,
        stride: 8,
        region: { size: { height: 1, width: 2 }, x: 0, y: 0 }
    };
    let bufferArr: Uint8Array = new Uint8Array(area.pixels);
    for (let i = 0; i < bufferArr.length; i++) {
        bufferArr[i] = i + 1;
    }
    if (pixelMap != undefined) {
        pixelMap.writePixels(area).then(() => {
            console.info('Succeeded to write pixelmap into the specified area.');
        }).catch((error: BusinessError) => {
            console.error(`Failed to write pixelmap into the specified area. code is ${error.code}, message is ${error.message}`);
        })
    }
}

writePixels⁷⁺

writePixels(area: PositionArea, callback: AsyncCallback<void>): void

将PixelMap写入指定区域内，使用callback形式返回写入结果。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    const area: image.PositionArea = { pixels: new ArrayBuffer(8),
        offset: 0,
        stride: 8,
        region: { size: { height: 1, width: 2 }, x: 0, y: 0 }
    };
    let bufferArr: Uint8Array = new Uint8Array(area.pixels);
    for (let i = 0; i < bufferArr.length; i++) {
        bufferArr[i] = i + 1;
    }
    if (pixelMap != undefined) {
        pixelMap.writePixels(area, (error : BusinessError) => {
            if (error != undefined) {
                console.error('Failed to write pixelmap into the specified area.');
                return;
            } else {
                console.info('Succeeded to write pixelmap into the specified area.');
            }
        })
    }
}

writeBufferToPixels⁷⁺

writeBufferToPixels(src: ArrayBuffer): Promise<void>

读取缓冲区中的图片数据，结果写入PixelMap中，使用Promise形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    const color: ArrayBuffer = new ArrayBuffer(96); // 96为需要创建的像素buffer大小，取值为：height * width *4
    let bufferArr: Uint8Array = new Uint8Array(color);
    for (let i = 0; i < bufferArr.length; i++) {
        bufferArr[i] = i + 1;
    }
    if (pixelMap != undefined) {
        pixelMap.writeBufferToPixels(color).then(() => {
            console.info("Succeeded in writing data from a buffer to a PixelMap.");
        }).catch((error: BusinessError) => {
            console.error("Failed to write data from a buffer to a PixelMap.");
        })
    }
}

writeBufferToPixels⁷⁺

writeBufferToPixels(src: ArrayBuffer, callback: AsyncCallback<void>): void

读取缓冲区中的图片数据，结果写入PixelMap中，使用callback形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    const color: ArrayBuffer = new ArrayBuffer(96);  //96为需要创建的像素buffer大小，取值为：height * width *4
    let bufferArr: Uint8Array = new Uint8Array(color);
    for (let i = 0; i < bufferArr.length; i++) {
        bufferArr[i] = i + 1;
    }
    if (pixelMap != undefined) {
        pixelMap.writeBufferToPixels(color, (err: BusinessError) => {
            if (err != undefined) {
                console.error("Failed to write data from a buffer to a PixelMap.");
                return;
            } else {
                console.info("Succeeded in writing data from a buffer to a PixelMap.");
            }
        })
    }
}

getImageInfo⁷⁺

getImageInfo(): Promise<ImageInfo>

获取图像像素信息，使用Promise形式返回获取的图像像素信息。

系统能力： SystemCapability.Multimedia.Image.Core

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    if (pixelMap != undefined) {
        pixelMap.getImageInfo().then((imageInfo: image.ImageInfo) => {
            if (imageInfo == undefined) {
                console.error("Failed to obtain the image pixel map information.");
            }
            if (imageInfo.size.height == 4 && imageInfo.size.width == 6) {
                console.info("Succeeded in obtaining the image pixel map information.");
            }
        })
    }
}

getImageInfo⁷⁺

getImageInfo(callback: AsyncCallback<ImageInfo>): void

获取图像像素信息，使用callback形式返回获取的图像像素信息。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例:

import { BusinessError } from '@ohos.base';

async function Demo() {
    if (pixelMap != undefined) {
        pixelMap.getImageInfo((err: BusinessError, imageInfo: image.ImageInfo) => {
            if (imageInfo == undefined) {
                console.error("Failed to obtain the image pixel map information.");
                return;
            }
            if (imageInfo.size.height == 4 && imageInfo.size.width == 6) {
                console.info("Succeeded in obtaining the image pixel map information.");
            }
        })
    }
}

getBytesNumberPerRow⁷⁺

getBytesNumberPerRow(): number

获取图像像素每行字节数。

系统能力： SystemCapability.Multimedia.Image.Core

返回值：

示例：

let rowCount: number = pixelMap.getBytesNumberPerRow();

getPixelBytesNumber⁷⁺

getPixelBytesNumber(): number

获取图像像素的总字节数。

系统能力： SystemCapability.Multimedia.Image.Core

返回值：

示例：

let pixelBytesNumber: number = pixelMap.getPixelBytesNumber();

getDensity⁹⁺

getDensity():number

获取当前图像像素的密度。

系统能力： SystemCapability.Multimedia.Image.Core

返回值：

示例：

let getDensity: number = pixelMap.getDensity();

opacity⁹⁺

opacity(rate: number, callback: AsyncCallback<void>): void

通过设置透明比率来让PixelMap达到对应的透明效果，使用callback形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    let rate: number = 0.5;
    if (pixelMap != undefined) {
        pixelMap.opacity(rate, (err: BusinessError) => {
            if (err) {
                console.error("Failed to set opacity.");
                return;
            } else {
                console.info("Succeeded in setting opacity.");
            }
        })
    }
}

opacity⁹⁺

opacity(rate: number): Promise<void>

通过设置透明比率来让PixelMap达到对应的透明效果，使用Promise形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    let rate: number = 0.5;
    if (pixelMap != undefined) {
        pixelMap.opacity(rate).then(() => {
            console.info('Sucessed in setting opacity.');
        }).catch((err: BusinessError) => {
            console.error('Failed to set opacity.');
        })
    }
}

createAlphaPixelmap⁹⁺

createAlphaPixelmap(): Promise<PixelMap>

根据Alpha通道的信息，来生成一个仅包含Alpha通道信息的pixelmap，可用于阴影效果，使用Promise形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    if (pixelMap != undefined) {
        pixelMap.createAlphaPixelmap().then((alphaPixelMap: image.PixelMap) => {
            console.info('Succeeded in creating alpha pixelmap.');
        }).catch((error: BusinessError) => {
            console.error('Failed to create alpha pixelmap.');
        })
    }
}

createAlphaPixelmap⁹⁺

createAlphaPixelmap(callback: AsyncCallback<PixelMap>): void

根据Alpha通道的信息，来生成一个仅包含Alpha通道信息的pixelmap，可用于阴影效果，使用callback形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    if (pixelMap != undefined) {
        pixelMap.createAlphaPixelmap((err: BusinessError, alphaPixelMap: image.PixelMap) => {
            if (alphaPixelMap == undefined) {
                console.error('Failed to obtain new pixel map.');
                return;
            } else {
                console.info('Succeed in obtaining new pixel map.');
            }
        }) 
    }
}

scale⁹⁺

scale(x: number, y: number, callback: AsyncCallback<void>): void

根据输入的宽高对图片进行缩放，使用callback形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    let scaleX: number = 2.0;
    let scaleY: number = 1.0;
    if (pixelMap != undefined) {
        pixelMap.scale(scaleX, scaleY, (err: BusinessError) => {
            if (err) {
                console.error("Failed to scale pixelmap.");
                return;
            } else {
                console.info("Succeeded in scaling pixelmap.");
            }
        })
    }
}

scale⁹⁺

scale(x: number, y: number): Promise<void>

根据输入的宽高对图片进行缩放，使用Promise形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    let scaleX: number = 2.0;
    let scaleY: number = 1.0;
    if (pixelMap != undefined) {
        pixelMap.scale(scaleX, scaleY).then(() => {
            console.info('Sucessed in scaling pixelmap.');
        }).catch((err: BusinessError) => {
            console.error('Failed to scale pixelmap.');
        })   
    }
}

translate⁹⁺

translate(x: number, y: number, callback: AsyncCallback<void>): void

根据输入的坐标对图片进行位置变换，使用callback形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    let translateX: number = 50.0;
    let translateY: number = 10.0;
    if (pixelMap != undefined) {
        pixelMap.translate(translateX, translateY, (err: BusinessError) => {
            if (err) {
                console.error("Failed to translate pixelmap.");
                return;
            } else {
                console.info("Succeeded in translating pixelmap.");
            }
        })
    }
}

translate⁹⁺

translate(x: number, y: number): Promise<void>

根据输入的坐标对图片进行位置变换，使用Promise形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    let translateX: number = 50.0;
    let translateY: number = 10.0;
    if (pixelMap != undefined) {
        pixelMap.translate(translateX, translateY).then(() => {
            console.info('Sucessed in translating pixelmap.');
        }).catch((err: BusinessError) => {
            console.error('Failed to translate pixelmap.');
        })
    }
}

rotate⁹⁺

rotate(angle: number, callback: AsyncCallback<void>): void

根据输入的角度对图片进行旋转，使用callback形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    let angle: number = 90.0;
    if (pixelMap != undefined) {
        pixelMap.rotate(angle, (err: BusinessError) => {
            if (err != undefined) {
                console.error("Failed to rotate pixelmap.");
                return;
            } else {
                console.info("Succeeded in rotating pixelmap.");
            }
        })
    }
}

rotate⁹⁺

rotate(angle: number): Promise<void>

根据输入的角度对图片进行旋转，使用Promise形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    let angle: number = 90.0;
    if (pixelMap != undefined) {
        pixelMap.rotate(angle).then(() => {
            console.info('Sucessed in rotating pixelmap.');
        }).catch((err: BusinessError) => {
            console.error('Failed to rotate pixelmap.');
        })
    }
}

flip⁹⁺

flip(horizontal: boolean, vertical: boolean, callback: AsyncCallback<void>): void

根据输入的条件对图片进行翻转，使用callback形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    let horizontal: boolean = true;
    let vertical: boolean = false;
    if (pixelMap != undefined) {
        pixelMap.flip(horizontal, vertical, (err: BusinessError) => {
            if (err != undefined) {
                console.error("Failed to flip pixelmap.");
                return;
            } else {
                console.info("Succeeded in flipping pixelmap.");
            }
        })
    }
}

flip⁹⁺

flip(horizontal: boolean, vertical: boolean): Promise<void>

根据输入的条件对图片进行翻转，使用Promise形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    let horizontal: boolean = true;
    let vertical: boolean = false;
    if (pixelMap != undefined) {
        pixelMap.flip(horizontal, vertical).then(() => {
            console.info('Sucessed in flipping pixelmap.');
        }).catch((err: BusinessError) => {
            console.error('Failed to flip pixelmap.');
        })
    }
}

crop⁹⁺

crop(region: Region, callback: AsyncCallback<void>): void

根据输入的尺寸对图片进行裁剪，使用callback形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    let region: image.Region = { x: 0, y: 0, size: { height: 100, width: 100 } };
    if (pixelMap != undefined) {
        pixelMap.crop(region, (err: BusinessError) => {
            if (err != undefined) {
                console.error("Failed to crop pixelmap.");
                return;
            } else {
                console.info("Succeeded in cropping pixelmap.");
            }
        })
    }
}

crop⁹⁺

crop(region: Region): Promise<void>

根据输入的尺寸对图片进行裁剪，使用Promise形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    let region: image.Region = { x: 0, y: 0, size: { height: 100, width: 100 } };
    if (pixelMap != undefined) {
        pixelMap.crop(region).then(() => {
            console.info('Sucessed in cropping pixelmap.');
        }).catch((err: BusinessError) => {
            console.error('Failed to crop pixelmap.');
        });
    }
}

getColorSpace¹⁰⁺

getColorSpace(): colorSpaceManager.ColorSpaceManager

获取图像广色域信息。

系统能力： SystemCapability.Multimedia.Image.Core

返回值：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

async function Demo() {
    if (pixelMap != undefined) {
        let csm = pixelMap.getColorSpace();
    }
}

setColorSpace¹⁰⁺

setColorSpace(colorSpace: colorSpaceManager.ColorSpaceManager): void

设置图像广色域信息。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import colorSpaceManager from '@ohos.graphics.colorSpaceManager';
async function Demo() {
    let colorSpaceName = colorSpaceManager.ColorSpace.SRGB;
    let csm: colorSpaceManager.ColorSpaceManager = colorSpaceManager.create(colorSpaceName);
    if (pixelMap != undefined) {
        pixelMap.setColorSpace(csm);
    }
}

applyColorSpace¹¹⁺

applyColorSpace(targetColorSpace: colorSpaceManager.ColorSpaceManager, callback: AsyncCallback<void>): void

根据输入的目标色彩空间对图像像素颜色进行色彩空间转换，使用callback形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import colorSpaceManager from '@ohos.graphics.colorSpaceManager';
import { BusinessError } from '@ohos.base'

async function Demo() {
    let colorSpaceName = colorSpaceManager.ColorSpace.SRGB;
    let targetColorSpace: colorSpaceManager.ColorSpaceManager = colorSpaceManager.create(colorSpaceName);
    if (pixelMap != undefined) {
        pixelMap.applyColorSpace(targetColorSpace, (err: BusinessError) => {
            if (err) {
                console.error('Failed to apply color space for pixelmap object.');
                return;
            } else {
                console.info('Succeeded in applying color space for pixelmap object.');
            }
        })
    }
}

applyColorSpace¹¹⁺

applyColorSpace(targetColorSpace: colorSpaceManager.ColorSpaceManager): Promise<void>

根据输入的目标色彩空间对图像像素颜色进行色彩空间转换，使用Promise形式返回。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import colorSpaceManager from '@ohos.graphics.colorSpaceManager';
import { BusinessError } from '@ohos.base'

async function Demo() {
    let colorSpaceName = colorSpaceManager.ColorSpace.SRGB;
    let targetColorSpace: colorSpaceManager.ColorSpaceManager = colorSpaceManager.create(colorSpaceName);
    if (pixelMap != undefined) {
        pixelMap.applyColorSpace(targetColorSpace).then(() => {
            console.info('Succeeded in applying color space for pixelmap object.');
        }).catch((error: BusinessError) => {
            console.error('Failed to apply color space for pixelmap object.');
        })
    }
}

marshalling¹⁰⁺

marshalling(sequence: rpc.MessageSequence): void

将PixelMap序列化后写入MessageSequence。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import image from '@ohos.multimedia.image';
import rpc from '@ohos.rpc';

class MySequence implements rpc.Parcelable {
    pixel_map: image.PixelMap;
    constructor(conPixelMap : image.PixelMap) {
        this.pixel_map = conPixelMap;
    }
    marshalling(messageSequence : rpc.MessageSequence) {
        this.pixel_map.marshalling(messageSequence);
        console.info('marshalling');
        return true;
    }
    unmarshalling(messageSequence : rpc.MessageSequence) {
      image.createPixelMap(new ArrayBuffer(96), {size: { height:4, width: 6}}).then((pixelParcel: image.PixelMap) => {
        pixelParcel.unmarshalling(messageSequence).then(async (pixelMap: image.PixelMap) => {
          this.pixel_map = pixelMap;
          pixelMap.getImageInfo().then((imageInfo: image.ImageInfo) => {
            console.info("unmarshalling information h:" + imageInfo.size.height + "w:" + imageInfo.size.width);
          })
        })
      });
      return true;
    }
}
async function Demo() {
   const color: ArrayBuffer = new ArrayBuffer(96);
   let bufferArr: Uint8Array = new Uint8Array(color);
   for (let i = 0; i < bufferArr.length; i++) {
      bufferArr[i] = 0x80;
   }
   let opts: image.InitializationOptions = {
      editable: true,
      pixelFormat: 4,
      size: { height: 4, width: 6 },
      alphaType: 3
   }
   let pixelMap: image.PixelMap | undefined = undefined;
   image.createPixelMap(color, opts).then((srcPixelMap: image.PixelMap) => {
      pixelMap = srcPixelMap;
   })
   if (pixelMap != undefined) {
    // 序列化
     let parcelable: MySequence = new MySequence(pixelMap);
     let data: rpc.MessageSequence = rpc.MessageSequence.create();
     data.writeParcelable(parcelable);

    // 反序列化 rpc获取到data
     let ret: MySequence = new MySequence(pixelMap);
     data.readParcelable(ret);
   }
}

unmarshalling¹⁰⁺

unmarshalling(sequence: rpc.MessageSequence): Promise<PixelMap>

从MessageSequence中获取PixelMap， 如需使用同步方式创建PixelMap可使用：createPixelMapFromParcel。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import image from '@ohos.multimedia.image';
import rpc from '@ohos.rpc';

class MySequence implements rpc.Parcelable {
    pixel_map: image.PixelMap;
    constructor(conPixelMap: image.PixelMap) {
        this.pixel_map = conPixelMap;
    }
    marshalling(messageSequence: rpc.MessageSequence) {
        this.pixel_map.marshalling(messageSequence);
        console.info('marshalling');
        return true;
    }
    unmarshalling(messageSequence: rpc.MessageSequence) {
      image.createPixelMap(new ArrayBuffer(96), {size: { height:4, width: 6}}).then((pixelParcel : image.PixelMap) => {
        pixelParcel.unmarshalling(messageSequence).then(async (pixelMap : image.PixelMap) => {
          this.pixel_map = pixelMap;
          pixelMap.getImageInfo().then((imageInfo : image.ImageInfo) => {
            console.info("unmarshalling information h:" + imageInfo.size.height + "w:" + imageInfo.size.width);
          })
        })
      });
      return true;
    }
}
async function Demo() {
   const color: ArrayBuffer = new ArrayBuffer(96);
   let bufferArr: Uint8Array = new Uint8Array(color);
   for (let i = 0; i < bufferArr.length; i++) {
      bufferArr[i] = 0x80;
   }
   let opts: image.InitializationOptions = {
      editable: true,
      pixelFormat: 4,
      size: { height: 4, width: 6 },
      alphaType: 3
   }
   let pixelMap: image.PixelMap | undefined = undefined;
   image.createPixelMap(color, opts).then((srcPixelMap : image.PixelMap) => {
      pixelMap = srcPixelMap;
   })
   if (pixelMap != undefined) {
    // 序列化
     let parcelable: MySequence = new MySequence(pixelMap);
     let data : rpc.MessageSequence = rpc.MessageSequence.create();
     data.writeParcelable(parcelable);


    // 反序列化 rpc获取到data
     let ret : MySequence = new MySequence(pixelMap);
     data.readParcelable(ret);
   }
}

release⁷⁺

release():Promise<void>

释放PixelMap对象，使用Promise形式返回释放结果。

系统能力： SystemCapability.Multimedia.Image.Core

返回值：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    if (pixelMap != undefined) {
        pixelMap.release().then(() => {
            console.info('Succeeded in releasing pixelmap object.');
        }).catch((error: BusinessError) => {
            console.error('Failed to release pixelmap object.');
        })
    }
}

release⁷⁺

release(callback: AsyncCallback<void>): void

释放PixelMap对象，使用callback形式返回释放结果。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

async function Demo() {
    if (pixelMap != undefined) {
        pixelMap.release((err: BusinessError) => {
            if (err != undefined) {
                console.error('Failed to release pixelmap object.');
                return;
            } else {
                console.info('Succeeded in releasing pixelmap object.');
            }
        })
    }
}

image.createImageSource

createImageSource(uri: string): ImageSource

通过传入的uri创建图片源实例。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

const context: Context = getContext(this);
const path: string = context.cacheDir + "/test.jpg";
const imageSourceApi: image.ImageSource = image.createImageSource(path);

image.createImageSource⁹⁺

createImageSource(uri: string, options: SourceOptions): ImageSource

通过传入的uri创建图片源实例。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

let sourceOptions: image.SourceOptions = { sourceDensity: 120 };
let imageSourceApi: image.ImageSource = image.createImageSource('test.png', sourceOptions);

image.createImageSource⁷⁺

createImageSource(fd: number): ImageSource

通过传入文件描述符来创建图片源实例。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

const imageSourceApi: image.ImageSource = image.createImageSource(0);

image.createImageSource⁹⁺

createImageSource(fd: number, options: SourceOptions): ImageSource

通过传入文件描述符来创建图片源实例。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

let sourceOptions: image.SourceOptions = { sourceDensity: 120 };
const imageSourceApi: image.ImageSource = image.createImageSource(0, sourceOptions);

image.createImageSource⁹⁺

createImageSource(buf: ArrayBuffer): ImageSource

通过缓冲区创建图片源实例。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

const buf: ArrayBuffer = new ArrayBuffer(96); // 96为需要创建的像素buffer大小，取值为：height * width *4
const imageSourceApi: image.ImageSource = image.createImageSource(buf);

image.createImageSource⁹⁺

createImageSource(buf: ArrayBuffer, options: SourceOptions): ImageSource

通过缓冲区创建图片源实例。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

const data: ArrayBuffer = new ArrayBuffer(112);
let sourceOptions: image.SourceOptions = { sourceDensity: 120 };
const imageSourceApi: image.ImageSource = image.createImageSource(data, sourceOptions);

image.createImageSource¹¹⁺

createImageSource(rawfile: resourceManager.RawFileDescriptor, options?: SourceOptions): ImageSource

通过图像资源文件的RawFileDescriptor创建图片源实例。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

import resourceManager from '@ohos.resourceManager';

const context: Context = getContext(this);
// 获取resourceManager资源管理器
const resourceMgr: resourceManager.ResourceManager = context.resourceManager;
resourceMgr.getRawFd('test.jpg').then((rawFileDescriptor: resourceManager.RawFileDescriptor) => {
    const imageSourceApi: image.ImageSource = image.createImageSource(rawFileDescriptor);
}).catch((error: BusinessError) => {
    console.error(`Failed to get RawFileDescriptor.code is ${error.code}, message is ${error.message}`);
})

image.CreateIncrementalSource⁹⁺

CreateIncrementalSource(buf: ArrayBuffer): ImageSource

通过缓冲区以增量的方式创建图片源实例。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

const buf: ArrayBuffer = new ArrayBuffer(96); // 96为需要创建的像素buffer大小，取值为：height * width *4
const imageSourceIncrementalSApi: image.ImageSource = image.CreateIncrementalSource(buf);

image.CreateIncrementalSource⁹⁺

CreateIncrementalSource(buf: ArrayBuffer, options?: SourceOptions): ImageSource

通过缓冲区以增量的方式创建图片源实例。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

const buf: ArrayBuffer = new ArrayBuffer(96); // 96为需要创建的像素buffer大小，取值为：height * width *4
let sourceOptions: image.SourceOptions = { sourceDensity: 120 };
const imageSourceIncrementalSApi: image.ImageSource = image.CreateIncrementalSource(buf, sourceOptions);

ImageSource

图片源类，用于获取图片相关信息。在调用ImageSource的方法前，需要先通过createImageSource构建一个ImageSource实例。

属性

系统能力： SystemCapability.Multimedia.Image.ImageSource

getImageInfo

getImageInfo(index: number, callback: AsyncCallback<ImageInfo>): void

获取指定序号的图片信息，使用callback形式返回图片信息。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.getImageInfo(0, (error: BusinessError, imageInfo: image.ImageInfo) => { 
    if (error) {
        console.error('getImageInfo failed.');
    } else {
        console.info('getImageInfo succeeded.');
    }
})

getImageInfo

getImageInfo(callback: AsyncCallback<ImageInfo>): void

获取图片信息，使用callback形式返回图片信息。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.getImageInfo((err: BusinessError, imageInfo: image.ImageInfo) => { 
    if (err != undefined) {
        console.error(`Failed to obtaining the image information.code is ${err.code}, message is ${err.message}`);
    } else {
        console.info('Succeeded in obtaining the image information.');
    }
})

getImageInfo

getImageInfo(index?: number): Promise<ImageInfo>

获取图片信息，使用Promise形式返回图片信息。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.getImageInfo(0)
    .then((imageInfo: image.ImageInfo) => {
		console.info('Succeeded in obtaining the image information.');
	}).catch((error: BusinessError) => {
		console.error('Failed to obtain the image information.');
	})

getImageProperty¹¹⁺

getImageProperty(key:PropertyKey, options?: ImagePropertyOptions): Promise<string>

获取图片中给定索引处图像的指定属性键的值，用Promise形式返回结果，仅支持JPEG文件，且需要包含exif信息。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import { BusinessError } from '@ohos.base';

let options: image.ImagePropertyOptions = { index: 0, defaultValue: '9999' }
imageSourceApi.getImageProperty(image.PropertyKey.BITS_PER_SAMPLE, options)
.then((data: string) => {
    console.info('Succeeded in getting the value of the specified attribute key of the image.');
}).catch((error: BusinessError) => {
    console.error('Failed to get the value of the specified attribute key of the image.');
})

getImageProperty^(deprecated)

getImageProperty(key:string, options?: GetImagePropertyOptions): Promise<string>

获取图片中给定索引处图像的指定属性键的值，用Promise形式返回结果，仅支持JPEG文件，且需要包含exif信息。

说明：

从API version 11开始不再维护，建议使用getImageProperty代替。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.getImageProperty("BitsPerSample")
    .then((data: string) => {
		console.info('Succeeded in getting the value of the specified attribute key of the image.');
	}).catch((error: BusinessError) => {
		console.error('Failed to get the value of the specified attribute key of the image.');
	})

getImageProperty^(deprecated)

getImageProperty(key:string, callback: AsyncCallback<string>): void

获取图片中给定索引处图像的指定属性键的值，用callback形式返回结果，仅支持JPEG文件，且需要包含exif信息。

说明：

从API version 11开始不再维护，建议使用getImageProperty代替。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.getImageProperty("BitsPerSample", (error: BusinessError, data: string) => { 
    if (error) {
        console.error('Failed to get the value of the specified attribute key of the image.');
    } else {
        console.info('Succeeded in getting the value of the specified attribute key of the image.');
    }
})

getImageProperty^(deprecated)

getImageProperty(key:string, options: GetImagePropertyOptions, callback: AsyncCallback<string>): void

获取图片指定属性键的值，callback形式返回结果，仅支持JPEG文件，且需要包含exif信息。

说明：

从API version 11开始不再维护，建议使用getImageProperty代替。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

示例：

import { BusinessError } from '@ohos.base';

let property: image.GetImagePropertyOptions = { index: 0, defaultValue: '9999' }
imageSourceApi.getImageProperty("BitsPerSample", property, (error: BusinessError, data: string) => { 
    if (error) {
        console.error('Failed to get the value of the specified attribute key of the image.');
    } else {
        console.info('Succeeded in getting the value of the specified attribute key of the image.');
    }
})

modifyImageProperty¹¹⁺

modifyImageProperty(key: PropertyKey, value: string): Promise<void>

通过指定的键修改图片属性的值，使用Promise形式返回结果，仅支持JPEG文件，且需要包含exif信息。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.modifyImageProperty(image.PropertyKey.IMAGE_WIDTH, "120").then(() => {
    imageSourceApi.getImageProperty(image.PropertyKey.IMAGE_WIDTH).then((width: string) => {
        console.info(`ImageWidth is :${width}`);
    }).catch((error: BusinessError) => {
        console.error('Failed to get the Image Width.');
	})
}).catch((error: BusinessError) => {
	console.error('Failed to modify the Image Width');
})

modifyImageProperty^(deprecated)

modifyImageProperty(key: string, value: string): Promise<void>

通过指定的键修改图片属性的值，使用Promise形式返回结果，仅支持JPEG文件，且需要包含exif信息。

说明：

从API version 11开始不再维护，建议使用modifyImageProperty代替。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.modifyImageProperty("ImageWidth", "120").then(() => {
    imageSourceApi.getImageProperty("ImageWidth").then((width: string) => {
        console.info(`ImageWidth is :${width}`);
    }).catch((error: BusinessError) => {
        console.error('Failed to get the Image Width.');
	})
}).catch((error: BusinessError) => {
	console.error('Failed to modify the Image Width');
})

modifyImageProperty^(deprecated)

modifyImageProperty(key: string, value: string, callback: AsyncCallback<void>): void

通过指定的键修改图片属性的值，callback形式返回结果，仅支持JPEG文件，且需要包含exif信息。

说明：

从API version 11开始不再维护，建议使用modifyImageProperty代替。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.modifyImageProperty("ImageWidth", "120", (err: BusinessError) => {
    if (err != undefined) {
        console.error('modifyImageProperty Failed');
    } else {
        console.info('modifyImageProperty Succeeded');
    }
})

updateData⁹⁺

updateData(buf: ArrayBuffer, isFinished: boolean, offset: number, length: number): Promise<void>

更新增量数据，使用Promise形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

const array: ArrayBuffer = new ArrayBuffer(100);
imageSourceApi.updateData(array, false, 0, 10).then(() => {
    console.info('Succeeded in updating data.');
}).catch((err: BusinessError) => {
    console.error(`Failed to update data.code is ${err.code},message is ${err.message}`);
})

updateData⁹⁺

updateData(buf: ArrayBuffer, isFinished: boolean, offset: number, length: number, callback: AsyncCallback<void>): void

更新增量数据，callback形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

示例：

import { BusinessError } from '@ohos.base';

const array: ArrayBuffer = new ArrayBuffer(100);
imageSourceApi.updateData(array, false, 0, 10, (err: BusinessError) => {
    if (err != undefined) {
        console.error(`Failed to update data.code is ${err.code},message is ${err.message}`);
    } else {
        console.info('Succeeded in updating data.');
    }
})

createPixelMap⁷⁺

createPixelMap(options?: DecodingOptions): Promise<PixelMap>

通过图片解码参数创建PixelMap对象。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.createPixelMap().then((pixelMap: image.PixelMap) => {
    console.info('Succeeded in creating pixelMap object through image decoding parameters.');
}).catch((error: BusinessError) => {
    console.error('Failed to create pixelMap object through image decoding parameters.');
})

createPixelMap⁷⁺

createPixelMap(callback: AsyncCallback<PixelMap>): void

通过默认参数创建PixelMap对象，使用callback形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.createPixelMap((err: BusinessError, pixelMap: image.PixelMap) => {
    if (err != undefined) {
        console.error(`Failed to create pixelMap.code is ${err.code},message is ${err.message}`);
    } else {
        console.info('Succeeded in creating pixelMap object.');
    }
})

createPixelMap⁷⁺

createPixelMap(options: DecodingOptions, callback: AsyncCallback<PixelMap>): void

通过图片解码参数创建PixelMap对象。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

示例：

import { BusinessError } from '@ohos.base';

let decodingOptions: image.DecodingOptions = {
    sampleSize: 1,
    editable: true,
    desiredSize: { width: 1, height: 2 },
    rotate: 10,
    desiredPixelFormat: 3,
    desiredRegion: { size: { height: 1, width: 2 }, x: 0, y: 0 },
    index: 0
};
imageSourceApi.createPixelMap(decodingOptions, (err: BusinessError, pixelMap: image.PixelMap) => { 
    if (err != undefined) {
        console.error(`Failed to create pixelMap.code is ${err.code},message is ${err.message}`);
    } else {
        console.info('Succeeded in creating pixelMap object.');
    }
})

createPixelMapList¹⁰⁺

createPixelMapList(options?: DecodingOptions): Promise<Array<PixelMap>>

通过图片解码参数创建PixelMap数组。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import { BusinessError } from '@ohos.base';

let decodeOpts: image.DecodingOptions = {
    sampleSize: 1,
    editable: true,
    desiredSize: { width: 198, height: 202 },
    rotate: 0,
    desiredPixelFormat: 3,
    index: 0,
};
imageSourceApi.createPixelMapList(decodeOpts).then((pixelMapList: Array<image.PixelMap>) => {
    console.info('Succeeded in creating pixelMapList object.');
}).catch((err: BusinessError) => {
    console.error(`Failed to create pixelMapList object.code is ${err.code},message is ${err.message}`);
})

createPixelMapList¹⁰⁺

createPixelMapList(callback: AsyncCallback<Array<PixelMap>>): void

通过默认参数创建PixelMap数组，使用callback形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.createPixelMapList((err: BusinessError, pixelMapList: Array<image.PixelMap>) => {
    if (err != undefined) {
        console.error(`Failed to create pixelMapList object.code is ${err.code},message is ${err.message}`);
    } else {
        console.info('Succeeded in creating pixelMapList object.');
    }
})

createPixelMapList¹⁰⁺

createPixelMapList(options: DecodingOptions, callback: AsyncCallback<Array<PixelMap>>): void

通过图片解码参数创建PixelMap数组，使用callback形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import { BusinessError } from '@ohos.base';

let decodeOpts: image.DecodingOptions = {
    sampleSize: 1,
    editable: true,
    desiredSize: { width: 198, height: 202 },
    rotate: 0,
    desiredPixelFormat: 3,
    index: 0,
};
imageSourceApi.createPixelMapList(decodeOpts, (err: BusinessError, pixelMapList: Array<image.PixelMap>) => {
    if (err != undefined) {
        console.error(`Failed to create pixelMapList object.code is ${err.code},message is ${err.message}`);
    } else {
        console.info('Succeeded in creating pixelMapList object.');
    }
})

getDelayTimeList¹⁰⁺

getDelayTimeList(callback: AsyncCallback<Array<number>>): void

获取图像延迟时间数组，使用callback形式返回结果。此接口仅用于gif图片。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.getDelayTimeList((err: BusinessError, delayTimes: Array<number>) => {
    if (err != undefined) {
        console.error(`Failed to get delayTimes object.code is ${err.code},message is ${err.message}`);
    } else {
        console.info('Succeeded in delayTimes object.');
    }
})

getDelayTimeList¹⁰⁺

getDelayTimeList(): Promise<Array<number>>

获取图像延迟时间数组，使用Promise形式返回结果。此接口仅用于gif图片。

系统能力： SystemCapability.Multimedia.Image.ImageSource

返回值：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.getDelayTimeList().then((delayTimes: Array<number>) => {
    console.info('Succeeded in delayTimes object.');
}).catch((err: BusinessError) => {
    console.error(`Failed to get delayTimes object.code is ${err.code},message is ${err.message}`);
})

getFrameCount¹⁰⁺

getFrameCount(callback: AsyncCallback<number>): void

获取图像帧数，使用callback形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.getFrameCount((err: BusinessError, frameCount: number) => {
    if (err != undefined) {
        console.error(`Failed to get frame count.code is ${err.code},message is ${err.message}`);
    } else {
        console.info('Succeeded in getting frame count.');
    }
})

getFrameCount¹⁰⁺

getFrameCount(): Promise<number>

获取图像帧数，使用Promise形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageSource

返回值：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.getFrameCount().then((frameCount: number) => {
    console.info('Succeeded in getting frame count.');
}).catch((err: BusinessError) => {
    console.error(`Failed to get frame count.code is ${err.code},message is ${err.message}`);
})

release

release(callback: AsyncCallback<void>): void

释放图片源实例，使用callback形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageSource

参数：

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.release((err: BusinessError) => { 
    if (err != undefined) {
        console.error('Failed to release the image source instance.');
    } else {
        console.info('Succeeded in releasing the image source instance.');
    }
})

release

release(): Promise<void>

释放图片源实例，使用Promise形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageSource

返回值：

示例：

import { BusinessError } from '@ohos.base';

imageSourceApi.release().then(() => {
    console.info('Succeeded in releasing the image source instance.');
}).catch((error: BusinessError) => {
    console.error('Failed to release the image source instance.');
})

image.createImagePacker

createImagePacker(): ImagePacker

创建ImagePacker实例。

系统能力： SystemCapability.Multimedia.Image.ImagePacker

返回值：

示例：

const imagePackerApi: image.ImagePacker = image.createImagePacker();

ImagePacker

图片打包器类，用于图片压缩和打包。在调用ImagePacker的方法前，需要先通过createImagePacker构建一个ImagePacker实例，当前支持格式有：jpeg、webp、png。

属性

系统能力： SystemCapability.Multimedia.Image.ImagePacker

packing

packing(source: ImageSource, option: PackingOption, callback: AsyncCallback<ArrayBuffer>): void

图片压缩或重新打包，使用callback形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImagePacker

参数：

示例：

import { BusinessError } from '@ohos.base';

const imageSourceApi: image.ImageSource = image.createImageSource(0);
let packOpts: image.PackingOption = { format: "image/jpeg", quality: 98 };
imagePackerApi.packing(imageSourceApi, packOpts, (err: BusinessError, data: ArrayBuffer) => {
    if (err) {
        console.error('packing failed.');
    } else {
        console.info('packing succeeded.');
    }
})

packing

packing(source: ImageSource, option: PackingOption): Promise<ArrayBuffer>

图片压缩或重新打包，使用Promise形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImagePacker

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

const imageSourceApi: image.ImageSource = image.createImageSource(0);
let packOpts: image.PackingOption = { format: "image/jpeg", quality: 98 }
imagePackerApi.packing(imageSourceApi, packOpts)
    .then((data: ArrayBuffer) => {
        console.info('packing succeeded.');
	}).catch((error: BusinessError) => {
	    console.error('packing failed.');
	})

packing⁸⁺

packing(source: PixelMap, option: PackingOption, callback: AsyncCallback<ArrayBuffer>): void

图片压缩或重新打包，使用callback形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImagePacker

参数：

示例：

import { BusinessError } from '@ohos.base';

const color: ArrayBuffer = new ArrayBuffer(96); // 96为需要创建的像素buffer大小，取值为：height * width *4
let opts: image.InitializationOptions = { editable: true, pixelFormat: 3, size: { height: 4, width: 6 } }
image.createPixelMap(color, opts).then((pixelMap: image.PixelMap) => {
    let packOpts: image.PackingOption = { format: "image/jpeg", quality: 98 }
    imagePackerApi.packing(pixelMap, packOpts, (err: BusinessError, data: ArrayBuffer) => { 
        console.info('Succeeded in packing the image.');
    })
}).catch((error: BusinessError) => {
	console.error('createPixelMap failed.');
})

packing⁸⁺

packing(source: PixelMap, option: PackingOption): Promise<ArrayBuffer>

图片压缩或重新打包，使用Promise形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImagePacker

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

const color: ArrayBuffer = new ArrayBuffer(96); // 96为需要创建的像素buffer大小，取值为：height * width *4
let opts: image.InitializationOptions = { editable: true, pixelFormat: 3, size: { height: 4, width: 6 } }
image.createPixelMap(color, opts).then((pixelMap: image.PixelMap) => {
    let packOpts: image.PackingOption = { format: "image/jpeg", quality: 98 }
    imagePackerApi.packing(pixelMap, packOpts)
        .then((data: ArrayBuffer) => {
            console.info('Succeeded in packing the image.');
        }).catch((error: BusinessError) => {
            console.error('Failed to pack the image..');
        })
}).catch((error: BusinessError) => {
	console.error('createPixelMap failed.');
})

release

release(callback: AsyncCallback<void>): void

释放图片打包实例，使用callback形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImagePacker

参数：

示例：

import { BusinessError } from '@ohos.base';

imagePackerApi.release((err: BusinessError)=>{ 
    if (err != undefined) {
        console.error('Failed to release image packaging.'); 
    } else {
        console.info('Succeeded in releasing image packaging.');
    }
})

release

release(): Promise<void>

释放图片打包实例，使用Promise形式返回释放结果。

系统能力： SystemCapability.Multimedia.Image.ImagePacker

返回值：

示例：

import { BusinessError } from '@ohos.base';

imagePackerApi.release().then(() => {
    console.info('Succeeded in releasing image packaging.');
}).catch((error: BusinessError) => { 
    console.error('Failed to release image packaging.'); 
})

packToFile¹¹⁺

packToFile(source: ImageSource, fd: number, options: PackingOption, callback: AsyncCallback<void>): void

指定打包参数，将ImageSource图片源编码后直接打包进文件。使用callback形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImagePacker

参数：

示例：

import { BusinessError } from '@ohos.base'
import fs from '@ohos.file.fs'

const context: Context = getContext(this);
const path: string = context.filesDir + "/test.png";
const imageSourceApi: image.ImageSource = image.createImageSource(path);
let packOpts: image.PackingOption = { format: "image/jpeg", quality: 98 };
const filePath: string = context.cacheDir + "/image_source.jpg";
let file = fs.openSync(filePath, fs.OpenMode.CREATE | fs.OpenMode.READ_WRITE);
const imagePackerApi: image.ImagePacker = image.createImagePacker();
imagePackerApi.packToFile(imageSourceApi, file.fd, packOpts, (err: BusinessError) => {
    if (err) {
        console.error('packToFile failed.');
    } else {
        console.info('packToFile succeeded.');
    }
})

packToFile¹¹⁺

packToFile (source: ImageSource, fd: number, options: PackingOption): Promise<void>

指定打包参数，将ImageSource图片源编码后直接打包进文件。使用Promise形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImagePacker

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base'
import fs from '@ohos.file.fs'

const context: Context = getContext(this);
const path: string = context.filesDir + "/test.png";
const imageSourceApi: image.ImageSource = image.createImageSource(path);
let packOpts: image.PackingOption = { format: "image/jpeg", quality: 98 };
const filePath: string = context.cacheDir + "/image_source.jpg";
let file = fs.openSync(filePath, fs.OpenMode.CREATE | fs.OpenMode.READ_WRITE);
const imagePackerApi: image.ImagePacker = image.createImagePacker();
imagePackerApi.packToFile(imageSourceApi, file.fd, packOpts).then(() => {
    console.info('Succeeded in packToFile.');
}).catch((error: BusinessError) => { 
    console.error('Failed to packToFile.'); 
}) 

packToFile¹¹⁺

packToFile (source: PixelMap, fd: number, options: PackingOption, callback: AsyncCallback<void>): void;

指定打包参数，将PixelMap图片源编码后直接打包进文件。使用callback形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImagePacker

参数：

示例：

import { BusinessError } from '@ohos.base'
import fs from '@ohos.file.fs'

const color: ArrayBuffer = new ArrayBuffer(96); // 96为需要创建的像素buffer大小，取值为：height * width *4
let opts: image.InitializationOptions = { editable: true, pixelFormat: 3, size: { height: 4, width: 6 } }
const context: Context = getContext(this);
const path: string = context.cacheDir + "/pixel_map.jpg";
image.createPixelMap(color, opts).then((pixelmap: image.PixelMap) => {
    let packOpts: image.PackingOption = { format: "image/jpeg", quality: 98 }
    let file = fs.openSync(path, fs.OpenMode.CREATE | fs.OpenMode.READ_WRITE);
    const imagePackerApi: image.ImagePacker = image.createImagePacker();
    imagePackerApi.packToFile(pixelmap, file.fd, packOpts, (err: BusinessError) => {
        if (err) {
            console.error('packToFile failed.');
        } else {
            console.info('packToFile succeeded.');
        }
    })
})

packToFile¹¹⁺

packToFile (source: PixelMap, fd: number, options: PackingOption): Promise<void>

指定打包参数，将PixelMap图片源编码后直接打包进文件。使用Promise形式返回结果。

系统能力： SystemCapability.Multimedia.Image.ImagePacker

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base'
import fs from '@ohos.file.fs'

const color: ArrayBuffer = new ArrayBuffer(96); // 96为需要创建的像素buffer大小，取值为：height * width *4
let opts: image.InitializationOptions = { editable: true, pixelFormat: 3, size: { height: 4, width: 6 } }
const context: Context = getContext(this);
const path: string = context.cacheDir + "/pixel_map.jpg";
image.createPixelMap(color, opts).then((pixelmap: image.PixelMap) => {
    let packOpts: image.PackingOption = { format: "image/jpeg", quality: 98 }
    let file = fs.openSync(path, fs.OpenMode.CREATE | fs.OpenMode.READ_WRITE);
    const imagePackerApi: image.ImagePacker = image.createImagePacker();
    imagePackerApi.packToFile(pixelmap, file.fd, packOpts)
        .then(() => {
            console.info('Succeeded in packToFile.');
        }).catch((error: BusinessError) => {
            console.error('Failed to packToFile.');
        })
})

image.createImageReceiver¹¹⁺

createImageReceiver(size: Size, format: ImageFormat, capacity: number): ImageReceiver

通过图片大小、图片格式、容量创建ImageReceiver实例。

系统能力： SystemCapability.Multimedia.Image.ImageReceiver

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

let size: image.Size = {
    height: 8192,
    width: 8
} 
let receiver: image.ImageReceiver = image.createImageReceiver(size, image.ImageFormat.JPEG, 8);

image.createImageReceiver^(deprecated)

createImageReceiver(width: number, height: number, format: number, capacity: number): ImageReceiver

通过宽、高、图片格式、容量创建ImageReceiver实例。

说明：

从API version 11开始不再维护，建议使用createImageReceiver代替。

系统能力： SystemCapability.Multimedia.Image.ImageReceiver

参数：

返回值：

示例：

let receiver: image.ImageReceiver = image.createImageReceiver(8192, 8, image.ImageFormat.JPEG, 8);

ImageReceiver⁹⁺

图像接收类，用于获取组件surface id，接收最新的图片和读取下一张图片，以及释放ImageReceiver实例。

在调用以下方法前需要先创建ImageReceiver实例。

属性

系统能力： SystemCapability.Multimedia.Image.ImageReceiver

getReceivingSurfaceId⁹⁺

getReceivingSurfaceId(callback: AsyncCallback<string>): void

用于获取一个surface id供Camera或其他组件使用。使用callback返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageReceiver

参数：

示例:

import { BusinessError } from '@ohos.base';

receiver.getReceivingSurfaceId((err: BusinessError, id: string) => { 
    if (err) {
        console.error('getReceivingSurfaceId failed.');
    } else {
        console.info('getReceivingSurfaceId succeeded.');
    }
});

getReceivingSurfaceId⁹⁺

getReceivingSurfaceId(): Promise<string>

用于获取一个surface id供Camera或其他组件使用。使用promise返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageReceiver

返回值：

示例：

import { BusinessError } from '@ohos.base';

receiver.getReceivingSurfaceId().then((id: string) => { 
    console.info('getReceivingSurfaceId succeeded.');
}).catch((error: BusinessError) => {
    console.error('getReceivingSurfaceId failed.');
})

readLatestImage⁹⁺

readLatestImage(callback: AsyncCallback<Image>): void

从ImageReceiver读取最新的图片，并使用callback返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageReceiver

参数：

示例：

import { BusinessError } from '@ohos.base';

receiver.readLatestImage((err: BusinessError, img: image.Image) => { 
    if (err) {
        console.error('readLatestImage failed.');
    } else {
        console.info('readLatestImage succeeded.');
    }
});

readLatestImage⁹⁺

readLatestImage(): Promise<Image>

从ImageReceiver读取最新的图片，并使用promise返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageReceiver

返回值：

示例：

import { BusinessError } from '@ohos.base';

receiver.readLatestImage().then((img: image.Image) => {
    console.info('readLatestImage succeeded.');
}).catch((error: BusinessError) => {
    console.error('readLatestImage failed.');
})

readNextImage⁹⁺

readNextImage(callback: AsyncCallback<Image>): void

从ImageReceiver读取下一张图片，并使用callback返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageReceiver

参数：

示例：

import { BusinessError } from '@ohos.base';

receiver.readNextImage((err: BusinessError, img: image.Image) => { 
    if (err) {
        console.error('readNextImage failed.');
    } else {
        console.info('readNextImage succeeded.');
    }
});

readNextImage⁹⁺

readNextImage(): Promise<Image>

从ImageReceiver读取下一张图片，并使用promise返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageReceiver

返回值：

示例：

import { BusinessError } from '@ohos.base';

receiver.readNextImage().then((img: image.Image) => {
    console.info('readNextImage succeeded.');
}).catch((error: BusinessError) => {
    console.error('readNextImage failed.');
})

on⁹⁺

on(type: 'imageArrival', callback: AsyncCallback<void>): void

接收图片时注册回调。

系统能力： SystemCapability.Multimedia.Image.ImageReceiver

参数：

示例：

receiver.on('imageArrival', () => {
    // image arrival, do something.
})

release⁹⁺

release(callback: AsyncCallback<void>): void

释放ImageReceiver实例并使用回调返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageReceiver

参数：

示例：

import { BusinessError } from '@ohos.base'

receiver.release((err: BusinessError) => {
    if (err) {
        console.error('release ImageReceiver failed.');
    } else {
        console.info('release ImageReceiver succeeded.');
    }
})

release⁹⁺

release(): Promise<void>

释放ImageReceiver实例并使用promise返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageReceiver

返回值：

示例：

import { BusinessError } from '@ohos.base';

receiver.release().then(() => {
    console.info('release succeeded.');
}).catch((error: BusinessError) => {
    console.error('release failed.');
})

image.createImageCreator¹¹⁺

createImageCreator(size: Size, format: ImageFormat, capacity: number): ImageCreator

通过图片大小、图片格式、容量创建ImageCreator实例。

系统能力： SystemCapability.Multimedia.Image.ImageCreator

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Image错误码。

示例：

let size: image.Size = {
    height: 8192,
    width: 8
} 
let creator: image.ImageCreator = image.createImageCreator(size, image.ImageFormat.JPEG, 8);

image.createImageCreator^(deprecated)

createImageCreator(width: number, height: number, format: number, capacity: number): ImageCreator

通过宽、高、图片格式、容量创建ImageCreator实例。

说明：

从API version 11开始不再维护，建议使用createImageCreator代替。

系统能力： SystemCapability.Multimedia.Image.ImageCreator

参数：

返回值：

示例：

let creator: image.ImageCreator = image.createImageCreator(8192, 8, image.ImageFormat.JPEG, 8);

ImageCreator⁹⁺

图像创建模块，用于请求图像原生数据区域，并开放给应用编译原生图像数据的能力。 在调用以下方法前需要先创建ImageCreator实例，ImageCreator不支持多线程。

属性

系统能力： SystemCapability.Multimedia.Image.ImageCreator

dequeueImage⁹⁺

dequeueImage(callback: AsyncCallback<Image>): void

从空闲队列中获取buffer图片，用于绘制UI内容，并使用callback返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageCreator

参数：

示例：

import { BusinessError } from '@ohos.base';

creator.dequeueImage((err: BusinessError, img: image.Image) => {
    if (err) {
        console.error('dequeueImage failed.');
    } else {
        console.info('dequeueImage succeeded.');
    }
});

dequeueImage⁹⁺

dequeueImage(): Promise<Image>

从空闲队列中获取buffer图片，用于绘制UI内容，并使用promise返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageCreator

返回值：

示例：

import { BusinessError } from '@ohos.base';

creator.dequeueImage().then((img: image.Image) => {
    console.info('dequeueImage succeeded.');
}).catch((error: BusinessError) => {
    console.error('dequeueImage failed: ' + error);
})

queueImage⁹⁺

queueImage(interface: Image, callback: AsyncCallback<void>): void

将绘制好的图片放入Dirty队列，并使用callback返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageCreator

参数：

示例：

import { BusinessError } from '@ohos.base';

creator.dequeueImage().then((img: image.Image) => {
    //绘制图片
    img.getComponent(4).then((component : image.Component) => {
        let bufferArr: Uint8Array = new Uint8Array(component.byteBuffer);
        for (let i = 0; i < bufferArr.length; i += 4) {
            bufferArr[i] = 0; //B
            bufferArr[i + 1] = 0; //G
            bufferArr[i + 2] = 255; //R
            bufferArr[i + 3] = 255; //A
        }
    })
    creator.queueImage(img, (err: BusinessError) => {
        if (err) {
            console.error('queueImage failed: ' + err);
        } else {
            console.info('queueImage succeeded');
        }
    })
})

queueImage⁹⁺

queueImage(interface: Image): Promise<void>

将绘制好的图片放入Dirty队列，并使用promise返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageCreator

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

creator.dequeueImage().then((img: image.Image) => {
    //绘制图片
    img.getComponent(4).then((component: image.Component) => {
        let bufferArr: Uint8Array = new Uint8Array(component.byteBuffer);
        for (let i = 0; i < bufferArr.length; i += 4) {
            bufferArr[i] = 0; //B
            bufferArr[i + 1] = 0; //G
            bufferArr[i + 2] = 255; //R
            bufferArr[i + 3] = 255; //A
        }
    })
    creator.queueImage(img).then(() => {
        console.info('queueImage succeeded.');
    }).catch((error: BusinessError) => {
        console.error('queueImage failed: ' + error);
    })
})

on⁹⁺

on(type: 'imageRelease', callback: AsyncCallback<void>): void

监听imageRelease事件，并使用callback返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageCreator

参数：

示例：

import { BusinessError } from '@ohos.base';

creator.on('imageRelease', (err: BusinessError) => {
    if (err) {
        console.error('on faild' + err);
    } else {
        console.info('on succeeded');
    }
})

release⁹⁺

release(callback: AsyncCallback<void>): void

释放当前图像，并使用callback返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageCreator

参数：

示例：

import { BusinessError } from '@ohos.base';

creator.release((err: BusinessError) => {
    if (err) {
        console.error('release failed: ' + err);
    } else {
        console.info('release succeeded');
    }
});

release⁹⁺

release(): Promise<void>

释放当前图像，并使用promise返回结果。

系统能力： SystemCapability.Multimedia.Image.ImageCreator

返回值：

示例：

import { BusinessError } from '@ohos.base';

creator.release().then(() => {
    console.info('release succeeded');
}).catch((error: BusinessError) => {
    console.error('release failed');
})

Image⁹⁺

提供基本的图像操作，包括获取图像信息、读写图像数据。调用readNextImage和readLatestImage接口时会返回image。

属性

系统能力： SystemCapability.Multimedia.Image.Core

getComponent⁹⁺

getComponent(componentType: ComponentType, callback: AsyncCallback<Component>): void

根据图像的组件类型从图像中获取组件缓存并使用callback返回结果。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

img.getComponent(4, (err: BusinessError, component: image.Component) => {
    if (err) {
        console.error('getComponent failed.');
    } else {
        console.info('getComponent succeeded.');
    }
})

getComponent⁹⁺

getComponent(componentType: ComponentType): Promise<Component>

根据图像的组件类型从图像中获取组件缓存并使用Promise方式返回结果。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

返回值：

示例：

import { BusinessError } from '@ohos.base';

img.getComponent(4).then((component: image.Component) => {
    console.info('getComponent succeeded.');
}).catch((error: BusinessError) => {
    console.error('getComponent failed');
})

release⁹⁺

release(callback: AsyncCallback<void>): void

释放当前图像并使用callback返回结果。

在接收另一个图像前必须先释放对应资源。

系统能力： SystemCapability.Multimedia.Image.Core

参数：

示例：

import { BusinessError } from '@ohos.base';

img.release((err: BusinessError) => {
    if (err != undefined) {
        console.error('Failed to release the image source instance.');
    } else {
        console.info('Succeeded in releasing the image source instance.');
    }
})

release⁹⁺

release(): Promise<void>

释放当前图像并使用Promise方式返回结果。

在接收另一个图像前必须先释放对应资源。

系统能力： SystemCapability.Multimedia.Image.Core

返回值：

示例：

import { BusinessError } from '@ohos.base';

img.release().then(() => {
    console.info('release succeeded.');
}).catch((error: BusinessError) => {
    console.error('release failed.');
})

PositionArea⁷⁺

表示图片指定区域内的数据。

系统能力： SystemCapability.Multimedia.Image.Core

ImageInfo

表示图片信息。

系统能力： SystemCapability.Multimedia.Image.Core

Size

表示图片尺寸。

系统能力： SystemCapability.Multimedia.Image.Core

PixelMapFormat⁷⁺

枚举，图片像素格式。

系统能力： SystemCapability.Multimedia.Image.Core

AlphaType⁹⁺

枚举，图像的透明度类型。

系统能力： SystemCapability.Multimedia.Image.Core

ScaleMode⁹⁺

枚举，图像的缩放模式。

系统能力： SystemCapability.Multimedia.Image.Core

SourceOptions⁹⁺

ImageSource的初始化选项。

系统能力： SystemCapability.Multimedia.Image.Core

InitializationOptions⁸⁺

PixelMap的初始化选项。

系统能力： SystemCapability.Multimedia.Image.Core

DecodingOptions⁷⁺

图像解码设置选项。

系统能力： SystemCapability.Multimedia.Image.ImageSource

Region⁷⁺

表示区域信息。

系统能力： SystemCapability.Multimedia.Image.Core

PackingOption

表示图片打包选项。

系统能力： SystemCapability.Multimedia.Image.ImagePacker

ImagePropertyOptions¹¹⁺

表示查询图片属性的索引。

系统能力： SystemCapability.Multimedia.Image.ImageSource

GetImagePropertyOptions^(deprecated)

表示查询图片属性的索引。

说明：

从API version 11开始不再维护，建议使用ImagePropertyOptions代替。

系统能力： SystemCapability.Multimedia.Image.ImageSource

PropertyKey⁷⁺

枚举，Exif（Exchangeable image file format）图片信息。

系统能力： SystemCapability.Multimedia.Image.Core