VTS-DEBUG VtsHalCameraProviderV2_4TargetTest CameraHidlTest.noHal1AfterP FAIL

最新推荐文章于 2023-11-06 11:43:31 发布
最新推荐文章于 2023-11-06 11:43:31 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： android 源码 CTS DEBUG 文章标签： VTS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yxdspirit/article/details/110121814
版权

Android Q vts 测试failed 项

09-02 09:58:06.205 ERROR <testsuites tests="1" failures="1" disabled="0" errors="0" timestamp="2020-09-02T01:58:06" time="0.008" name="AllTests">
09-02 09:58:06.205 ERROR   <testsuite name="CameraHidlTest" tests="1" failures="1" disabled="0" errors="0" time="0.008">
09-02 09:58:06.205 ERROR     <testcase name="noHal1AfterP" status="run" time="0.008" classname="CameraHidlTest">
09-02 09:58:06.205 ERROR       <failure message="hardware/interfaces/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp:1570&#x0A;Expected: (deviceVersion) != (CAMERA_DEVICE_API_VERSION_1_0), actual: 256 vs 256" type=""><![CDATA[hardware/interfaces/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp:1570
09-02 09:58:06.205 ERROR Expected: (deviceVersion) != (CAMERA_DEVICE_API_VERSION_1_0), actual: 256 vs 256]]></failure>
09-02 09:58:06.205 ERROR     </testcase>
09-02 09:58:06.205 ERROR   </testsuite>
09-02 09:58:06.205 ERROR </testsuites>
09-02 09:58:06.205 ERROR hardware/interfaces/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp:1570
Expected: (deviceVersion) != (CAMERA_DEVICE_API_VERSION_1_0), actual: 256 vs 256
09-02 09:58:06.205 ERROR [Test Case] 1/43 CameraHidlTest.noHal1AfterP(legacy/0)_64bit FAIL

测试的fail项是CameraHidlTest.noHal1AfterP ，看名字就知道是要android P 之后不能有Camera Hal1

查看报错的文件hardware/interfaces/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp

// Test devices with first_api_level >= P does not advertise device@1.0
TEST_F(CameraHidlTest, noHal1AfterP) {
    constexpr int32_t HAL1_PHASE_OUT_API_LEVEL = 28;
    int32_t firstApiLevel = 0;
    getFirstApiLevel(&firstApiLevel);

    // all devices with first API level == 28 and <= 1GB of RAM must set low_ram
    // and thus be allowed to continue using HAL1
    if ((firstApiLevel == HAL1_PHASE_OUT_API_LEVEL) &&
        (property_get_bool("ro.config.low_ram", /*default*/ false))) {
        ALOGI("Hal1 allowed for low ram device");
        return;
    }

    if (firstApiLevel >= HAL1_PHASE_OUT_API_LEVEL) {
        hidl_vec<hidl_string> cameraDeviceNames = getCameraDeviceNames(mProvider);
        for (const auto& name : cameraDeviceNames) {
            int deviceVersion = getCameraDeviceVersion(name, mProviderType);
            ASSERT_NE(deviceVersion, 0); // Must be a valid device version
            ASSERT_NE(deviceVersion, CAMERA_DEVICE_API_VERSION_1_0); // Must not be device@1.0
        }
    }
}

deviceVersion Must not be device@1.0，

查看deviceVersion 生成逻辑，

  int getCameraDeviceVersion(const hidl_string& deviceName,
            const hidl_string &providerType) {
        std::string version;
        bool match = matchDeviceName(deviceName, providerType, &version, nullptr);
        if (!match) {
            return -1;
        }

        if (version.compare(kHAL3_5) == 0) {
            return CAMERA_DEVICE_API_VERSION_3_5;
        } else if (version.compare(kHAL3_4) == 0) {
            return CAMERA_DEVICE_API_VERSION_3_4;
        } else if (version.compare(kHAL3_3) == 0) {
            return CAMERA_DEVICE_API_VERSION_3_3;
        } else if (version.compare(kHAL3_2) == 0) {
            return CAMERA_DEVICE_API_VERSION_3_2;
        } else if (version.compare(kHAL1_0) == 0) {
            return CAMERA_DEVICE_API_VERSION_1_0;
        }
        return 0;
    }

