Java最新Camera Open 流程源码分析(1)，java开发中常见中间件面试

最新推荐文章于 2024-05-29 10:05:08 发布

2401_84584289

最新推荐文章于 2024-05-29 10:05:08 发布

阅读量770

点赞数 27

分类专栏：程序员文章标签： java 面试学习

本文链接：https://blog.csdn.net/2401_84584289/article/details/138690666

版权

程序员专栏收录该内容

130 篇文章 1 订阅

订阅专栏

最后总结

ActiveMQ+Kafka+RabbitMQ学习笔记PDF

RabbitMQ实战指南

手写RocketMQ笔记

手写“Kafka笔记”

关于分布式，限流+缓存+缓存，这三大技术（包含：ZooKeeper+Nginx+MongoDB+memcached+Redis+ActiveMQ+Kafka+RabbitMQ）等等。这些相关的面试也好，还有手写以及学习的笔记PDF，都是啃透分布式技术必不可少的宝藏。以上的每一个专题每一个小分类都有相关的介绍，并且小编也已经将其整理成PDF啦

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

CameraManager 会根据传递过来的参数不同，调用不同的Opencamera 方法。




    @RequiresPermission(android.Manifest.permission.CAMERA)

    public void openCamera(@NonNull String cameraId,

            @NonNull final CameraDevice.StateCallback callback, @Nullable Handler handler)

            throws CameraAccessException {



        openCameraForUid(cameraId, callback, CameraDeviceImpl.checkAndWrapHandler(handler),

                USE_CALLING_UID);

    }

    // CameraDeviceImpl.checkAndWrapHandler 会将 Handler 封装成Executor 类型 

    public static Executor checkAndWrapHandler(Handler handler) {

        return new CameraHandlerExecutor(checkHandler(handler));

    }

    

    @RequiresPermission(android.Manifest.permission.CAMERA)

    public void openCamera(@NonNull String cameraId,

            @NonNull @CallbackExecutor Executor executor,

            @NonNull final CameraDevice.StateCallback callback)

            throws CameraAccessException {

        

        openCameraForUid(cameraId, callback, executor, USE_CALLING_UID);

    }

从代码中看，openCamera 参数主要区别是 CallbackExecutor 、Handler 这两个，最终都会走到 openCameraForUid 方法。

openCameraForUid 主要是根据 Camera id 打开一个Camera 连接。


    public void openCameraForUid(@NonNull String cameraId,

            @NonNull final CameraDevice.StateCallback callback, @NonNull Executor executor,

            int clientUid)

            throws CameraAccessException {

            // 

            openCameraDeviceUserAsync(cameraId, callback, executor, clientUid);

            

    }

openCameraForUid 会调用 openCameraDeviceUserAsync 方法去帮助opencamera 连接的创建


    private CameraDevice openCameraDeviceUserAsync(String cameraId,

            CameraDevice.StateCallback callback, Executor executor, final int uid)

            throws CameraAccessException {

            // 获取 特定camera的特性

            CameraCharacteristics characteristics = getCameraCharacteristics(cameraId);

            

            android.hardware.camera2.impl.CameraDeviceImpl deviceImpl = new  CameraDeviceImpl();

            ICameraDeviceCallbacks callbacks = deviceImpl.getCallbacks()

            

              if (supportsCamera2ApiLocked(cameraId)) {

                    // Use cameraservice's cameradeviceclient implementation for HAL3.2+ devices

                    ICameraService cameraService = CameraManagerGlobal.get().getCameraService();

                    

                    cameraService.connectDevice(callbacks, cameraId,mContext.getOpPackageName(), uid);

                    

              }else{

                    ... ...

              }

            // TODO: factor out callback to be non-nested, then move setter to constructor

            // For now, calling setRemoteDevice will fire initial

            // onOpened/onUnconfigured callbacks.

            // This function call may post onDisconnected and throw CAMERA_DISCONNECTED if

            // cameraUser dies during setup.

            deviceImpl.setRemoteDevice(cameraUser);

            

    }

