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 "EmulatedBaseCamera.h" 21 #include "QemuClient.h" 22 23 #include <cutils/properties.h> 24 25 #include <ui/GraphicBufferMapper.h> 26 #include <utils/RefBase.h> 27 #include <vector> 28 29 namespace android { 30 31 class EmulatedCameraHotplugThread; 32 33 /* 34 * Contains declaration of a class EmulatedCameraFactory that manages cameras 35 * available for the emulation. A global instance of this class is statically 36 * instantiated and initialized when camera emulation HAL is loaded. 37 */ 38 39 /* 40 * Class EmulatedCameraFactoryManages cameras available for the emulation. 41 * 42 * When the global static instance of this class is created on the module load, 43 * it enumerates cameras available for the emulation by connecting to the 44 * emulator's 'camera' service. For every camera found out there it creates an 45 * instance of an appropriate class, and stores it an in array of emulated 46 * cameras. In addition to the cameras reported by the emulator, a fake camera 47 * emulator is always created, so there is always at least one camera that is 48 * available. 49 * 50 * Instance of this class is also used as the entry point for the camera HAL API, 51 * including: 52 * - hw_module_methods_t::open entry point 53 * - camera_module_t::get_number_of_cameras entry point 54 * - camera_module_t::get_camera_info entry point 55 * 56 */ 57 class EmulatedCameraFactory { 58 public: 59 /* 60 * Constructs EmulatedCameraFactory instance. 61 * In this constructor the factory will create and initialize a list of 62 * emulated cameras. All errors that occur on this constructor are reported 63 * via mConstructedOK data member of this class. 64 */ 65 EmulatedCameraFactory(); 66 67 /* 68 * Destructs EmulatedCameraFactory instance. 69 */ 70 ~EmulatedCameraFactory(); 71 72 public: 73 /**************************************************************************** 74 * Camera HAL API handlers. 75 ***************************************************************************/ 76 77 /* 78 * Opens (connects to) a camera device. 79 * 80 * This method is called in response to hw_module_methods_t::open callback. 81 */ 82 int cameraDeviceOpen(int camera_id, hw_device_t **device); 83 84 /* 85 * Gets emulated camera information. 86 * 87 * This method is called in response to camera_module_t::get_camera_info 88 * callback. 89 */ 90 int getCameraInfo(int camera_id, struct camera_info *info); 91 92 /* 93 * Sets emulated camera callbacks. 94 * 95 * This method is called in response to camera_module_t::set_callbacks 96 * callback. 97 */ 98 int setCallbacks(const camera_module_callbacks_t *callbacks); 99 100 /* 101 * Fill in vendor tags for the module. 102 * 103 * This method is called in response to camera_module_t::get_vendor_tag_ops 104 * callback. 105 */ 106 void getVendorTagOps(vendor_tag_ops_t *ops); 107 108 public: 109 /**************************************************************************** 110 * Camera HAL API callbacks. 111 ***************************************************************************/ 112 113 /* 114 * camera_module_t::get_number_of_cameras callback entry point. 115 */ 116 static int get_number_of_cameras(void); 117 118 /* 119 * camera_module_t::get_camera_info callback entry point. 120 */ 121 static int get_camera_info(int camera_id, struct camera_info *info); 122 123 /* 124 * camera_module_t::set_callbacks callback entry point. 125 */ 126 static int set_callbacks(const camera_module_callbacks_t *callbacks); 127 128 /* 129 * camera_module_t::get_vendor_tag_ops callback entry point. 130 */ 131 static void get_vendor_tag_ops(vendor_tag_ops_t *ops); 132 133 /* 134 * camera_module_t::open_legacy callback entry point. 135 */ 136 static int open_legacy(const struct hw_module_t *module, const char *id, 137 uint32_t halVersion, struct hw_device_t **device); 138 139 private: 140 /* 141 * hw_module_methods_t::open callback entry point. 142 */ 143 static int device_open(const hw_module_t *module, const char *name, 144 hw_device_t **device); 145 146 public: 147 /**************************************************************************** 148 * Public API. 149 ***************************************************************************/ 150 151 /* 152 * Gets fake camera orientation. 153 */ getFakeCameraOrientation()154 int getFakeCameraOrientation() { 155 const char *key = "qemu.camera.fake.orientation"; 156 int degree = property_get_int32(key, 90); 157 return degree; 158 } 159 160 /* 161 * Gets qemu camera orientation. 162 */ getQemuCameraOrientation()163 int getQemuCameraOrientation() { 164 const char *key = "qemu.camera.webcam.orientation"; 165 int degree = property_get_int32(key, 90); 166 return degree; 167 } 168 169 /* 170 * Gets number of emulated cameras. 171 */ getEmulatedCameraNum()172 int getEmulatedCameraNum() const { 173 return mEmulatedCameras.size(); 174 } 175 176 /* 177 * Checks whether or not the constructor has succeeded. 178 */ isConstructedOK()179 bool isConstructedOK() const { 180 return mConstructedOK; 181 } 182 183 void onStatusChanged(int cameraId, int newStatus); 184 185 private: 186 /**************************************************************************** 187 * Private API 188 ***************************************************************************/ 189 190 // For carrying QEMU camera information between methods. 191 struct QemuCameraInfo { 192 char *name; 193 char *frameDims; 194 char *dir; 195 }; 196 197 /* 198 * Args: 199 * token: token whose value is being searched for. 200 * s: string containing one or more tokens in the format 201 * "token_name=token_value". 202 * value: Output parameter for the value of the token. 203 * 204 * Returns: 205 * true if the token was successfully parsed. 206 */ 207 bool getTokenValue(const char *token, const std::string &s, char **value); 208 209 /* 210 * Args: 211 * qemuCameras: Output parameter for the list of detected camera 212 * strings. Each camera is represented by a string of three 213 * attributes "name=... framedims=... dir=...", not 214 * necessarily in that order. 215 */ 216 void findQemuCameras(std::vector<QemuCameraInfo> *qemuCameras); 217 218 /* 219 * Populates emulated cameras array with cameras that are available via 220 * 'camera' service in the emulator. For each such camera, one of the 221 * EmulatedQemuCamera* classes will be created and added to 222 * mEmulatedCameras (based on the HAL version specified in system 223 * properties). 224 */ 225 void createQemuCameras(const std::vector<QemuCameraInfo> &qemuCameras); 226 227 std::unique_ptr<EmulatedBaseCamera> createQemuCameraImpl( 228 int halVersion, 229 const QemuCameraInfo& cameraInfo, 230 int cameraId, 231 struct hw_module_t* module); 232 233 /* 234 * Creates a fake camera and adds it to mEmulatedCameras. If backCamera is 235 * true, it will be created as if it were a camera on the back of the phone. 236 * Otherwise, it will be front-facing. 237 */ 238 void createFakeCamera(bool backCamera); 239 240 std::unique_ptr<EmulatedBaseCamera> createFakeCameraImpl( 241 bool backCamera, 242 int halVersion, 243 int cameraId, 244 struct hw_module_t* module); 245 246 /* 247 * Waits till qemu-props has done setup, timeout after 500ms. 248 */ 249 void waitForQemuSfFakeCameraPropertyAvailable(); 250 251 /* 252 * Checks if fake camera emulation is on for the camera facing back. 253 */ 254 bool isFakeCameraEmulationOn(bool backCamera); 255 256 /* 257 * Gets camera device version number to use for back camera emulation. 258 */ 259 int getCameraHalVersion(bool backCamera); 260 261 262 private: 263 /**************************************************************************** 264 * Data members. 265 ***************************************************************************/ 266 267 // Connection to the camera service in the emulator. 268 FactoryQemuClient mQemuClient; 269 270 // Array of cameras available for the emulation. 271 std::vector<std::unique_ptr<EmulatedBaseCamera>> mEmulatedCameras; 272 273 // Flags whether or not constructor has succeeded. 274 bool mConstructedOK; 275 276 GraphicBufferMapper *mGBM; 277 278 // Camera callbacks (for status changing). 279 const camera_module_callbacks_t *mCallbacks; 280 281 // Hotplug thread (to call onStatusChanged). 282 sp<EmulatedCameraHotplugThread> mHotplugThread; 283 284 public: 285 // Contains device open entry point, as required by HAL API. 286 static struct hw_module_methods_t mCameraModuleMethods; 287 }; 288 289 }; // end of namespace android 290 291 // References the global EmulatedCameraFactory instance. 292 extern android::EmulatedCameraFactory gEmulatedCameraFactory; 293 294 #endif // HW_EMULATOR_CAMERA_EMULATED_CAMERA_FACTORY_H 295