鸿蒙（API 12 Beta3版）【自界说界面扫码】

基本概念

自界说界面扫码本领提供了相机流控制接口，可根据自身需求自界说扫码界面，适用于对扫码界面有定制化需求的应用开发。
说明
通过自界说页面扫码可以实现应用内的扫码功能，为了应用更好的体验，保举同时[接入“扫码直达”服务]，应用可以同时支持系统扫码入口（控制中心扫一扫）和应用内扫码两种方式跳转到指定服务页面。
场景先容

自界说界面扫码本领提供扫码相机流控制接口，支持相机流的初始化、开启、暂停、释放、重新扫码功能；支持闪光灯的状态获取、开启、关闭；支持变焦比的获取和设置；支持设置相机核心和连续主动对焦；支持对条形码、二维码、MULTIFUNCTIONAL CODE进行扫码识别（详细类型参见[ScanType]），并获得码类型、码值、码位置信息、相机预览流（YUV）。该本领可用于单码和多码的扫描识别。
开发者集成自界说界面扫码本领可以自行界说扫码的界面样式，请按照业务流程完成扫码接口调用实现实时扫码功能。建议开发者基于[Sample Code]做个性化修改。
说明
YUV（相机预览流图像数据）适合于扫码和识物的综合识别场景，开发者需要自己控制相机流，普通扫码场景无需关注。
约束与限定

• 需要请求相机的利用权限。
  
• 需要开发者自行实现扫码的人机交互界面。比方：多码场景需要暂停相机流由用户选择一个码图进行识别。
  

业务流程

• 发起请求： 用户向开发者的应用发起扫码请求，应用拉起已界说好的扫码界面。
  
• 申请授权： 应用需要向用户申请相机权限授权。若未同意授权，则无法利用此功能。
  
• 启动自界说界面扫码： 在扫码前必须调用init接口初始化自界说扫码界面，加载资源。相机流初始化竣事后，调用start接口开始扫码。
  
• 自界说界面扫码相机操作： 可以设置自界说界面扫码相机操作参数，调整相应功能，包括闪光灯、变焦、焦距、暂停、重启扫码等。比方：
  
  
  
  • 根据当前码图位置，比如当前码图太远或太近时，调用getZoom获取变焦比，setZoom接口设置变焦比，调整焦距以便于用户扫码。
    
  • 根据当前扫码的光线条件或根据on(‘lightingFlash’)监听闪光灯开启时机，通过getFlashLightStatus接口先获取闪光灯状态，再调用openFlashLight/closeFlashLight接口控制闪光灯开启或关闭，以便于用户进行扫码。
    
  • 调用setFocusPoint设置对焦位置，resetFocus规复默认对焦模式，以便于用户进行扫码。
    
  • 在应用处于前后台或其他特别场景需要停止/重新进行扫码时，可调用stop或start接口来控制相机流达到暂停或重新扫码的目的。
    
  
  
• 自界说界面扫码： Scan Kit API在扫码完成后会返回扫码结果。同时根据开发者的需要，Scan Kit API会返回每帧相机预览流数据。如需不重启相机并重新触发一次扫码，可以在start接口的Callback异步回调中，调用rescan接口。完成扫码后，需调用release接口进行释放扫码资源的操作。
  
• 获取结果： 解析码值结果跳转应用服务页。
  

接口说明

自界说界面扫码提供init、start、stop、release、getFlashLightStatus、openFlashLight、closeFlashLight、setZoom、getZoom、setFocusPoint、resetFocus、rescan、on(‘lightingFlash’)、off(‘lightingFlash’)接口，其中部分接口返回值有两种返回形式：Callback和Promise回调。Callback和Promise回调函数只是返回值方式不一样，功能相同。
接口名描述[init](options?: scanBarcode.[ScanOptions]): void初始化自界说界面扫码，加载资源。无返回结果。[start](viewControl: [ViewControl]): Promise<Array<scanBarcode.[ScanResult]>>启动扫码相机流。利用Promise异步回调获取扫码结果。stop: Promise暂停扫码相机流。利用Promise异步回调返回执行结果。release: Promise释放扫码相机流。利用Promise异步回调返回执行结果。[start](viewControl: ViewControl, callback: AsyncCallback<Array<scanBarcode.ScanResult>>, frameCallback?: AsyncCallback<[ScanFrame]>): void启动扫码相机流。利用Callback异步回调返回扫码结果以及YUV图像数据。getFlashLightStatus: boolean获取闪光灯状态。返回结果为布尔值，true为打开状态，false为关闭状态。openFlashLight: void开启闪光灯。无返回结果。closeFlashLight: void关闭闪光灯。无返回结果。[setZoom](zoomValue : number): void设置变焦比。无返回结果。getZoom: number获取当前的变焦比。[setFocusPoint](point: scanBarcode.[Point]): void设置相机核心。resetFocus: void设置连续主动对焦模式。rescan: void触发一次重新扫码。仅对start接口Callback异步回调有效，Promise异步回调无效。[stop](callback: AsyncCallback): void暂停扫码相机流。利用Callback异步回调返回执行结果。[release](callback: AsyncCallback): void释放扫码相机流。利用Callback异步回调返回执行结果。[on](type: ‘lightingFlash’, callback: AsyncCallback): void注册闪光灯打开时机回调，利用Callback异步回调返回闪光灯打开时机。[off](type: ‘lightingFlash’, callback?: AsyncCallback): void注销闪光灯打开时机回调，利用Callback异步回调返回注销结果。 开发步骤

