鸿蒙App相机权限与基础调用（打开摄像头预览）详解

引言

技术背景

相机权限的重要性

1. 用户隐私：相机涉及用户隐私，必须明确授权
2. 系统安全：防止恶意应用未经授权访问摄像头
3. 合规要求：满足相关法律法规（如GDPR）

鸿蒙相机架构

• 应用层：调用相机API实现业务功能
• 框架层：提供CameraManager、CameraDevice等核心类
• 服务层：Camera Service管理相机硬件资源
• 驱动层：与摄像头硬件交互

权限分类

应用使用场景

1. 扫码应用：扫描二维码/条形码
2. 社交应用：拍摄照片或视频
3. 视频通话：实时视频流传输
4. 监控系统：实时预览监控画面
5. AR应用：增强现实体验
6. 文档扫描：拍摄并识别文档
7. 人脸识别：身份验证或美颜

不同场景下详细代码实现

场景1：基础相机权限申请

// CameraPermissionHelper.java
package com.example.camerademo;

import ohos.aafwk.ability.Ability;
import ohos.aafwk.content.Intent;
import ohos.app.Context;
import ohos.bundle.IBundleManager;
import ohos.security.SystemPermission;
import java.util.ArrayList;
import java.util.List;

public class CameraPermissionHelper {
    private static final int PERMISSION_REQUEST_CODE = 1001;
    private Ability ability;
    private PermissionCallback callback;
    
    public interface PermissionCallback {
        void onPermissionGranted();
        void onPermissionDenied(List<String> deniedPermissions);
    }
    
    public CameraPermissionHelper(Ability ability) {
        this.ability = ability;
    }
    
    public void requestCameraPermission(PermissionCallback callback) {
        this.callback = callback;
        
        if (hasCameraPermission()) {
            callback.onPermissionGranted();
        } else {
            requestPermission();
        }
    }
    
    private boolean hasCameraPermission() {
        return ability.verifySelfPermission(SystemPermission.CAMERA) 
               == IBundleManager.PERMISSION_GRANTED;
    }
    
    private void requestPermission() {
        List<String> permissions = new ArrayList<>();
        permissions.add(SystemPermission.CAMERA);
        ability.requestPermissionsFromUser(permissions.toArray(new String[0]), PERMISSION_REQUEST_CODE);
    }
    
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        if (requestCode != PERMISSION_REQUEST_CODE) {
            return;
        }
        
        List<String> deniedPermissions = new ArrayList<>();
        for (int i = 0; i < permissions.length; i++) {
            if (grantResults[i] != IBundleManager.PERMISSION_GRANTED) {
                deniedPermissions.add(permissions[i]);
            }
        }
        
        if (deniedPermissions.isEmpty()) {
            callback.onPermissionGranted();
        } else {
            callback.onPermissionDenied(deniedPermissions);
        }
    }
}

场景2：打开摄像头预览

// CameraPreviewAbilitySlice.java
package com.example.camerademo;

import ohos.aafwk.ability.AbilitySlice;
import ohos.aafwk.content.Intent;
import ohos.agp.components.Component;
import ohos.agp.components.DirectionalLayout;
import ohos.agp.components.Text;
import ohos.agp.components.surfaceprovider.SurfaceProvider;
import ohos.agp.graphics.Surface;
import ohos.agp.utils.LayoutAlignment;
import ohos.agp.window.dialog.ToastDialog;
import ohos.app.Context;
import ohos.media.camera.CameraKit;
import ohos.media.camera.device.Camera;
import ohos.media.camera.device.CameraConfig;
import ohos.media.camera.device.CameraStateCallback;
import ohos.media.camera.params.InputConfiguration;
import ohos.media.image.Image;
import ohos.media.image.ImageReceiver;
import ohos.media.image.common.Size;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;

