camera1 api调用流程

一、Camera1 api调用流程与参数设置获取分析

framework 代码

/frameworks/base/core/java/android/hardware/Camera.java

    //开启摄像头并获取对应cameraid的句柄
    public static Camera open(int cameraId) {
        String disable = SystemProperties.get("sys.verifone.camera.disable","false");
        if(disable.equals("true")){
           Log.e(TAG, "Error verifone  disable  camera");
           return null;
        }    
        return new Camera(cameraId);                                                                                                                                   
    } 
    
    //通过camera句柄获得native取得的参数并设置到key列表其中
    public Parameters getParameters() {                                                                                                                                
        Parameters p = new Parameters();
        String s = native_getParameters();
        p.unflatten(s);//设置到key列表。比如KEY_PREVIEW_SIZE
        return p;
    }
    
    public void unflatten(String flattened) {                                                                                                                      
            mMap.clear();

            TextUtils.StringSplitter splitter = new TextUtils.SimpleStringSplitter(';');
            splitter.setString(flattened);
            for (String kv : splitter) {
                int pos = kv.indexOf('=');
                if (pos == -1) {
                    continue;
                }
                String k = kv.substring(0, pos);
                String v = kv.substring(pos + 1);
                mMap.put(k, v);
            }
        }
    //例如获取这个支持列表
        public List<Size> getSupportedPreviewSizes() {
            String str = get(KEY_PREVIEW_SIZE + SUPPORTED_VALUES_SUFFIX);                                                                                              
            return splitSize(str);
        }

frameworks/base/core/jni/android_hardware_Camera.cpp

static jstring android_hardware_Camera_getParameters(JNIEnv *env, jobject thiz)                                                                                        
{
    ALOGV("getParameters");
    sp<Camera> camera = get_native_camera(env, thiz, NULL);
    if (camera == 0) return 0;

    String8 params8 = camera->getParameters();//获取参数
    if (params8.isEmpty()) {
        jniThrowRuntimeException(env, "getParameters failed (empty parameters)");
        return 0;
    }    
    return env->NewStringUTF(params8.string());
}

camera->getParameters（）调用到

frameworks/av/services/camera/libcameraservice/api1/Camera2Client.cpp 

String8 Camera2Client::getParameters() const {                                                                                                                         
    ATRACE_CALL();
    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
    Mutex::Autolock icl(mBinderSerializationLock);
    // The camera service can unconditionally get the parameters at all times
    if (CameraThreadState::getCallingPid() != mServicePid && checkPid(__FUNCTION__) != OK) return String8();

    SharedParameters::ReadLock l(mParameters);

    return l.mParameters.get();
}

调用到服务端基本都在这个目录例如参数处理的代码路径

实际paramaters初始化赋值的位置
frameworks/av/services/camera/libcameraservice/api1/Camera2Client.cpp

tatus_t Camera2Client::initializeImpl(TProviderPtr providerPtr, const String8& monitorTags)
{
    ATRACE_CALL();
    ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
    status_t res;

    res = Camera2ClientBase::initialize(providerPtr, monitorTags);
    if (res != OK) {
        return res;
    }

    {
        SharedParameters::Lock l(mParameters);

        res = l.mParameters.initialize(mDevice.get(), mDeviceVersion);//初始化位置
        if (res != OK) {
            ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
                    __FUNCTION__, mCameraId, strerror(-res), res);
            return NO_INIT;
        }

        l.mParameters.isDeviceZslSupported = isZslEnabledInStillTemplate();
    }

调用到
frameworks/av/services/camera/libcameraservice/api1/client2/Parameters.cpp

