第10讲 cameraserver进程启动之HIDL CameraDevice初始化addDevice流程

最新推荐文章于 2024-09-27 19:58:59 发布
最新推荐文章于 2024-09-27 19:58:59 发布
阅读量54 收藏
点赞数
分类专栏： 极客笔记_安卓Camera Native Framework 文章标签： android
原文链接：https://deepinout.com/android-camera-native-framework/cameraserver-process-startup-enumerateproviders-hidl-cameradevice-adddevice.html
版权

https://deepinout.com/android-camera-native-framework/cameraserver-process-startup-enumerateproviders-hidl-cameradevice-adddevice.html

1 initializeProviderInfoCommon

initializeProviderInfoCommon主要完成2件事情：

  1. 调用addDevice将CameraDevice保持在mDevices中
  2. 处理Cached Status回调

在这里插入图片描述

void CameraProviderManager::ProviderInfo::initializeProviderInfoCommon(
        const std::vector<std::string> &devices) {

    sp<StatusListener> listener = mManager->getStatusListener();
	//1. 添加设备
    for (auto& device : devices) {
        std::string id;
        status_t res = addDevice(device, CameraDeviceStatus::PRESENT, &id);
        if (res != OK) {
            ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
                    __FUNCTION__, device.c_str(), strerror(-res), res);
            continue;
        }
    }

    ALOGI("Camera provider %s ready with %zu camera devices",
            mProviderName.c_str(), mDevices.size());


	//2. 处理cachedStatus 
    // Process cached status callbacks
    std::unique_ptr<std::vector<CameraStatusInfoT>> cachedStatus =
            std::make_unique<std::vector<CameraStatusInfoT>>();
    {
        std::lock_guard<std::mutex> lock(mInitLock);

        for (auto& statusInfo : mCachedStatus) {
            std::string id, physicalId;
            status_t res = OK;
            if (statusInfo.isPhysicalCameraStatus) {
                res = physicalCameraDeviceStatusChangeLocked(&id, &physicalId,
                    statusInfo.cameraId, statusInfo.physicalCameraId, statusInfo.status);
            } else {
                res = cameraDeviceStatusChangeLocked(&id, statusInfo.cameraId, statusInfo.status);
            }
            if (res == OK) {
                cachedStatus->emplace_back(statusInfo.isPhysicalCameraStatus,
                        id.c_str(), physicalId.c_str(), statusInfo.status);
            }
        }
        mCachedStatus.clear();

        mInitialized = true;
    }

    // The cached status change callbacks cannot be fired directly from this
    // function, due to same-thread deadlock trying to acquire mInterfaceMutex
    // twice.
    if (listener != nullptr) {
        mInitialStatusCallbackFuture = std::async(std::launch::async,
                &CameraProviderManager::ProviderInfo::notifyInitialStatusChange, this,
                listener, std::move(cachedStatus));
    }
}

2 addDevice完成的4件事情

在这里插入图片描述

