camera hardware module

ICS 中 沿用了linux驱动模块化的方式，把camera hal 形成一个hardware module，这点跟HC明显不同。

打开camera时， cameraservice 会先打开camera hw_moudle, 如下代码所示：

[cpp] view plain copy print ?

1. void CameraService::onFirstRef()  
2.     {  
3.         BnCameraService::onFirstRef();  
4.         if (hw_get_module(CAMERA_HARDWARE_MODULE_ID,      //获得camera 模块，   
5.                     (const hw_module_t **)&mModule) < 0) {    //&mModule 应该就是camera.medfield.so.   
6.             LOGE("Could not load camera HAL module");  
7.             mNumberOfCameras = 0;  
8.         }  
9.         else {  
10.             mNumberOfCameras = mModule->get_number_of_cameras();  //调用camera hal 层函数。   
11.             if (mNumberOfCameras > MAX_CAMERAS) {  
12.                 LOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",  
13.                         mNumberOfCameras, MAX_CAMERAS);  
14.                 mNumberOfCameras = MAX_CAMERAS;  
15.             }  
16.             for (int i = 0; i < mNumberOfCameras; i++) {  
17.                 setCameraFree(i);  
18.             }  
19.         }  
20.         // Read the system property to determine if we have to use the   
21.         // AUDIO_STREAM_ENFORCED_AUDIBLE type.   
22.         char value[PROPERTY_VALUE_MAX];  
23.         property_get("ro.camera.sound.forced", value, "0");  
24.         if (strcmp(value, "0") != 0) {  
25.             mAudioStreamType = AUDIO_STREAM_ENFORCED_AUDIBLE;  
26.         } else {  
27.             mAudioStreamType = AUDIO_STREAM_MUSIC;  
28.         }  
29.     }  

void CameraService::onFirstRef()
    {
        BnCameraService::onFirstRef();
        if (hw_get_module(CAMERA_HARDWARE_MODULE_ID,      //获得camera 模块，
                    (const hw_module_t **)&mModule) < 0) {    //&mModule 应该就是camera.medfield.so.
            LOGE("Could not load camera HAL module");
            mNumberOfCameras = 0;
        }
        else {
            mNumberOfCameras = mModule->get_number_of_cameras();  //调用camera hal 层函数。
            if (mNumberOfCameras > MAX_CAMERAS) {
                LOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",
                        mNumberOfCameras, MAX_CAMERAS);
                mNumberOfCameras = MAX_CAMERAS;
            }
            for (int i = 0; i < mNumberOfCameras; i++) {
                setCameraFree(i);
            }
        }
        // Read the system property to determine if we have to use the
        // AUDIO_STREAM_ENFORCED_AUDIBLE type.
        char value[PROPERTY_VALUE_MAX];
        property_get("ro.camera.sound.forced", value, "0");
        if (strcmp(value, "0") != 0) {
            mAudioStreamType = AUDIO_STREAM_ENFORCED_AUDIBLE;
        } else {
            mAudioStreamType = AUDIO_STREAM_MUSIC;
        }
    }

1. 这里的
hw_get_module(CAMERA_HARDWARE_MODULE_ID, (const hw_module_t **)&mModule)
调用了hardware/libhardware/hardware.c

[cpp] view plain copy print ?

