2. 程式人生 > >Android8.0 Camera系統架構(一)

Android8.0 Camera系統架構(一)

阿新 • • 發佈：2018-12-31

隨著Android系統的不斷升級，相機子系統框架也在不斷進化，由最初的API1和HAL1到現在的API2和HAL3，由最初簡單的拍照，錄製到現在的連拍，AI人像；可以說是架構上變動最大最頻繁的子系統。很多裝置仍然依賴相機 HAL1，因此 Android 7.0 繼續支援該模組。此外，Android 相機服務還支援同時實現兩種 HAL（1 和 3），如果您希望通過相機 HAL1 支援效能略低的前置攝像頭，並通過相機 HAL3 支援更為高階的後置攝像頭。Android 的相機硬體抽象層 (HAL) 可將 Camera 2 中較高級別的相機框架 API 連線到底層的相機驅動程式和硬體。相機子系統包括相機管道元件的實現，而相機 HAL 則可提供用於實現您的這些元件版本的介面。從 Android 8.0 開始，相機 HAL 介面是 Project Treble 的一部分，相應的 HIDL 介面在硬體/介面/相機中定義。該實現會封裝仍在使用舊版 API 的舊 HAL。從 Android 8.0 開始，相機 HAL 實現必須使用 HIDL API；不支援使用舊版介面。Android8.0下最新的相機架構具有更高的靈活性。架構如下：

這裡寫圖片描述

重新設計 Android Camera API 的目的在於大幅提高應用對於 Android 裝置上的相機子系統的控制能力，同時重新組織 API，提高其效率和可維護性。藉助額外的控制能力，您可以更輕鬆地在 Android 裝置上構建高品質的相機應用，這些應用可在多種產品上穩定執行，同時仍會盡可能使用裝置專用演算法來最大限度地提升質量和效能。版本 3 相機子系統將多個執行模式整合為一個統一的檢視，您可以使用這種檢視實現之前的任何模式以及一些其他模式，例如連拍模式。這樣一來，便可以提高使用者對聚焦、曝光以及更多後期處理（例如降噪、對比度和銳化）效果的控制能力。此外，這種簡化的檢視還能夠使應用開發者更輕鬆地使用相機的各種功能。架構圖已經很清晰的描述了各層架構之間的關係，我們按圖索驥從最新的架構開始，再看完整的架構，最後我們回到應用層來看Camera子系統的設計。

1. CameraService

CameraManager與CameraService通過Binder機制，形成推拉回調

frameworks\base\core\java\android\hardware\camera2\CameraManager.java
frameworks\av\camera\aidl\android\hardware\ICameraService.aidl
frameworks\av\camera\aidl\android\hardware\ICameraServiceListener.aidl

private static final class
 
 CameraManagerGlobal extends ICameraServiceListener.Stub {
         ......
         public ICameraService getCameraService() {
            synchronized(mLock) {
                connectCameraServiceLocked(); //連線服務
                if (mCameraService == null) {
                    Log.e(TAG, "Camera service is unavailable");
                }
                return mCameraService;
            }
        }
        ......
}

CameraManager通過CameraManagerGlobal訪問CameraService服務，並註冊監聽，CamreaService持有CameraServiceListener列表，並回調結果給CameraManager

private void connectCameraServiceLocked() {
        //查詢服務引用
        IBinder cameraServiceBinder = ServiceManager.getService(CAMERA_SERVICE_BINDER_NAME);
        //轉換服務介面
        ICameraService cameraService = ICameraService.Stub.asInterface(cameraServiceBinder);
        try {
           CameraStatus[] cameraStatuses = cameraService.addListener(this); //註冊回撥監聽
           //存副本
           mCameraService = cameraService;
       }
}

frameworks\av\services\camera\libcameraservice\CameraService.h

class CameraService :
    public BinderService<CameraService>,
    public virtual ::android::hardware::BnCameraService, //Bn端(服務端)
    public virtual IBinder::DeathRecipient {.....}

註冊CameraService回撥監聽

Status CameraService::addListener(const sp<ICameraServiceListener>& listener,
        std::vector<hardware::CameraStatus> *cameraStatuses) {
    {
        Mutex::Autolock lock(mStatusListenerLock);
        for (auto& it : mListenerList) {
            if (IInterface::asBinder(it) == IInterface::asBinder(listener)) {
                return STATUS_ERROR(ERROR_ALREADY_EXISTS, "Listener already registered");
            }
        }
        mListenerList.push_back(listener); //註冊
    }

    return Status::ok();
}

