Android Camera(三)Camera Service的初始化代码分析

---

highlight: a11y-dark

1.APP CameraManager初始化

CameraManager初始化代码较少，放在这里进行讲解，CameraManager是一个用来管理相机的系统服务，可以通过此服务获取到相机设备和相机信息，在frameworks/base/core/java/android/app/SystemServiceRegistry.java 注册

应用层可以通过下面方法获取一个CameraManager实例

CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);

代码实现：/frameworks/base/core/java/android/hardware/camera2/

2.Native层CameraServer启动

由于CameraServer需要连接CameraProvider，所以一般来说CameraSever后于CameraProvider启动，CameraServer的启动脚本在cameraserver.rc这个文件，文件位置为frameworks/av/camera/cameraserver/cameraserver.rc

service cameraserver/system/bin/camera
       class main
       user   cameraserver
       group audio   camera input drmrpc
         ioprio rt 4
         task_profiles CameraServiceCapacity MaxPerformance
         rlimit rtprio 10 10

2.1 main_cameraserver.cpp

此文件为camerserver的入口，创建CameraService实例，并将其添加到ServiceManager中
路径：frameworks/av/camera/cameraserver/main_cameraserver.cpp

#define LOG_TAG "cameraserver"
   //#define LOG_NDEBUG 0
  
   #include   "CameraService.h"
   #include   <hidl/HidlTransportSupport.h>
    
   using namespace android;
    
   int main(int argc __unused, char** argv   __unused)
   {
         signal(SIGPIPE, SIG_IGN);
    
         // Set 5 threads for HIDL calls.   Now cameraserver will serve HIDL calls in
         // addition to consuming them from   the Camera HAL as well.
         hardware::configureRpcThreadpool(5, /*willjoin*/ false);
    
         sp<ProcessState> proc(ProcessState::self());
         sp<IServiceManager> sm = defaultServiceManager();
         ALOGI("ServiceManager:   %p", sm.get());
         CameraService::instantiate();
         ALOGI("ServiceManager: %p done   instantiate", sm.get());
         ProcessState::self()->startThreadPool();
         IPCThreadState::self()->joinThreadPool();
   }
    
   //路径http://aospxref.com/android-11.0.0_r21/xref/frameworks/native/include/binder/BinderService.h
   template<typename SERVICE>
     class BinderService
     {
     public:
           static status_t publish(bool allowIsolated =   false,
                                 int dumpFlags =   IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT)   {
               sp<IServiceManager> sm(defaultServiceManager());
               return sm->addService(String16(SERVICE::getServiceName()),   new SERVICE(), allowIsolated,
                                   dumpFlags);
         }
     
    
           static void instantiate() { publish(); }
   }
   //http://aospxref.com/android-11.0.0_r21/xref/frameworks/av/services/camera/libcameraservice/CameraService.h
     class CameraService :
         public   BinderService<CameraService>,
         public   virtual ::android::hardware::BnCameraService,
         public   virtual IBinder::DeathRecipient,
         public   virtual CameraProviderManager::StatusListener
     {
       
     static char const* getServiceName(){ return "media.camera"; }
     }
    
   //http://aospxref.com/android-11.0.0_r21/xref/frameworks/native/cmds/servicemanager/ServiceManager.cpp
   inline   virtual status_t addService(const String16 &   name, const   sp<IBinder> & service, bool allowIsolated) {
           。。。。
           };	 

CameraService::instantiate()用来实例化一个CameraService对象,其中CameraService继承BinderService，BinderService为一个模板类，native service通过sm->addService(String16(SERVICE::getServiceName()), new SERVICE(), allowIsolated,dumpFlags)这种方式来将服务注册到ServiceManager，所以SERVICE为CameraService,向sp sm注册CameraService服务。调用addService函数时会实例化CameraService并将赋值sp强指针引用，从而调用CameraService的onFirstRef成员函数

2.2 CameraService::onFirstRef