1. int hw_get_module(const char *id, const struct hw_module_t **module)  
2.     {  
3.         return hw_get_module_by_class(id, NULL, module);  
4.     }  
5.   
6. const char *id ------- 应该是module name  
7. const struct hw_module_t **module -----应该是module模块地址。  
8.   
9.     int hw_get_module_by_class(const char *class_id, const char *inst,  
10.                                const struct hw_module_t **module)  
11.     {  
12.         int status;  
13.         int i;  
14.         const struct hw_module_t *hmi = NULL;  
15.         char prop[PATH_MAX];  
16.         char path[PATH_MAX];  
17.         char name[PATH_MAX];  
18.         if (inst)  
19.             snprintf(name, PATH_MAX, "%s.%s", class_id, inst);  // 这里class_id 是camera，inst 应该是medfield，   
20.         else  
21.             strlcpy(name, class_id, PATH_MAX);  
22.         /* 
23.          * Here we rely on the fact that calling dlopen multiple times on 
24.          * the same .so will simply increment a refcount (and not load 
25.          * a new copy of the library). 
26.          * We also assume that dlopen() is thread-safe. 
27.          */  
28.           
29.         /* Loop through the configuration variants looking for a module */  
30.         for (i=0 ; i<HAL_VARIANT_KEYS_COUNT+1 ; i++) {  
31.             if (i < HAL_VARIANT_KEYS_COUNT) {  
32.                 if (property_get(variant_keys[i], prop, NULL) == 0) {  
33.                     continue;  
34.                 }  
35.                 snprintf(path, sizeof(path), "%s/%s.%s.so",  
36.                          HAL_LIBRARY_PATH2, name, prop);  
37.                 if (access(path, R_OK) == 0) break;  
38.                 snprintf(path, sizeof(path), "%s/%s.%s.so",  
39.                          HAL_LIBRARY_PATH1, name, prop);  
40.                 if (access(path, R_OK) == 0) break;  
41.             } else {  
42.                 snprintf(path, sizeof(path), "%s/%s.default.so",  
43.                          HAL_LIBRARY_PATH1, name);  
44.                 if (access(path, R_OK) == 0) break;  
45.             }  
46.         }  
47.           
48.         status = -ENOENT;  
49.         if (i < HAL_VARIANT_KEYS_COUNT+1) {  
50.             /* load the module, if this fails, we're doomed, and we should not try 
51.              * to load a different variant. */  
52.             status = load(class_id, path, module);  
53.         }  
54.           
55.         return status;  
56.     }  

int hw_get_module(const char *id, const struct hw_module_t **module)
    {
        return hw_get_module_by_class(id, NULL, module);
    }

const char *id ------- 应该是module name
const struct hw_module_t **module -----应该是module模块地址。

    int hw_get_module_by_class(const char *class_id, const char *inst,
                               const struct hw_module_t **module)
    {
        int status;
        int i;
        const struct hw_module_t *hmi = NULL;
        char prop[PATH_MAX];
        char path[PATH_MAX];
        char name[PATH_MAX];
        if (inst)
            snprintf(name, PATH_MAX, "%s.%s", class_id, inst);  // 这里class_id 是camera，inst 应该是medfield，
        else
            strlcpy(name, class_id, PATH_MAX);
        /*
         * Here we rely on the fact that calling dlopen multiple times on
         * the same .so will simply increment a refcount (and not load
         * a new copy of the library).
         * We also assume that dlopen() is thread-safe.
         */
        
        /* Loop through the configuration variants looking for a module */
        for (i=0 ; i<HAL_VARIANT_KEYS_COUNT+1 ; i++) {
            if (i < HAL_VARIANT_KEYS_COUNT) {
                if (property_get(variant_keys[i], prop, NULL) == 0) {
                    continue;
                }
                snprintf(path, sizeof(path), "%s/%s.%s.so",
                         HAL_LIBRARY_PATH2, name, prop);
                if (access(path, R_OK) == 0) break;
                snprintf(path, sizeof(path), "%s/%s.%s.so",
                         HAL_LIBRARY_PATH1, name, prop);
                if (access(path, R_OK) == 0) break;
            } else {
                snprintf(path, sizeof(path), "%s/%s.default.so",
                         HAL_LIBRARY_PATH1, name);
                if (access(path, R_OK) == 0) break;
            }
        }
        
        status = -ENOENT;
        if (i < HAL_VARIANT_KEYS_COUNT+1) {
            /* load the module, if this fails, we're doomed, and we should not try
             * to load a different variant. */
            status = load(class_id, path, module);
        }
        
        return status;
    }

load(class_id, path, module) 代码如下：

[cpp] view plain copy print ?