CameraService初始化

void CameraService::onFirstRef()
{
    BnCameraService::onFirstRef();
    res = enumerateProviders(); //列舉Provider
    CameraService::pingCameraServiceProxy();
}

呼叫CameraProviderManager列舉裝置

status_t CameraService::enumerateProviders() {

    if (nullptr == mCameraProviderManager.get()) {
        mCameraProviderManager = new CameraProviderManager();
        res = mCameraProviderManager->initialize(this); //初始化
    }

    mNumberOfCameras = mCameraProviderManager->getCameraCount(); //相機數目
    mNumberOfNormalCameras =
            mCameraProviderManager->getAPI1CompatibleCameraCount(); //可用API

    mCameraProviderManager->setUpVendorTags(); //第三方廠商Tag

    if (nullptr == mFlashlight.get()) {
        mFlashlight = new CameraFlashlight(mCameraProviderManager, this); //閃光燈
    }
    res = mFlashlight->findFlashUnits();
    return OK;
}

2. CameraProviderManager

frameworks\av\services\camera\libcameraservice\common\CameraProviderManager.cpp

status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
        ServiceInteractionProxy* proxy) {
    std::lock_guard<std::mutex> lock(mInterfaceMutex);
    mListener = listener;
    mServiceProxy = proxy;

    // Registering will trigger notifications for all already-known providers
    bool success = mServiceProxy->registerForNotifications( //註冊代理通知
        /* instance name, empty means no filter */ "",
        this);
        return INVALID_OPERATION;
    }

    //新增提供者
    addProviderLocked(kLegacyProviderName, /*expected*/ false);
    return OK;
}

查詢初始化並儲存Provider; mServiceProxy是ServiceInteractionProxy*；

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

    sp<provider::V2_4::ICameraProvider> interface;
    interface = mServiceProxy->getService(newProvider); //獲取服務

    sp<ProviderInfo> providerInfo =
            new ProviderInfo(newProvider, interface, this);
    status_t res = providerInfo->initialize(); //執行初始化

    mProviders.push_back(providerInfo); //備份

    return OK;
}

frameworks\av\services\camera\libcameraservice\common\CameraProviderManager.h

struct ServiceInteractionProxy {
        virtual bool registerForNotifications(
                const std::string &serviceName,
                const sp<hidl::manager::V1_0::IServiceNotification>
                &notification) = 0;
        virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(
                const std::string &serviceName) = 0;
        virtual ~ServiceInteractionProxy() {}
    };

    // Standard use case - call into the normal generated static methods which invoke
    // the real hardware service manager
    struct HardwareServiceInteractionProxy : public ServiceInteractionProxy {
        virtual bool registerForNotifications(
                const std::string &serviceName,
                const sp<hidl::manager::V1_0::IServiceNotification>
                &notification) override {
            return hardware::camera::provider::V2_4::ICameraProvider::registerForNotifications(
                    serviceName, notification);
        }
        virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(
                const std::string &serviceName) override { //呼叫HAL
            return hardware::camera::provider::V2_4::ICameraProvider::getService(serviceName);
        }
    };

3. Camera硬體抽象層

hardware\interfaces\camera\provider\2.4\default\CameraProvider.h

struct CameraProvider : public ICameraProvider, public camera_module_callbacks_t {......}

執行初始化

bool CameraProvider::initialize() {
    camera_module_t *rawModule;
    int err = hw_get_module(CAMERA_HARDWARE_MODULE_ID, //熟悉的配方,熟悉的操作
            (const hw_module_t **)&rawModule);
    mModule = new CameraModule(rawModule); //封裝了一層
    err = mModule->init();
    // Setup callback now because we are going to try openLegacy next
    err = mModule->setCallbacks(this);
    mNumberOfLegacyCameras = mModule->getNumberOfCameras();
    for (int i = 0; i < mNumberOfLegacyCameras; i++) {
        struct camera_info info;
        auto rc = mModule->getCameraInfo(i, &info); //查相機資訊
        char cameraId[kMaxCameraIdLen];
        snprintf(cameraId, sizeof(cameraId), "%d", i);
        std::string cameraIdStr(cameraId);
        mCameraStatusMap[cameraIdStr] = CAMERA_DEVICE_STATUS_PRESENT;
        mCameraIds.add(cameraIdStr);
        ......
    }

    return false; // mInitFailed
}