public class CameraPreviewAbilitySlice extends AbilitySlice {
    private SurfaceProvider surfaceProvider;
    private CameraKit cameraKit;
    private Camera cameraDevice;
    private ImageReceiver imageReceiver;
    private static final int IMAGE_QUEUE_SIZE = 3;
    private ArrayBlockingQueue<Image> imageQueue = new ArrayBlockingQueue<>(IMAGE_QUEUE_SIZE);
    
    @Override
    public void onStart(Intent intent) {
        super.onStart(intent);
        initUI();
        checkPermissionAndStartCamera();
    }
    
    private void initUI() {
        DirectionalLayout layout = new DirectionalLayout(this);
        layout.setOrientation(Component.VERTICAL);
        
        surfaceProvider = new SurfaceProvider(this);
        surfaceProvider.setLayoutConfig(ComponentContainer.LayoutConfig.MATCH_PARENT, 
                                      ComponentContainer.LayoutConfig.MATCH_PARENT);
        layout.addComponent(surfaceProvider);
        
        super.setUIContent(layout);
    }
    
    private void checkPermissionAndStartCamera() {
        CameraPermissionHelper helper = new CameraPermissionHelper(this);
        helper.requestCameraPermission(new CameraPermissionHelper.PermissionCallback() {
            @Override
            public void onPermissionGranted() {
                startCameraPreview();
            }
            
            @Override
            public void onPermissionDenied(List<String> deniedPermissions) {
                showToast("需要相机权限");
            }
        });
    }
    
    private void startCameraPreview() {
        cameraKit = CameraKit.getInstance(getContext());
        if (cameraKit == null) {
            showToast("相机不可用");
            return;
        }
        
        // 获取可用的相机设备
        String[] cameraIds = cameraKit.getCameraIdList();
        if (cameraIds.length == 0) {
            showToast("没有找到相机设备");
            return;
        }
        
        // 打开后置相机
        String cameraId = cameraIds[0];
        cameraKit.getCameraDevice(cameraId, new CameraStateCallback() {
            @Override
            public void onCreated(Camera camera) {
                cameraDevice = camera;
                createCameraSession();
            }
            
            @Override
            public void onCreateFailed(String cameraId, int errorCode) {
                showToast("相机打开失败: " + errorCode);
            }
            
            @Override
            public void onReleased(String cameraId) {
                cameraDevice = null;
            }
        });
    }
    
    private void createCameraSession() {
        try {
            // 配置相机参数
            CameraConfig.Builder configBuilder = cameraDevice.getCameraConfigBuilder();
            configBuilder.setPreviewSize(640, 480);
            CameraConfig config = configBuilder.build();
            
            // 创建图像接收器用于预览
            imageReceiver = ImageReceiver.create(config.getPreviewSize().width, 
                                               config.getPreviewSize().height, 
                                               ImageFormat.JPEG, IMAGE_QUEUE_SIZE);
            imageReceiver.setImageArrivalListener(image -> {
                // 将图像放入队列
                if (imageQueue.size() < IMAGE_QUEUE_SIZE) {
                    imageQueue.offer(image);
                }
            });
            
            // 创建会话
            cameraDevice.configure(config);
            cameraDevice.createCaptureSession(new SessionConfiguration(
                SessionConfiguration.SESSION_TYPE_PREVIEW,
                new OutputConfiguration[] { new OutputConfiguration(imageReceiver.getReceivingSurface()) }
            ));
            
            // 开始预览
            cameraDevice.start();
            
            // 将预览图像显示在Surface上
            surfaceProvider.getSurfaceOps().get().addCallback(new Surface.Callback() {
                @Override
                public void surfaceCreated(Surface surface) {
                    // 将图像队列中的图像绘制到Surface
                    drawPreview();
                }
                
                @Override
                public void surfaceChanged(Surface surface, int format, int width, int height) {}
                
                @Override
                public void surfaceDestroyed(Surface surface) {}
            });
            
        } catch (UnsupportedOperationException e) {
            showToast("相机配置失败: " + e.getMessage());
        }
    }
    