自界说界面扫码接口支持自界说UI界面，识别相机流中的条形码，二维码以及MULTIFUNCTIONAL CODE，并返回码图的值、类型、码的位置信息（码图最小外接矩形左上角和右下角的坐标）以及相机预览流（YUV）。
以下示例为调用自界说界面扫码接口拉起相机流并返回扫码结果和相机预览流（YUV）。

• 在开发应用前，需要先申请相机相干权限，确保应用拥有访问相机的权限。在“module.json5”文件中设置相机权限，详细设置方式
     权限名说明授权方式ohos.permission.CAMERA答应应用利用相机扫码。user_grant
  
• 利用接口[requestPermissionsFromUser]请求用户授权。详细申请方式及校验方式。
  
• 导入自界说界面扫码接口以及相干接口模块，导入方法如下。
  

1. import { scanCore, scanBarcode, customScan } from '@kit.ScanKit';
2. // 导入功能涉及的权限申请、回调接口
3. import { router, promptAction, display } from '@kit.ArkUI';
4. import { AsyncCallback, BusinessError } from '@kit.BasicServicesKit';
5. import { hilog } from '@kit.PerformanceAnalysisKit';
6. import { common, abilityAccessCtrl } from '@kit.AbilityKit';

复制代码

• 遵循[业务流程]完成自界说界面扫码功能。
  说明
  
  
  
  • 在设置start接口的viewControl参数时，width和height与[XComponent]的宽高值相同，start接口会根据XComponent的宽高比例从相机的分辨率选择最优分辨率，假如比例与相机的分辨率比例相差过大会返回内部错误。当前支持的分辨率比例为16:9、4:3、1:1。竖屏场景下，XComponent的高度需要大于宽度，且高宽比在支持的分辨率比例中。横屏场景下，XComponent的宽度需要大于高度，且宽高比在支持的分辨率比例中。
    
  • XComponent的宽高需根据利用场景盘算适配。比方：在开发设备为折叠屏时，需按照折叠屏的展开态和折叠态分别盘算XComponent的宽高，start接口会根据XComponent的宽高适配对应的相机分辨率。设备屏幕宽高可通过[display.getDefaultDisplaySync]方法获取（获取的为px单位，需要通过[px2vp]。
    
     
  
  
  
  • 通过Promise方式回调，调用自界说界面扫码接口拉起相机流并返回扫码结果。
    
  
  