status_t CameraProviderManager::ProviderInfo::addDevice(
        const std::string& name, CameraDeviceStatus initialStatus,
        /*out*/ std::string* parsedId) {

    ALOGI("Enumerating new camera device: %s", name.c_str());

    uint16_t major, minor;
    std::string type, id;
    //1.1 获取transport
    IPCTransport transport = getIPCTransport();

    //1.2 获取主设备号、次设备号、类型等
    status_t res = parseDeviceName(name, &major, &minor, &type, &id);
    if (res != OK) {
        return res;
    }

    if (type != mType) {
        ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
                type.c_str(), mType.c_str());
        return BAD_VALUE;
    }
    // 1.3 检查设备的合法性，会便利每个provider的每个device，以免重复。
    if (mManager->isValidDeviceLocked(id, major, transport)) {
        ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
                name.c_str(), id.c_str(), major);
        return BAD_VALUE;
    }

    std::unique_ptr<DeviceInfo> deviceInfo;
    switch (transport) {
        case IPCTransport::HIDL:
            switch (major) {
                case 3:
                    break;
                default:
                    ALOGE("%s: Device %s: Unsupported HIDL device HAL major version %d:",
                          __FUNCTION__,  name.c_str(), major);
                    return BAD_VALUE;
            }
            break;
        case IPCTransport::AIDL:
            if (major != 1) {
                ALOGE("%s: Device %s: Unsupported AIDL device HAL major version %d:", __FUNCTION__,
                        name.c_str(), major);
                return BAD_VALUE;
            }
            break;
        default:
            ALOGE("%s Invalid transport %d", __FUNCTION__, transport);
            return BAD_VALUE;
    }

    //2 	初始化DeviceInfo
    deviceInfo = initializeDeviceInfo(name, mProviderTagid, id, minor);
    if (deviceInfo == nullptr) return BAD_VALUE;
    //3 根据手机设备状态去更新ANDROID_SENSOR_ORIENTATION，如屏幕折叠
    deviceInfo->notifyDeviceStateChange(getDeviceState());
    deviceInfo->mStatus = initialStatus;

    //4 判断是否支持API1
    bool isAPI1Compatible = deviceInfo->isAPI1Compatible();

    mDevices.push_back(std::move(deviceInfo));

    mUniqueCameraIds.insert(id);
    if (isAPI1Compatible) {
        // addDevice can be called more than once for the same camera id if HAL
        // supports openLegacy.
        if (std::find(mUniqueAPI1CompatibleCameraIds.begin(), mUniqueAPI1CompatibleCameraIds.end(),
                id) == mUniqueAPI1CompatibleCameraIds.end()) {
            mUniqueAPI1CompatibleCameraIds.push_back(id);
        }
    }

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

2.1 HidlProviderInfo::initializeDeviceInfo完成3件事情

在这里插入图片描述

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

    //1 获取实例
    auto cameraInterface = startDeviceInterface(name);
    if (cameraInterface == nullptr) return nullptr;

    //2 获取resourceCost
    common::V1_0::CameraResourceCost resourceCost;
    cameraInterface->getResourceCost([&status, &resourceCost](
        Status s, common::V1_0::CameraResourceCost cost) {
                status = s;
                resourceCost = cost;
            });
    if (status != Status::OK) {
        ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
                name.c_str(), statusToString(status));
        return nullptr;
    }

    // 检查名字
    for (auto& conflictName : resourceCost.conflictingDevices) {
        uint16_t major, minor;
        std::string type, id;
        status_t res = parseDeviceName(conflictName, &major, &minor, &type, &id);
        if (res != OK) {
            ALOGE("%s: Failed to parse conflicting device %s", __FUNCTION__, conflictName.c_str());
            return nullptr;
        }
        conflictName = id;
    }

    //3. 创建HidlDeviceInfo3
    return std::unique_ptr<DeviceInfo3>(
        new HidlDeviceInfo3(name, tagId, id, minorVersion, HalToFrameworkResourceCost(resourceCost),
                this, mProviderPublicCameraIds, cameraInterface));
}

startDeviceInterface
先判断是否为空、如果不为空直接返接口，否则 startDeviceInterface

sp<hardware::camera::device::V3_2::ICameraDevice>
HidlProviderInfo::HidlDeviceInfo3::startDeviceInterface() {
    Mutex::Autolock l(mDeviceAvailableLock);
    sp<hardware::camera::device::V3_2::ICameraDevice> device;
    ATRACE_CALL();
    if (mSavedInterface == nullptr) {
        sp<HidlProviderInfo> parentProvider =
                static_cast<HidlProviderInfo *>(mParentProvider.promote().get());
        if (parentProvider != nullptr) {
            // Wait for lazy HALs to confirm device availability
            if (parentProvider->isExternalLazyHAL() && !mIsDeviceAvailable) {
                ALOGV("%s: Wait for external device to become available %s",
                      __FUNCTION__,
                      mId.c_str());

                auto res = mDeviceAvailableSignal.waitRelative(mDeviceAvailableLock,
                                                         kDeviceAvailableTimeout);
                if (res != OK) {
                    ALOGE("%s: Failed waiting for device to become available",
                          __FUNCTION__);
                    return nullptr;
                }
            }

            device = parentProvider->startDeviceInterface(mName);
        }
    } else {
        device = (hardware::camera::device::V3_2::ICameraDevice *) mSavedInterface.get();
    }
    return device;
}

