blob: c844c564c8a2e694bf8c4fe376e8c1f57497db20
1 | /* |
2 | * Copyright (C) 2011 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 | |
17 | #ifndef HW_EMULATOR_CAMERA_EMULATED_CAMERA_FACTORY_H |
18 | #define HW_EMULATOR_CAMERA_EMULATED_CAMERA_FACTORY_H |
19 | |
20 | #include <utils/RefBase.h> |
21 | #include "EmulatedBaseCamera.h" |
22 | #include "QemuClient.h" |
23 | |
24 | #include <hardware/hardware.h> |
25 | #include <hardware/camera_common.h> |
26 | #include <system/camera_vendor_tags.h> |
27 | #include "VendorTags.h" |
28 | namespace android { |
29 | |
30 | #ifndef ARRAY_SIZE |
31 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) |
32 | #endif |
33 | |
34 | struct EmulatedCameraHotplugThread; |
35 | |
36 | |
37 | /* |
38 | * Contains declaration of a class EmulatedCameraFactory that manages cameras |
39 | * available for the emulation. A global instance of this class is statically |
40 | * instantiated and initialized when camera emulation HAL is loaded. |
41 | */ |
42 | |
43 | /* Class EmulatedCameraFactoryManages cameras available for the emulation. |
44 | * |
45 | * When the global static instance of this class is created on the module load, |
46 | * it enumerates cameras available for the emulation by connecting to the |
47 | * emulator's 'camera' service. For every camera found out there it creates an |
48 | * instance of an appropriate class, and stores it an in array of emulated |
49 | * cameras. In addition to the cameras reported by the emulator, a fake camera |
50 | * emulator is always created, so there is always at least one camera that is |
51 | * available. |
52 | * |
53 | * Instance of this class is also used as the entry point for the camera HAL API, |
54 | * including: |
55 | * - hw_module_methods_t::open entry point |
56 | * - camera_module_t::get_number_of_cameras entry point |
57 | * - camera_module_t::get_camera_info entry point |
58 | * |
59 | */ |
60 | |
61 | #ifndef MAX_CAMERA_NUM |
62 | #define MAX_CAMERA_NUM 6 |
63 | #endif |
64 | class EmulatedCameraFactory { |
65 | public: |
66 | /* Constructs EmulatedCameraFactory instance. |
67 | * In this constructor the factory will create and initialize a list of |
68 | * emulated cameras. All errors that occur on this constructor are reported |
69 | * via mConstructedOK data member of this class. |
70 | */ |
71 | EmulatedCameraFactory(); |
72 | |
73 | /* Destructs EmulatedCameraFactory instance. */ |
74 | ~EmulatedCameraFactory(); |
75 | |
76 | /**************************************************************************** |
77 | * Camera HAL API handlers. |
78 | ***************************************************************************/ |
79 | |
80 | public: |
81 | EmulatedBaseCamera* getValidCameraOject(void); |
82 | |
83 | int getValidCameraOjectId(void); |
84 | /* Opens (connects to) a camera device. |
85 | * This method is called in response to hw_module_methods_t::open callback. |
86 | */ |
87 | int cameraDeviceOpen(int camera_id, hw_device_t** device); |
88 | |
89 | /* Gets emulated camera information. |
90 | * This method is called in response to camera_module_t::get_camera_info callback. |
91 | */ |
92 | int getCameraInfo(int camera_id, struct camera_info *info); |
93 | |
94 | /* Sets emulated camera callbacks. |
95 | * This method is called in response to camera_module_t::set_callbacks callback. |
96 | */ |
97 | int setCallbacks(const camera_module_callbacks_t *callbacks); |
98 | |
99 | /* Sets emulated camera vendor tag. |
100 | * This method is called in response to camera_module_t::get_vendor_tag_ops callback. |
101 | */ |
102 | void getvendortagops(vendor_tag_ops_t* ops); |
103 | /**************************************************************************** |
104 | * Camera HAL API callbacks. |
105 | ***************************************************************************/ |
106 | |
107 | public: |
108 | /* camera_module_t::get_number_of_cameras callback entry point. */ |
109 | static int get_number_of_cameras(void); |
110 | |
111 | /* camera_module_t::get_camera_info callback entry point. */ |
112 | static int get_camera_info(int camera_id, struct camera_info *info); |
113 | |
114 | /* camera_module_t::set_callbacks callback entry point. */ |
115 | static int set_callbacks(const camera_module_callbacks_t *callbacks); |
116 | /* camera_module_t::get_vendor_tag_ops callback entry point. */ |
117 | static void get_vendor_tag_ops(vendor_tag_ops_t* ops); |
118 | |
119 | private: |
120 | /* hw_module_methods_t::open callback entry point. */ |
121 | static int device_open(const hw_module_t* module, |
122 | const char* name, |
123 | hw_device_t** device); |
124 | |
125 | /**************************************************************************** |
126 | * Public API. |
127 | ***************************************************************************/ |
128 | |
129 | public: |
130 | |
131 | /* Gets fake camera orientation. */ |
132 | int getFakeCameraOrientation() { |
133 | /* TODO: Have a boot property that controls that. */ |
134 | return 90; |
135 | } |
136 | |
137 | /* Gets qemu camera orientation. */ |
138 | int getQemuCameraOrientation() { |
139 | /* TODO: Have a boot property that controls that. */ |
140 | return 270; |
141 | } |
142 | |
143 | /* Gets number of emulated cameras. |
144 | */ |
145 | int getEmulatedCameraNum() const { |
146 | return mEmulatedCameraNum; |
147 | } |
148 | |
149 | /* Checks whether or not the constructor has succeeded. |
150 | */ |
151 | bool isConstructedOK() const { |
152 | return mConstructedOK; |
153 | } |
154 | |
155 | void onStatusChanged(int cameraId, int newStatus); |
156 | |
157 | int getValidCameraId(void); |
158 | |
159 | /**************************************************************************** |
160 | * Private API |
161 | ***************************************************************************/ |
162 | |
163 | private: |
164 | /* Populates emulated cameras array with cameras that are available via |
165 | * 'camera' service in the emulator. For each such camera and instance of |
166 | * the EmulatedCameraQemud will be created and added to the mEmulatedCameras |
167 | * array. |
168 | */ |
169 | void createQemuCameras(); |
170 | |
171 | /* Checks if fake camera emulation is on for the camera facing front. */ |
172 | bool isFakeCameraFacingBack(int cameraId); |
173 | |
174 | /* Gets camera device version number to use for front camera emulation */ |
175 | int getFakeCameraHalVersion(int cameraId); |
176 | |
177 | /**************************************************************************** |
178 | * Data members. |
179 | ***************************************************************************/ |
180 | |
181 | private: |
182 | /* Connection to the camera service in the emulator. */ |
183 | FactoryQemuClient mQemuClient; |
184 | |
185 | /* Array of cameras available for the emulation. */ |
186 | EmulatedBaseCamera* mEmulatedCameras[MAX_CAMERA_NUM]; |
187 | |
188 | /* Number of emulated cameras (including the fake ones). */ |
189 | int mEmulatedCameraNum; |
190 | |
191 | /* Number of emulated fake cameras. */ |
192 | int mFakeCameraNum; |
193 | |
194 | /* Flags whether or not constructor has succeeded. */ |
195 | bool mConstructedOK; |
196 | |
197 | /* Camera callbacks (for status changing) */ |
198 | const camera_module_callbacks_t* mCallbacks; |
199 | |
200 | /* Hotplug thread (to call onStatusChanged) */ |
201 | sp<EmulatedCameraHotplugThread> mHotplugThread; |
202 | |
203 | public: |
204 | /* Contains device open entry point, as required by HAL API. */ |
205 | static struct hw_module_methods_t mCameraModuleMethods; |
206 | }; |
207 | |
208 | }; /* namespace android */ |
209 | |
210 | /* References the global EmulatedCameraFactory instance. */ |
211 | extern android::EmulatedCameraFactory gEmulatedCameraFactory; |
212 | |
213 | #endif /* HW_EMULATOR_CAMERA_EMULATED_CAMERA_FACTORY_H */ |
214 |