    private void drawPreview() {
        // 从队列中取出图像并绘制到Surface
        // 实际实现需要处理图像格式转换和绘制
        // 这里简化处理，实际应使用OpenGL ES或GPU加速
    }
    
    private void showToast(String message) {
        new ToastDialog(this)
            .setText(message)
            .setAlignment(LayoutAlignment.CENTER)
            .show();
    }
    
    @Override
    public void onActive() {
        super.onActive();
    }
    
    @Override
    public void onInactive() {
        super.onInactive();
        releaseCamera();
    }
    
    private void releaseCamera() {
        if (cameraDevice != null) {
            cameraDevice.release();
            cameraDevice = null;
        }
        if (imageReceiver != null) {
            imageReceiver.release();
            imageReceiver = null;
        }
    }
}

场景3：拍照功能实现

// PhotoCaptureHelper.java
package com.example.camerademo;

import ohos.agp.graphics.Surface;
import ohos.app.Context;
import ohos.media.camera.Camera;
import ohos.media.camera.device.CaptureRequest;
import ohos.media.camera.params.OutputConfiguration;
import ohos.media.image.Image;
import ohos.media.image.ImageReceiver;
import java.util.concurrent.ArrayBlockingQueue;

public class PhotoCaptureHelper {
    private Camera cameraDevice;
    private ImageReceiver photoReceiver;
    private CaptureCallback captureCallback;
    
    public interface CaptureCallback {
        void onCaptureSuccess(Image image);
        void onCaptureFailed(int errorCode);
    }
    
    public PhotoCaptureHelper(Camera cameraDevice) {
        this.cameraDevice = cameraDevice;
    }
    
    public void takePhoto(CaptureCallback callback) {
        this.captureCallback = callback;
        
        try {
            // 创建图像接收器
            photoReceiver = ImageReceiver.create(1920, 1080, ImageFormat.JPEG, 1);
            photoReceiver.setImageArrivalListener(image -> {
                if (captureCallback != null) {
                    captureCallback.onCaptureSuccess(image);
                }
            });
            
            // 创建拍照请求
            CaptureRequest.Builder requestBuilder = cameraDevice.createCaptureRequest(CameraMetadata.REQUEST_TYPE_CAPTURE);
            requestBuilder.addOutputConfiguration(new OutputConfiguration(photoReceiver.getReceivingSurface()));
            
            // 发送请求
            cameraDevice.submitRequest(requestBuilder.build(), true);
            
        } catch (Exception e) {
            if (captureCallback != null) {
                captureCallback.onCaptureFailed(-1);
            }
        }
    }
    
    public void release() {
        if (photoReceiver != null) {
            photoReceiver.release();
            photoReceiver = null;
        }
    }
}

原理解释

1. 权限管理：
   • 应用需在config.json声明相机权限
   • 运行时动态申请权限
   • 用户授权后才能访问相机
2. 相机服务架构：
   • Camera Kit：提供给应用的入口
   • Camera Manager：管理相机设备
   • Camera Device：代表物理相机
   • Session：管理多个输入输出流
3. 预览流程：
   • 获取Camera Kit实例
   • 枚举可用相机设备
   • 打开指定相机设备
   • 配置相机参数（分辨率、帧率等）
   • 创建预览会话
   • 绑定Surface用于显示预览画面
   • 启动预览
4. 数据流：
   • 相机硬件捕获图像
   • 通过ImageReceiver传递给应用
   • 应用将图像绘制到Surface显示

核心特性

1. 多设备支持：前置/后置摄像头切换
2. 分辨率灵活配置：支持多种预览分辨率
3. 实时预览：低延迟预览画面
4. 拍照/录像：支持静态图像和视频捕获
5. 参数调整：曝光、对焦、闪光灯等控制
6. 生命周期管理：自动释放相机资源

原理流程图及解释