1. /** 
2.      * Load the file defined by the variant and if successful 
3.      * return the dlopen handle and the hmi. 
4.      * @return 0 = success, !0 = failure. 
5.      */  
6.     static int load(const char *id,  
7.             const char *path,  
8.             const struct hw_module_t **pHmi)  
9.     {  
10.         int status;  
11.         void *handle;  
12.         struct hw_module_t *hmi;  
13.         /* 
14.          * load the symbols resolving undefined symbols before 
15.          * dlopen returns. Since RTLD_GLOBAL is not or'd in with 
16.          * RTLD_NOW the external symbols will not be global 
17.          */  
18.         handle = dlopen(path, RTLD_NOW);  
19.         if (handle == NULL) {  
20.             char const *err_str = dlerror();  
21.             LOGE("load: module=%s\n%s", path, err_str?err_str:"unknown");  
22.             status = -EINVAL;  
23.             goto done;  
24.         }  
25.         /* Get the address of the struct hal_module_info. */  
26.         const char *sym = HAL_MODULE_INFO_SYM_AS_STR;  
27.         hmi = (struct hw_module_t *)dlsym(handle, sym);  
28.         if (hmi == NULL) {  
29.             LOGE("load: couldn't find symbol %s", sym);  
30.             status = -EINVAL;  
31.             goto done;  
32.         }  
33.         /* Check that the id matches */  
34.         if (strcmp(id, hmi->id) != 0) {  
35.             LOGE("load: id=%s != hmi->id=%s", id, hmi->id);  
36.             status = -EINVAL;  
37.             goto done;  
38.         }  
39.         hmi->dso = handle;  
40.         /* success */  
41.         status = 0;  
42.         done:  
43.         if (status != 0) {  
44.             hmi = NULL;  
45.             if (handle != NULL) {  
46.                 dlclose(handle);  
47.                 handle = NULL;  
48.             }  
49.         } else {  
50.             LOGV("loaded HAL id=%s path=%s hmi=%p handle=%p",  
51.                     id, path, *pHmi, handle);  
52.         }  
53.         *pHmi = hmi;  
54.         return status;  
55.     }  

/**
     * Load the file defined by the variant and if successful
     * return the dlopen handle and the hmi.
     * @return 0 = success, !0 = failure.
     */
    static int load(const char *id,
            const char *path,
            const struct hw_module_t **pHmi)
    {
        int status;
        void *handle;
        struct hw_module_t *hmi;
        /*
         * load the symbols resolving undefined symbols before
         * dlopen returns. Since RTLD_GLOBAL is not or'd in with
         * RTLD_NOW the external symbols will not be global
         */
        handle = dlopen(path, RTLD_NOW);
        if (handle == NULL) {
            char const *err_str = dlerror();
            LOGE("load: module=%s\n%s", path, err_str?err_str:"unknown");
            status = -EINVAL;
            goto done;
        }
        /* Get the address of the struct hal_module_info. */
        const char *sym = HAL_MODULE_INFO_SYM_AS_STR;
        hmi = (struct hw_module_t *)dlsym(handle, sym);
        if (hmi == NULL) {
            LOGE("load: couldn't find symbol %s", sym);
            status = -EINVAL;
            goto done;
        }
        /* Check that the id matches */
        if (strcmp(id, hmi->id) != 0) {
            LOGE("load: id=%s != hmi->id=%s", id, hmi->id);
            status = -EINVAL;
            goto done;
        }
        hmi->dso = handle;
        /* success */
        status = 0;
        done:
        if (status != 0) {
            hmi = NULL;
            if (handle != NULL) {
                dlclose(handle);
                handle = NULL;
            }
        } else {
            LOGV("loaded HAL id=%s path=%s hmi=%p handle=%p",
                    id, path, *pHmi, handle);
        }
        *pHmi = hmi;
        return status;
    }

2.  mNumberOfCameras = mModule->get_number_of_cameras();
调用了 hardware/intel/libcamera/IntelCameraHAL.cpp 中的

