小白也能开发相机？Sample来教你

2023-4-1

[[418309]]

想了解更多内容，请访问：

和华为官方合作共建的鸿蒙技术社区

https://harmonyos.

上期我们给大家介绍了HarmonyOS Sample，收到了不少小伙伴的反馈，想学习一下HarmonyOS相机开发，现在，他来了!

相机开发概览

相机是智能设备最重要的功能之一，它能捕捉美好的瞬间、记录关键的时刻，被广泛应用于日常生活中。本文将详细地讲解一个带有拍摄照片和录制视频功能的相机开发过程。

目前，HarmonyOS相机模块支持相机业务的开发，开发者可以通过已开放的接口实现相机硬件的访问、操作和新功能开发。如下图所示，是HarmonyOS为相机应用开发者提供的3个包的内容，包括方法、枚举、以及常量/变量，方便开发者更容易地实现相机功能：

相机的开发流程如图所示：

相机权限申请

在使用相机之前，需要申请相机的相关权限，比如获取设备的相机权限、麦克风权限、存储权限等。保证应用拥有相机硬件及其他功能权限。

视频链接

开发者需在config.json中配置相关的权限，如下所示：

 
 
 
 
    
  
  
  
  
  1. "reqPermissions": [ 
    2. 
  
  
  
  
  2.   { 
    3. 
  
  
  
  
  3.     "name": "ohos.permission.CAMERA" 
    4. 
  
  
  
  
  4.   }, 
    5. 
  
  
  
  
  5.   { 
    6. 
  
  
  
  
  6.     "name": "ohos.permission.WRITE_USER_STORAGE" 
    7. 
  
  
  
  
  7.   }, 
    8. 
  
  
  
  
  8.   { 
    9. 
  
  
  
  
  9.     "name": "ohos.permission.READ_USER_STORAGE" 
    10. 
  
  
  
  
  10.   }, 
    11. 
  
  
  
  
  11.   { 
    12. 
  
  
  
  
  12.     "name": "ohos.permission.MICROPHONE" 
    13. 
  
  
  
  
  13.   }, 
    14. 
  
  
  
  
  14.   { 
    15. 
  
  
  
  
  15.     "name": "ohos.permission.LOCATION" 
    16. 
  
  
  
  
  16.   } 
    17. 
  
  
  
  
  17. ] 
    18.