graph TD
    A[应用启动] --> B[检查相机权限]
    B --> C{权限已授予?}
    C -- 是 --> D[获取Camera Kit实例]
    C -- 否 --> E[申请相机权限]
    E --> F{用户同意?}
    F -- 是 --> D
    F -- 否 --> G[显示权限拒绝提示]
    D --> H[枚举相机设备]
    H --> I[打开指定相机]
    I --> J[配置相机参数]
    J --> K[创建预览会话]
    K --> L[绑定Surface显示]
    L --> M[启动预览]
    M --> N[实时更新预览画面]
    N --> O[用户操作]
    O --> P[拍照/录像]
    P --> Q[保存媒体文件]
    Q --> R[释放相机资源]

1. 应用启动后首先检查相机权限
2. 有权限则获取Camera Kit实例，否则申请权限
3. 用户同意后继续，拒绝则提示
4. 枚举可用相机设备（前置/后置）
5. 打开指定相机设备
6. 配置相机参数（分辨率、帧率等）
7. 创建预览会话并绑定Surface
8. 启动预览，实时更新画面
9. 用户触发拍照或录像
10. 保存媒体文件
11. 应用退出时释放相机资源

环境准备

开发环境要求

• 操作系统：Windows 10/macOS/Linux
• 开发工具：DevEco Studio 3.0+
• SDK版本：API Version 7+
• 设备要求：HarmonyOS 2.0+真机或模拟器（支持相机）

安装步骤

1. 下载安装DevEco Studio

   https://developer.harmonyos.com/cn/develop/deveco-studio

2. 配置开发环境

   # 设置环境变量
   export HARMONY_HOME=/path/to/harmonyos/sdk
   export PATH=$PATH:$HARMONY_HOME/tools

3. 创建新项目

   # 使用命令行工具创建项目
   hpm init -p org.example.camerademo

4. 添加权限配置

   // config.json
   {
     "module": {
       "reqPermissions": [
         {
           "name": "ohos.permission.CAMERA",
           "reason": "$string:camera_permission_reason"
         }
       ]
     }
   }

5. 添加字符串资源

   // resources/base/element/string.json
   {
     "string": [
       {
         "name": "camera_permission_reason",
         "value": "需要相机权限以拍摄照片"
       }
     ]
   }

实际详细应用代码示例实现

// MainAbilitySlice.java
package com.example.camerademo;

import ohos.aafwk.ability.AbilitySlice;
import ohos.aafwk.content.Intent;
import ohos.agp.components.Button;
import ohos.agp.components.Component;
import ohos.agp.components.DirectionalLayout;
import ohos.agp.components.surfaceprovider.SurfaceProvider;
import ohos.agp.utils.LayoutAlignment;
import ohos.agp.window.dialog.ToastDialog;
import ohos.media.camera.CameraKit;
import ohos.media.camera.device.Camera;
import ohos.media.camera.device.CameraConfig;
import ohos.media.camera.device.CameraStateCallback;
import ohos.media.image.Image;
import ohos.media.image.ImageReceiver;
import ohos.media.image.common.Size;
import java.util.Arrays;
import java.util.List;

public class MainAbilitySlice extends AbilitySlice {
    private SurfaceProvider surfaceProvider;
    private CameraKit cameraKit;
    private Camera cameraDevice;
    private ImageReceiver previewReceiver;
    private PhotoCaptureHelper photoCaptureHelper;
    private Button captureButton;
    
    @Override
    public void onStart(Intent intent) {
        super.onStart(intent);
        initUI();
        checkPermissionAndStartCamera();
    }
    