status_t Parameters::initialize(CameraDeviceBase *device, int deviceVersion) {
    status_t res; 
    if (device == nullptr) {
        ALOGE("%s: device is null!", __FUNCTION__);
        return BAD_VALUE;
    }    

    const CameraMetadata& info = device->info();
    if (info.entryCount() == 0) { 
        ALOGE("%s: No static information provided!", __FUNCTION__);
        return BAD_VALUE;
    }    
    Parameters::info = &info;
    mDeviceVersion = deviceVersion;

    res = buildFastInfo(device);
    if (res != OK) return res; 

    res = buildQuirks();
    if (res != OK) return res; 

#ifdef SPRD_FRAMEWORKS_CAMERA_EX
    // SPRD some chips can't support to 1920x1920 preview size
    // 预览赋值
    Size maxPreviewSize = { MAX_PREVIEW_WIDTH, MAX_PREVIEW_HEIGHT };
    camera_metadata_ro_entry_t previewSize =
        staticInfo(ANDROID_SPRD_MAX_PREVIEW_SIZE, 2);
    if (previewSize.count) {
        ALOGV("maxPreviewSize w=%d, h=%d", previewSize.data.i32[0],
            previewSize.data.i32[1]);
        if (previewSize.data.i32[0] > 0 && 
                previewSize.data.i32[1] > 0 && 
                previewSize.data.i32[0] <= maxPreviewSize.width &&
                previewSize.data.i32[1] <= maxPreviewSize.height) {
            maxPreviewSize.width = previewSize.data.i32[0];
            maxPreviewSize.height = previewSize.data.i32[1];
        }    
    }    
#else
    const Size maxPreviewSize = { MAX_PREVIEW_WIDTH, MAX_PREVIEW_HEIGHT };
#endif
//省略………………   参数初始化设置paramas.setxxxx

    params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov);
    params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov);

    exposureCompensation = 0;
    params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
                exposureCompensation);

    camera_metadata_ro_entry_t exposureCompensationRange =
        staticInfo(ANDROID_CONTROL_AE_COMPENSATION_RANGE, 2, 2);
    if (!exposureCompensationRange.count) return NO_INIT;

    params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
            exposureCompensationRange.data.i32[1]);
    params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
            exposureCompensationRange.data.i32[0]);

    camera_metadata_ro_entry_t exposureCompensationStep =
        staticInfo(ANDROID_CONTROL_AE_COMPENSATION_STEP, 1, 1);
    if (!exposureCompensationStep.count) return NO_INIT;

    params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
            (float)exposureCompensationStep.data.r[0].numerator /
            exposureCompensationStep.data.r[0].denominator);

    autoExposureLock = false;
    autoExposureLockAvailable = false;
    camera_metadata_ro_entry_t exposureLockAvailable =
        staticInfo(ANDROID_CONTROL_AE_LOCK_AVAILABLE, 1, 1);
    if ((0 < exposureLockAvailable.count) &&
            (ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE ==
                    exposureLockAvailable.data.u8[0])) {
        params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK,
                CameraParameters::FALSE);
        params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
                   CameraParameters::TRUE);
        autoExposureLockAvailable = true;
    } else {
        params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
                   CameraParameters::FALSE);
    }

//省略………………


    paramsFlattened = params.flatten();

    return OK;
}

分析到这里是不是还没发现preview的分辨率的key哪里设置的？

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

onFirstRef()

void CameraService::onFirstRef()
{
    ALOGI("CameraService process starting");

    BnCameraService::onFirstRef();

    // Update battery life tracking if service is restarting
    BatteryNotifier& notifier(BatteryNotifier::getInstance());
    notifier.noteResetCamera();
    notifier.noteResetFlashlight();

    status_t res = INVALID_OPERATION;
                                                                                                                                                                       
    res = enumerateProviders();//关键调用
    if (res == OK) {
        mInitialized = true;
    }    

    CameraService::pingCameraServiceProxy();

    mUidPolicy = new UidPolicy(this);
    mUidPolicy->registerSelf();
    mSensorPrivacyPolicy = new SensorPrivacyPolicy(this);
    mSensorPrivacyPolicy->registerSelf();
    sp<HidlCameraService> hcs = HidlCameraService::getInstance(this);
    if (hcs->registerAsService() != android::OK) {
        ALOGE("%s: Failed to register default android.frameworks.cameraservice.service@1.0",
              __FUNCTION__);
    }    
}