hardware\interfaces\camera\common\1.0\default\CameraModule.cpp

CameraModule::CameraModule(camera_module_t *module) {
    mModule = module; //save this ref
}

做了一些版本相關處理

int CameraModule::init() {
    ATRACE_CALL();
    int res = OK;
    if (getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4 &&
            mModule->init != NULL) {
        ATRACE_BEGIN("camera_module->init");
        res = mModule->init(); //初始化
        ATRACE_END();
    }
    mCameraInfoMap.setCapacity(getNumberOfCameras());
    return res;
}

hardware\libhardware\include\hardware\camera_common.h
最終通過HAL與相機裝置驅動互動

{
    ......
     */
    int (*init)();

    /* reserved for future use */
    void* reserved[5];
} camera_module_t;

讓我們往回倒一下車，providerInfo->initialize(); 

status_t CameraProviderManager::ProviderInfo::initialize() {
    status_t res = parseProviderName(mProviderName, &mType, &mId);
    hardware::Return<Status> status = mInterface->setCallback(this);
    hardware::Return<bool> linked = mInterface->linkToDeath(this, /*cookie*/ mId);
    //初始化相機裝置
    // Get initial list of camera devices, if any
    std::vector<std::string> devices;
    hardware::Return<void> ret = mInterface->getCameraIdList([&status, &devices]( //獲取device
            Status idStatus,
            const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
        status = idStatus;

    sp<StatusListener> listener = mManager->getStatusListener();
    for (auto& device : devices) {
        std::string id;
        status_t res = addDevice(device, //天加device
                hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT, &id);
    }

    for (auto& device : mDevices) {
        mUniqueCameraIds.insert(device->mId);
        if (device->isAPI1Compatible()) {
            mUniqueAPI1CompatibleCameraIds.insert(device->mId);
        }
    }
    mUniqueDeviceCount = mUniqueCameraIds.size();
    return OK;
}
status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
        CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {

    uint16_t major, minor;
    std::string type, id;

    status_t res = parseDeviceName(name, &major, &minor, &type, &id); //解析裝置名

    if (mManager->isValidDeviceLocked(id, major)) { //驗證
        return BAD_VALUE;
    }

    std::unique_ptr<DeviceInfo> deviceInfo;
    switch (major) {
        case 1:
            deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, mProviderTagid, //Device1
                    id, minor);
            break;
        case 3:
            deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid, //Device3
                    id, minor);
            break;
        default:
            return BAD_VALUE;
    }
    if (deviceInfo == nullptr) return BAD_VALUE;
    deviceInfo->mStatus = initialStatus; //回撥設定

    mDevices.push_back(std::move(deviceInfo)); //儲存引用

    if (parsedId != nullptr) {
        *parsedId = id;
    }
    return OK;
}

初始化裝置資訊

template<class DeviceInfoT>
std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
    CameraProviderManager::ProviderInfo::initializeDeviceInfo(
        const std::string &name, const metadata_vendor_id_t tagId,
        const std::string &id, uint16_t minorVersion) const {
    Status status;

    auto cameraInterface =
            getDeviceInterface<typename DeviceInfoT::InterfaceT>(name); //獲取HAL裝置遠端介面
    if (cameraInterface == nullptr) return nullptr;
    return std::unique_ptr<DeviceInfo>( //返回裝置資訊
        new DeviceInfoT(name, tagId, id, minorVersion, resourceCost,
                cameraInterface));
}

通過ICameraDevice關聯硬體抽象層

template<>
sp<device::V1_0::ICameraDevice>
CameraProviderManager::ProviderInfo::getDeviceInterface
        <device::V1_0::ICameraDevice>(const std::string &name) const {
    Status status;
    sp<device::V1_0::ICameraDevice> cameraInterface;
    hardware::Return<void> ret;
    ret = mInterface->getCameraDeviceInterface_V1_x(name, [&status, &cameraInterface](
        Status s, sp<device::V1_0::ICameraDevice> interface) {
                status = s;
                cameraInterface = interface;
            });
    return cameraInterface;
}