1. @Entry
2. @Component
3. struct CustomScanPage {
4.   @State userGrant: boolean = false // 是否已申请相机权限
5.   @State surfaceId: string = '' // xComponent组件生成id
6.   @State isShowBack: boolean = false // 是否已经返回扫码结果
7.   @State isFlashLightEnable: boolean = false // 是否开启了闪光灯
8.   @State isSensorLight: boolean = false // 记录当前环境亮暗状态
9.   @State cameraHeight: number = 640 // 设置预览流高度，默认单位：vp
10.   @State cameraWidth: number = 360 // 设置预览流宽度，默认单位：vp
11.   @State cameraOffsetX: number = 0 // 设置预览流x轴方向偏移量，默认单位：vp
12.   @State cameraOffsetY: number = 0 // 设置预览流y轴方向偏移量，默认单位：vp
13.   @State zoomValue: number = 1 // 预览流缩放比例
14.   @State setZoomValue: number = 1 // 已设置的预览流缩放比例
15.   @State scaleValue: number = 1 // 屏幕缩放比
16.   @State pinchValue: number = 1 // 双指缩放比例
17.   @State displayHeight: number = 0 // 屏幕高度，单位vp
18.   @State displayWidth: number = 0 // 屏幕宽度，单位vp
19.   @State scanResult: Array<scanBarcode.ScanResult> = [] // 扫码结果
20.   private mXComponentController: XComponentController = new XComponentController()
21.   private TAG: string = '[customScanPage]'
23.   async onPageShow() {
24.     // 自定义启动第一步，用户申请权限
25.     await this.requestCameraPermission();
26.     // 多码扫码识别，enableMultiMode: true 单码扫码识别enableMultiMode: false
27.     let options: scanBarcode.ScanOptions = {
28.       scanTypes: [scanCore.ScanType.ALL],
29.       enableMultiMode: true,
30.       enableAlbum: true
31.     }
32.     // 自定义启动第二步：设置预览流布局尺寸
33.     this.setDisplay();
34.     // 自定义启动第三步，初始化接口
35.     customScan.init(options);
36.   }
38.   async onPageHide() {
39.     // 页面消失或隐藏时，停止并释放相机流
40.     this.userGrant = false;
41.     this.isFlashLightEnable = false;
42.     this.isSensorLight = false;
43.     try {
44.       customScan.off('lightingFlash');
45.     } catch (error) {
46.       hilog.error(0x0001, this.TAG, `Failed to off lightingFlash. Code: ${error.code}, message: ${error.message}`);
47.     }
48.     await customScan.stop();
49.     // 自定义相机流释放接口
50.     customScan.release().then(() => {
51.       hilog.info(0x0001, this.TAG, 'Succeeded in releasing customScan by promise.');
52.     }).catch((error: BusinessError) => {
53.       hilog.error(0x0001, this.TAG,
54.         `Failed to release customScan by promise. Code: ${error.code}, message: ${error.message}`);
55.     })
56.   }
58.   // 用户申请权限
59.   async reqPermissionsFromUser(): Promise<number[]> {
60.     hilog.info(0x0001, this.TAG, 'reqPermissionsFromUser start');
61.     let context = getContext() as common.UIAbilityContext;
62.     let atManager = abilityAccessCtrl.createAtManager();
63.     let grantStatus = await atManager.requestPermissionsFromUser(context, ['ohos.permission.CAMERA']);
64.     return grantStatus.authResults;
65.   }
67.   // 用户申请相机权限
68.   async requestCameraPermission() {
69.     let grantStatus = await this.reqPermissionsFromUser();
70.     for (let i = 0; i < grantStatus.length; i++) {
71.       if (grantStatus[i] === 0) {
72.         // 用户授权，可以继续访问目标操作
73.         hilog.info(0x0001, this.TAG, 'Succeeded in getting permissions.');
74.         this.userGrant = true;
75.       }
76.     }
77.   }
79.   // 竖屏时获取屏幕尺寸，设置预览流全屏示例
80.   setDisplay() {
81.     // 默认竖屏
82.     let displayClass = display.getDefaultDisplaySync();
83.     this.displayHeight = px2vp(displayClass.height);
84.     this.displayWidth = px2vp(displayClass.width);
85.     let maxLen: number = Math.max(this.displayWidth, this.displayHeight);
86.     let minLen: number = Math.min(this.displayWidth, this.displayHeight);
87.     const RATIO: number = 16 / 9;
88.     this.cameraHeight = maxLen;
89.     this.cameraWidth = maxLen / RATIO;
90.     this.cameraOffsetX = (minLen - this.cameraWidth) / 2;
91.   }
93.   // toast显示扫码结果
94.   async showScanResult(result: scanBarcode.ScanResult) {
95.     // 使用toast显示出扫码结果
96.     promptAction.showToast({
97.       message: JSON.stringify(result),
98.       duration: 5000
99.     });
100.   }
101.   initCamera() {
102.     this.isShowBack = false;
103.     this.scanResult = [];
104.     let viewControl: customScan.ViewControl = {
105.       width: this.cameraWidth,
106.       height: this.cameraHeight,
107.       surfaceId: this.surfaceId
108.     };
109.     // 自定义启动第四步，请求扫码接口，通过Promise方式回调
110.     customScan.start(viewControl)
111.       .then(async (result: Array<scanBarcode.ScanResult>) => {
112.         hilog.info(0x0001, this.TAG, `result: ${JSON.stringify(result)}`);
113.         if (result.length) {
114.           // 解析码值结果跳转应用服务页
115.           this.scanResult = result;
116.           this.isShowBack = true;
117.           // 获取到扫描结果后暂停相机流
118.           customScan.stop();
119.         }
120.       });
121.   }
123.   // 自定义扫码界面的顶部返回按钮和扫码提示
124.   @Builder
125.   TopTool() {
126.     Column() {
127.       Flex({ direction: FlexDirection.Row, justifyContent: FlexAlign.SpaceBetween, alignItems: ItemAlign.Center }) {
128.         Text('返回')
129.           .onClick(async () => {
130.             router.back();
131.           })
132.       }.padding({ left: 24, right: 24, top: 40 })
134.       Column() {
135.         Text('扫描二维码/条形码')
136.         Text('对准二维码/条形码，即可自动扫描')
137.       }.margin({ left: 24, right: 24, top: 24 })
138.     }
139.     .height(146)
140.     .width('100%')
141.   }
143.   build() {
144.     Stack() {
145.       if (this.userGrant) {
146.         Column() {
147.           XComponent({
148.             id: 'componentId',
149.             type: XComponentType.SURFACE,
150.             controller: this.mXComponentController
151.           })
152.             .onLoad(async () => {
153.               hilog.info(0x0001, this.TAG, 'Succeeded in loading, onLoad is called.');
154.               // 获取XComponent组件的surfaceId
155.               this.surfaceId = this.mXComponentController.getXComponentSurfaceId();
156.               hilog.info(0x0001, this.TAG, `Succeeded in getting surfaceId: ${this.surfaceId}`);
157.               this.initCamera();
158.               // 闪光灯监听接口
159.               customScan.on('lightingFlash', (error, isLightingFlash) => {
160.                 if (error) {
161.                   hilog.error(0x0001, this.TAG,
162.                     `Failed to on lightingFlash. Code: ${error.code}, message: ${error.message}`);
163.                   return;
164.                 }
165.                 if (isLightingFlash) {
166.                   this.isFlashLightEnable = true;
167.                 } else {
168.                   if (!customScan.getFlashLightStatus()) {
169.                     this.isFlashLightEnable = false;
170.                   }
171.                 }
172.                 this.isSensorLight = isLightingFlash;
173.               });
174.             })  
175.             .width(this.cameraWidth)
176.             .height(this.cameraHeight)
177.             .position({ x: this.cameraOffsetX, y: this.cameraOffsetY })
178.         }
179.         .height('100%')
180.         .width('100%')
181.       }
183.       Column() {
184.         this.TopTool()
185.         Column() {
186.         }
187.         .layoutWeight(1)
188.         .width('100%')
190.         Column() {
191.           Row() {
192.             // 闪光灯按钮，启动相机流后才能使用
193.             Button('FlashLight')
194.               .onClick(() => {
195.                 // 根据当前闪光灯状态，选择打开或关闭闪关灯
196.                 if (customScan.getFlashLightStatus()) {
197.                   customScan.closeFlashLight();
198.                   setTimeout(() => {
199.                     this.isFlashLightEnable = this.isSensorLight;
200.                   }, 200);
201.                 } else {
202.                   customScan.openFlashLight();
203.                 }
204.               })
205.               .visibility((this.userGrant && this.isFlashLightEnable) ? Visibility.Visible : Visibility.None)
207.             // 扫码成功后，点击按钮后重新扫码
208.             Button('Scan')
209.               .onClick(() => {
210.                 // 点击按钮重启相机流，重新扫码
211.                 this.initCamera();
212.               })
213.               .visibility(this.isShowBack ? Visibility.Visible : Visibility.None)
214.           }
216.           Row() {
217.             // 预览流设置缩放比例
218.             Button('缩放比例,当前比例:' + this.setZoomValue)
219.               .onClick(() => {
220.                 // 设置相机缩放比例
221.                 if (!this.isShowBack) {
222.                   if (!this.zoomValue || this.zoomValue === this.setZoomValue) {
223.                     this.setZoomValue = customScan.getZoom();
224.                   } else {
225.                     this.zoomValue = this.zoomValue;
226.                     customScan.setZoom(this.zoomValue);
227.                     setTimeout(() => {
228.                       if (!this.isShowBack) {
229.                         this.setZoomValue = customScan.getZoom();
230.                       }
231.                     }, 1000);
232.                   }
233.                 }
234.               })
235.           }
236.           .margin({ top: 10, bottom: 10 })
238.           Row() {
239.             // 输入要设置的预览流缩放比例
240.             TextInput({ placeholder: '输入缩放倍数' })
241.               .type(InputType.Number)
242.               .borderWidth(1)
243.               .backgroundColor(Color.White)
244.               .onChange(value => {
245.                 this.zoomValue = Number(value);
246.               })
247.           }
248.         }
249.         .width('50%')
250.         .height(180)
251.       }
253.       // 单码、多码扫描后，显示码图蓝点位置。点击toast码图信息
254.       ForEach(this.scanResult, (item: scanBarcode.ScanResult, index: number) => {
255.         if (item.scanCodeRect) {
256.           Image($rawfile('scan_selected2.svg'))
257.             .width(40)
258.             .height(40)
259.             .markAnchor({ x: 20, y: 20 })
260.             .position({
261.               x: (item.scanCodeRect.left + item?.scanCodeRect?.right) / 2 + this.cameraOffsetX,
262.               y: (item.scanCodeRect.top + item?.scanCodeRect?.bottom) / 2 + this.cameraOffsetY
263.             })
264.             .onClick(() => {
265.               this.showScanResult(item);
266.             })
267.         }
268.       })
269.     }
270.     // 建议相机流设置为全屏
271.     .width('100%')
272.     .height('100%')
273.     .onClick((event: ClickEvent) => {
274.       // 是否已扫描到结果
275.       if (this.isShowBack) {
276.         return;
277.       }
278.       // 点击屏幕位置，获取点击位置(x,y)，设置相机焦点
279.       let x1 = vp2px(event.displayY) / (this.displayHeight + 0.0);
280.       let y1 = 1.0 - (vp2px(event.displayX) / (this.displayWidth + 0.0));
281.       customScan.setFocusPoint({ x: x1, y: y1 });
282.       hilog.info(0x0001, this.TAG, `Succeeded in setting focusPoint x1: ${x1}, y1: ${y1}`);
283.       // 设置连续自动对焦模式
284.       setTimeout(() => {
285.         customScan.resetFocus();
286.       }, 200);
287.     }).gesture(PinchGesture({ fingers: 2 })
288.       .onActionStart((event: GestureEvent) => {
289.         hilog.info(0x0001, this.TAG, 'Pinch start');
290.       })
291.       .onActionUpdate((event: GestureEvent) => {
292.         if (event) {
293.           this.scaleValue = event.scale;
294.         }
295.       })
296.       .onActionEnd((event: GestureEvent) => {
297.         // 是否已扫描到结果
298.         if (this.isShowBack) {
299.           return;
300.         }
301.         // 获取双指缩放比例，设置变焦比
302.         try {
303.           let zoom = customScan.getZoom();
304.           this.pinchValue = this.scaleValue * zoom;
305.           customScan.setZoom(this.pinchValue);
306.           hilog.info(0x0001, this.TAG, 'Pinch end');
307.         } catch (error) {
308.           hilog.error(0x0001, this.TAG, `Failed to setZoom. Code: ${error.code}, message: ${error.message}`);
309.         }
310.       }))
311.   }
312. }