enumerateProviders（）

status_t CameraService::enumerateProviders() {                                                                                                                         
    status_t res;

    std::vector<std::string> deviceIds;
    {
        Mutex::Autolock l(mServiceLock);

        if (nullptr == mCameraProviderManager.get()) { //provider中去取get_hw_module取代旧版本的get
            mCameraProviderManager = new CameraProviderManager();
            res = mCameraProviderManager->initialize(this);//初始化provider,取get_hw_module
            if (res != OK) {
                ALOGE("%s: Unable to initialize camera provider manager: %s (%d)",
                        __FUNCTION__, strerror(-res), res);
                return res;
            }
        }


        // Setup vendor tags before we call get_camera_info the first time
        // because HAL might need to setup static vendor keys in get_camera_info
        // TODO: maybe put this into CameraProviderManager::initialize()?
        mCameraProviderManager->setUpVendorTags();

        if (nullptr == mFlashlight.get()) {
            mFlashlight = new CameraFlashlight(mCameraProviderManager, this);
        }

        res = mFlashlight->findFlashUnits();
        if (res != OK) {
            ALOGE("Failed to enumerate flash units: %s (%d)", strerror(-res), res);
        }

        deviceIds = mCameraProviderManager->getCameraDeviceIds();
    }


    for (auto& cameraId : deviceIds) {
        String8 id8 = String8(cameraId.c_str());
        if (getCameraState(id8) == nullptr) {
            onDeviceStatusChanged(id8, CameraDeviceStatus::PRESENT);
        }
    }

    return OK;
}

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

initialize

status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
        ServiceInteractionProxy* proxy) {
    std::lock_guard<std::mutex> lock(mInterfaceMutex);
    if (proxy == nullptr) {
        ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
        return BAD_VALUE;
    }    
    mListener = listener;
    mServiceProxy = proxy;
    mDeviceState = static_cast<hardware::hidl_bitfield<provider::V2_5::DeviceState>>(
        provider::V2_5::DeviceState::NORMAL);

    // Registering will trigger notifications for all already-known providers
    bool success = mServiceProxy->registerForNotifications(
        /* instance name, empty means no filter */ "",
        this);
    if (!success) {
        ALOGE("%s: Unable to register with hardware service manager for notifications "
                "about camera providers", __FUNCTION__);
        return INVALID_OPERATION;
    }    

    // See if there's a passthrough HAL, but let's not complain if there's not
    addProviderLocked(kLegacyProviderName, /*expected*/ false);//关键调用                                                                                                        
    addProviderLocked(kExternalProviderName, /*expected*/ false);

    IPCThreadState::self()->flushCommands();

    return OK;
}

addProviderLocked

status_t CameraProviderManager::addProviderLocked(const std::string& newProvider, bool expected) {
    for (const auto& providerInfo : mProviders) {
        if (providerInfo->mProviderName == newProvider) {
            ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__,
                    newProvider.c_str());
            return ALREADY_EXISTS;
        }
    }

    sp<provider::V2_4::ICameraProvider> interface;
    interface = mServiceProxy->getService(newProvider);//取到provider接口

    if (interface == nullptr) {
        if (expected) {
            ALOGE("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
                    newProvider.c_str());
            return BAD_VALUE;
        } else {
            return OK;
        }
    }

    sp<ProviderInfo> providerInfo = new ProviderInfo(newProvider, this);
    status_t res = providerInfo->initialize(interface, mDeviceState);//初始化providerinfo
    if (res != OK) {
        return res;
    }

    mProviders.push_back(providerInfo);

    return OK;
} 

分析至此应该看看providermanager的初始化流程了。参考博文。

Android Camera(一) Provider启动流程 (androidP)(HIDL)_android provider启动_liujun3512159的博客-CSDN博客我们的目的是找到预览参数设置的位置。

最终调用到