获取相关权限的具体代码如下所示：

 
 
 
 
    
  
  
  
  
  1. private void requestPermissions() { 
    2. 
  
  
  
  
  2.     String[] permissions = { 
    3. 
  
  
  
  
  3.             //允许应用程序创建或删除文件，或将数据写入设备存储中的文件。 
    4. 
  
  
  
  
  4.             SystemPermission.WRITE_USER_STORAGE, 
    5. 
  
  
  
  
  5.             //允许应用程序从设备存储中读取文件。 
    6. 
  
  
  
  
  6.             SystemPermission.READ_USER_STORAGE, 
    7. 
  
  
  
  
  7.             //允许应用程序使用相机。 
    8. 
  
  
  
  
  8.             SystemPermission.CAMERA, 
    9. 
  
  
  
  
  9.             //允许应用程序访问麦克风。 
    10. 
  
  
  
  
  10.             SystemPermission.MICROPHONE, 
    11. 
  
  
  
  
  11.             //允许应用程序获取设备位置。 
    12. 
  
  
  
  
  12.             SystemPermission.LOCATION 
    13. 
  
  
  
  
  13.     }; 
    14. 
  
  
  
  
  14.     List<String> permissionFiltered = Arrays.stream(permissions) 
    15. 
  
  
  
  
  15.         .filter(permission -> verifySelfPermission(permission) != IBundleManager.PERMISSION_GRANTED) 
    16. 
  
  
  
  
  16.         .collect(Collectors.toList()); 
    17. 
  
  
  
  
  17.     requestPermissionsFromUser(permissionFiltered.toArray(new String[permissionFiltered.size()]), 0); 
    18.

初始化相机界面

获取到设备权限后，需要初始化相机界面。通过getWindow()获取当前Ability对应的窗口，再通过addCallback()添加界面操作的回调。代码如下所示：

 
 
 
 
    
  
  
  
  
  1. private void initSurface() { 
    2. 
  
  
  
  
  2.     //获取当前Ability对应的窗口，设置是否启用透明度。isEnable -指定是否启用透明度。True表示启用透明度，False表示禁用。 
    3. 
  
  
  
  
  3.     getWindow().setTransparent(true); 
    4. 
  
  
  
  
  4.     DirectionalLayout.LayoutConfig params = new DirectionalLayout.LayoutConfig( 
    5. 
  
  
  
  
  5.         ComponentContainer.LayoutConfig.MATCH_PARENT, ComponentContainer.LayoutConfig.MATCH_PARENT); 
    6. 
  
  
  
  
  6.     surfaceProvider = new SurfaceProvider(this); 
    7. 
  
  
  
  
  7.     surfaceProvider.setLayoutConfig(params); 
    8. 
  
  
  
  
  8.     /** 
    9. 
  
  
  
  
  9.      * 设置是否将此SurfaceProvider的Surface放置在AGP容器组件的顶层。 
    10. 
  
  
  
  
  10.      * 参数说明： 
    11. 
  
  
  
  
  11.      * toTop -指定是否将相机界面固定在顶部。值true表示将Surface放在AGP容器组件的顶层，而值false表示相反。*/ 
    12. 
  
  
  
  
  12.     surfaceProvider.pinToZTop(false); 
    13. 
  
  
  
  
  13.     //通过addCallback()添加界面操作的回调 
    14. 
  
  
  
  
  14.     surfaceProvider.getSurfaceOps().get().addCallback(new SurfaceCallBack()); 
    15. 
  
  
  
  
  15.     surfaceContainer.addComponent(surfaceProvider); 
    16. 
  
  
  
  
  16. } 
    17.

通过postTask()来执行相机任务：

 
 
 
 
    
  
  
  
  
  1. private class SurfaceCallBack implements SurfaceOps.Callback { 
    2. 
  
  
  
  
  2.     @Override 
    3. 
  
  
  
  
  3.     public void surfaceCreated(SurfaceOps callbackSurfaceOps) { 
    4. 
  
  
  
  
  4.         if (callbackSurfaceOps != null) { 
    5. 
  
  
  
  
  5.             //setFixedSize:设置界面的固定大小。参数说明：宽度-指示界面的宽度。高度-指示界面的高度。 
    6. 
  
  
  
  
  6.             callbackSurfaceOps.setFixedSize(SCREEN_HEIGHT,SCREEN_WIDTH); 
    7. 
  
  
  
  
  7.         } 
    8. 
  
  
  
  
  8. //设置延时200ms的postTask，用于相机界面的显示 
    9. 
  
  
  
  
  9.         eventHandler.postTask(new Runnable() { 
    10. 
  
  
  
  
  10.             @Override 
    11. 
  
  
  
  
  11.             public void run() { 
    12. 
  
  
  
  
  12.                 openCamera(); 
    13. 
  
  
  
  
  13.             } 
    14. 
  
  
  
  
  14.         },200); 
    15. 
  
  
  
  
  15.     } 
    16.

相机设备创建

1.创建相机对象

相机界面准备好后，我们需要创建相机设备。在实现一个相机应用之前必须先创建一个独立的相机设备，然后才能继续相机的其他操作。CameraKit类是相机的入口API类，如下所示：

相机设备创建的代码如下：

 
 
 
 
    
  
  
  
  
  1. private void openCamera() { 
    2. 
  
  
  
  
  2.     //ImageReceiver:连接到图像输出设备的图像接收器，并提供一个缓冲队列来接收图像数据 
    3. 
  
  
  
  
  3.     //create:根据指定的图像宽度、高度、格式和缓冲队列容量创建ImageReceiver实例 
    4. 
  
  
  
  
  4.     imageReceiver = ImageReceiver.create(SCREEN_WIDTH, SCREEN_HEIGHT, ImageFormat.JPEG, IMAGE_RCV_CAPACITY); 
    5. 
  
  
  
  
  5.     //设置接收到新图像数据时将调用的图像侦听器。 
    6. 
  
  
  
  
  6.     imageReceiver.setImageArrivalListener(this::saveImage); 
    7. 
  
  
  
  
  7.     //获取CameraKit实例 
    8. 
  
  
  
  
  8.     CameraKit cameraKit = CameraKit.getInstance(getApplicationContext()); 
    9. 
  
  
  
  
  9.     //获取当前使用的设备支持的逻辑相机列表 
    10. 
  
  
  
  
  10.     String[] cameraList = cameraKit.getCameraIds(); 
    11. 
  
  
  
  
  11.     String cameraId = ""; 
    12. 
  
  
  
  
  12.     //获取当前逻辑相机的信息 
    13. 
  
  
  
  
  13.     for (String logicalCameraId : cameraList) { 
    14. 
  
  
  
  
  14.         int faceType = cameraKit.getCameraInfo(logicalCameraId).getFacingType(); 
    15. 
  
  
  
  
  15.         switch (faceType){ 
    16. 
  
  
  
  
  16.             case CameraInfo.FacingType.CAMERA_FACING_FRONT: 
    17. 
  
  
  
  
  17.                 if (isFrontCamera) { 
    18. 
  
  
  
  
  18.                     cameraId = logicalCameraId; 
    19. 
  
  
  
  
  19.                 } 
    20. 
  
  
  
  
  20.                 break; 
    21. 
  
  
  
  
  21.             case CameraInfo.FacingType.CAMERA_FACING_BACK: 
    22. 
  
  
  
  
  22.                 if (!isFrontCamera) { 
    23. 
  
  
  
  
  23.                     cameraId = logicalCameraId; 
    24. 
  
  
  
  
  24.                 } 
    25. 
  
  
  
  
  25.                 break; 
    26. 
  
  
  
  
  26.             case CameraInfo.FacingType.CAMERA_FACING_OTHERS: 
    27. 
  
  
  
  
  27.             default: 
    28. 
  
  
  
  
  28.                 break; 
    29. 
  
  
  
  
  29.         } 
    30. 
  
  
  
  
  30.     } 
    31. 
  
  
  
  
  31.     if (cameraId != null && !cameraId.isEmpty()) { 
    32. 
  
  
  
  
  32.         CameraStateCallbackImpl cameraStateCallback = new CameraStateCallbackImpl(); 
    33. 
  
  
  
  
  33.         /**createCamera()用于创建相机对象 
    34. 
  
  
  
  
  34.          * 该方法的第一个参数代表要打开的摄像头ID； 
    35. 
  
  
  
  
  35.          * 第二个参数用于监听摄像头的状态； 
    36. 
  
  
  
  
  36.          * 第三个参数代表执行callback的Handler，如果程序希望直接在当前线程中执行callback，则可将handler参数设为null。*/ 
    37. 
  
  
  
  
  37.         cameraKit.createCamera(cameraId, cameraStateCallback, eventHandler); 
    38. 
  
  
  
  
  38.     } 
    39. 
  
  
  
  
  39. } 
    40.

创建相机设备成功后，在CameraStateCallback中会触发onCreated(Camera camera)回调，并且带回Camera对象，用于执行相机设备的操作。

 
 
 
 
    
  
  
  
  
  1. @Override 
    2. 
  
  
  
  
  2. public void onCreated(Camera camera) { 
    3. 
  
  
  
  
  3.     previewSurface = surfaceProvider.getSurfaceOps().get().getSurface(); 
    4. 
  
  
  
  
  4.     if (previewSurface == null) { 
    5. 
  
  
  
  
  5.         HiLog.error(LABEL_LOG, "%{public}s", "Create camera filed, preview surface is null"); 
    6. 
  
  
  
  
  6.         return; 
    7. 
  
  
  
  
  7.     } 
    8. 
  
  
  
  
  8.     //获取相机Config.Builder实例。 
    9. 
  
  
  
  
  9.     CameraConfig.Builder cameraConfigBuilder = camera.getCameraConfigBuilder(); 
    10. 
  
  
  
  
  10.     //addSurface:添加界面作为相机流的输出。 
    11. 
  
  
  
  
  11.     cameraConfigBuilder.addSurface(previewSurface); 
    12. 
  
  
  
  
  12.     cameraConfigBuilder.addSurface(imageReceiver.getRecevingSurface()); 
    13. 
  
  
  
  
  13.     camera.configure(cameraConfigBuilder.build()); 
    14. 
  
  
  
  
  14.     cameraDevice = camera; 
    15. 
  
  
  
  
  15.     updateComponentVisible(true); 
    16. 
  
  
  
  
  16. } 
    17.

2.配置预览

在使用相机的过程中，用户一般都是先看见预览画面才执行拍照或者其他功能，所以对于一个普通的相机应用，预览是必不可少的。在上述CameraStateCallback中，会调用configure()方法实现预览配置，通过triggerLoopingCapture()方法实现循环帧捕获，从而达到预览的目的。具体代码如下：

 
 
 
 
    
  
  
  
  
  1. @Override 
    2. 
  
  
  
  
  2. public void onConfigured(Camera camera) { 
    3. 
  
  
  
  
  3.     FrameConfig.Builder framePreviewConfigBuilder = camera.getFrameConfigBuilder(FRAME_CONFIG_PREVIEW); 
    4. 
  
  
  
  
  4.     framePreviewConfigBuilder.addSurface(previewSurface); 
    5. 
  
  
  
  
  5.     //triggerLoopingCapture:开始循环帧捕获。循环帧捕获通常用于预览或录制 
    6. 
  
  
  
  
  6.     camera.triggerLoopingCapture(framePreviewConfigBuilder.build()); 
    7. 
  
  
  
  
  7. } 
    8.

相机功能实现

相机的基本功能主要分为拍摄照片和录制视频，目前HarmonyOS为开发者提供了如下相机拍照功能实现的Camera操作类，开发者可以通过这些方法，实现各种相机应用的开发：

如下图所示是相机的使用过程，接下来的相机功能实现，也会根据此流程图来实现。

(1)选择功能

通过初始化相机界面组件，设置点击事件侦听器来实现相机功能选择。代码如下所示：

 
 
 
 
    
  
  
  
  
  1. private void initComponents() { 
    2. 
  
  
  
  
  2.     Component takePhoto = findComponentById(ResourceTable.Id_take_photo); 
    3. 
  
  
  
  
  3.     Component videoRecord = findComponentById(ResourceTable.Id_video_record); 
    4. 
  
  
  
  
  4.     //设置点击事件侦听器，用于拍摄照片 
    5. 
  
  
  
  
  5.     takePhoto.setClickedListener((component) -> startAbility(TakePhotoAbility.class.getName())); 
    6. 
  
  
  
  
  6.     //设置点击事件侦听器，用于录制视频 
    7. 
  
  
  
  
  7.     videoRecord.setClickedListener((component) -> startAbility(VideoRecordAbility.class.getName())); 
    8. 
  
  
  
  
  8. } 
    9.

(2)切换摄像头

开始拍摄照片或录制视频时，由于相机默认打开后置摄像头，需根据场景切换前置摄像头或后置摄像头。如果检测到相机正在工作中，将执行release()方法释放当前相机设备。代码如下：

 
 
 
 
    
  
  
  
  
  1. Image takePhotoImage = (Image) findComponentById(ResourceTable.Id_tack_picture_btn); 
    2. 
  
  
  
  
  2. //setClickedListener:为组件中的单击事件注册侦听器。 
    3. 
  
  
  
  
  3. takePhotoImage.setClickedListener(this::takeSingleCapture); 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. private void takeSingleCapture(Component component) { 
    6. 
  
  
  
  
  6.     if (cameraDevice == null || imageReceiver == null) { 
    7. 
  
  
  
  
  7.         return; 
    8. 
  
  
  
  
  8.     } 
    9. 
  
  
  
  
  9.     //用于配置帧捕获、图像处理和图像输出的接口 
    10. 
  
  
  
  
  10.     FrameConfig.Builder framePictureConfigBuilder = cameraDevice.getFrameConfigBuilder(FRAME_CONFIG_PICTURE); 
    11. 
  
  
  
  
  11.     framePictureConfigBuilder.addSurface(imageReceiver.getRecevingSurface()); 
    12. 
  
  
  
  
  12.     FrameConfig pictureFrameConfig = framePictureConfigBuilder.build(); 
    13. 
  
  
  
  
  13.     //triggerSingleCapture():开始单帧捕获。这种方法通常用于拍照。 
    14. 
  
  
  
  
  14.     cameraDevice.triggerSingleCapture(pictureFrameConfig); 
    15. 
  
  
  
  
  15. } 
    16.

(3)拍摄照片

拍照功能属于相机应用的最重要功能之一，而且照片质量对用户至关重要。相机模块基于相机复杂的逻辑，从应用接口层到器件驱动层都已经默认的做好了最适合用户的配置，这些默认配置尽可能地保证用户拍出的每张照片的质量。

实现单帧拍照

单帧拍照，其实就是单帧捕获的过程。通过设置点击事件侦听器setClickedListener()，来触发takeSingleCapture()方法，实现单帧捕获。具体代码如下：

 
 
 
 
    
  
  
  
  
  1. Image takePhotoImage = (Image) findComponentById(ResourceTable.Id_tack_picture_btn); 
    2. 
  
  
  
  
  2. //setClickedListener:为组件中的单击事件注册侦听器。 
    3. 
  
  
  
  
  3. takePhotoImage.setClickedListener(this::takeSingleCapture); 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. private void takeSingleCapture(Component component) { 
    6. 
  
  
  
  
  6.     if (cameraDevice == null || imageReceiver == null) { 
    7. 
  
  
  
  
  7.         return; 
    8. 
  
  
  
  
  8.     } 
    9. 
  
  
  
  
  9.     //用于配置帧捕获、图像处理和图像输出的接口 
    10. 
  
  
  
  
  10.     FrameConfig.Builder framePictureConfigBuilder = cameraDevice.getFrameConfigBuilder(FRAME_CONFIG_PICTURE); 
    11. 
  
  
  
  
  11.     framePictureConfigBuilder.addSurface(imageReceiver.getRecevingSurface()); 
    12. 
  
  
  
  
  12.     FrameConfig pictureFrameConfig = framePictureConfigBuilder.build(); 
    13. 
  
  
  
  
  13.     //triggerSingleCapture():开始单帧捕获。这种方法通常用于拍照。 
    14. 
  
  
  
  
  14.     cameraDevice.triggerSingleCapture(pictureFrameConfig); 
    15. 
  
  
  
  
  15. } 
    16.

实现连拍

连拍功能方便用户一次拍照获取多张照片，用于捕捉精彩瞬间。

同单帧拍照的实现流程一致，但连拍需要使用triggerMultiCapture(frameConfigs)方法用于多帧捕获。

 
 
 
 
    
  
  
  
  
  1. private void takeMultiCapture(Component component) { 
    2. 
  
  
  
  
  2.     FrameConfig.Builder framePictureConfigBuilder = cameraDevice.getFrameConfigBuilder(FRAME_CONFIG_PICTURE); 
    3. 
  
  
  
  
  3.     framePictureConfigBuilder.addSurface(imageReceiver.getRecevingSurface()); 
    4. 
  
  
  
  
  4.     List<FrameConfig> frameConfigs = new ArrayList<>(); 
    5. 
  
  
  
  
  5.     FrameConfig firstFrameConfig = framePictureConfigBuilder.build(); 
    6. 
  
  
  
  
  6.     frameConfigs.add(firstFrameConfig); 
    7. 
  
  
  
  
  7.     FrameConfig secondFrameConfig = framePictureConfigBuilder.build(); 
    8. 
  
  
  
  
  8.     frameConfigs.add(secondFrameConfig); 
    9. 
  
  
  
  
  9.     /**triggerMultiCapture(frameConfigs):启动多帧捕获。 
    10. 
  
  
  
  
  10.     cameraDevice.triggerMultiCapture(frameConfigs); 
    11. 
  
  
  
  
  11. } 
    12.

存储照片

拍摄后的照片通过saveImage()实现照片存储。具体代码如下：

 
 
 
 
    
  
  
  
  
  1. /** 
    2. 
  
  
  
  
  2.   * 存储照片*/ 
    3. 
  
  
  
  
  3. private void saveImage(ImageReceiver receiver) { 
    4. 
  
  
  
  
  4.     //getFilesDir():获取应用程序在设备内部存储上的文件存储目录。 
    5. 
  
  
  
  
  5.     File saveFile = new File(getFilesDir(), "IMG_" + System.currentTimeMillis() + ".jpg"); 
    6. 
  
  
  
  
  6.     ohos.media.image.Image image = receiver.readNextImage(); 
    7. 
  
  
  
  
  7.     //定义图像格式，提供获取图像格式信息的接口。 
    8. 
  
  
  
  
  8.     ohos.media.image.Image.Component component = image.getComponent(ImageFormat.ComponentType.JPEG); 
    9. 
  
  
  
  
  9.     byte[] bytes = new byte[component.remaining()]; 
    10. 
  
  
  
  
  10.     component.read(bytes); 
    11. 
  
  
  
  
  11.     try (FileOutputStream output = new FileOutputStream(saveFile)) { 
    12. 
  
  
  
  
  12.         output.write(bytes); 
    13. 
  
  
  
  
  13.         output.flush(); 
    14. 
  
  
  
  
  14.         showTips(this, "Take photo succeed"); 
    15. 
  
  
  
  
  15.     } catch (IOException e) { 
    16. 
  
  
  
  
  16.         HiLog.error(LABEL_LOG, "%{public}s", "saveImage IOException"); 
    17. 
  
  
  
  
  17.     } 
    18. 
  
  
  
  
  18. } 
    19.

(4)录制视频

配置音视频模块

录制视频除了要进行预览配置，还需要进行音视频模块的配置。

比如视频编码格式配置：

 
 
 
 
    
  
  
  
  
  1. setRecorderVideoEncoder(Recorder.VideoEncoder.H264) 
    2.

音频编码格式配置：

 
 
 
 
    
  
  
  
  
  1. setRecorderAudioEncoder(Recorder.AudioEncoder.AAC) 
    2.

以及视频的编码码率、帧捕获率、帧率配置等。代码如下所示：

 
 
 
 
    
  
  
  
  
  1. private void initMediaRecorder() { 
    2. 
  
  
  
  
  2.     mediaRecorder = new Recorder(); 
    3. 
  
  
  
  
  3.     VideoProperty.Builder videoPropertyBuilder = new VideoProperty.Builder(); 
    4. 
  
  
  
  
  4.     videoPropertyBuilder.setRecorderBitRate(10000000);//setRecorderBitRate:设置视频编码码率。 
    5. 
  
  
  
  
  5.     videoPropertyBuilder.setRecorderDegrees(90);  //setRecorderDegrees:设置视频旋转角度。 
    6. 
  
  
  
  
  6.     videoPropertyBuilder.setRecorderFps(30);//setRecorderFps:设置视频帧捕获速率。 
    7. 
  
  
  
  
  7.     videoPropertyBuilder.setRecorderHeight(Math.min(1440, 720));//设置视频高度。 
    8. 
  
  
  
  
  8.     videoPropertyBuilder.setRecorderWidth(Math.max(1440, 720));//设置视频宽度。 
    9. 
  
  
  
  
  9.     videoPropertyBuilder.setRecorderVideoEncoder(Recorder.VideoEncoder.H264);//setRecorderVideoEncoder:设置视频编码格式。 
    10. 
  
  
  
  
  10.     videoPropertyBuilder.setRecorderRate(30);//setRecorderRate:设置视频帧率。 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12.     Source source = new Source(); 
    13. 
  
  
  
  
  13.     //表示使用麦克风作为音频源。 
    14. 
  
  
  
  
  14.     source.setRecorderAudioSource(Recorder.AudioSource.MIC); 
    15. 
  
  
  
  
  15.     //表示使用相机界面作为视频源。 
    16. 
  
  
  
  
  16.     source.setRecorderVideoSource(Recorder.VideoSource.SURFACE); 
    17. 
  
  
  
  
  17.     mediaRecorder.setSource(source); 
    18. 
  
  
  
  
  18.     //setOutputFormat:设置输出文件格式。 
    19. 
  
  
  
  
  19.     mediaRecorder.setOutputFormat(Recorder.OutputFormat.MPEG_4); 
    20. 
  
  
  
  
  20.     //getFilesDir():获取文件存储目录。 
    21. 
  
  
  
  
  21.     File file = new File(getFilesDir(), "VID_" + System.currentTimeMillis() + ".mp4"); 
    22. 
  
  
  
  
  22.     StorageProperty.Builder storagePropertyBuilder = new StorageProperty.Builder(); 
    23. 
  
  
  
  
  23.     storagePropertyBuilder.setRecorderFile(file); 
    24. 
  
  
  
  
  24.     mediaRecorder.setStorageProperty(storagePropertyBuilder.build()); 
    25. 
  
  
  
  
  25.  
    26. 
  
  
  
  
  26.     AudioProperty.Builder audioPropertyBuilder = new AudioProperty.Builder(); 
    27. 
  
  
  
  
  27.     //setRecorderAudioEncoder:设置音频编码格式。 
    28. 
  
  
  
  
  28.     audioPropertyBuilder.setRecorderAudioEncoder(Recorder.AudioEncoder.AAC); 
    29. 
  
  
  
  
  29.     mediaRecorder.setAudioProperty(audioPropertyBuilder.build()); 
    30. 
  
  
  
  
  30.     mediaRecorder.setVideoProperty(videoPropertyBuilder.build()); 
    31. 
  
  
  
  
  31.     mediaRecorder.prepare(); 
    32. 
  
  
  
  
  32. } 
    33.

开始录制

通过设置长按点击事件侦听器setLongClickedListener()来触发startRecord()，实现开始录制。代码如下：

 
 
 
 
    
  
  
  
  
  1. //为组件中的长单击事件注册侦听器（单击并按住组件）。所有注册的观察员都将收到调度到组件的长单击事件的通知。 
    2. 
  
  
  
  
  2. videoRecord.setLongClickedListener(component -> { 
    3. 
  
  
  
  
  3.     startRecord(); 
    4. 
  
  
  
  
  4.     isRecording = true; 
    5. 
  
  
  
  
  5.     videoRecord.setPixelMap(ResourceTable.Media_ic_camera_video_press); 
    6. 
  
  
  
  
  6. }); 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8. private void startRecord() { 
    9. 
  
  
  
  
  9.     if (cameraDevice == null) { 
    10. 
  
  
  
  
  10.         HiLog.error(LABEL_LOG, "%{public}s", "startRecord failed, parameters is illegal"); 
    11. 
  
  
  
  
  11.         return; 
    12. 
  
  
  
  
  12.     } 
    13. 
  
  
  
  
  13.     synchronized (lock) { 
    14. 
  
  
  
  
  14.         initMediaRecorder(); 
    15. 
  
  
  
  
  15.         recorderSurface = mediaRecorder.getVideoSurface(); 
    16. 
  
  
  
  
  16.         cameraConfigBuilder = cameraDevice.getCameraConfigBuilder(); 
    17. 
  
  
  
  
  17.         try { 
    18. 
  
  
  
  
  18.             cameraConfigBuilder.addSurface(previewSurface); 
    19. 
  
  
  
  
  19.             if (recorderSurface != null) { 
    20. 
  
  
  
  
  20.                 //添加界面作为相机流的输出。 
    21. 
  
  
  
  
  21.                 cameraConfigBuilder.addSurface(recorderSurface); 
    22. 
  
  
  
  
  22.             } 
    23. 
  
  
  
  
  23.             cameraDevice.configure(cameraConfigBuilder.build()); 
    24. 
  
  
  
  
  24.         } catch (IllegalStateException | IllegalArgumentException e) { 
    25. 
  
  
  
  
  25.             HiLog.error(LABEL_LOG, "%{public}s", "startRecord IllegalStateException "); 
    26. 
  
  
  
  
  26.         } 
    27. 
  
  
  
  
  27.     } 
    28. 
  
  
  
  
  28.     new ToastDialog(this).setText("Recording").show(); 
    29. 
  
  
  
  
  29. } 
    30.

停止录制

通过设置触摸事件侦听器setTouchEventListener()来触发stopRecord()，实现停止录制。

 
 
 
 
    
  
  
  
  
  1. //在组件中注册触摸事件的侦听器。所有注册的观察员都将收到调度到组件的触摸事件的通知。 
    2. 
  
  
  
  
  2. videoRecord.setTouchEventListener((component, touchEvent) -> { 
    3. 
  
  
  
  
  3.     if (touchEvent != null && touchEvent.getAction() == TouchEvent.PRIMARY_POINT_UP && isRecording) { 
    4. 
  
  
  
  
  4.         stopRecord(); 
    5. 
  
  
  
  
  5.         isRecording = false; 
    6. 
  
  
  
  
  6.         videoRecord.setPixelMap(ResourceTable.Media_ic_camera_video_ready); 
    7. 
  
  
  
  
  7.     } 
    8. 
  
  
  
  
  8.     return true; 
    9. 
  
  
  
  
  9. }); 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. private void stopRecord() { 
    12. 
  
  
  
  
  12.     synchronized (lock) { 
    13. 
  
  
  
  
  13.         try { 
    14. 
  
  
  
  
  14.             eventHandler.postTask(() -> mediaRecorder.stop());//stop():停止录制。 
    15. 
  
  
  
  
  15.             if (cameraDevice == null || cameraDevice.getCameraConfigBuilder() == null) { 
    16. 
  
  
  
  
  16.                 HiLog.error(LABEL_LOG, "%{public}s", "StopRecord cameraDevice or getCameraConfigBuilder is null"); 
    17. 
  
  
  
  
  17.                 return; 
    18. 
  
  
  
  
  18.             } 
    19. 
  
  
  
  
  19.             cameraConfigBuilder = cameraDevice.getCameraConfigBuilder(); 
    20. 
  
  
  
  
  20.             cameraConfigBuilder.addSurface(previewSurface); 
    21. 
  
  
  
  
  21.             cameraConfigBuilder.removeSurface(recorderSurface); 
    22. 
  
  
  
  
  22.             cameraDevice.configure(cameraConfigBuilder.build()); 
    23. 
  
  
  
  
  23.         } catch (IllegalStateException | IllegalArgumentException exception) { 
    24. 
  
  
  
  
  24.             HiLog.error(LABEL_LOG, "%{public}s", "stopRecord occur exception"); 
    25. 
  
  
  
  
  25.         } 
    26. 
  
  
  
  
  26.     } 
    27. 
  
  
  
  
  27.     new ToastDialog(this).setText("video saved").show(); 
    28. 
  
  
  
  
  28. } 
    29.

视频存储和照片存储类似，本文就不做赘述，更多相机的开发请参照HarmonyOS相机开发指导：

https://developer.harmonyos.com/cn/docs/documentation/doc-guides/media-camera-overview-0000000000031783

相机设备释放

使用完相机后，必须通过release()来关闭相机和释放资源，否则可能导致其他相机应用无法启动。一旦相机被释放，它所提供的操作就不能再被调用，否则会导致不可预期的结果，或是会引发状态异常。相机设备释放的示例代码如下：

 
 
 
 
    
  
  
  
  
  1. private void releaseCamera() { 
    2. 
  
  
  
  
  2.     if (cameraDevice != null) { 
    3. 
  
  
  
  
  3.         //release():释放摄像机。 
    4. 
  
  
  
  
  4.         //释放摄像机后，摄像机的所有操作都不可用。任何操作都会导致意外结果或异常。 
    5. 
  
  
  
  
  5.         cameraDevice.release(); 
    6. 
  
  
  
  
  6.     } 
    7. 
  
  
  
  
  7.     if (imageReceiver != null) { 
    8. 
  
  
  
  
  8.         imageReceiver.release(); 
    9. 
  
  
  
  
  9.     } 
    10. 
  
  
  
  
  10. } 
    11.

 至此，就完成了一个具有拍摄照片和录制视频功能的相机开发，开发者也可以通过合适的接口或者接口组合实现闪光灯控制、曝光时间控制、手动对焦和自动对焦控制、变焦控制、人脸识别以及更多的功能。

文章相关附件可以点击下面的原文链接前往下载

相机示例程序的完整代码.zip

想了解更多内容，请访问：

和华为官方合作共建的鸿蒙技术社区

https://harmonyos.

 

版权声明：
作者：后浪云
链接：https://www.idc.net/help/344431/
文章版权归作者所有，未经允许请勿转载。
THE END
Copyright © 2025 后浪云 网站地图