是从version判断的，version又是从deviceName来的，看log deviceName格式是3303:09-02 01:58:38.540 15587 15587 I camera_hidl_hal_test: Camera Id[0] is device@1.0/legacy/0

查看deviceName

hidl_vec<hidl_string> CameraHidlTest::getCameraDeviceNames(sp<ICameraProvider> provider) {
    std::vector<std::string> cameraDeviceNames;
    Return<void> ret;
    ret = provider->getCameraIdList(
        [&](auto status, const auto& idList) {
            ALOGI("getCameraIdList returns status:%d", (int)status);
            for (size_t i = 0; i < idList.size(); i++) {
                ALOGI("Camera Id[%zu] is %s", i, idList[i].c_str());
            }
            ASSERT_EQ(Status::OK, status);
            for (const auto& id : idList) {
                cameraDeviceNames.push_back(id);
            }
        });
    if (!ret.isOk()) {
        ADD_FAILURE();
    }

    // External camera devices are reported through cameraDeviceStatusChange
    struct ProviderCb : public ICameraProviderCallback {
        virtual Return<void> cameraDeviceStatusChange(
                const hidl_string& devName,
                CameraDeviceStatus newStatus) override {
            ALOGI("camera device status callback name %s, status %d",
                    devName.c_str(), (int) newStatus);
            if (newStatus == CameraDeviceStatus::PRESENT) {
                externalCameraDeviceNames.push_back(devName);

            }
            return Void();
        }

        virtual Return<void> torchModeStatusChange(
                const hidl_string&, TorchModeStatus) override {
            return Void();
        }

        std::vector<std::string> externalCameraDeviceNames;
    };
    sp<ProviderCb> cb = new ProviderCb;
    auto status = mProvider->setCallback(cb);

    for (const auto& devName : cb->externalCameraDeviceNames) {
        if (cameraDeviceNames.end() == std::find(
                cameraDeviceNames.begin(), cameraDeviceNames.end(), devName)) {
            cameraDeviceNames.push_back(devName);
        }
    }

    hidl_vec<hidl_string> retList(cameraDeviceNames.size());
    for (size_t i = 0; i < cameraDeviceNames.size(); i++) {
        retList[i] = cameraDeviceNames[i];
    }
    return retList;
}

看provider->getCameraIdList 到hardware/interfaces/camera/provider/2.4/default/LegacyCameraProviderImpl_2_4.cpp

Return<void> LegacyCameraProviderImpl_2_4::getCameraIdList(
        ICameraProvider::getCameraIdList_cb _hidl_cb) {
    std::vector<hidl_string> deviceNameList;
    for (auto const& deviceNamePair : mCameraDeviceNames) {
        if (std::stoi(deviceNamePair.first) >= mNumberOfLegacyCameras) {
            // External camera devices must be reported through the device status change callback,
            // not in this list.
            continue;
        }
        if (mCameraStatusMap[deviceNamePair.first] == CAMERA_DEVICE_STATUS_PRESENT) {
            deviceNameList.push_back(deviceNamePair.second);
        }
    }
    hidl_vec<hidl_string> hidlDeviceNameList(deviceNameList);
    _hidl_cb(Status::OK, hidlDeviceNameList);
    return Void();
}

mCameraDeviceNames 