hardware/interfaces/camera/provider/2.4/default/CameraProvider_2_4.cpp

CameraProvider<IMPL>* getProviderImpl() {                                                                                                                              
    CameraProvider<IMPL> *provider = new CameraProvider<IMPL>();//new创建provider
    if (provider == nullptr) {
        ALOGE("%s: cannot allocate camera provider!", __FUNCTION__);
        return nullptr;
    }   
    if (provider->isInitFailed()) {
        ALOGE("%s: camera provider init failed!", __FUNCTION__);
        delete provider;
        return nullptr;
    }   
    return provider;
}
//由引用文章可知HIDL调用到此处  
ICameraProvider* HIDL_FETCH_ICameraProvider(const char* name) {
    using namespace android::hardware::camera::provider::V2_4::implementation;
    ICameraProvider* provider = nullptr;
    if (strcmp(name, kLegacyProviderName) == 0) {
        provider = getProviderImpl<LegacyCameraProviderImpl_2_4>();//legacy参数
    } else if (strcmp(name, kExternalProviderName) == 0) {
        provider = getProviderImpl<ExternalCameraProviderImpl_2_4>();
    } else {
        ALOGE("%s: unknown instance name: %s", __FUNCTION__, name);
    }   

    return provider;
}

由传参可知

hardware/interfaces/camera/provider/2.4/default/LegacyCameraProviderImpl_2_4.cpp

LegacyCameraProviderImpl_2_4::LegacyCameraProviderImpl_2_4() :
        camera_module_callbacks_t({sCameraDeviceStatusChange,
                                   sTorchModeStatusChange}) {
    mInitFailed = initialize();//初始化
}

bool LegacyCameraProviderImpl_2_4::initialize() {
    camera_module_t *rawModule;
    int err = hw_get_module(CAMERA_HARDWARE_MODULE_ID,
            (const hw_module_t **)&rawModule);//旧安卓的hw_module_t结构。
    if (err < 0) {
        ALOGE("Could not load camera HAL module: %d (%s)", err, strerror(-err));
        return true;
    }

    mModule = new CameraModule(rawModule);
    err = mModule->init();
    if (err != OK) {
        ALOGE("Could not initialize camera HAL module: %d (%s)", err, strerror(-err));
        mModule.clear();
        return true;
    }
    ALOGI("Loaded \"%s\" camera module", mModule->getModuleName());

    // Setup vendor tags here so HAL can setup vendor keys in camera characteristics
    VendorTagDescriptor::clearGlobalVendorTagDescriptor();
    if (!setUpVendorTags()) {
        ALOGE("%s: Vendor tag setup failed, will not be available.", __FUNCTION__);
    }

    // Setup callback now because we are going to try openLegacy next
    err = mModule->setCallbacks(this);
    if (err != OK) {
        ALOGE("Could not set camera module callback: %d (%s)", err, strerror(-err));
        mModule.clear();
        return true;
    }

    mPreferredHal3MinorVersion =
        property_get_int32("ro.vendor.camera.wrapper.hal3TrebleMinorVersion", 3);
    ALOGV("Preferred HAL 3 minor version is %d", mPreferredHal3MinorVersion);
    switch(mPreferredHal3MinorVersion) {
        case 2:
        case 3:
            // OK
            break;
        default:
            ALOGW("Unknown minor camera device HAL version %d in property "
                    "'camera.wrapper.hal3TrebleMinorVersion', defaulting to 3",
                    mPreferredHal3MinorVersion);
            mPreferredHal3MinorVersion = 3;
    }
    mNumberOfLegacyCameras = mModule->getNumberOfCameras();
    for (int i = 0; i < mNumberOfLegacyCameras; i++) {
        struct camera_info info;
        auto rc = mModule->getCameraInfo(i, &info);//调用到HAL层getCameraInfo
        if (rc != NO_ERROR) {
            ALOGE("%s: Camera info query failed!", __func__);
            mModule.clear();
            return true;
        }

        if (checkCameraVersion(i, info) != OK) {
            ALOGE("%s: Camera version check failed!", __func__);
            mModule.clear();
            return true;
        }

        char cameraId[kMaxCameraIdLen];
        snprintf(cameraId, sizeof(cameraId), "%d", i);
        std::string cameraIdStr(cameraId);
        mCameraStatusMap[cameraIdStr] = CAMERA_DEVICE_STATUS_PRESENT;

        addDeviceNames(i);
    }

    return false; // mInitFailed
} 