[cpp] view plain copy print ?

1. camera_module_t HAL_MODULE_INFO_SYM = {  
2.         common: {  
3.              tag: HARDWARE_MODULE_TAG,  
4.              version_major: 1,  
5.              version_minor: 0,  
6.              id: CAMERA_HARDWARE_MODULE_ID,  
7.              name: "Intel CameraHardware Module",  
8.              author: "Intel",  
9.              methods: &camera_module_methods,     //这里面定义了各种函数接口。   
10.              dso: NULL, /* remove compilation warnings */  
11.              reserved: {0}, /* remove compilation warnings */  
12.         },  
13.         get_number_of_cameras: HAL_GetNumberOfCameras,   //cameraservice 中会调用这两个函数。   
14.         get_camera_info: HAL_GetCameraInfo,  
15.     };  

camera_module_t HAL_MODULE_INFO_SYM = {
        common: {
             tag: HARDWARE_MODULE_TAG,
             version_major: 1,
             version_minor: 0,
             id: CAMERA_HARDWARE_MODULE_ID,
             name: "Intel CameraHardware Module",
             author: "Intel",
             methods: &camera_module_methods,     //这里面定义了各种函数接口。
             dso: NULL, /* remove compilation warnings */
             reserved: {0}, /* remove compilation warnings */
        },
        get_number_of_cameras: HAL_GetNumberOfCameras,   //cameraservice 中会调用这两个函数。
        get_camera_info: HAL_GetCameraInfo,
    };

a.  get_number_of_cameras: HAL_GetNumberOfCameras,

[cpp] view plain copy print ?

1. int HAL_GetNumberOfCameras(void)  
2.     {  
3.         return android::CameraHardware::getNumberOfCameras();  
4.     }  
5.   
6.     /* This function will be called when the camera service is created. 
7.      * Do some init work in this function. 
8.      */  
9.     int CameraHardware::getNumberOfCameras()  
10.     {  
11.         LogEntry(LOG_TAG, __FUNCTION__);  
12.         if (num_cameras != 0)  
13.             return num_cameras;  
14.         int ret;  
15.         struct v4l2_input input;  
16.         int fd = -1;  
17.         char *dev_name = "/dev/video0";  
18.         fd = open(dev_name, O_RDWR);  
19.         if (fd <= 0) {  
20.             LogError("Error opening video device %s: %s",  
21.                  dev_name, strerror(errno));  
22.             return 0;  
23.         }  
24.         int i;  
25.         for (i = 0; i < MAX_CAMERAS; i++) {  
26.             memset(&input, 0, sizeof(input));  
27.             input.index = i;  
28.             ret = ioctl(fd, VIDIOC_ENUMINPUT, &input);  //从kernel 获得相应信息，枚举input通道信息。   
29.             if (ret < 0) {  
30.                 break;  
31.             }  
32.             camInfo[i].port = input.reserved[1];  
33.             strncpy(camInfo[i].name, (const char *)input.name, MAX_SENSOR_NAME_LENGTH);  
34.         }  
35.         close(fd);  
36.         num_cameras = i;  
37.         return num_cameras;  
38.     }  

int HAL_GetNumberOfCameras(void)
    {
        return android::CameraHardware::getNumberOfCameras();
    }

    /* This function will be called when the camera service is created.
     * Do some init work in this function.
     */
    int CameraHardware::getNumberOfCameras()
    {
        LogEntry(LOG_TAG, __FUNCTION__);
        if (num_cameras != 0)
            return num_cameras;
        int ret;
        struct v4l2_input input;
        int fd = -1;
        char *dev_name = "/dev/video0";
        fd = open(dev_name, O_RDWR);
        if (fd <= 0) {
            LogError("Error opening video device %s: %s",
                 dev_name, strerror(errno));
            return 0;
        }
        int i;
        for (i = 0; i < MAX_CAMERAS; i++) {
            memset(&input, 0, sizeof(input));
            input.index = i;
            ret = ioctl(fd, VIDIOC_ENUMINPUT, &input);  //从kernel 获得相应信息，枚举input通道信息。
            if (ret < 0) {
                break;
            }
            camInfo[i].port = input.reserved[1];
            strncpy(camInfo[i].name, (const char *)input.name, MAX_SENSOR_NAME_LENGTH);
        }
        close(fd);
        num_cameras = i;
        return num_cameras;
    }