    private void initUI() {
        DirectionalLayout layout = new DirectionalLayout(this);
        layout.setOrientation(Component.VERTICAL);
        
        // 预览Surface
        surfaceProvider = new SurfaceProvider(this);
        surfaceProvider.setLayoutConfig(ComponentContainer.LayoutConfig.MATCH_PARENT, 
                                      ComponentContainer.LayoutConfig.MATCH_PARENT);
        layout.addComponent(surfaceProvider);
        
        // 拍照按钮
        captureButton = new Button(this);
        captureButton.setText("拍照");
        captureButton.setLayoutConfig(ComponentContainer.LayoutConfig.MATCH_CONTENT, 
                                     ComponentContainer.LayoutConfig.MATCH_CONTENT);
        captureButton.setMarginTop(20);
        captureButton.setClickedListener(component -> takePhoto());
        layout.addComponent(captureButton);
        
        super.setUIContent(layout);
    }
    
    private void checkPermissionAndStartCamera() {
        CameraPermissionHelper helper = new CameraPermissionHelper(this);
        helper.requestCameraPermission(new CameraPermissionHelper.PermissionCallback() {
            @Override
            public void onPermissionGranted() {
                startCameraPreview();
            }
            
            @Override
            public void onPermissionDenied(List<String> deniedPermissions) {
                showToast("需要相机权限才能使用此功能");
            }
        });
    }
    
    private void startCameraPreview() {
        cameraKit = CameraKit.getInstance(getContext());
        if (cameraKit == null) {
            showToast("相机服务不可用");
            return;
        }
        
        // 获取相机设备列表
        String[] cameraIds = cameraKit.getCameraIdList();
        if (cameraIds == null || cameraIds.length == 0) {
            showToast("没有可用的相机设备");
            return;
        }
        
        // 打开第一个相机设备（通常是后置）
        String cameraId = cameraIds[0];
        cameraKit.getCameraDevice(cameraId, new CameraStateCallback() {
            @Override
            public void onCreated(Camera camera) {
                cameraDevice = camera;
                createPreviewSession();
            }
            
            @Override
            public void onCreateFailed(String cameraId, int errorCode) {
                showToast("打开相机失败: " + errorCode);
            }
            
            @Override
            public void onReleased(String cameraId) {
                cameraDevice = null;
            }
        });
    }
    
    private void createPreviewSession() {
        try {
            // 配置预览参数
            CameraConfig.Builder configBuilder = cameraDevice.getCameraConfigBuilder();
            configBuilder.setPreviewSize(1280, 720); // 720p预览
            CameraConfig config = configBuilder.build();
            
            // 创建预览图像接收器
            previewReceiver = ImageReceiver.create(config.getPreviewSize().width, 
                                                 config.getPreviewSize().height, 
                                                 ImageFormat.NV21, 3);
            
            // 设置图像到达监听器
            previewReceiver.setImageArrivalListener(image -> {
                // 实际项目中应将图像渲染到Surface
                // 这里简化处理
            });
            
            // 创建预览会话
            cameraDevice.configure(config);
            cameraDevice.createCaptureSession(new SessionConfiguration(
                SessionConfiguration.SESSION_TYPE_PREVIEW,
                new OutputConfiguration[] { new OutputConfiguration(previewReceiver.getReceivingSurface()) }
            ));
            
            // 开始预览
            cameraDevice.start();
            
            // 初始化拍照助手
            photoCaptureHelper = new PhotoCaptureHelper(cameraDevice);
            
            // 绑定Surface用于显示预览
            bindSurfaceToPreview();
            
        } catch (Exception e) {
            showToast("创建预览会话失败: " + e.getMessage());
        }
    }
    
    private void bindSurfaceToPreview() {
        surfaceProvider.getSurfaceOps().get().addCallback(new Surface.Callback() {
            @Override
            public void surfaceCreated(Surface surface) {
                // 将预览图像渲染到Surface
                renderPreview(surface);
            }
            
            @Override
            public void surfaceChanged(Surface surface, int format, int width, int height) {}
            
            @Override
            public void surfaceDestroyed(Surface surface) {}
        });
    }
    
    private void renderPreview(Surface surface) {
        // 实际实现中，这里应该从previewReceiver获取图像并渲染到Surface
        // 可以使用OpenGL ES或Canvas绘制
        // 这里简化处理，仅显示一个提示
        showToast("预览已启动");
    }
    