硬體抽象層呼叫介面(Treble架構)

struct CameraDevice : public ICameraDevice {......}

4. CameraDeviceClient與CameraDevice

新的架構圖中右邊的分支已經跟蹤完畢，我們回過頭來看左邊的分支
frameworks/base/core/java/android/hardware/camera2/CameraManager.java

private CameraDevice openCameraDeviceUserAsync(String cameraId,
            CameraDevice.StateCallback callback, Handler handler, final int uid)
            throws CameraAccessException {
        CameraCharacteristics characteristics = getCameraCharacteristics(cameraId);
        CameraDevice device = null;

        synchronized (mLock) {

            ICameraDeviceUser cameraUser = null;
            //CameraDeviceImpl 為 CameraDevice抽象類的自類
            android.hardware.camera2.impl.CameraDeviceImpl deviceImpl =
                    new android.hardware.camera2.impl.CameraDeviceImpl(
                        cameraId,
                        callback,
                        handler,
                        characteristics,
                        mContext.getApplicationInfo().targetSdkVersion);

            ICameraDeviceCallbacks callbacks = deviceImpl.getCallbacks();

            try {
                if (supportsCamera2ApiLocked(cameraId)) {
                    // Use cameraservice's cameradeviceclient implementation for HAL3.2+ devices
                    ICameraService cameraService = CameraManagerGlobal.get().getCameraService();
                    //連線相機Device
                    cameraUser = cameraService.connectDevice(callbacks, cameraId,
                            mContext.getOpPackageName(), uid);
                } else {
                    // Use legacy camera implementation for HAL1 devices
                    //使用舊版HAL1
                    cameraUser = CameraDeviceUserShim.connectBinderShim(callbacks, id);
                }
            } catch (ServiceSpecificException e) {
               ......
            }

            // 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); //設定
            device = deviceImpl;
        }

        return device;
    }

frameworks/av/services/camera/libcameraservice/CameraService.cpp

Status CameraService::connectDevice(
        const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb,
        const String16& cameraId,
        const String16& clientPackageName,
        int clientUid,
        /*out*/
        sp<hardware::camera2::ICameraDeviceUser>* device) {

    ATRACE_CALL();
    Status ret = Status::ok();
    String8 id = String8(cameraId);
    sp<CameraDeviceClient> client = nullptr;
    //呼叫模板函式
    ret = connectHelper<hardware::camera2::ICameraDeviceCallbacks,CameraDeviceClient>(cameraCb, id,
            CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName,
            clientUid, USE_CALLING_PID, API_2,
            /*legacyMode*/ false, /*shimUpdateOnly*/ false,
            /*out*/client);

    if(!ret.isOk()) {
        logRejected(id, getCallingPid(), String8(clientPackageName),
                ret.toString8());
        return ret;
    }

    *device = client; //返回裝置
    return ret;
}

模板函式

template<class CALLBACK, class CLIENT>
Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
        int halVersion, const String16& clientPackageName, int clientUid, int clientPid,
        apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,
        /*out*/sp<CLIENT>& device) {
    binder::Status ret = binder::Status::ok();

    String8 clientName8(clientPackageName);

    int originalClientPid = 0;
    sp<CLIENT> client = nullptr;
    {
        ......
        // Enforce client permissions and do basic sanity checks
        if(!(ret = validateConnectLocked(cameraId, clientName8, //連線驗證
                /*inout*/clientUid, /*inout*/clientPid, /*out*/originalClientPid)).isOk()) {
            return ret;
        }

        // Check the shim parameters after acquiring lock, if they have already been updated and
        // we were doing a shim update, return immediately
        if (shimUpdateOnly) {
            auto cameraState = getCameraState(cameraId);
            if (cameraState != nullptr) {
                if (!cameraState->getShimParams().isEmpty()) return ret;
            }
        }

        ......

        sp<BasicClient> tmp = nullptr;
        if(!(ret = makeClient(this, cameraCb, clientPackageName, cameraId, facing, clientPid,
                clientUid, getpid(), legacyMode, halVersion, deviceVersion, effectiveApiLevel,
                /*out*/&tmp)).isOk()) {
            return ret;
        }
        client = static_cast<CLIENT*>(tmp.get());
        //初始化
        err = client->initialize(mCameraProviderManager);

        // Update shim paremeters for legacy clients
        if (effectiveApiLevel == API_1) { //系統舊版本API1
            // Assume we have always received a Client subclass for API1
            sp<Client> shimClient = reinterpret_cast<Client*>(client.get());
            String8 rawParams = shimClient->getParameters();
            CameraParameters params(rawParams);

            auto cameraState = getCameraState(cameraId);
            if (cameraState != nullptr) {
                cameraState->setShimParams(params);
            }
        }
    } // lock is destroyed, allow further connect calls
    device = client;
    return ret;
}