void LegacyCameraProviderImpl_2_4::addDeviceNames(int camera_id, CameraDeviceStatus status, bool cam_new)
{
    char cameraId[kMaxCameraIdLen];
    snprintf(cameraId, sizeof(cameraId), "%d", camera_id);
    std::string cameraIdStr(cameraId);

    mCameraIds.add(cameraIdStr);

    // initialize mCameraDeviceNames and mOpenLegacySupported
    mOpenLegacySupported[cameraIdStr] = false;
    int deviceVersion = mModule->getDeviceVersion(camera_id);
    auto deviceNamePair = std::make_pair(cameraIdStr,
                                         getHidlDeviceName(cameraIdStr, deviceVersion));
    mCameraDeviceNames.add(deviceNamePair);
    if (cam_new) {
        mCallbacks->cameraDeviceStatusChange(deviceNamePair.second, status);
    }
    if (deviceVersion >= CAMERA_DEVICE_API_VERSION_3_2 &&
            mModule->isOpenLegacyDefined()) {
        // try open_legacy to see if it actually works
        if ((property_get_bool("ro.config.low_ram", /*default*/ false))) {
           deviceNamePair = std::make_pair(cameraIdStr,
                            getHidlDeviceName(cameraIdStr, CAMERA_DEVICE_API_VERSION_1_0));
           mCameraDeviceNames.add(deviceNamePair);
           if (cam_new) {
              mCallbacks->cameraDeviceStatusChange(deviceNamePair.second, status);
           }
          } else {
            struct hw_device_t* halDev = nullptr;
            int ret = mModule->openLegacy(cameraId, CAMERA_DEVICE_API_VERSION_1_0, &halDev);
            if (ret == 0) {
               mOpenLegacySupported[cameraIdStr] = true;
               halDev->close(halDev);
               deviceNamePair = std::make_pair(cameraIdStr,
                                getHidlDeviceName(cameraIdStr, CAMERA_DEVICE_API_VERSION_1_0));
               mCameraDeviceNames.add(deviceNamePair);
               if (cam_new) {
                 mCallbacks->cameraDeviceStatusChange(deviceNamePair.second, status);
              }
            } else if (ret == -EBUSY || ret == -EUSERS) {
            // Looks like this provider instance is not initialized during
            // system startup and there are other camera users already.
            // Not a good sign but not fatal.
              ALOGW("%s: open_legacy try failed!", __FUNCTION__);
            }
         }
    }
}

 getHidlDeviceName  devicename 的格式就是在这边定义的

std::string LegacyCameraProviderImpl_2_4::getHidlDeviceName(
        std::string cameraId, int deviceVersion) {
    // Maybe consider create a version check method and SortedVec to speed up?
    if (deviceVersion != CAMERA_DEVICE_API_VERSION_1_0 &&
            deviceVersion != CAMERA_DEVICE_API_VERSION_3_2 &&
            deviceVersion != CAMERA_DEVICE_API_VERSION_3_3 &&
            deviceVersion != CAMERA_DEVICE_API_VERSION_3_4 &&
            deviceVersion != CAMERA_DEVICE_API_VERSION_3_5 &&
            deviceVersion != CAMERA_DEVICE_API_VERSION_3_6) {
        return hidl_string("");
    }

    // Supported combinations:
    // CAMERA_DEVICE_API_VERSION_1_0 -> ICameraDevice@1.0
    // CAMERA_DEVICE_API_VERSION_3_[2-4] -> ICameraDevice@[3.2|3.3]
    // CAMERA_DEVICE_API_VERSION_3_5 + CAMERA_MODULE_API_VERSION_2_4 -> ICameraDevice@3.4
    // CAMERA_DEVICE_API_VERSION_3_[5-6] + CAMERA_MODULE_API_VERSION_2_5 -> ICameraDevice@3.5
    bool isV1 = deviceVersion == CAMERA_DEVICE_API_VERSION_1_0;
    int versionMajor = isV1 ? 1 : 3;
    int versionMinor = isV1 ? 0 : mPreferredHal3MinorVersion;
    if (deviceVersion == CAMERA_DEVICE_API_VERSION_3_5) {
        if (mModule->getModuleApiVersion() == CAMERA_MODULE_API_VERSION_2_5) {
            versionMinor = 5;
        } else {
            versionMinor = 4;
        }
    } else if (deviceVersion == CAMERA_DEVICE_API_VERSION_3_6) {
        versionMinor = 5;
    }
    char deviceName[kMaxCameraDeviceNameLen];
    snprintf(deviceName, sizeof(deviceName), "device@%d.%d/legacy/%s",
            versionMajor, versionMinor, cameraId.c_str());
    return deviceName;
}

在看上面addDeviceNames的逻辑  mModule->isOpenLegacyDefined() 有定义OpenLegacy的话 和 mModule->openLegacy 打开成功的话会使用CAMERA_DEVICE_API_VERSION_1_0

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

bool CameraModule::isOpenLegacyDefined() const {
    if (getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_3) {
        return false;
    }
    return mModule->open_legacy != NULL;
}

int CameraModule::openLegacy(
        const char* id, uint32_t halVersion, struct hw_device_t** device) {
    int res;
    ATRACE_BEGIN("camera_module->open_legacy");
    res = mModule->open_legacy(&mModule->common, id, halVersion, device);
    ATRACE_END();
    return res;
}

查找open_legacy

在hardware/qcom/camera/QCamera2/QCamera2Hal.cpp 有这么个定义配置

