FireFly RK3399 Android8.1系统Camera HAL层内存泄漏问题分析

static jint android_hardware_Camera_getNumberOfCameras(JNIEnv *env, jobject thiz)
{
    return Camera::getNumberOfCameras();
}

template <typename TCam, typename TCamTraits>
int CameraBase<TCam, TCamTraits>::getNumberOfCameras() {
    const sp<::android::hardware::ICameraService> cs = getCameraService();

    if (!cs.get()) {
        // as required by the public Java APIs
        return 0;
    }
    int32_t count;
    binder::Status res = cs->getNumberOfCameras(
            ::android::hardware::ICameraService::CAMERA_TYPE_BACKWARD_COMPATIBLE,
            &count);
    ...
}

Status CameraService::getNumberOfCameras(int32_t type, int32_t* numCameras) {
    ATRACE_CALL();
    Mutex::Autolock l(mServiceLock);
    char value[PROPERTY_VALUE_MAX];
    switch (type) {
        case CAMERA_TYPE_BACKWARD_COMPATIBLE:
            memset(value, 0, sizeof(value));
            property_get("persist.sys.usbcamera.status", value, "");
            if((strcmp(value, "add") == 0)||(strcmp(value, "remove") == 0)){
                //property_set("persist.sys.usbcamera.status", "");
                mCameraProviderManager->updateCameraCount();
                mNumberOfNormalCameras = mCameraProviderManager->getAPI1CompatibleCameraCount();
            }
            *numCameras = mNumberOfNormalCameras;
            ALOGD("CameraService mNumberOfNormalCameras:%d\n", mNumberOfNormalCameras);
            break;
...
}

int CameraProviderManager::updateCameraCount(){
    const std::string& newProvider = kLegacyProviderName;
    sp<provider::V2_4::ICameraProvider> interface;
    sp<StatusListener> listener = getStatusListener();
    ServiceInteractionProxy *proxy = &sHardwareServiceInteractionProxy;

    interface = mServiceProxy->getService(newProvider);
    status_t res = OK;
    CameraProviderManager::initialize(listener, proxy);
    sp<ProviderInfo> providerInfo = mProviders.front();
    if (providerInfo != NULL) {
        res = providerInfo->initialize();
    }
    if (res != OK) {
        return res;
    }
    return 0;
}

status_t CameraProviderManager::ProviderInfo::initialize() {
    ...
    // Get initial list of camera devices, if any
    std::vector<std::string> devices;
    hardware::Return<void> ret = mInterface->getCameraIdList([&status, &devices](
            Status idStatus,
            const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
        status = idStatus;
        if (status == Status::OK) {
            for (size_t i = 0; i < cameraDeviceNames.size(); i++) {
                devices.push_back(cameraDeviceNames[i]);
            }
        } });
...
}

Return<void> CameraProvider::getCameraIdList(getCameraIdList_cb _hidl_cb)  {
    std::vector<hidl_string> deviceNameList;
    char value[PROPERTY_VALUE_MAX];

    memset(value, 0, sizeof(value));
    property_get("persist.sys.usbcamera.status", value, "");
    if((strcmp(value, "add") == 0)||(strcmp(value, "remove") == 0)){
        ALOGD("usb camera hotpluged,reinit camera provider");
        mModule.clear();
        deviceNameList.clear();
        initialize();
    }
    for (auto const& deviceNamePair : mCameraDeviceNames) {
        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();
}

bool CameraProvider::initialize() {
    camera_module_t *rawModule;
    int err = hw_get_module(CAMERA_HARDWARE_MODULE_ID,
            (const hw_module_t **)&rawModule);
    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());
    ...
    mCameraDeviceNames.clear();
    mNumberOfLegacyCameras = mModule->getNumberOfCameras();
    ...
}

    /**
     * get_number_of_cameras:
     *
     * Returns the number of camera devices accessible through the camera
     * module.  The camera devices are numbered 0 through N-1, where N is the
     * value returned by this call. The name of the camera device for open() is
     * simply the number converted to a string. That is, "0" for camera ID 0,
     * "1" for camera ID 1.
     *
     * Version information (based on camera_module_t.common.module_api_version):
     *
     * CAMERA_MODULE_API_VERSION_2_3 or lower:
     *
     *   The value here must be static, and cannot change after the first call
     *   to this method.
     *
     * CAMERA_MODULE_API_VERSION_2_4 or higher:
     *
     *   The value here must be static, and must count only built-in cameras,
     *   which have CAMERA_FACING_BACK or CAMERA_FACING_FRONT camera facing values
     *   (camera_info.facing). The HAL must not include the external cameras
     *   (camera_info.facing == CAMERA_FACING_EXTERNAL) into the return value
     *   of this call. Frameworks will use camera_device_status_change callback
     *   to manage number of external cameras.
     */
    int (*get_number_of_cameras)(void);

camera_module_t HAL_MODULE_INFO_SYM = {
    common: {
         tag: HARDWARE_MODULE_TAG,
         version_major: ((CONFIG_CAMERAHAL_VERSION&0xffff00)>>16),
         version_minor: CONFIG_CAMERAHAL_VERSION&0xff,
         id: CAMERA_HARDWARE_MODULE_ID,
         name: CAMERA_MODULE_NAME,
         author: "RockChip",
         methods: &camera_module_methods,
         dso: NULL, /* remove compilation warnings */
         reserved: {0}, /* remove compilation warnings */
    },
    get_number_of_cameras: camera_get_number_of_cameras,
    get_camera_info: camera_get_camera_info,
    set_callbacks:NULL,
    get_vendor_tag_ops:NULL,
#if defined(ANDROID_5_X)
    open_legacy:NULL,
#endif
#if defined(ANDROID_6_X) || defined(ANDROID_7_X) || defined(ANDROID_8_X)
    set_torch_mode:NULL,
    init:NULL,
#endif
    reserved: {0}   
};

int camera_get_number_of_cameras(void)
{

    char cam_num[3],i;
    int cam_cnt=0,fd=-1,rk29_cam[CAMERAS_SUPPORT_MAX];
	camera_board_profiles * profiles = NULL;
    size_t nCamDev = 0;
	int connectUvc=0;
    ...
    profiles = camera_board_profiles::getInstance();
    nCamDev = profiles->mDevieVector.size();
	LOGD("board profiles cam num %d\n", nCamDev);
        for (i=0; i<CAMERAS_SUPPORT_MAX; i++) {
            cam_path[0] = 0x00;
            strcat(cam_path, CAMERA_DEVICE_NAME);                                                                                              
            sprintf(cam_num, "%d", i);
            strcat(cam_path,cam_num);
            fd = open(cam_path, O_RDONLY);
            if (fd < 0) {
                LOGE("Open %s failed! strr: %s",cam_path,strerror(errno));
                break;
            }
	    connectUvc = 1;
            LOGD("Open %s success!",cam_path);
	    close(fd);
	}

if (i < 2){
    if (nCamDev>0) {
	    if (connectUvc == 1)
	        goto CSI_PRO;
	    else
	    camera_board_profiles::OpenAndRegistALLSensor(profiles);
        ...
    }
}
CSI_PRO:
   	if(cam_cnt<CAMERAS_SUPPORT_MAX){
		int i=0;
        ...
        for (i=0; i<10; i++) {
            ...
            if ((capability.capabilities & (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING)) != (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING)) {
        	    LOGD("Video device(%s): video capture not supported.\n",cam_path);
            } else {
            	rk_cam_total_info* pNewCamInfo = new rk_cam_total_info();
                ...
				if(strcmp((char*)&capability.driver[0],"uvcvideo") == 0)//uvc
				{
					...
					//add usb camera to board_profiles 
					rk_DV_info *pDVResolution = new rk_DV_info();
					...
					for(i=0; i<element_count; i++){
						...
						rk_DV_info *pDVResolution = new rk_DV_info();
						pDVResolution->mWidth = width;
		    	    	pDVResolution->mHeight = height;
		    	    	pDVResolution->mFps = 0;
		    	    	...
						if ((width>sensor_resolution_w) || (height>sensor_resolution_h)) {
							pNewCamInfo->mSoftInfo.mDV_vector.add(pDVResolution);
	                		continue;
	            		}
	            		...
						pNewCamInfo->mSoftInfo.mDV_vector.add(pDVResolution);	        
					}
				}
				...
				profiles->mCurDevice= pNewCamInfo;
            	profiles->mDevieVector.add(pNewCamInfo);
				pNewCamInfo->mDeviceIndex = (profiles->mDevieVector.size()) - 1;
                camInfoTmp[cam_cnt].pcam_total_info = pNewCamInfo;
                cam_cnt++;
                if (cam_cnt >= CAMERAS_SUPPORT_MAX)
                    i = 10;
            }
    loop_continue:
            if (fd > 0) {
                close(fd);
                fd = -1;
            }
            continue;    
        }
   	}
    gCamerasNumber = cam_cnt;
...  
camera_get_number_of_cameras_end:
    LOGD("%s(%d): Current board have %d cameras attached.",__FUNCTION__, __LINE__, gCamerasNumber);
    return gCamerasNumber;
}

camera_get_number_of_cameras_end:
    LOGD("%s(%d): Current board have %d cameras attached.",__FUNCTION__, __LINE__, gCamerasNumber);
    //add by wyh for fixing memory leak--start
    for (Vector<rk_cam_total_info*>::const_iterator itr=profiles->mDevieVector.begin(); itr!=profiles->mDevieVector.end(); ++itr) {
        for (Vector<rk_DV_info*>::const_iterator itr2=(*itr)->mSoftInfo.mDV_vector.begin(); itr2!=(*itr)->mSoftInfo.mDV_vector.end(); ++itr2) {
            delete *itr2;
		}
		(*itr)->mSoftInfo.mDV_vector.clear();
		delete *itr;
    }
    profiles->mDevieVector.clear();
    delete profiles;
    //add by wyh for fixing memory leak--end

    return gCamerasNumber;
}

    if (nCamDev>0) {
	    camera_board_profiles::OpenAndRegistALLSensor(profiles);