    private void takePhoto() {
        if (photoCaptureHelper == null) {
            showToast("相机未准备好");
            return;
        }
        
        photoCaptureHelper.takePhoto(new PhotoCaptureHelper.CaptureCallback() {
            @Override
            public void onCaptureSuccess(Image image) {
                // 保存照片到文件
                saveImageToFile(image);
                showToast("拍照成功");
            }
            
            @Override
            public void onCaptureFailed(int errorCode) {
                showToast("拍照失败: " + errorCode);
            }
        });
    }
    
    private void saveImageToFile(Image image) {
        // 实际实现中，将Image保存为文件
        // 这里简化处理
    }
    
    private void showToast(String message) {
        new ToastDialog(this)
            .setText(message)
            .setAlignment(LayoutAlignment.CENTER)
            .show();
    }
    
    @Override
    public void onActive() {
        super.onActive();
    }
    
    @Override
    public void onInactive() {
        super.onInactive();
        releaseCamera();
    }
    
    private void releaseCamera() {
        if (cameraDevice != null) {
            cameraDevice.release();
            cameraDevice = null;
        }
        if (previewReceiver != null) {
            previewReceiver.release();
            previewReceiver = null;
        }
        if (photoCaptureHelper != null) {
            photoCaptureHelper.release();
            photoCaptureHelper = null;
        }
    }
}

运行结果

1. 启动时请求相机权限
2. 权限授予后打开后置摄像头
3. 显示实时预览画面
4. 点击拍照按钮捕获当前画面
5. 保存照片到设备存储
6. 退出应用时释放相机资源

预览已启动
拍照成功
照片保存至: /storage/emulated/0/Pictures/CameraDemo/IMG_20230825_143022.jpg

测试步骤以及详细代码

测试步骤

1. 创建鸿蒙应用项目
2. 添加上述代码文件
3. 配置config.json权限
4. 连接鸿蒙设备或启动模拟器
5. 运行应用并授权相机权限
6. 观察预览画面是否正常
7. 点击拍照按钮测试拍照功能
8. 检查照片是否正确保存

完整测试代码

// CameraTestAbility.java
package com.example.camerademo.test;

import ohos.aafwk.ability.Ability;
import ohos.aafwk.content.Intent;
import ohos.app.Context;
import ohos.bundle.IBundleManager;
import ohos.media.camera.CameraKit;
import ohos.security.SystemPermission;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;

public class CameraTestAbility extends Ability {
    private Context context;
    
    @Before
    public void setUp() {
        context = getContext();
    }
    
    @Test
    public void testCameraPermission() {
        // 检查相机权限状态
        int result = verifySelfPermission(SystemPermission.CAMERA);
        assertTrue("应具备相机权限", result == IBundleManager.PERMISSION_GRANTED);
    }
    
    @Test
    public void testCameraKitAvailability() {
        CameraKit cameraKit = CameraKit.getInstance(context);
        assertNotNull("CameraKit实例不应为空", cameraKit);
        
        String[] cameraIds = cameraKit.getCameraIdList();
        assertTrue("应至少有一个相机设备", cameraIds != null && cameraIds.length > 0);
    }
    