b. get_camera_info: HAL_GetCameraInfo,

[cpp] view plain copy print ?

1. int HAL_GetCameraInfo(int camera_id, struct camera_info *info)  
2.     {  
3.         return android::CameraHardware::getCameraInfo(camera_id, info);  
4.     }  
5.   
6.     int CameraHardware::getCameraInfo(int cameraId, struct camera_info* cameraInfo)  
7.     {  
8.         LogEntry(LOG_TAG, __FUNCTION__);  
9.         if (cameraId >= MAX_CAMERAS)  
10.             return -EINVAL;  
11.         memcpy(cameraInfo, &HAL_cameraInfo[cameraId], sizeof(camera_info));  //从HAL_cameraInfo[cameraId] 中获得信息。   
12.         return 0;  
13.     }  

int HAL_GetCameraInfo(int camera_id, struct camera_info *info)
    {
        return android::CameraHardware::getCameraInfo(camera_id, info);
    }

    int CameraHardware::getCameraInfo(int cameraId, struct camera_info* cameraInfo)
    {
        LogEntry(LOG_TAG, __FUNCTION__);
        if (cameraId >= MAX_CAMERAS)
            return -EINVAL;
        memcpy(cameraInfo, &HAL_cameraInfo[cameraId], sizeof(camera_info));  //从HAL_cameraInfo[cameraId] 中获得信息。
        return 0;
    }

HAL_cameraInfo[cameraId] 定义如下：

[cpp] view plain copy print ?

1. static camera_info HAL_cameraInfo[MAX_CAMERAS] = {  
2.         {  
3.             CAMERA_FACING_FRONT,  
4.             180,  
5.         },  
6.         {  
7.             CAMERA_FACING_BACK,  
8.             0,  
9.         }  
10.     };  

static camera_info HAL_cameraInfo[MAX_CAMERAS] = {
        {
            CAMERA_FACING_FRONT,
            180,
        },
        {
            CAMERA_FACING_BACK,
            0,
        }
    };

c. methods: &camera_module_methods,     //这里面定义了各种函数接口。

[cpp] view plain copy print ?