建立不同HAL版本對應的相機Client

Status CameraService::makeClient(const sp<CameraService>& cameraService,
        const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,
        int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,
        int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
        /*out*/sp<BasicClient>* client) {

    if (halVersion < 0 || halVersion == deviceVersion) {
        // Default path: HAL version is unspecified by caller, create CameraClient
        // based on device version reported by the HAL.
        switch(deviceVersion) {
          //HAL1的架構
          case CAMERA_DEVICE_API_VERSION_1_0:
            if (effectiveApiLevel == API_1) {  // Camera1 API route
                sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
                *client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),
                        facing, clientPid, clientUid, getpid(), legacyMode);
            } else { // Camera2 API route
                ALOGW("Camera using old HAL version: %d", deviceVersion);
                return STATUS_ERROR_FMT(ERROR_DEPRECATED_HAL,
                        "Camera device \"%s\" HAL version %d does not support camera2 API",
                        cameraId.string(), deviceVersion);
            }
            break;
          //HAL3的架構
          case CAMERA_DEVICE_API_VERSION_3_0:
          case CAMERA_DEVICE_API_VERSION_3_1:
          case CAMERA_DEVICE_API_VERSION_3_2:
          case CAMERA_DEVICE_API_VERSION_3_3:
          case CAMERA_DEVICE_API_VERSION_3_4:
            if (effectiveApiLevel == API_1) { // Camera1 API route
                sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
                *client = new Camera2Client(cameraService, tmp, packageName, cameraIdToInt(cameraId),
                        facing, clientPid, clientUid, servicePid, legacyMode);
            } else { // Camera2 API route
                sp<hardware::camera2::ICameraDeviceCallbacks> tmp =
                        static_cast<hardware::camera2::ICameraDeviceCallbacks*>(cameraCb.get());
                *client = new CameraDeviceClient(cameraService, tmp, packageName, cameraId,
                        facing, clientPid, clientUid, servicePid);
            }
            break;
          default:
            // Should not be reachable
            ALOGE("Unknown camera device HAL version: %d", deviceVersion);
            return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
                    "Camera device \"%s\" has unknown HAL version %d",
                    cameraId.string(), deviceVersion);
        }
    } else {
        // A particular HAL version is requested by caller. Create CameraClient
        // based on the requested HAL version.
        if (deviceVersion > CAMERA_DEVICE_API_VERSION_1_0 &&
            halVersion == CAMERA_DEVICE_API_VERSION_1_0) {
            // Only support higher HAL version device opened as HAL1.0 device.
            sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
            *client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),
                    facing, clientPid, clientUid, servicePid, legacyMode);
        } else {
            // Other combinations (e.g. HAL3.x open as HAL2.x) are not supported yet.
            ALOGE("Invalid camera HAL version %x: HAL %x device can only be"
                    " opened as HAL %x device", halVersion, deviceVersion,
                    CAMERA_DEVICE_API_VERSION_1_0);
            return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
                    "Camera device \"%s\" (HAL version %d) cannot be opened as HAL version %d",
                    cameraId.string(), deviceVersion, halVersion);
        }
    }
    return Status::ok();
}

frameworks/av/services/camera/libcameraservice/api2/CameraDeviceClient.h

struct CameraDeviceClientBase :
         public CameraService::BasicClient,
         public hardware::camera2::BnCameraDeviceUser //CameraDeviceUser的服務端
{
    typedef hardware::camera2::ICameraDeviceCallbacks TCamCallbacks; //該回調在CameraDeviceImpl

    const sp<hardware::camera2::ICameraDeviceCallbacks>& getRemoteCallback() {
        return mRemoteCallback;
    }
    ......
};

HAL3對應的CameraDeviceClient