在此函数中，主要调用的函数为enumerateProviders(),用来获取CameraProvider的信息
代码位置：frameworks/av/services/camera/libcameraservice/CameraService.cpp

   151  void CameraService::onFirstRef()
   152  {
   153      ALOGI("CameraService   process starting");
   154  
   155        BnCameraService::onFirstRef();//调用父类的OnFirstRef()函数
   156  
   157      //   Update battery life tracking if service is restarting
   158      BatteryNotifier& notifier(BatteryNotifier::getInstance());
   159      notifier.noteResetCamera();
   160      notifier.noteResetFlashlight();
   161  
   162      status_t res = INVALID_OPERATION;
   163  
   164      res =   enumerateProviders();//获取CameraProvider信息
   165      if (res == OK) {
   166          mInitialized = true;
   167      }
   168  
   169      mUidPolicy = new UidPolicy(this);
   170      mUidPolicy->registerSelf();
   171      mSensorPrivacyPolicy = new   SensorPrivacyPolicy(this);
   172        mSensorPrivacyPolicy->registerSelf();
   173        mAppOps.setCameraAudioRestriction(mAudioRestriction);
   174      sp<HidlCameraService> hcs =   HidlCameraService::getInstance(this);
   175      if (hcs->registerAsService() != android::OK) {
   176          ALOGE("%s: Failed to register default   android.frameworks.cameraservice.service@1.0",
   177                __FUNCTION__);
   178      }
   179  
   180      //   This needs to be last call in this function, so that it's as close to
   181      //   ServiceManager::addService() as possible.
   182        CameraService::pingCameraServiceProxy();
   183      ALOGI("CameraService   pinged cameraservice proxy");
   184  }

2.3 CameraService::enumerateProviders()

在enumerateProviders()中会实例化一个CameraProviderManager对象，并调用CameraProviderManager的initialize函数，将CameraSevice作为一个成员变量传入到initialize
代码位置：frameworks/av/services/camera/libcameraservice/CameraService.cpp#enumerateProviders

   186  status_t CameraService::enumerateProviders() {
   187      status_t res;
   188  
   189      std::vector<std::string> deviceIds;
   190      {
   191          Mutex::Autolock l(mServiceLock);
   192  
   193          if (nullptr == mCameraProviderManager.get()) {
   194                mCameraProviderManager = new CameraProviderManager();//实例化CameraProviderManager,并且调用其initialize函数
   195              res =   mCameraProviderManager->initialize(this);
   196              if (res != OK) {
   197                  ALOGE("%s: Unable to initialize camera provider manager:   %s (%d)",
   198                          __FUNCTION__,   strerror(-res), res);
   199                  return res;
   200              }
   201          }
   202  
   203  
   204          //   Setup vendor tags before we call get_camera_info the first time
   205          //   because HAL might need to setup static vendor keys in get_camera_info
   206          //   TODO:   maybe put this into CameraProviderManager::initialize()?
   207            mCameraProviderManager->setUpVendorTags();
   208  
   209          if (nullptr == mFlashlight.get()) {
   210                mFlashlight = new CameraFlashlight(mCameraProviderManager, this);//创建Flashlight对象
   211          }
   212  
   213          res =   mFlashlight->findFlashUnits();
   214          if (res != OK) {
   215              ALOGE("Failed to enumerate flash units: %s (%d)", strerror(-res), res);
   216          }
   217  
   218            deviceIds = mCameraProviderManager->getCameraDeviceIds();//获取摄像头ID集合
   219      }
   220  
   221  
   222      for (auto& cameraId : deviceIds) {
   223          String8 id8 =   String8(cameraId.c_str());
   224          if (getCameraState(id8) == nullptr) {
   225                onDeviceStatusChanged(id8, CameraDeviceStatus::PRESENT);//更新Camera的状态，暂时不理解
   226          }
   227      }
   228  
   229      return OK;
   230  }

2.4 CameraProviderManager::initialize

代码位置：frameworks/av/services/camera/libcameraservice/common/CameraProviderManager.cpp

initialize主要做三件事情