cameraService是通过Binder 继承 ICameraServiceListener.Stub


    private static final class CameraManagerGlobal extends ICameraServiceListener.Stub

            implements IBinder.DeathRecipient {

                // This must match the ICameraService definition

                private static final String CAMERA_SERVICE_BINDER_NAME = "media.camera";

                

                public ICameraService getCameraService() {

                    

                    synchronized(mLock) {

                        // 

                        connectCameraServiceLocked();

                        return mCameraService;

                    }

                }

                

                private void connectCameraServiceLocked() {

                     IBinder cameraServiceBinder = ServiceManager.getService(CAMERA_SERVICE_BINDER_NAME);

                

                     ICameraService cameraService = ICameraService.Stub.asInterface(cameraServiceBinder);

                     

                     for (CameraStatus c : cameraStatuses) {

                        onStatusChangedLocked(c.status, c.cameraId);

                     }

                     mCameraService = cameraService;

                }       

            }

3.CameraService.cpp

(frameworks\av\services\camera\libcameraservice)

cameraService.connectDevice 通过AIDL 到用到 CameraService.cpp 中的connectDevice 方法。


Status CameraService::connectDevice(

        const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb,

        const String16& cameraId,

        const String16& clientPackageName,

        int clientUid,

        /*out*/

        sp<hardware::camera2::ICameraDeviceUser>* device) {

            //调用connectHelper 方法

            ret = connectHelper<hardware::camera2::ICameraDeviceCallbacks,CameraDeviceClient>(cameraCb, id,

            /*api1CameraId*/-1,

            CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageNameAdj,

            clientUid, USE_CALLING_PID, API_2, /*shimUpdateOnly*/ false, /*out*/client);

        

        }

connectDevice 会调用到 connectHelper 方法




Status CameraService::connectHelper(){



        // 闪光灯进入预准备阶段

        mFlashlight->prepareDeviceOpen(cameraId);



        //获取当前设备的Version

        int deviceVersion = getDeviceVersion(cameraId, /*out*/&facing);

        

        

        // 初始化CameraproviderManager

        err = client->initialize(mCameraProviderManager, mMonitorTags);

        

        }

4.CameraProviderManager.cpp

(frameworks\av\services\camera\libcameraservice\common)




status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,

        ServiceInteractionProxy* proxy) {

        // 调用 addProviderLocked 方法

        for (const auto& instance : mServiceProxy->listServices()) {

            this->addProviderLocked(instance);

        }

        

        }

        

status_t CameraProviderManager::addProviderLocked(const std::string& newProvider) {

         

        sp<ProviderInfo> providerInfo = new ProviderInfo(newProvider, this);

        status_t res = providerInfo->initialize(interface, mDeviceState);



}



//ProviderInfo::initialize 初始化方法

status_t CameraProviderManager::ProviderInfo::initialize(){





     status_t res = addDevice(device, common::V1_0::CameraDeviceStatus::PRESENT, &id);



}       





status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,

        CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {

        

        //

        deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid,

                    id, minor);

        

        }

        

        

std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>

    CameraProviderManager::ProviderInfo::initializeDeviceInfo(){

        // 后续调用待完善 如何 跳转到 Camera3device.cpp 的initialize 方法

        return std::unique_ptr<DeviceInfo>(

        new DeviceInfoT(name, tagId, id, minorVersion, resourceCost, this,

                mProviderPublicCameraIds, cameraInterface));

    }

5.Camera3Device.cpp

(frameworks\av\services\camera\libcameraservice\device3)


status_t Camera3Device::initialize(sp<CameraProviderManager> manager, const String8& monitorTags) {



        // 调用 CameraProviderManager openSession

        ATRACE_BEGIN("CameraHal::openSession");

        status_t res = manager->openSession(mId.string(), this,

                /*out*/ &session);

        ATRACE_END();



        return initializeCommonLocked();

}

6.CameraProviderManager.cpp

(frameworks\av\services\camera\libcameraservice\common)