startDeviceInterface 调用provider的getCameraDeviceInterface_V3_x 获取interface的实例

sp<device::V3_2::ICameraDevice>
HidlProviderInfo::startDeviceInterface(const std::string &name) {
    Status status;
    sp<device::V3_2::ICameraDevice> cameraInterface;
    hardware::Return<void> ret;
    const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
    if (interface == nullptr) {
        return nullptr;
    }
    ret = interface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
        Status s, sp<device::V3_2::ICameraDevice> interface) {
                status = s;
                cameraInterface = interface;
            });
    if (!ret.isOk()) {
        ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
                __FUNCTION__, name.c_str(), ret.description().c_str());
        return nullptr;
    }
    if (status != Status::OK) {
        ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
                name.c_str(), statusToString(status));
        return nullptr;
    }
    return cameraInterface;
}

2.1.1 创建HidlDeviceInfo3完成5件事情

在这里插入图片描述
第四步和第五步 主要是为了，vendor HAL是老版本system framwork 是新版本的情况。

HidlProviderInfo::HidlDeviceInfo3::HidlDeviceInfo3(
        const std::string& name,
        const metadata_vendor_id_t tagId,
        const std::string &id, uint16_t minorVersion,
        const CameraResourceCost& resourceCost,
        sp<CameraProviderManager::ProviderInfo> parentProvider,
        const std::vector<std::string>& publicCameraIds,
        sp<hardware::camera::device::V3_2::ICameraDevice> interface) :
        DeviceInfo3(name, tagId, id, minorVersion, resourceCost, parentProvider, publicCameraIds) {

    // Get camera characteristics and initialize flash unit availability
    Status status;
    hardware::Return<void> ret;
    // 获取metadata，保存到 mCameraCharacteristics
    ret = interface->getCameraCharacteristics([&status, this](Status s,
                    device::V3_2::CameraMetadata metadata) {
                status = s;
                if (s == Status::OK) {
                    camera_metadata_t *buffer =
                            reinterpret_cast<camera_metadata_t*>(metadata.data());
                    size_t expectedSize = metadata.size();
                    int res = validate_camera_metadata_structure(buffer, &expectedSize);
                    if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
                        set_camera_metadata_vendor_id(buffer, mProviderTagid);
                        mCameraCharacteristics = buffer;
                    } else {
                        ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
                        status = Status::INTERNAL_ERROR;
                    }
                }
            });
    if (!ret.isOk()) {
        ALOGE("%s: Transaction error getting camera characteristics for device %s"
                " to check for a flash unit: %s", __FUNCTION__, id.c_str(),
                ret.description().c_str());
        return;
    }
    if (status != Status::OK) {
        ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)",
                __FUNCTION__, id.c_str(), statusToString(status), status);
        return;
    }

    //2 获取 DeviceStateOrientationMap
    if (mCameraCharacteristics.exists(ANDROID_INFO_DEVICE_STATE_ORIENTATIONS)) {
        const auto &stateMap = mCameraCharacteristics.find(ANDROID_INFO_DEVICE_STATE_ORIENTATIONS);
        if ((stateMap.count > 0) && ((stateMap.count % 2) == 0)) {
            for (size_t i = 0; i < stateMap.count; i += 2) {
                mDeviceStateOrientationMap.emplace(stateMap.data.i64[i], stateMap.data.i64[i+1]);
            }
        } else {
            ALOGW("%s: Invalid ANDROID_INFO_DEVICE_STATE_ORIENTATIONS map size: %zu", __FUNCTION__,
                    stateMap.count);
        }
    }

    //3 获取 mSystemCameraKind
    mSystemCameraKind = getSystemCameraKind();

    //4 修复
    status_t res = fixupMonochromeTags();
    if (OK != res) {
        ALOGE("%s: Unable to fix up monochrome tags based for older HAL version: %s (%d)",
                __FUNCTION__, strerror(-res), res);
        return;
    }
    auto stat = addDynamicDepthTags();
    if (OK != stat) {
        ALOGE("%s: Failed appending dynamic depth tags: %s (%d)", __FUNCTION__, strerror(-stat),
                stat);
    }
    res = deriveHeicTags();
    if (OK != res) {
        ALOGE("%s: Unable to derive HEIC tags based on camera and media capabilities: %s (%d)",
                __FUNCTION__, strerror(-res), res);
    }

    if (SessionConfigurationUtils::isUltraHighResolutionSensor(mCameraCharacteristics)) {
        status_t status = addDynamicDepthTags(/*maxResolution*/true);
        if (OK != status) {
            ALOGE("%s: Failed appending dynamic depth tags for maximum resolution mode: %s (%d)",
                    __FUNCTION__, strerror(-status), status);
        }

        status = deriveHeicTags(/*maxResolution*/true);
        if (OK != status) {
            ALOGE("%s: Unable to derive HEIC tags based on camera and media capabilities for"
                    "maximum resolution mode: %s (%d)", __FUNCTION__, strerror(-status), status);
        }
    }

    res = addRotateCropTags();
    if (OK != res) {
        ALOGE("%s: Unable to add default SCALER_ROTATE_AND_CROP tags: %s (%d)", __FUNCTION__,
                strerror(-res), res);
    }
    res = addPreCorrectionActiveArraySize();
    if (OK != res) {
        ALOGE("%s: Unable to add PRE_CORRECTION_ACTIVE_ARRAY_SIZE: %s (%d)", __FUNCTION__,
                strerror(-res), res);
    }
    res = camera3::ZoomRatioMapper::overrideZoomRatioTags(
            &mCameraCharacteristics, &mSupportNativeZoomRatio);
    if (OK != res) {
        ALOGE("%s: Unable to override zoomRatio related tags: %s (%d)",
                __FUNCTION__, strerror(-res), res);
    }

    camera_metadata_entry flashAvailable =
            mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);
    if (flashAvailable.count == 1 &&
            flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
        mHasFlashUnit = true;
        // Fix up flash strength tags for devices without these keys.
        res = fixupTorchStrengthTags();
        if (OK != res) {
            ALOGE("%s: Unable to add default ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL and"
                    "ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL tags: %s (%d)", __FUNCTION__,
                    strerror(-res), res);
        }
    } else {
        mHasFlashUnit = false;
    }

    camera_metadata_entry entry =
            mCameraCharacteristics.find(ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL);
    if (entry.count == 1) {
        mTorchDefaultStrengthLevel = entry.data.i32[0];
    } else {
        mTorchDefaultStrengthLevel = 0;
    }
    entry = mCameraCharacteristics.find(ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL);
    if (entry.count == 1) {
        mTorchMaximumStrengthLevel = entry.data.i32[0];
    } else {
        mTorchMaximumStrengthLevel = 0;
    }

    mTorchStrengthLevel = 0;

    queryPhysicalCameraIds();

    // Get physical camera characteristics if applicable
    auto castResult = device::V3_5::ICameraDevice::castFrom(interface);
    if (!castResult.isOk()) {
        ALOGV("%s: Unable to convert ICameraDevice instance to version 3.5", __FUNCTION__);
        return;
    }
    sp<device::V3_5::ICameraDevice> interface_3_5 = castResult;
    if (interface_3_5 == nullptr) {
        ALOGE("%s: Converted ICameraDevice instance to nullptr", __FUNCTION__);
        return;
    }

    if (mIsLogicalCamera) {
        for (auto& id : mPhysicalIds) {
            if (std::find(mPublicCameraIds.begin(), mPublicCameraIds.end(), id) !=
                    mPublicCameraIds.end()) {
                continue;
            }

            hardware::hidl_string hidlId(id);
            ret = interface_3_5->getPhysicalCameraCharacteristics(hidlId,
                    [&status, &id, this](Status s, device::V3_2::CameraMetadata metadata) {
                status = s;
                if (s == Status::OK) {
                    camera_metadata_t *buffer =
                            reinterpret_cast<camera_metadata_t*>(metadata.data());
                    size_t expectedSize = metadata.size();
                    int res = validate_camera_metadata_structure(buffer, &expectedSize);
                    if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
                        set_camera_metadata_vendor_id(buffer, mProviderTagid);
                        mPhysicalCameraCharacteristics[id] = buffer;
                    } else {
                        ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
                        status = Status::INTERNAL_ERROR;
                    }
                }
            });

            if (!ret.isOk()) {
                ALOGE("%s: Transaction error getting physical camera %s characteristics for %s: %s",
                        __FUNCTION__, id.c_str(), id.c_str(), ret.description().c_str());
                return;
            }
            if (status != Status::OK) {
                ALOGE("%s: Unable to get physical camera %s characteristics for device %s: %s (%d)",
                        __FUNCTION__, id.c_str(), mId.c_str(),
                        statusToString(status), status);
                return;
            }

            res = camera3::ZoomRatioMapper::overrideZoomRatioTags(
                    &mPhysicalCameraCharacteristics[id], &mSupportNativeZoomRatio);
            if (OK != res) {
                ALOGE("%s: Unable to override zoomRatio related tags: %s (%d)",
                        __FUNCTION__, strerror(-res), res);
            }
        }
    }

    if (!kEnableLazyHal) {
        // Save HAL reference indefinitely
        mSavedInterface = interface;
    }


}
风不止G
关注
专栏目录
android camera client、CameraService及camera hal调用流程
kk3087961的博客
02-02 1771
这里的 hardware::camera::provider::V2_4::ICameraProvider 对应 android.hardware.camera.provider@2.4 .so模块，CameraProvider就是与HAL层so的交互。因为 Camera 也继承 ::android::hardware::BnCameraClient 所以可以将 Camera 赋值给 TCamCallbacks（即 TCam为::android::hardware::ICameraClient）
Android8.0 Camera系统架构(一)
热门推荐
Sherlock的博客
08-27 1万+
随着Android系统的不断升级，相机子系统框架也在不断进化，由最初的API1和HAL1到现在的API2和HAL3，由最初简单的拍照，录制到现在的连拍，AI人像；可以说是架构上变动最大最频繁的子系统。整个架构可以从下面这张图看出来： Android 的相机硬件抽象层 (HAL) 可将 Camera 2 中较高级别的相机框架 API 连接到底层的相机驱动程序和硬件。相机子系统包括相机管道组件的...
camera启动之---cameraserver启动与cameraprovider链接（4）
weixin_43503508的博客
08-01 1163
Camera服务还是从rc文件开始 frameworks/av/camera/cameraserver/cameraserver.rc service cameraserver /system/bin/cameraserver class main user cameraserver group audio camera input drmrpc readproc ioprio rt 4 writepid /dev/cpuset/camera-daemon/tasks /dev/stune/top-app/
第11讲 cameraserver进程启动之HIDL CameraDevice初始化 修正CameraCharacteristics - Android Camera Native Framework
yzm65580952的博客
08-18 34
如果HAL不支持ANDROID_CONTROL_ZOOM_RATIO_RANGE，则通过ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM来构造一个Zoom Ratio Range，更新到ANDROID_CONTROL_ZOOM_RATIO_RANGE。如果ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE没有填，则获取ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE的值填进去。
第9讲 cameraserver进程启动之HIDL CameraProvider初始化
yzm65580952的博客
08-10 30
调用ICameraProvider的getCameraldList方法获取到当前Proyider支持的Camera Device,解析出 Camera ID存放在mProviderPublicCameralds(解析规则解读)调用notifyDeviceStateChange通知Camera HAL进程，该功能在 Provider 2.5及之后的版本才有。原因: 有些API是新的版本才支持的，如果没有支持，调用起来就会crash。创建新的结构体变量，记录provider的信息。监听provider的通知。
第8讲 cameraserver进程启动之enumerateProviders概述
yzm65580952的博客
08-10 32
Android Camera HAL接口分成HIDL和AIDL两种，谷歌之后会强推AIDL。ICameraProvider管理多个ICameraDeviceICameraDevice管理和维护某一颗CameraDevice通过ICameraProvider获取到ICameraDevice通过ICameraDevice获取到ICameraDeviceSession初始化时，ICameraProvider和ICameraDevice的实例就会被创建起来，
第7讲 cameraserver进程启动流程概述
yzm65580952的博客
08-04 48
在TCP通信中，当通信的双方中的一方close一个连接时，若另一方接着发数据，根据TCP协议的规定，会收到一个RST响应报文，若再往这个服务器发送数据时，系统会发出一个SIGPIPE信号给进程，告诉进程这个连接已经断开了，不能再写入数据。new SERVICE 的时候 会创建一个binder对象并返回其指针 ，onFirstRef机制通过检查强引用计数来判断对象是否是第一次被调用。该信号的缺省行为是终止进程，因此进程必须捕获它以免不情愿的被终止。可以通过ps 命令查看有几个线程。查看服务是否注册成功。
第15讲 cameraserver进程启动之与CameraID和CameraDevice相关变量梳理 - Android Camera Native Framework
yzm65580952的博客
08-20 34
【代码】第15讲 cameraserver进程启动之与CameraID和CameraDevice相关变量梳理 - Android Camera Native Framework。
【Camera Framework笔记】一、Cameraserver简介及启动、实例化流程
Cam_Rxy的博客
04-10 474
并将以上两个参数add到 servicemanager，这时cameraservice就已经成功注册到servicemanager中了，查看命令：service list | grep -i “media.camera”此时new出来的 cameraservice 会赋值给sp（调用完cameraservice构造函数后，继续调用CameraService::onfirstRef）tcp通信中，比如 a与b通信，如果b关闭了通信，系统会发出一个sigpipe信号给a，告诉a连接已经断开。
[安卓相机系列] 零、CameraServer和CameraProvider的启动初始化
也说安卓
03-29 2735
[安卓相机系列] 零、CameraServer和CameraProvider的启动初始化 一、前言 本文所使用代码为**android-10.0.0_r30分支，可以通过Android Code Search在线浏览源码，或通过repo工具将代码下载到本地。如何下载代码，请参考下载源代码，建议使用清华大学的Android镜像**，使用帮助：Android 镜像使用帮助。 在开始前，最好能掌握或了解...
基于Android 14系统启动流程之zygote进程启动解析 (详细分析从kernel启动到zygote启动完了的过程)
qq_15125719的博客
03-01 1615
本篇文章主要讲解zygote是如何启动的，从内核kernel启动开始，一直贯穿到java层代码，包括以下几部分： 1、init 进程的启动时机 2、init 进程都做了哪些事情 3、zygote进程启动的时机，都做了哪些内容 4、java代码是如何运行的 5、简单画了函数之间的调用关系。
cameraserver启动流程
07-30
启动流程大致可以分为以下几个步骤： 1. **环境准备**：确保已经安装了ROS及其相关的相机驱动包，如`opencv_camera`或`usb_cam`等。 2. **创建节点**：在ROS工作空间下创建一个Node，通过`rosrun`命令加载`camera_...
O版本后CameraServer启动流程
weixin_35640359的博客
09-28 1404
#CameraServer
【鸿蒙OS开发入门】10 - 启动流程代码分析之第一个用户态进程：init 进程
|~~~热爱生活、努力学习的小伙汁~~~|
12-22 1464
【鸿蒙OS开发入门】10 - 启动流程代码分析之第一个用户态进程：init 进程
Unity android 接USBCamera
Cat的博客
09-23 541
3.在android工程中找到AndroidManifest.xml加入usb权限相关。1. unity打包android后，链接USB摄像头，需要USB权限。2.导出android工程。
Android常用C++特性之std::chrono
最新发布
Android-Graphics&Display
09-27 434
是 C++11 中提供的时间库，用于处理时间点和时间间隔。通过duration表示时间间隔，time_point表示时间点。支持不同精度的时间单位，如纳秒、毫秒、秒等。和。提供精确的时间测量和单位转换功能。
Android Camera 预览角度和拍照保存图片角度相关
sinat_37429535的博客
09-23 1179
基于Android R(11)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值