1. static struct hw_module_methods_t camera_module_methods = {  
2.         open: HAL_OpenCameraHardware   // 也就是这个函数   
3.     };  
4.   
5. open: HAL_OpenCameraHardware，  
6.   
7.     int HAL_OpenCameraHardware(const hw_module_t* module, const char* name,  
8.                     hw_device_t** device)  
9.     {  
10.         int rv = 0;  
11.         int num_cameras = 0;  
12.         int cameraid;  
13.         intel_camera_device_t* camera_device = NULL;  
14.         camera_device_ops_t* camera_ops = NULL;  
15.         android::CameraHardware* camera = NULL;  
16.         android::Mutex::Autolock lock(gCameraHalDeviceLock);  
17.         LOGI("camera_device open");  
18.         if (name != NULL) {  
19.             cameraid = atoi(name);  
20.             num_cameras = android::CameraHardware::getNumberOfCameras();  
21.             if(cameraid > num_cameras)  
22.             {  
23.                 LOGE("camera service provided cameraid out of bounds, "  
24.                         "cameraid = %d, num supported = %d",  
25.                         cameraid, num_cameras);  
26.                 rv = -EINVAL;  
27.                 goto fail;  
28.             }  
29.             if(gCamerasOpen >= MAX_CAMERAS)  
30.             {  
31.                 LOGE("maximum number of cameras already open");  
32.                 rv = -ENOMEM;  
33.                 goto fail;  
34.             }  
35.             camera_device = (intel_camera_device_t*)malloc(sizeof(*camera_device));  
36.             if(!camera_device)  
37.             {  
38.                 LOGE("camera_device allocation fail");  
39.                 rv = -ENOMEM;  
40.                 goto fail;  
41.             }  
42.             camera_ops = (camera_device_ops_t*)malloc(sizeof(*camera_ops));  
43.             if(!camera_ops)  
44.             {  
45.                 LOGE("camera_ops allocation fail");  
46.                 rv = -ENOMEM;  
47.                 goto fail;  
48.             }  
49.             memset(camera_device, 0, sizeof(*camera_device));  
50.             memset(camera_ops, 0, sizeof(*camera_ops));  
51.             camera_device->device.common.tag = HARDWARE_DEVICE_TAG;  
52.             camera_device->device.common.version = 0;  
53.             camera_device->device.common.module = (hw_module_t *)(module);  
54.             camera_device->device.common.close = HAL_CloseCameraHardware;  
55.             camera_device->device.ops = camera_ops;  
56.             camera_ops->set_preview_window = camera_set_preview_window;  
57.             camera_ops->set_callbacks = camera_set_callbacks;  
58.             camera_ops->enable_msg_type = camera_enable_msg_type;  
59.             camera_ops->disable_msg_type = camera_disable_msg_type;  
60.             camera_ops->msg_type_enabled = camera_msg_type_enabled;  
61.             camera_ops->start_preview = camera_start_preview;  
62.             camera_ops->stop_preview = camera_stop_preview;  
63.             camera_ops->preview_enabled = camera_preview_enabled;  
64.             camera_ops->store_meta_data_in_buffers = camera_store_meta_data_in_buffers;  
65.             camera_ops->start_recording = camera_start_recording;  
66.             camera_ops->stop_recording = camera_stop_recording;  
67.             camera_ops->recording_enabled = camera_recording_enabled;  
68.             camera_ops->release_recording_frame = camera_release_recording_frame;  
69.             camera_ops->auto_focus = camera_auto_focus;  
70.             camera_ops->cancel_auto_focus = camera_cancel_auto_focus;  
71.             camera_ops->take_picture = camera_take_picture;  
72.             camera_ops->cancel_picture = camera_cancel_picture;  
73.             camera_ops->set_parameters = camera_set_parameters;  
74.             camera_ops->get_parameters = camera_get_parameters;  
75.             camera_ops->put_parameters = camera_put_parameters;  
76.             camera_ops->send_command = camera_send_command;  
77.             camera_ops->release = camera_release;  
78.             camera_ops->dump = camera_dump;  
79.             *device = &camera_device->device.common;  
80.             camera_device->cameraId = cameraid;  
81.             camera = new android::CameraHardware(cameraid);  
82.             if(!camera)  
83.             {  
84.                 LOGE("Couldn't create instance of CameraHardware class!");  
85.                 rv = -ENOMEM;  
86.                 goto fail;  
87.             }  
88.             gCameraHals[cameraid] = camera;  
89.             gCamerasOpen++;  
90.         }  
91.         return rv;  
92.     fail:  
93.         if(camera_device) {  
94.             free(camera_device);  
95.             camera_device = NULL;  
96.         }  
97.         if(camera_ops) {  
98.             free(camera_ops);  
99.             camera_ops = NULL;  
100.         }  
101.         if(camera) {  
102.             delete camera;  
103.             camera = NULL;  
104.         }  
105.         *device = NULL;  
106.         return rv;  
107.     }  

static struct hw_module_methods_t camera_module_methods = {
        open: HAL_OpenCameraHardware   // 也就是这个函数
    };