status_t CameraProviderManager::openSession(const std::string &id,

        const sp<device::V3_2::ICameraDeviceCallback>& callback,

        /*out*/

        sp<device::V3_2::ICameraDeviceSession> *session) {

        

            auto interface = deviceInfo3->startDeviceInterface<

            CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();

            

            ret = interface->open(callback, [&status, &session]

            (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {

                status = s;

                if (status == Status::OK) {

                    *session = cameraSession;

                }

            });

        

        

        }

7.ICameraDevice.hal

(hardware\interfaces\camera\device\3.2)


//Power on and initialize this camera device for active use, returning a

//session handle for active operations.

 open(ICameraDeviceCallback callback) generates

            (Status status, ICameraDeviceSession session);

8.CameraDevice.cpp

(hardware\interfaces\camera\device\3.2\default)


Return<void> CameraDevice::open(const sp<ICameraDeviceCallback>& callback,

        ICameraDevice::open_cb _hidl_cb)  {

        

        

        /** Open HAL device */

        status_t res;

        camera3_device_t *device;

        // 1. 开始 open Hal Device 

        ATRACE_BEGIN("camera3->open");

        res = mModule->open(mCameraId.c_str(),

                reinterpret_cast<hw_device_t**>(&device));

        ATRACE_END();

        

        // 2. 获取Camera 信息

        res = mModule->getCameraInfo(mCameraIdInt, &info);

        

        // 3. 创建 CameraDeviceSession

        session = createSession(device, info.static_camera_characteristics, callback);

        }

CameraModule.cpp

(hardware\interfaces\camera\common\1.0\default)


int CameraModule::open(const char* id, struct hw_device_t** device) {

    int res;

    ATRACE_BEGIN("camera_module->open");

    res = filterOpenErrorCode(mModule->common.methods->open(&mModule->common, id, device));

    ATRACE_END();

    return res;

}

10.Camxhal3entry.cpp

(vendor\qcom\proprietary\camx\src\core\hal)


int open(

    const struct hw_module_t*   pHwModuleAPI,

    const char*                 pCameraIdAPI,

    struct hw_device_t**        ppHwDeviceAPI)


#### 线程、数据库、算法、JVM、分布式、微服务、框架、Spring相关知识

![](https://img-blog.csdnimg.cn/img_convert/7f9194de8ef702bed83b88a7b9cda9ae.webp?x-oss-process=image/format,png)

#### 一线互联网P7面试集锦+各种大厂面试集锦

![](https://img-blog.csdnimg.cn/img_convert/e94767b53eff9b2b7dbb256eb58dffd6.webp?x-oss-process=image/format,png)

#### 学习笔记以及面试真题解析

![](https://img-blog.csdnimg.cn/img_convert/71550592340dfa6ef013b06bfc0af8db.webp?x-oss-process=image/format,png)

> **本文已被[CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)收录**

**[需要这份系统化的资料的朋友，可以点击这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**

(vendor\\qcom\\proprietary\\camx\\src\\core\\hal)

int open(

const struct hw_module_t*   pHwModuleAPI,

const char*                 pCameraIdAPI,

struct hw_device_t**        ppHwDeviceAPI)

线程、数据库、算法、JVM、分布式、微服务、框架、Spring相关知识

[外链图片转存中…(img-N8kneDaY-1715366535812)]

一线互联网P7面试集锦+各种大厂面试集锦

[外链图片转存中…(img-BlyAnwaV-1715366535812)]

学习笔记以及面试真题解析

[外链图片转存中…(img-5VA75m7V-1715366535812)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

2401_84584289

关注

27
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

Java最新Camera Open 流程源码分析(1)，java开发中常见中间件面试

最后总结

ActiveMQ+Kafka+RabbitMQ学习笔记PDF

RabbitMQ实战指南

手写RocketMQ笔记

手写“Kafka笔记”

线程、数据库、算法、JVM、分布式、微服务、框架、Spring相关知识

一线互联网P7面试集锦+各种大厂面试集锦

学习笔记以及面试真题解析