    @Test
    public void testCameraDeviceOpen() {
        CameraKit cameraKit = CameraKit.getInstance(context);
        String[] cameraIds = cameraKit.getCameraIdList();
        assertNotNull(cameraIds);
        
        // 测试打开第一个相机设备
        cameraKit.getCameraDevice(cameraIds[0], new Camera.StateCallback() {
            @Override
            public void onCreated(Camera camera) {
                assertNotNull("相机设备应成功打开", camera);
                camera.release();
            }
            
            @Override
            public void onCreateFailed(String s, int i) {
                fail("相机打开失败");
            }
            
            @Override
            public void onReleased(String s) {
            }
        });
        
        // 等待异步操作完成
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

部署场景

1. 智能手机和平板电脑：
   • 直接部署到HarmonyOS设备
   • 针对不同屏幕尺寸优化预览UI
   • 考虑不同摄像头规格（前置/后置、分辨率）
2. 智能穿戴设备：
   • 圆形屏幕适配
   • 简化相机控制界面
   • 优化低功耗模式
3. 车机系统：
   • 驾驶时简化操作
   • 语音控制拍照
   • 广角模式支持
4. 电视设备：
   • 遥控器友好的控制
   • 大屏幕预览显示
   • 高清输出支持
5. 企业级应用：
   • 集中管理相机策略
   • 审计相机使用情况
   • 远程配置参数

疑难解答

常见问题1：相机权限被拒绝

• 用户未授予相机权限
• 权限申请流程错误
• 设备策略限制

// 检查权限是否被永久拒绝
private boolean shouldShowPermissionRationale() {
    return shouldShowRequestPermissionRationale(SystemPermission.CAMERA);
}

// 在回调中处理
@Override
public void onPermissionDenied(List<String> deniedPermissions) {
    if (deniedPermissions.contains(SystemPermission.CAMERA)) {
        if (shouldShowPermissionRationale()) {
            // 显示解释并再次请求
            showPermissionExplanation();
            requestPermission();
        } else {
            // 永久拒绝，引导用户去设置
            showGoToSettingsDialog();
        }
    }
}

常见问题2：预览画面黑屏

• Surface未正确绑定
• 图像格式不匹配
• 相机未正确配置

// 确保Surface正确创建
surfaceProvider.getSurfaceOps().get().addCallback(new Surface.Callback() {
    @Override
    public void surfaceCreated(Surface surface) {
        // 绑定Surface到相机会话
        bindSurfaceToSession(surface);
    }
    // ...
});

// 检查图像格式
private void bindSurfaceToSession(Surface surface) {
    // 创建基于Surface的输出配置
    OutputConfiguration outputConfig = new OutputConfiguration(surface);
    // 添加到会话
    sessionConfig.addOutputConfiguration(outputConfig);
}

常见问题3：拍照模糊或卡顿

• 对焦模式未设置
• 分辨率过高导致处理慢
• 光线不足

// 设置对焦模式
CameraConfig.Builder configBuilder = cameraDevice.getCameraConfigBuilder();
configBuilder.setFocusMode(CameraMetadata.FOCUS_MODE_CONTINUOUS_PICTURE);

// 降低拍照分辨率
configBuilder.setPictureSize(1280, 720); // 720p

// 确保光线充足或使用闪光灯
configBuilder.setFlashMode(CameraMetadata.FLASH_MODE_AUTO);

未来展望

1. AI增强摄影：集成图像识别和增强算法
2. 多摄协同：同时使用多个摄像头
3. AR融合：实时叠加虚拟物体
4. 云边协同：云端图像处理与存储
5. 隐私保护：端到端加密图像传输

技术趋势与挑战

趋势

1. 计算摄影：多帧合成、夜景模式
2. 3D感知：深度相机应用
3. 视频分析：实时行为识别
4. 低功耗设计：Always-on视觉
5. 标准化API：跨平台相机控制

挑战

1. 硬件碎片化：不同设备相机能力差异
2. 性能优化：高分辨率实时处理
3. 功耗控制：长时间使用相机
4. 隐私安全：防止图像泄露
5. 多任务协调：与其他应用共享相机

总结

1. 核心技术：
   • 相机权限申请流程
   • Camera Kit API使用
   • 预览会话创建
   • 图像捕获与保存
2. 实现方案：
   • 权限申请封装
   • 相机预览实现
   • 拍照功能集成
   • 资源释放管理
3. 最佳实践：
   • 权限请求时机
   • 错误处理策略
   • 性能优化技巧
   • 用户体验设计
4. 未来方向：
   • AI摄影增强
   • 多摄协同
   • AR融合
   • 隐私保护