1. 将传下来的CameraService对象赋给mListener以此来通知CameraSevice状态的变化，mListener的实现类似于java的回调机制，由于CameraService在调用initialize函数
   时没有传入第二个参数，所以proxy使用默认参数并且将sHardwareServiceInteractionProxy静态变量赋给mServiceProxy，
   代码位置frameworks/av/services/camera/libcameraservice/common/CameraProviderManager.h
   

2.调用mServiceProxy->registerForNotifications来调用hardware:📷:provider::V2_4::ICameraProvider的静态方法registerForNotifications
代码位置：frameworks/av/services/camera/libcameraservice/common/CameraProviderManager.h

3.通过this->addProviderLocked来获取当前系统中的CameraProiver对象
代码位置：

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

1.调用mServiceProxy->tryGetService(newProvider)，会最终调用到一个名为HIDL_FETCH_ICameraProvider 的函数,并且将CameraProvider赋值给
interface
代码位置：hardware/interfaces/camera/provider/2.4/default/CameraProvider_2_4.cpp

template<typename IMPL>
   CameraProvider<IMPL>* getProviderImpl() {
         CameraProvider<IMPL> *provider = new   CameraProvider<IMPL>();
         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;
   }
    
   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>();
         } else if (strcmp(name, kExternalProviderName) == 0) {
           provider   = getProviderImpl<ExternalCameraProviderImpl_2_4>();
         } else {
             ALOGE("%s: unknown instance   name: %s", __FUNCTION__, name);
       }
    
         return provider;
   }
    
   const   char *kLegacyProviderName = "legacy/0";
   const   char *kExternalProviderName = "external/0";

通过比较名字来初始化对应的CameraProvider,从而调用不同CamerProvider的构造函数,以LegacyCameraProviderImpl_2_4为例，在initialize函数中会调用
camera hal module中的函数，例如原生的camera.v4l2.so
代码位置：hardware/interfaces/camera/provider/2.4/default/LegacyCameraProviderImpl_2_4.cpp

2.实例化一个ProviderInfo对象，并传入对应的CameraProvider对象和CameraProviderManager对象，将保存CameraProvider的名字，这里的名字分别为
“legacy/0” 和 “external/0”，也可自行扩展，并将CameraProviderManager对象赋值给mManager,方便后续查找

3.调用已经实例化的ProviderInfo对象的initialize，在initialize函数中主要调用interface即对应CameraProiver对象的来和Hal层进行通信

 setCallback(this)
    linkToDeath
    getCameraIdList
   isSetTorchModeSupported

填充从Camera Provider中获取到的Camera名字到device向量中和填充Camera id到mProviderPublicCameraIds向量中
代码位置：