// Camera dependencies
#include "QCamera2Factory.h"
#include "util/QCameraCommon.h"
#include "HAL3/QCamera3VendorTags.h"
#include "util/QCameraCommon.h"

static hw_module_t camera_common = {
    .tag                    = HARDWARE_MODULE_TAG,
    .module_api_version     = CAMERA_MODULE_API_VERSION_2_4,
    .hal_api_version        = HARDWARE_HAL_API_VERSION,
    .id                     = CAMERA_HARDWARE_MODULE_ID,
    .name                   = "QCamera Module",
    .author                 = "Qualcomm Innovation Center Inc",
    .methods                = &qcamera::QCamera2Factory::mModuleMethods,
    .dso                    = NULL,
    .reserved               = {0}
};

camera_module_t HAL_MODULE_INFO_SYM = {
    .common                 = camera_common,
    .get_number_of_cameras  = qcamera::QCamera2Factory::get_number_of_cameras,
    .get_camera_info        = qcamera::QCamera2Factory::get_camera_info,
    .set_callbacks          = qcamera::QCamera2Factory::set_callbacks,
    .get_vendor_tag_ops     = qcamera::QCamera3VendorTags::get_vendor_tag_ops,
    .open_legacy            = (qcamera::QCameraCommon::needHAL1Support()) ?
                                    qcamera::QCamera2Factory::open_legacy : NULL,
    .set_torch_mode         = qcamera::QCamera2Factory::set_torch_mode,
    .init                   = NULL,
    .reserved               = {0}
};

needHAL1Support 

hardware/qcom/camera/QCamera2/util/QCameraCommon.cpp


/*===========================================================================
 * FUNCTION   : needHAL1Support
 *
 * DESCRIPTION: Function to check whether HAL1 is supported or not.
 *
 * PARAMETERS : None
 *
 * RETURN     : TRUE -- HAL1/HAL3 supported target.
 *              FALSE -- Only HAL3 supported target.
 *==========================================================================*/
bool QCameraCommon::needHAL1Support()
{
    char prop[PROPERTY_VALUE_MAX];
    memset(prop, 0, PROPERTY_VALUE_MAX);
    property_get("persist.vendor.camera.hal1.enable",prop,"");

    if(0 < strlen(prop))
    {
        return (atoi(prop) == 1);
    }

#ifdef SUPPORT_ONLY_HAL3
        LOGI("ONLY HAL3 SUPPORTED");
        return FALSE;
#else
    // HAL1/HAL3 is supported
    LOGI("HAL1/HAL3 IS SUPPORTED");
    return TRUE;
#endif

#ifndef HAS_LOW_RAM
     // QM215, QM2150 non-GO supports only HAL3
     if ((is_target_QM215() || is_target_QM2150())) {
         LOGI("ONLY HAL3 SUPPORTED");
         return FALSE;
     }
#else
     // HAL1/HAL3 is supported
     LOGI("HAL1/HAL3 IS SUPPORTED");
     return TRUE;
#endif
}

到此就比较明了了，解决方法有以下几个可行

1.设置 prop persist.vendor.camera.hal1.enable = 0  关闭hal1

2.定义SUPPORT_ONLY_HAL3 仅允许使用hal3

3.修改QCamera2Hal.cpp  将 “.open_legacy = (qcamera::QCameraCommon::needHAL1Support()) ? qcamera::QCamera2Factory::open_legacy : NULL”, 直接赋值 NULL “.open_legacy = NULL”

其中 第二点SUPPORT_ONLY_HAL3 修改文件 hardware/qcom/camera/QCamera2/Android.mk

修改下满足条件即可

ifneq (,$(filter $(TRINKET) msm8937_32go-userdebug, $(TARGET_BOARD_PLATFORM)))
LOCAL_CFLAGS += -DSUPPORT_ONLY_HAL3
endif

 