class CameraDeviceClient :
        public Camera2ClientBase<CameraDeviceClientBase>,
        public camera2::FrameProcessorBase::FilteredListener
{......}

如此以來CameraDeviceClient就繼承了CameraDeviceClientBase，間接繼承了BnCameraDeviceUser

template <typename TClientBase>
class Camera2ClientBase :
        public TClientBase,
        public CameraDeviceBase::NotificationListener
{

持有遠端mRemoteDevice的Binder物件

    public void setRemoteDevice(ICameraDeviceUser remoteDevice) throws CameraAccessException {
        synchronized(mInterfaceLock) {
            mRemoteDevice = new ICameraDeviceUserWrapper(remoteDevice); //包裝

            IBinder remoteDeviceBinder = remoteDevice.asBinder();//遠端Binder服務,HAL3架構下是CameraDeviceClient
            ......

            mDeviceHandler.post(mCallOnOpened);
            mDeviceHandler.post(mCallOnUnconfigured);
        }
    }

通過此遠端回撥將CamreaDevice與CameraDeviceClient聯絡起來，處理來自CameraDeviceClient的訊息

public class CameraDeviceCallbacks extends ICameraDeviceCallbacks.Stub {......}

5. CameraDeviceClient與Camera3Device

回到剛才的err = client->initialize(mCameraProviderManager);

status_t CameraDeviceClient::initialize(sp<CameraProviderManager> manager) {
    return initializeImpl(manager);
}

template<typename TProviderPtr>
status_t CameraDeviceClient::initializeImpl(TProviderPtr providerPtr) {
    ATRACE_CALL();
    status_t res;

    res = Camera2ClientBase::initialize(providerPtr); //呼叫初始化
    if (res != OK) {
        return res;
    }
    ......
    return OK;
}

frameworks/av/services/camera/libcameraservice/common/Camera2ClientBase.cpp

template <typename TClientBase>
status_t Camera2ClientBase<TClientBase>::initialize(sp<CameraProviderManager> manager) {
    return initializeImpl(manager);
}

template <typename TClientBase>
template <typename TProviderPtr>
status_t Camera2ClientBase<TClientBase>::initializeImpl(TProviderPtr providerPtr) {
    ATRACE_CALL();
    ALOGV("%s: Initializing client for camera %s", __FUNCTION__,
          TClientBase::mCameraIdStr.string());
    status_t res;

    // Verify ops permissions
    res = TClientBase::startCameraOps();
    if (res != OK) {
        return res;
    }

    if (mDevice == NULL) {
        ALOGE("%s: Camera %s: No device connected",
                __FUNCTION__, TClientBase::mCameraIdStr.string());
        return NO_INIT;
    }

    res = mDevice->initialize(providerPtr); //呼叫具體的裝置初始化
    if (res != OK) {
        ALOGE("%s: Camera %s: unable to initialize device: %s (%d)",
                __FUNCTION__, TClientBase::mCameraIdStr.string(), strerror(-res), res);
        return res;
    }

    wp<CameraDeviceBase::NotificationListener> weakThis(this);
    res = mDevice->setNotifyCallback(weakThis);

    return OK;
}

frameworks/av/services/camera/libcameraservice/common/Camera2ClientBase.h

 sp<CameraDeviceBase>  mDevice;

rameworks/av/services/camera/libcameraservice/device3/Camera3Device.h

class Camera3Device :
            public CameraDeviceBase, //繼承了CameraDeviceBase
            virtual public hardware::camera::device::V3_2::ICameraDeviceCallback,
            private camera3_callback_ops {

frameworks/av/services/camera/libcameraservice/device3/Camera3Device.cpp

status_t Camera3Device::initialize(sp<CameraProviderManager> manager) {
    ......
    sp<ICameraDeviceSession> session;
    ATRACE_BEGIN("CameraHal::openSession");
    status_t res = manager->openSession(mId.string(), this, //通過session獲取Device
            /*out*/ &session);
    res = manager->getCameraCharacteristics(mId.string(), &mDeviceInfo); //通過相機引數獲取Device
    std::shared_ptr<RequestMetadataQueue> queue;
    auto requestQueueRet = session->getCaptureRequestMetadataQueue(//元資料捕獲請求佇列
        [&queue](const auto& descriptor) {
            queue = std::make_shared<RequestMetadataQueue>(descriptor);
            if (!queue->isValid() || queue->availableToWrite() <= 0) {
                ALOGE("HAL returns empty request metadata fmq, not use it");
                queue = nullptr;
                // don't use the queue onwards.
            }
        });

    std::unique_ptr<ResultMetadataQueue>& resQueue = mResultMetadataQueue;
    auto resultQueueRet = session->getCaptureResultMetadataQueue(//元資料捕獲結果佇列
        [&resQueue](const auto& descriptor) {
            resQueue = std::make_unique<ResultMetadataQueue>(descriptor);
            if (!resQueue->isValid() || resQueue->availableToWrite() <= 0) {
                ALOGE("HAL returns empty result metadata fmq, not use it");
                resQueue = nullptr;
                // Don't use the resQueue onwards.
            }
        });
    IF_ALOGV() {
        session->interfaceChain([](
            ::android::hardware::hidl_vec<::android::hardware::hidl_string> interfaceChain) {
                ALOGV("Session interface chain:");
                for (auto iface : interfaceChain) {
                    ALOGV("  %s", iface.c_str());
                }
            });
    }

    mInterface = new HalInterface(session, queue); //新建硬體抽象層介面例項
    std::string providerType;
    mVendorTagId = manager->getProviderTagIdLocked(mId.string());

    return initializeCommonLocked();
}

至此新Camera架構整個藍圖構建完成，我們只是按圖索驥從Java層一直到HAL層，事實上Camera大部分重要的東西都在其驅動演算法層，我們暫且不去深究。下一篇我們將從整個新舊架構的角度去分析Camera系統。

相關推薦

Android8.0 Camera系統架構(一)

隨著Android系統的不斷升級，相機子系統框架也在不斷進化，由最初的API1和HAL1到現在的API2和HAL3，由最初簡單的拍照，錄製到現在的連拍，AI人像；可以說是架構上變動最大最頻繁的子系統。很多裝置仍然依賴相機 HAL1，因此 Android 7.0

Android8.0 儲存系統

Android 一直在不斷髮展，可支援各種儲存裝置型別和功能。所有 Android 版本均支援配有傳統儲存（包括行動式儲存和內建儲存）的裝置。行動式儲存是指物理介質（如 SD 卡或 USB 裝置），用於進行臨時資料傳輸/檔案儲存。物理介質可以隨裝置一起保留更長時間，但並非固定在裝置上，可

Android8.0 儲存系統

Android 一直在不斷髮展，可支援各種儲存裝置型別和功能。所有 Android 版本均支援配有傳統儲存（包括行動式儲存和內建儲存）的裝置。行動式儲存是指物理介質（如 SD 卡或 USB 裝置），用於進行臨時資料傳輸/檔案儲存。物理介質可以隨裝置一起保留更長時

躺雨沒的學習筆記（4）——藍芽系統架構 （2.0 核心系統架構）

Agenda： 2.0 核心系統架構 （181頁）藍芽核心系統包括一個主機，一個主要控制器和零到多個次要控制器。 2.0.1 藍芽BR/EDR最小系統 藍芽BR/EDR最小核心系統包括： 控制器中四個最底層，BR/EDR射頻物理層

Android Camera 系統架構原始碼分析(4)---->Camera的資料來源及Camera的管理

Camera的資料來源及Camera的管理  我們接著第3篇，再返回Cam1DeviceBase::startPreview()的(4) mpCamAdapter->startPreview()。在講(4)前我們先來看看(1)onStartPreview(

Android 5.0 Camera系統原始碼分析(2)：Camera開啟流程

1. 前言 本文將分析android系統原始碼，從frameworks層到hal層，暫不涉及app層和kernel層。由於某些函式比較複雜，在貼出程式碼時會適當對其進行簡化。本文屬於自己對原始碼的總結，僅僅是貫穿程式碼流程，不會深入分析各個細節。歡迎聯絡討論，QQ：1026

Android 5.0 Camera系統原始碼分析(4)：Camera預覽流程資料流

1. 前言 上一篇講了怎麼讓Camera進入預覽模式，提到了DisplayClient負責顯示影象資料，而CamAdapter負責提供影象資料，這裡主要記錄了CamAdapter怎麼獲取影象，然後DisplayClient怎麼將影象顯示在螢幕上。 2.

Android 5.0 Camera系統原始碼分析(3)：Camera預覽流程控制流

1. 前言 本文分析的是Android系統原始碼，從frameworks層到hal層，記錄了Camera進入預覽模式的重點程式碼，主要為控制流程的程式碼，有關影象buffer的傳遞暫不涉及，硬體平臺基於mt6735。由於某些函式比較複雜，在貼出程式碼時會適當對

Android6.0 Audio系統架構

#android audio Why audio ? 由於個人興趣的原因，從系統科調整到音訊科。 一個禮拜前，對Audio的認識是這樣的： 之後，慢慢接觸程式碼之後，發現架構應該是這樣的： （圖來自AOSP：https://source.android

Android原始碼筆記——Camera系統架構

Camera的架構與Android系統的整體架構保持一致，如下圖所示，本文主要從以下四個方面對其進行說明。 Framework：Camera.javaAndroid Runtime：android_hardware_Camera.cppLibrary：Camera Cli

Android6.0 顯示系統（一） Surface建立

之前在分析Activity的時候，我們分析過Surface建立。這個系列的部落格是講述顯示系統，這裡再系統的分析下Surface建立過程。 之前我們分析在Activity在呼叫attach方法時，建立ViewRootImpl，以及建立其Surface過程，還有在WMS中建立

Android Camera 系統架構原始碼分析(2)---->Camera的startPreview和setPreviewCallback

Camera startPreview流程 上接第一篇，這個過程的主要任務是，如何讀取資料的，讀取的資料是什麼格式，最好能知道是如何去預覽的 上層APP呼叫的是Camera.java的startPreview();，下面列出startPreview的呼叫流程 //Camera

Android原始碼之Camera系統架構

Camera的架構與Android系統的整體架構保持一致，如下圖所示，本文主要從以下四個方面對其進行說明。 Framewo

Android8.0 Binder之面向系統服務(一)

Android碎片化問題一直是OS更新的痛點，Google在Android8.0引入的Treble旨在解決Android長期以來碎片化嚴重的問題，Treble計劃將Binder擴充套件為三角結構，分別對應dev/binder,dev/vndbinder,dev/

十年磨一劍，美國巨頭視頻網站 Hulu 的直播系統架構實踐

美國 視頻網站 直播系統架構 Hulu 是 2007 年在美國上市的在線視頻公司，提供會員制付費視頻服務，商業模式與國內的愛奇藝、優酷類似。Hulu 今年 5 月發布了最新的 OTT 電視直播應用——Hulu Live TV，目標是替代傳統的有線電視服務，和國內最近興起的直播應用，比如 YY，映

【大數據系統架構師】0.1 Java編程基礎

tar 數組 數據類型和運算符 網絡 網絡編程 https 架構 linux ocs 1. 初識Java 2. Java語法 快速入門點我 2.1 數據類型和運算符 2.2 流程控制語句 2.3 數組 2.4 類和對象 2.5 OOP三大特性 2.6 集合框架與泛型 2.7

電商系統架構總結（一）

get 部分 上傳 其他 維護 let turn 同事 stat 最近主導了一個電商系統的設計開發過程，包括前期分析設計，框架搭建，功能模塊的具體開發（主要負責在線支付部分），成功上線後的部署維護，運維策略等等全過程。 雖然這個系統不是什麽超大型的電商系統

Android系統架構（一）

查詢 核心 手機 例如 ava 模塊 api 操作系統 運行 　　一、Android系統版本簡介 　　Android操作系統已占據了手機操作系統的大半壁江山，截至本文寫作時，Android操作系統系統版本及其詳細信息，已發生了變化，具體信息見下表，當然也可以訪問https:

0. 視頻監控系統架構設計

無線 oot nfs服務 實現 圖1 In inux ubun 設計 0、視頻監控系統架構設計 0.1、功能指標 (1)搭建共享文件夾 (2)實現Ubuntu的NAT上網和橋接上網 (3)搭建局域網 (4)搭建nfs服務器、tftp服務器 (5)將uboot、kernel、

Android8.0適配那點事（一）

懸浮 新增功能 nta onstop config ges 保持 com dfa 1、通知渠道（Channeld） 當然，適配8.0的第一步自然是把targeSdk升級到26，在8.0中所有通知的實現都需要提供通知渠道，否則，所有通知在8.0系統上面都不能正常顯示； 下圖是