复制代码

• 通过Callback方式回调，调用自界说界面扫码接口拉起相机流并返回扫码结果和相机预览流（YUV）。
  

1. import { bundleManager, PermissionRequestResult, Permissions } from '@kit.AbilityKit';
3. const TAG = '[YUV CPSample]';
4. let context = getContext(this) as common.UIAbilityContext;
6. // 用户申请权限
7. export class PermissionsUtil {
8.   public static async checkAccessToken(permission: Permissions): Promise<abilityAccessCtrl.GrantStatus> {
9.     let atManager = abilityAccessCtrl.createAtManager();
10.     let grantStatus: abilityAccessCtrl.GrantStatus = -1;
11.     // 获取应用程序的accessTokenID
12.     let tokenId: number = 0;
13.     let bundleInfo: bundleManager.BundleInfo =
14.       await bundleManager.getBundleInfoForSelf(bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_APPLICATION);
15.     let appInfo: bundleManager.ApplicationInfo = bundleInfo.appInfo;
16.     tokenId = appInfo.accessTokenId;
17.     // 校验应用是否被授予权限
18.     grantStatus = await atManager.checkAccessToken(tokenId, permission);
19.     return grantStatus;
20.   }
22.   // 申请相机权限
23.   public static async reqPermissionsFromUser(): Promise<number[]> {
24.     hilog.info(0x0001, TAG, 'Succeeded in getting permissions by promise.')
25.     let atManager = abilityAccessCtrl.createAtManager();
26.     let grantStatus: PermissionRequestResult = { permissions: [], authResults: [] }
27.     grantStatus = await atManager.requestPermissionsFromUser(context, ['ohos.permission.CAMERA']);
28.     return grantStatus.authResults;
29.   }
30. }
32. @Extend(Column)
33. function mainStyle() {
34.   .width('100%')
35.   .height('100%')
36.   .padding({
37.     top: 40
38.   })
39.   .justifyContent(FlexAlign.Center)
40. }
42. @Entry
43. @Component
44. struct YUVScan {
45.   @State userGrant: boolean = false // 是否已申请相机权限
46.   @State surfaceId: string = '' // xComponent组件生成id
47.   @State cameraHeight: number = 640 // 设置预览流高度，默认单位：vp
48.   @State cameraWidth: number = 360 // 设置预览流宽度，默认单位：vp
49.   @State cameraOffsetX: number = 0 // 设置预览流x轴方向偏移量，默认单位：vp
50.   @State cameraOffsetY: number = 0 // 设置预览流y轴方向偏移量，默认单位：vp
51.   @State zoomValue: number = 1 // 预览流缩放比例
52.   @State setZoomValue: number = 1 // 已设置的预览流缩放比例
53.   @State isReleaseCamera: boolean = false // 是否已释放相机流
54.   @State scanWidth: number = 384 // xComponent宽度，默认设置384，单位vp
55.   @State scanHeight: number = 682 // xComponent高度，默认设置682，单位vp
56.   @State scanBottom: number = 220
57.   @State scanOffsetX: number = 0 // xComponent位置x轴偏移量，单位vp
58.   @State scanOffsetY: number = 0 // xComponent位置y轴偏移量，单位vp
59.   @State scanCodeRect: Array<scanBarcode.ScanCodeRect> = [] // 扫码结果码图位置
60.   @State scanFlag: boolean = false // 是否已经扫码到结果
61.   @State scanFrameResult: string = ''
62.   @State scaleValue: number = 1 // 屏幕缩放比
63.   @State pinchValue: number = 1 // 双指缩放比例
64.   @State displayHeight: number = 0 // 屏幕高度，单位vp
65.   @State displayWidth: number = 0 // 屏幕宽度，单位vp
66.   private mXComponentController: XComponentController = new XComponentController()
67.   private viewControl: customScan.ViewControl = { width: 1920, height: 1080, surfaceId: this.surfaceId }
68.   options: scanBarcode.ScanOptions = {
69.     // 扫码类型，可选参数
70.     scanTypes: [scanCore.ScanType.ALL],
71.     // 是否开启多码识别，可选参数
72.     enableMultiMode: true,
73.     // 是否开启相册扫码，可选参数
74.     enableAlbum: true,
75.   }
76.   // 返回自定义扫描结果的回调
77.   private callback: AsyncCallback<scanBarcode.ScanResult[]> =
78.     async (error: BusinessError, result: scanBarcode.ScanResult[]) => {
79.       if (error && error.code) {
80.         hilog.error(0x0001, TAG,
81.           `Failed to get ScanResult by callback. Code: ${error.code}, message: ${error.message}`);
82.         return;
83.       }
84.       // 解析码值结果跳转应用服务页
85.       hilog.info(0x0001, TAG, `Succeeded in getting ScanResult by callback, result: ${JSON.stringify(result)}`);
86.     }
87.   // 返回相机帧的回调
88.   private frameCallback: AsyncCallback<customScan.ScanFrame> =
89.     async (error: BusinessError, frameResult: customScan.ScanFrame) => {
90.       if (error) {
91.         hilog.error(0x0001, TAG, `Failed to get ScanFrame by callback. Code: ${error.code}, message: ${error.message}`);
92.         return;
93.       }
94.       // byteBuffer相机YUV图像数组
95.       hilog.info(0x0001, TAG,
96.         `Succeeded in getting ScanFrame.byteBuffer.byteLength: ${frameResult.byteBuffer.byteLength}`)
97.       hilog.info(0x0001, TAG, `Succeeded in getting ScanFrame.width: ${frameResult.width}`)
98.       hilog.info(0x0001, TAG, `Succeeded in getting ScanFrame.height: ${frameResult.height}`)
99.       this.scanFrameResult = JSON.stringify(frameResult.scanCodeRects);
100.       let newWidth = frameResult.height;
101.       if (frameResult && frameResult.scanCodeRects && frameResult.scanCodeRects.length > 0 && !this.scanFlag) {
102.         if (frameResult.scanCodeRects[0]) {
103.           this.stopCamera();
104.           this.scanCodeRect = [];
105.           this.scanFlag = true;
106.           // 码图位置信息转换
107.           this.changeToXComponent(frameResult);
108.         } else {
109.           this.scanFlag = false;
110.         }
111.       }
112.     }
114.   // frameCallback横向码图位置信息转换为预览流xComponent对应码图位置信息
115.   changeToXComponent(frameResult: customScan.ScanFrame) {
116.     if (frameResult && frameResult.scanCodeRects) {
117.       let frameHeight = frameResult.height;
118.       let ratio = this.scanWidth / frameHeight;
119.       frameResult.scanCodeRects.forEach((item) => {
120.         this.scanCodeRect.push({
121.           left: this.toFixedNumber((frameHeight - item.bottom) * ratio),
122.           top: this.toFixedNumber(item.left * ratio),
123.           right: this.toFixedNumber((frameHeight - item.top) * ratio),
124.           bottom: this.toFixedNumber(item.right * ratio)
125.         });
126.       });
127.       this.scanFrameResult = JSON.stringify(this.scanCodeRect);
128.     }
129.   }
131.   toFixedNumber(no: number): number {
132.     return Number((no).toFixed(1));
133.   }
135.   async onPageShow() {
136.     // 自定义启动第一步，用户申请权限
137.     const permissions: Array<Permissions> = ['ohos.permission.CAMERA'];
138.     // 自定义启动第二步：设置预览流布局尺寸
139.     this.setDisplay();
140.     let grantStatus = await PermissionsUtil.checkAccessToken(permissions[0]);
141.     if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
142.       // 已经授权，可以继续访问目标操作
143.       this.userGrant = true;
144.       if (this.surfaceId) {
145.         // 自定义启动第三步，初始化接口
146.         this.initCamera();
147.       }
148.     } else {
149.       // 申请相机权限
150.       this.requestCameraPermission();
151.     }
152.   }
154.   async onPageHide() {
155.     this.releaseCamera();
156.   }
158.   // 用户申请权限
159.   async requestCameraPermission() {
160.     let grantStatus = await PermissionsUtil.reqPermissionsFromUser()
161.     let length: number = grantStatus.length;
162.     for (let i = 0; i < length; i++) {
163.       if (grantStatus[i] === 0) {
164.         // 用户授权，可以继续访问目标操作
165.         this.userGrant = true;
166.       } else {
167.         // 用户拒绝授权，提示用户必须授权才能访问当前页面的功能，并引导用户到系统设置中打开相应的权限
168.         this.userGrant = false;
169.       }
170.     }
171.   }
173.   // 竖屏时获取屏幕尺寸，设置预览流全屏示例
174.   setDisplay() {
175.     // 以手机为例计算宽高
176.     let displayClass = display.getDefaultDisplaySync();
177.     this.displayHeight = px2vp(displayClass.height);
178.     this.displayWidth = px2vp(displayClass.width);
179.     if (displayClass !== null) {
180.       this.scanWidth = px2vp(displayClass.width);
181.       this.scanHeight = Math.round(this.scanWidth * this.viewControl.width / this.viewControl.height);
182.       this.scanBottom = Math.max(220, px2vp(displayClass.height) - this.scanHeight);
183.       this.scanOffsetX = 0;
184.       this.scanOffsetY = 0;
185.     }
186.   }
188.   // 初始化相机流
189.   async initCamera() {
190.     this.isReleaseCamera = false;
191.     customScan.init(this.options);
192.     hilog.info(0x0001, TAG, 'Succeeded in initing customScan with options.');
193.     this.scanCodeRect = [];
194.     this.scanFlag = false;
195.     // 自定义启动第四步，请求扫码接口
196.     customScan.start(this.viewControl, this.callback, this.frameCallback);
197.   }
199.   // 暂停相机流
200.   async stopCamera() {
201.     if (!this.isReleaseCamera) {
202.       customScan.stop();
203.     }
204.   }
206.   // 释放相机流
207.   async releaseCamera() {
208.     if (!this.isReleaseCamera) {
209.       await this.stopCamera();
210.       await customScan.release();
211.       this.isReleaseCamera = true;
212.     }
213.   }
215.   build() {
216.     Stack() {
217.       // 相机预览流XComponent
218.       if (this.userGrant) {
219.         Column() {
220.           XComponent({
221.             id: 'componentId',
222.             type: XComponentType.SURFACE,
223.             controller: this.mXComponentController
224.           })
225.             .onLoad(() => {
226.               hilog.info(0x0001, TAG, 'Succeeded in loading, onLoad is called.');
227.               this.surfaceId = this.mXComponentController.getXComponentSurfaceId();
228.               hilog.info(0x0001, TAG, `Succeeded in getting surfaceId is ${this.surfaceId}`);
229.               this.viewControl = { width: this.scanWidth, height: this.scanHeight, surfaceId: this.surfaceId };
230.               // 启动相机进行扫码
231.               this.initCamera();
232.             })
233.             .height(this.scanHeight)
234.             .width(this.scanWidth)
235.             .position({ x: 0, y: 0 })
236.         }
237.         .height('100%')
238.         .width('100%')
239.         .position({ x: this.scanOffsetX, y: this.scanOffsetY })
240.       }
242.       Column() {
243.         Column() {
244.         }
245.         .layoutWeight(1)
246.         .width('100%')
248.         Column() {
250.           Row() {
251.             // 闪光灯按钮，启动相机流后才能使用
252.             Button('FlashLight')
253.               .onClick(() => {
254.                 // 根据当前闪光灯状态，选择打开或关闭闪关灯
255.                 if (customScan.getFlashLightStatus()) {
256.                   customScan.closeFlashLight();
257.                 } else {
258.                   customScan.openFlashLight();
259.                 }
260.               })
261.               .visibility(this.scanFlag ? Visibility.None : Visibility.Visible)
262.           }
264.           Row() {
265.             // 预览流设置缩放比例
266.             Button('缩放比例,当前比例:' + this.setZoomValue)
267.               .width(200)
268.               .alignSelf(ItemAlign.Center)
269.               .onClick(() => {
270.                 // 设置相机缩放比例
271.                 if (!this.scanFlag) {
272.                   if (!this.zoomValue || this.zoomValue === this.setZoomValue) {
273.                     this.setZoomValue = customScan.getZoom();
274.                   } else {
275.                     this.zoomValue = this.zoomValue;
276.                     customScan.setZoom(this.zoomValue);
277.                     setTimeout(() => {
278.                       if (!this.scanFlag) {
279.                         this.setZoomValue = customScan.getZoom();
280.                       }
281.                     }, 1000);
282.                   }
283.                 }
284.               })
285.           }
286.           .margin({ top: 10, bottom: 10 })
287.           .visibility(this.scanFlag ? Visibility.None : Visibility.Visible)
289.           Row() {
290.             // 输入要设置的预览流缩放比例
291.             TextInput({ placeholder: '输入缩放倍数' })
292.               .width(200)
293.               .type(InputType.Number)
294.               .borderWidth(1)
295.               .backgroundColor(Color.White)
296.               .onChange(value => {
297.                 this.zoomValue = Number(value);
298.               })
299.           }
300.           .visibility(this.scanFlag ? Visibility.None : Visibility.Visible)
302.           Text(this.scanFlag ? '继续扫码' : '扫码中')
303.             .height(30)
304.             .fontSize(16)
305.             .fontColor(Color.White)
306.             .onClick(() => {
307.               if (this.scanFlag) {
308.                 this.scanFrameResult = '';
309.                 this.initCamera();
310.               }
311.             })
312.           Text('扫码结果：' + this.scanFrameResult).fontColor(Color.White).fontSize(12)
313.         }
314.         .width('100%')
315.         .height(this.scanBottom)
316.         .backgroundColor(Color.Black)
317.       }
318.       .mainStyle()
320.       Image($rawfile('scan_back.svg'))
321.         .width(20)
322.         .height(20)
323.         .position({
324.           x: 40,
325.           y: 40
326.         })
327.         .onClick(() => {
328.           router.back();
329.         })
331.       // 实时扫码码图中心点位置
332.       if (this.scanFlag && this.scanCodeRect.length > 0) {
333.         ForEach(this.scanCodeRect, (item: scanBarcode.ScanCodeRect, index: number) => {
334.           Image($rawfile('scan_selected2.svg'))
335.             .width(40)
336.             .height(40)
337.             .markAnchor({ x: 20, y: 20 })
338.             .position({
339.               x: (item.left + item.right) / 2 + this.scanOffsetX,
340.               y: (item.top + item.bottom) / 2 + this.scanOffsetY
341.             })
342.         })
343.       }
344.     }
345.     .width('100%')
346.     .height('100%')
347.     .backgroundColor(this.userGrant ? Color.Transparent : Color.Black)
348.     .onClick((event: ClickEvent) => {
349.       // 是否已扫描到结果
350.       if (this.scanFlag) {
351.         return;
352.       }
353.       // 点击屏幕位置，获取点击位置(x,y)，设置相机焦点
354.       let x1 = vp2px(event.displayY) / (this.displayHeight + 0.0);
355.       let y1 = 1.0 - (vp2px(event.displayX) / (this.displayWidth + 0.0));
356.       customScan.setFocusPoint({ x: x1, y: y1 });
357.       hilog.info(0x0001, TAG, `Succeeded in setting focusPoint x1: ${x1}, y1: ${y1}`);
358.       setTimeout(() => {
359.         customScan.resetFocus();
361.       }, 200);
362.     })
363.     .gesture(PinchGesture({ fingers: 2 })
364.       .onActionStart((event: GestureEvent) => {
365.         hilog.info(0x0001, TAG, 'Pinch start');
366.       })
367.       .onActionUpdate((event: GestureEvent) => {
368.         if (event) {
369.           this.scaleValue = event.scale;
370.         }
371.       })
372.       .onActionEnd((event: GestureEvent) => {
373.         // 是否已扫描到结果
374.         if (this.scanFlag) {
375.           return;
376.         }
377.         // 获取双指缩放比例，设置变焦比
378.         try {
379.           let zoom = customScan.getZoom();
380.           this.pinchValue = this.scaleValue * zoom;
381.           customScan.setZoom(this.pinchValue);
382.           hilog.info(0x0001, TAG, 'Pinch end');
383.         } catch (error) {
384.           hilog.error(0x0001, TAG, `Failed to setZoom. Code: ${error.code}, message: ${error.message}`);
385.         }
386.       }))
387.   }
388. }

