1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16//#define LOG_NDEBUG 0
17#define LOG_TAG "DefaultCameraHAL"
18
19#include <cstdlib>
20
21#include <log/log.h>
22#define ATRACE_TAG (ATRACE_TAG_CAMERA | ATRACE_TAG_HAL)
23#include <cutils/trace.h>
24
25#include <hardware/camera_common.h>
26#include <hardware/hardware.h>
27#include "ExampleCamera.h"
28#include "VendorTags.h"
29
30#include "CameraHAL.h"
31
32/*
33 * This file serves as the entry point to the HAL.  It contains the module
34 * structure and functions used by the framework to load and interface to this
35 * HAL, as well as the handles to the individual camera devices.
36 */
37
38namespace default_camera_hal {
39
40// Default Camera HAL has 2 cameras, front and rear.
41static CameraHAL gCameraHAL(2);
42// Handle containing vendor tag functionality
43static VendorTags gVendorTags;
44
45CameraHAL::CameraHAL(int num_cameras)
46  : mNumberOfCameras(num_cameras),
47    mCallbacks(NULL)
48{
49    // Allocate camera array and instantiate camera devices
50    mCameras = new Camera*[mNumberOfCameras];
51    // Rear camera
52    mCameras[0] = new ExampleCamera(0);
53    // Front camera
54    mCameras[1] = new ExampleCamera(1);
55}
56
57CameraHAL::~CameraHAL()
58{
59    for (int i = 0; i < mNumberOfCameras; i++) {
60        delete mCameras[i];
61    }
62    delete [] mCameras;
63}
64
65int CameraHAL::getNumberOfCameras()
66{
67    ALOGV("%s: %d", __func__, mNumberOfCameras);
68    return mNumberOfCameras;
69}
70
71int CameraHAL::getCameraInfo(int id, struct camera_info* info)
72{
73    ALOGV("%s: camera id %d: info=%p", __func__, id, info);
74    if (id < 0 || id >= mNumberOfCameras) {
75        ALOGE("%s: Invalid camera id %d", __func__, id);
76        return -ENODEV;
77    }
78    // TODO: return device-specific static metadata
79    return mCameras[id]->getInfo(info);
80}
81
82int CameraHAL::setCallbacks(const camera_module_callbacks_t *callbacks)
83{
84    ALOGV("%s : callbacks=%p", __func__, callbacks);
85    mCallbacks = callbacks;
86    return 0;
87}
88
89int CameraHAL::open(const hw_module_t* mod, const char* name, hw_device_t** dev)
90{
91    int id;
92    char *nameEnd;
93
94    ALOGV("%s: module=%p, name=%s, device=%p", __func__, mod, name, dev);
95    if (*name == '\0') {
96        ALOGE("%s: Invalid camera id name is NULL", __func__);
97        return -EINVAL;
98    }
99    id = strtol(name, &nameEnd, 10);
100    if (*nameEnd != '\0') {
101        ALOGE("%s: Invalid camera id name %s", __func__, name);
102        return -EINVAL;
103    } else if (id < 0 || id >= mNumberOfCameras) {
104        ALOGE("%s: Invalid camera id %d", __func__, id);
105        return -ENODEV;
106    }
107    return mCameras[id]->open(mod, dev);
108}
109
110extern "C" {
111
112static int get_number_of_cameras()
113{
114    return gCameraHAL.getNumberOfCameras();
115}
116
117static int get_camera_info(int id, struct camera_info* info)
118{
119    return gCameraHAL.getCameraInfo(id, info);
120}
121
122static int set_callbacks(const camera_module_callbacks_t *callbacks)
123{
124    return gCameraHAL.setCallbacks(callbacks);
125}
126
127static int get_tag_count(const vendor_tag_ops_t* ops)
128{
129    return gVendorTags.getTagCount(ops);
130}
131
132static void get_all_tags(const vendor_tag_ops_t* ops, uint32_t* tag_array)
133{
134    gVendorTags.getAllTags(ops, tag_array);
135}
136
137static const char* get_section_name(const vendor_tag_ops_t* ops, uint32_t tag)
138{
139    return gVendorTags.getSectionName(ops, tag);
140}
141
142static const char* get_tag_name(const vendor_tag_ops_t* ops, uint32_t tag)
143{
144    return gVendorTags.getTagName(ops, tag);
145}
146
147static int get_tag_type(const vendor_tag_ops_t* ops, uint32_t tag)
148{
149    return gVendorTags.getTagType(ops, tag);
150}
151
152static void get_vendor_tag_ops(vendor_tag_ops_t* ops)
153{
154    ALOGV("%s : ops=%p", __func__, ops);
155    ops->get_tag_count      = get_tag_count;
156    ops->get_all_tags       = get_all_tags;
157    ops->get_section_name   = get_section_name;
158    ops->get_tag_name       = get_tag_name;
159    ops->get_tag_type       = get_tag_type;
160}
161
162static int open_dev(const hw_module_t* mod, const char* name, hw_device_t** dev)
163{
164    return gCameraHAL.open(mod, name, dev);
165}
166
167static hw_module_methods_t gCameraModuleMethods = {
168    .open = open_dev
169};
170
171camera_module_t HAL_MODULE_INFO_SYM __attribute__ ((visibility("default"))) = {
172    .common = {
173        .tag                = HARDWARE_MODULE_TAG,
174        .module_api_version = CAMERA_MODULE_API_VERSION_2_2,
175        .hal_api_version    = HARDWARE_HAL_API_VERSION,
176        .id                 = CAMERA_HARDWARE_MODULE_ID,
177        .name               = "Default Camera HAL",
178        .author             = "The Android Open Source Project",
179        .methods            = &gCameraModuleMethods,
180        .dso                = NULL,
181        .reserved           = {0},
182    },
183    .get_number_of_cameras = get_number_of_cameras,
184    .get_camera_info       = get_camera_info,
185    .set_callbacks         = set_callbacks,
186    .get_vendor_tag_ops    = get_vendor_tag_ops,
187    .open_legacy           = NULL,
188    .set_torch_mode        = NULL,
189    .init                  = NULL,
190    .reserved              = {0},
191};
192} // extern "C"
193
194} // namespace default_camera_hal
195