frameworks/av/services/camera/libcameraservice/common/CameraProviderManager.cpp
status_t   CameraProviderManager::ProviderInfo::initialize(
             sp<provider::V2_4::ICameraProvider>& interface,
             hardware::hidl_bitfield<provider::V2_5::DeviceState>   currentDeviceState) {
       status_t res   = parseProviderName(mProviderName, &mType, &mId);
         if   (res != OK) {
             ALOGE("%s: Invalid provider   name, ignoring", __FUNCTION__);
             return BAD_VALUE;
       }
         ALOGI("Connecting to new   camera provider: %s, isRemote? %d",
                 mProviderName.c_str(), interface->isRemote());
    
         // Determine minor version
         mMinorVersion = 4;
         auto   cast2_6 = provider::V2_6::ICameraProvider::castFrom(interface);
         sp<provider::V2_6::ICameraProvider> interface2_6 = nullptr;
         if   (cast2_6.isOk()) {
             interface2_6 = cast2_6;
             if   (interface2_6 != nullptr) {
               mMinorVersion = 6;
           }
       }
         // We need to check again since   cast2_6.isOk() succeeds even if the provider
         // version isn't actually 2.6.
         if   (interface2_6 == nullptr){
             auto   cast2_5 =
                     provider::V2_5::ICameraProvider::castFrom(interface);
             sp<provider::V2_5::ICameraProvider> interface2_5 = nullptr;
             if   (cast2_5.isOk()) {
                 interface2_5 = cast2_5;
               if (interface != nullptr) {
                   mMinorVersion = 5;
               }
           }
       }
    
         // cameraDeviceStatusChange   callbacks may be called (and causing new devices added)
         // before setCallback returns
         hardware::Return<Status> status =   interface->setCallback(this);
         if   (!status.isOk()) {
             ALOGE("%s: Transaction error   setting up callbacks with camera provider '%s': %s",
                     __FUNCTION__, mProviderName.c_str(), status.description().c_str());
             return DEAD_OBJECT;
       }
         if   (status != Status::OK) {
             ALOGE("%s: Unable to register   callbacks with camera provider '%s'",
                     __FUNCTION__, mProviderName.c_str());
             return mapToStatusT(status);
       }
    
         hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
         if   (!linked.isOk()) {
             ALOGE("%s: Transaction error   in linking to camera provider '%s' death: %s",
                     __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
             return DEAD_OBJECT;
         } else if (!linked) {
             ALOGW("%s: Unable to link to   provider '%s' death notifications",
                     __FUNCTION__, mProviderName.c_str());
       }
    
         if   (!kEnableLazyHal) {
             // Save HAL reference indefinitely
           mSavedInterface = interface;//保存CameraProvider对象
         } else {
             mActiveInterface = interface;
       }
    
         ALOGV("%s: Setting device   state for %s: 0x%" PRIx64,
                 __FUNCTION__, mProviderName.c_str(), mDeviceState);
         notifyDeviceStateChange(currentDeviceState);
    
       res =   setUpVendorTags();
         if   (res != OK) {
             ALOGE("%s: Unable to set up   vendor tags from provider '%s'",
                     __FUNCTION__, mProviderName.c_str());
             return res;
       }
    
         // Get initial list of camera   devices, if any
         std::vector<std::string> devices;
         hardware::Return<void> ret =   interface->getCameraIdList([&status, this, &devices](
                 Status idStatus,
               const hardware::hidl_vec<hardware::hidl_string>&   cameraDeviceNames) {
           status =   idStatus;
             if   (status == Status::OK) {
               for (auto& name : cameraDeviceNames) {
                     uint16_t major, minor;
                   std::string type, id;
                     status_t res = parseDeviceName(name, &major, &minor,   &type, &id);
                   if (res != OK) {
                       ALOGE("%s: Error parsing deviceName: %s: %d", __FUNCTION__, name.c_str(), res);
                         status = Status::INTERNAL_ERROR;
                   } else {
                       devices.push_back(name);//填充从Camera Provider中获取到的Camera名字到device向量中
                         mProviderPublicCameraIds.push_back(id);//填充Camera   id到mProviderPublicCameraIds向量中
                     }
               }
           } });
         if   (!ret.isOk()) {
             ALOGE("%s: Transaction error   in getting camera ID list from provider '%s': %s",
                     __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
             return DEAD_OBJECT;
       }
         if   (status != Status::OK) {
             ALOGE("%s: Unable to query for   camera devices from provider '%s'",
                     __FUNCTION__, mProviderName.c_str());
             return mapToStatusT(status);
       }
    
         // Get list of concurrent streaming   camera device combinations
         if   (mMinorVersion >= 6) {
           res =   getConcurrentCameraIdsInternalLocked(interface2_6);
             if   (res != OK) {
               return res;
           }
       }
    
       ret =   interface->isSetTorchModeSupported(
             [this](auto status, bool supported) {
               if (status == Status::OK) {
                     mSetTorchModeSupported = supported;
               }
           });
         if   (!ret.isOk()) {
             ALOGE("%s: Transaction error   checking torch mode support '%s': %s",
                     __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
             return DEAD_OBJECT;
       }
    
       mIsRemote =   interface->isRemote();
    
         sp<StatusListener> listener = mManager->getStatusListener();//CameraSevice
         for   (auto&   device : devices) {
             std::string id;
           status_t   res = addDevice(device, common::V1_0::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());
    
         // 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));
       }
    
         return OK;
   }

并将每一个Camera的信息保存到ProviderInfo对象的mDevices中，并将Camera id插入到mUniqueCameraIds列表中

4.addProviderLocked将ProviderInfo信息push到CameraManagerProvider对象中