MTK camera --MiddleWare层
weixin_38360181的博客
07-21 504
Camera Provider createlCameraProvider_V2_4 生成CameraProvider对象 setCallback 清除之前存在的callback、设置新的callback initialize 设置setupVendorTags 检查生成CameraProvider对象传入mManager是否合理 onCameraDeviceStatusChange、onTouchModesStatusChange 给FWK通知camera、闪光灯的状态 mapToHidlCamera..
RK356x GKI版本user打印logcat ，user 版本刷入 vendor_boot-debug.img
qq_45087949的博客
06-18 641
事情是这样的，在某些场景下出现user 版本不开机的bug，这个时候需要开机就打印logcat。1.只需要刷入vendor_boot-debug.img 就能完成 user log 输出。2.刷入vendor_boot-debug.img 需要fastboot 解锁设备。这样就可以解锁设备了，再刷入vendor_boot-debug.img 就可以了。可以通过刷入misc.img 来进入fastboot。单刷这个分区就可以进入fastboot 再解锁设备。3.正常的状态无法进入 fastboot。
[Android O] Camera 服务provider启动流程简析 camx 初始化 及HIDL服务注册过程
shangbolei的博客
01-28 5065
注意： 作者：StoneDemo 原文：https://blog.csdn.net/qq_16775897/article/details/81240600 写的太好了忍不住全抄过来 Camera 服务启动流程概览 在 Android O 中，系统启动时，就会启动 CameraProvider 服务。它将 Camera HAL 从 cameraserver 进程中分离出来，作为一个...
Chapter3. [5]Android Camera System: Camera HAL
ifuleyou1668的博客
11-06 791
从上面的定义可以看出，主要是通过hw_module_t 代表了模块，通过其open方法用来打开一个设备，而该设备是用hw_device_t来表示，其中除了用来关闭设备的close方法外，并无其它方法，由此可见谷歌定义的HAL接口，并不能满足绝大部分HAL模块的需要，所以谷歌想出了一个比较好的解决方式，那便是将这两个基本结构嵌入到更大的结构体内部，同时在更大的结构内部定义了各自模块特有的方法，用于实现模块的功能，这样，一来对上保持了HAL的统一规范，二来也扩展了模块的功能。
vector::push_back() demo
\s
03-06 526
#include #include #include using namespace std; int main() { vector ivec; int val; cout << "Enter some integers: "; while (cin >> val) { ivec.push_back(val); } fo
Android C++服务创建和HIDL的生成
jamecer的博客
03-24 8397
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录Android C++服务创建和HIDL的生成一、HIDL的生成二、c++服务的创建三、SElinux总结 Android C++服务创建和HIDL的生成 总结c++创建服务和HIDL生成的一些步骤，本文未使用指令去生成创建hidl和对应的服务文件。 一、HIDL的生成 1.首先，在vendor/mediatek/proprietary/hardware/interfaces中创建文件夹testofhidl/1.0， 在上述.
nginx-prometheus-exporter-0.11.0-linux-386.tar.gz
08-31
1. **LICENSE**：这是项目所遵循的授权协议文件，通常为开源软件提供法律保障，确保用户可以在许可范围内自由使用、修改和分发该软件。 2. **README.md**：这是项目的使用指南，详细介绍了如何配置、安装和运行...
nginx-module-vts-0.1.18.tar.gz
09-29
解压之后安装如下：mv nginx-module-vts-0.1.18 /usr/local/ yum -y install gcc gcc-c++ pcre pcre-devel zlib zlib-devel openssl openssl-devel cd /usr/local/nginx/nginx-1.13.7 ./configure --add-module=/...
nginx-module-vts-0.2.2.tar.gz
最新发布
02-26
Nginx模块VTS全称为Nginx模块VirtualHost Traffic Status，即Nginx虚拟主机流量状态模块。该模块能够提供丰富的Nginx服务器运行时状态信息，包括各种HTTP状态统计，如响应时间、请求速率等，并能以JSON、HTML等格式...
AIS_Basics_Part-1_Basics_2020_EN_200226.pptx
12-03
AIS帮助海上交通服务（VTS）管理和监督其水域内的交通流动，尤其是在视线之外时（例如夜间、雷达盲区或距离较远时）识别船只，从而提高了识别船只的效率。 除此之外，AIS促进了船舶之间的自动信息交换，包括与陆地...
Android系统的VTS测试套件介绍
jasonj333
03-29 3348
下图是最新的Android系统架构：Android系统基于Linux系统内核，应用层使用Jave或Kotlin语言编写，底层控制设备的是Linux内核，Linux系统采用C语言和汇编语言编写，所以控制设备的代码是C/C++语言。那么应用层软件如何控制设备呢？Linux会提供控制设备的C/C++接口，也就是so动态库（一种ELF文件）。然后应用软件的Java通过JNI（它允许Java代码和其他语言写的代码进行交互）调用so库，那么so库就会继续往下调用设备，这些设备包括Audio，Camera，BlueToo
Android Camera（十）Session Parameters
书山有路勤为径
02-04 973
会话参数 目录 会话参数 示例和来源 实现 自定义 验证 会话重新配置查询 实现 验证 在捕获会话初始化阶段，会话参数功能使摄像头客户端可以主动配置一部分耗时较长的请求参数（即会话参数），从而减少延迟。借助此功能，您的 HAL 实现会在信息流配置阶段（而不是第一个捕获请求期间）接收客户端参数，并且可以根据它们的值更高效地准备和构建内部流水线。 在 Android 10 中，您...
8.1单前摄修改以及GMS测试单前摄引起的FAIL项相关修改
tonyechen的博客
05-26 1416
1.使用单前摄的时候 会出现图像左右反的问题需要修改 vendor/mediatek/proprietary/custom/mt6580/hal/imgsensor_metadata/common/config_static_metadata_common.h 把前摄跟后摄切换一下 switch (rInfo.getDeviceId()) { case 0: ...
高通mm-camera架构 几个ITS VTS fail项解决
xback_shaohan的博客
10-12 1788
1. ITS scene1 test_ev_compensation_basic 2. VTS CameraHidlTest.configureStreamsInvalidOutputs(legacy/0)_64bit； CameraHidlTest.configureStreamsConstrainedOutputs(legacy/0)_64bit
虚拟摄像头之六: 《详解 CameraService 都做了什么》之 CameraService 与 CameraProvider 通讯
weixin_38387929的博客
08-12 2281
上一篇梳理了 CameraProvider 是独立服务、通过 v4l2 框架管理物理摄像头,本篇主要描述的是 CameraService 如何与 CameraProvider 通讯; android 的 CameraService 是 Camera 子系统核心模块,Camera Api1 和 Api2 的接口、是如何与CameraService 通讯呢？笔者将分两篇来介绍。...
【Android 10 源码】深入理解 codecservice 启动
洪伟的专栏
10-24 5000
MediaCodec 系列文章： 【Android 10 源码】深入理解 MediaCodec 硬解码初始化 【Android 10 源码】深入理解 Omx 初始化 codecservice 主要负责 HAL 层给 framework 层提供调用音视频编解码接口。它的入口是 main_codecservice.cpp。 首先我们来看下启动它的配置 rc 脚本。可以看到它放在 vendor 目录下，说明和供应商有关。 frameworks/av/services/mediacodec/android.ha
【CTS、VTS、ITS、GTS、GSI camera 的基础操作和 debug】
Sugar_wolf的博客
01-31 2598
vts需要debug的权限，所以需要刷debug的镜像,另外fastboot 的版本不能太旧,太久分区不对，刷system.img会破坏分区，导致无限重启无法进去到系统里面进去.cts 的本质是下载测试的apk到手机中（在谷歌释放包中CtsCameraTest.apk），这个apk集成了测试相关的内容来调用手机的一些功能完成测试项目。进入设置打开开发者模式,usb调试模式,不锁定屏幕,语言设置成英语(这个语言无所谓)进入到tool目录下,手机电脑需要挂VPN 连接外网。进入到对应的 tools 目录下。
Android R camera Hal启动（下）
weixin_53065050的博客
10-10 805
文章目录前言代码流程分析总结 前言 接上一篇Android R camera Hal启动（上）接着写，把谷歌的代码都分析完成，高通/MTK的代码就不贴了。 代码流程分析 上一篇说到getProviderImpl函数。实例化了CameraProvider对象，先看CameraProvider的构造函数。 template<typename IMPL> struct CameraProvider : public ICameraProvider { CameraProvider() :
Camera2架构学习（二）——CameraServer和CameraProvider的启动初始化
qq_29121033的博客
12-21 3491
服务层位于Camera Framework与Camera Provider之间，作为一个独立进程存在于Android系统中，在系统启动初期会运行起来，它封装了Camera AIDL跨进程接口，提供给Framework进行调用，进而接收来自Framework的图像请求，同时内部维护着关于请求在该层的处理逻辑，最终通过调用Camera HIDL跨进程接口将请求再次下发到Camera Provider中，并且等待结果的回传，进而将结果上传至Framework中。 一、调用逻辑图 二、与Camera Provid
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值