getcamerainfo方法走到SprdCamera3Hal.cpp 

SprdCamera3Factory.cpp中调用

int SprdCamera3Factory::getCameraInfo(int camera_id, struct camera_info *info) {
    int rc; 
    struct camera_device_manager *devPtr = NULL;//mantis-63893 Added for dynamic camera by wuchenglin on 2020-12-14
    Mutex::Autolock l(mLock);

    HAL_LOGI("E, camera_id = %d", camera_id);

    if (!mNumOfCameras || camera_id >= mNumOfCameras || !info ||
        (camera_id < 0)) {
        return -ENODEV;
    }   

    //+Begin mantis-63893 Added for dynamic camera by wuchenglin on 2020-12-14
    devPtr =
        (struct camera_device_manager *)SprdCamera3Setting::getCameraIdentifyState();
    for (int m = 0; m < mNumOfCameras; m++) {
        HAL_LOGV("factory identify_state[%d]=%d", m, devPtr->identify_state[m]);
        if (gSprdCamera3Factory.mCameraCallbacks != NULL) {
            gSprdCamera3Factory.mCameraCallbacks->camera_device_status_change(
                gSprdCamera3Factory.mCameraCallbacks,
                m, devPtr->identify_state[m]);
        }   
    }   
    //-End mantis-63893 Added for dynamic camera by wuchenglin on 2020-12-14

    SprdCamera3Setting::getSensorStaticInfo(camera_id);//实际获取信息。

    SprdCamera3Setting::initDefaultParameters(camera_id);

    rc = SprdCamera3Setting::getStaticMetadata(camera_id, &mStaticMetadata);
    if (rc < 0) {
        return rc; 
    }   

    SprdCamera3Setting::getCameraInfo(camera_id, info);

    info->device_version =
        CAMERA_DEVICE_API_VERSION_3_2; // CAMERA_DEVICE_API_VERSION_3_0;
    info->static_camera_characteristics = mStaticMetadata;
    info->conflicting_devices_length = 0;

    HAL_LOGV("X");
    return rc;                                                                                                                                                         
}

SprdCamera3Setting::getSensorStaticInfo(xxx,xxx);走到

SprdCamera3Setting.cpp

int SprdCamera3Setting::getSensorStaticInfo(int32_t cameraId) {
    struct phySensorInfo *phyPtr = NULL;
    int ret = 0; 

    // just for camera developer debug
    char value[PROPERTY_VALUE_MAX];
    property_get("persist.vendor.cam.auto.detect.sensor", value, "on");
    if (!strcmp(value, "off")) {
        HAL_LOGI("turn off auto detect sensor, just for debug");
        setLargestSensorSize(cameraId, default_sensor_max_sizes[cameraId].width,
                             default_sensor_max_sizes[cameraId].height);
        return 0;
    }    

    if (alreadyGetSensorStaticInfo[cameraId] != 0) { 
        HAL_LOGD("already get sensor info");
        return 0;
    }    

    HAL_LOGI("E");

    phyPtr = sensorGetPhysicalSnsInfo(cameraId);//从driver中获取分辨率

    if (phyPtr == NULL) {
        HAL_LOGE("open camera (%d) failed, can't get sensor info", cameraId);
        goto exit;
    }
    //……………………省略    
}

sensorGetPhysicalSnsInfo 中实际获取driver配置的分辨率等。。。

通篇从api调用到获取到provider操作。再去查看provider如何初始化。最终找到了preview分辨率等参数的实际获取地方。