复制代码

• 通过scanCodeRect数据可确定码图中心点的位置，利用说明如下。
  
  
  
  • scanCodeRect的四个点坐标如下，可根据坐标点绘制码图外围矩形框。
    
    
    
    • 左上角(x, y)：(left, top)
      
             
    
    
    
    • 右上角(x, y)：(right, top)
      
             
    
    
    
    • 左下角(x, y)：(left, bottom)
      
             
    
    
    
    • 右下角(x, y)：(right, bottom)
      
    
    
  • 由于码图中心点坐标需和xComponent的坐标保持一致，假如xComponent的x轴和y轴存在偏移，则码图位置需做相应的偏移。比方：x轴偏移量为：scanOffsetX；y轴偏移量为：scanOffsetY，中心点坐标终极转换为：
    
    
    
    • x = (left + right) / 2 + scanOffsetX
      
    • y = (top + bottom) / 2 + scanOffsetY
      
    
    
  
  

模拟器开发

暂不支持模拟器利用，调用会返回错误信息“Emulator is not supported.”
最后呢

许多开发朋友不知道需要学习那些鸿蒙技术？鸿蒙开发岗位需要把握那些核心技术点？为此鸿蒙的开发学习必须要系统性的进行。
而网上有关鸿蒙的开发资料非常的少，假如你想学好鸿蒙的应用开发与系统底层开发。你可以参考这份资料，少走许多弯路，节省没必要的麻烦。由两位前阿里高级研发工程师团结打造的《鸿蒙NEXT星河版OpenHarmony开发文档》里面内容包含了（ArkTS、ArkUI开发组件、Stage模子、多端摆设、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、Harmony南向开发、鸿蒙项目实战等等）鸿蒙（Harmony NEXT）技术知识点
假如你是一名Android、Java、前端等等开发人员，想要转入鸿蒙方向发展。可以直接领取这份资料辅助你的学习。下面是鸿蒙开发的学习路线图。

针对鸿蒙发展路线打造的鸿蒙学习文档。话不多说，我们直接看详细鸿蒙（OpenHarmony ）手册（共计1236页）与鸿蒙（OpenHarmony ）开发入门视频，帮助各人在技术的道路上更进一步。

• 《鸿蒙 (OpenHarmony)开发学习视频》
  
• 《鸿蒙生态应用开发V2.0白皮书》
  
• 《鸿蒙 (OpenHarmony)开发底子到实战手册》
  
• OpenHarmony北向、南向开发情况搭建
  
• 《鸿蒙开发底子》
  
• 《鸿蒙开发进阶》
  
• 《鸿蒙开发实战》
  

总结

鸿蒙—作为国家主力推送的国产操作系统。部分的高校已经取消了安卓课程，从而开设鸿蒙课程；企业纷纷跟进启动了鸿蒙研发。
而且鸿蒙是完全具备无与伦比的机遇和潜力的；预计到年底将有 5,000 款的应用完成原生鸿蒙开发，未来将会支持 50 万款的应用。那么这么多的应用需要开发，也就意味着需要有更多的鸿蒙人才。鸿蒙开发工程师也将会迎来发作式的增长，学习鸿蒙势在必行！ 自↓↓↓拿

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。