open: HAL_OpenCameraHardware，

    int HAL_OpenCameraHardware(const hw_module_t* module, const char* name,
                    hw_device_t** device)
    {
        int rv = 0;
        int num_cameras = 0;
        int cameraid;
        intel_camera_device_t* camera_device = NULL;
        camera_device_ops_t* camera_ops = NULL;
        android::CameraHardware* camera = NULL;
        android::Mutex::Autolock lock(gCameraHalDeviceLock);
        LOGI("camera_device open");
        if (name != NULL) {
            cameraid = atoi(name);
            num_cameras = android::CameraHardware::getNumberOfCameras();
            if(cameraid > num_cameras)
            {
                LOGE("camera service provided cameraid out of bounds, "
                        "cameraid = %d, num supported = %d",
                        cameraid, num_cameras);
                rv = -EINVAL;
                goto fail;
            }
            if(gCamerasOpen >= MAX_CAMERAS)
            {
                LOGE("maximum number of cameras already open");
                rv = -ENOMEM;
                goto fail;
            }
            camera_device = (intel_camera_device_t*)malloc(sizeof(*camera_device));
            if(!camera_device)
            {
                LOGE("camera_device allocation fail");
                rv = -ENOMEM;
                goto fail;
            }
            camera_ops = (camera_device_ops_t*)malloc(sizeof(*camera_ops));
            if(!camera_ops)
            {
                LOGE("camera_ops allocation fail");
                rv = -ENOMEM;
                goto fail;
            }
            memset(camera_device, 0, sizeof(*camera_device));
            memset(camera_ops, 0, sizeof(*camera_ops));
            camera_device->device.common.tag = HARDWARE_DEVICE_TAG;
            camera_device->device.common.version = 0;
            camera_device->device.common.module = (hw_module_t *)(module);
            camera_device->device.common.close = HAL_CloseCameraHardware;
            camera_device->device.ops = camera_ops;
            camera_ops->set_preview_window = camera_set_preview_window;
            camera_ops->set_callbacks = camera_set_callbacks;
            camera_ops->enable_msg_type = camera_enable_msg_type;
            camera_ops->disable_msg_type = camera_disable_msg_type;
            camera_ops->msg_type_enabled = camera_msg_type_enabled;
            camera_ops->start_preview = camera_start_preview;
            camera_ops->stop_preview = camera_stop_preview;
            camera_ops->preview_enabled = camera_preview_enabled;
            camera_ops->store_meta_data_in_buffers = camera_store_meta_data_in_buffers;
            camera_ops->start_recording = camera_start_recording;
            camera_ops->stop_recording = camera_stop_recording;
            camera_ops->recording_enabled = camera_recording_enabled;
            camera_ops->release_recording_frame = camera_release_recording_frame;
            camera_ops->auto_focus = camera_auto_focus;
            camera_ops->cancel_auto_focus = camera_cancel_auto_focus;
            camera_ops->take_picture = camera_take_picture;
            camera_ops->cancel_picture = camera_cancel_picture;
            camera_ops->set_parameters = camera_set_parameters;
            camera_ops->get_parameters = camera_get_parameters;
            camera_ops->put_parameters = camera_put_parameters;
            camera_ops->send_command = camera_send_command;
            camera_ops->release = camera_release;
            camera_ops->dump = camera_dump;
            *device = &camera_device->device.common;
            camera_device->cameraId = cameraid;
            camera = new android::CameraHardware(cameraid);
            if(!camera)
            {
                LOGE("Couldn't create instance of CameraHardware class!");
                rv = -ENOMEM;
                goto fail;
            }
            gCameraHals[cameraid] = camera;
            gCamerasOpen++;
        }
        return rv;
    fail:
        if(camera_device) {
            free(camera_device);
            camera_device = NULL;
        }
        if(camera_ops) {
            free(camera_ops);
            camera_ops = NULL;
        }
        if(camera) {
            delete camera;
            camera = NULL;
        }
        *device = NULL;
        return rv;
    }

这个函数里 封装了一系列 camera interface。 但是cameraservice 并没有用到这些接口，还是老的调用方式，直接调用了 camerahardware， 而没经过这里的接口。
只有 HAL_GetCameraInfo 和 HAL_GetNumberOfCameras 通过这些接口来调用。