/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_CAMERA_FACTORY_H #define HW_EMULATOR_CAMERA_EMULATED_CAMERA_FACTORY_H #include "EmulatedBaseCamera.h" #include "QemuClient.h" #include #include #include #include namespace android { class EmulatedCameraHotplugThread; /* * Contains declaration of a class EmulatedCameraFactory that manages cameras * available for the emulation. A global instance of this class is statically * instantiated and initialized when camera emulation HAL is loaded. */ /* * Class EmulatedCameraFactoryManages cameras available for the emulation. * * When the global static instance of this class is created on the module load, * it enumerates cameras available for the emulation by connecting to the * emulator's 'camera' service. For every camera found out there it creates an * instance of an appropriate class, and stores it an in array of emulated * cameras. In addition to the cameras reported by the emulator, a fake camera * emulator is always created, so there is always at least one camera that is * available. * * Instance of this class is also used as the entry point for the camera HAL API, * including: * - hw_module_methods_t::open entry point * - camera_module_t::get_number_of_cameras entry point * - camera_module_t::get_camera_info entry point * */ class EmulatedCameraFactory { public: /* * Constructs EmulatedCameraFactory instance. * In this constructor the factory will create and initialize a list of * emulated cameras. All errors that occur on this constructor are reported * via mConstructedOK data member of this class. */ EmulatedCameraFactory(); /* * Destructs EmulatedCameraFactory instance. */ ~EmulatedCameraFactory(); public: /**************************************************************************** * Camera HAL API handlers. ***************************************************************************/ /* * Opens (connects to) a camera device. * * This method is called in response to hw_module_methods_t::open callback. */ int cameraDeviceOpen(int camera_id, hw_device_t **device); /* * Gets emulated camera information. * * This method is called in response to camera_module_t::get_camera_info * callback. */ int getCameraInfo(int camera_id, struct camera_info *info); /* * Sets emulated camera callbacks. * * This method is called in response to camera_module_t::set_callbacks * callback. */ int setCallbacks(const camera_module_callbacks_t *callbacks); /* * Fill in vendor tags for the module. * * This method is called in response to camera_module_t::get_vendor_tag_ops * callback. */ void getVendorTagOps(vendor_tag_ops_t *ops); public: /**************************************************************************** * Camera HAL API callbacks. ***************************************************************************/ /* * camera_module_t::get_number_of_cameras callback entry point. */ static int get_number_of_cameras(void); /* * camera_module_t::get_camera_info callback entry point. */ static int get_camera_info(int camera_id, struct camera_info *info); /* * camera_module_t::set_callbacks callback entry point. */ static int set_callbacks(const camera_module_callbacks_t *callbacks); /* * camera_module_t::get_vendor_tag_ops callback entry point. */ static void get_vendor_tag_ops(vendor_tag_ops_t *ops); /* * camera_module_t::open_legacy callback entry point. */ static int open_legacy(const struct hw_module_t *module, const char *id, uint32_t halVersion, struct hw_device_t **device); private: /* * hw_module_methods_t::open callback entry point. */ static int device_open(const hw_module_t *module, const char *name, hw_device_t **device); public: /**************************************************************************** * Public API. ***************************************************************************/ /* * Gets fake camera orientation. */ int getFakeCameraOrientation() { const char *key = "qemu.camera.fake.orientation"; int degree = property_get_int32(key, 90); return degree; } /* * Gets qemu camera orientation. */ int getQemuCameraOrientation() { const char *key = "qemu.camera.webcam.orientation"; int degree = property_get_int32(key, 90); return degree; } /* * Gets number of emulated cameras. */ int getEmulatedCameraNum() const { return mEmulatedCameras.size(); } /* * Checks whether or not the constructor has succeeded. */ bool isConstructedOK() const { return mConstructedOK; } void onStatusChanged(int cameraId, int newStatus); private: /**************************************************************************** * Private API ***************************************************************************/ // For carrying QEMU camera information between methods. struct QemuCameraInfo { char *name; char *frameDims; char *dir; }; /* * Args: * token: token whose value is being searched for. * s: string containing one or more tokens in the format * "token_name=token_value". * value: Output parameter for the value of the token. * * Returns: * true if the token was successfully parsed. */ bool getTokenValue(const char *token, const std::string &s, char **value); /* * Args: * qemuCameras: Output parameter for the list of detected camera * strings. Each camera is represented by a string of three * attributes "name=... framedims=... dir=...", not * necessarily in that order. */ void findQemuCameras(std::vector *qemuCameras); /* * Populates emulated cameras array with cameras that are available via * 'camera' service in the emulator. For each such camera, one of the * EmulatedQemuCamera* classes will be created and added to * mEmulatedCameras (based on the HAL version specified in system * properties). */ void createQemuCameras(const std::vector &qemuCameras); std::unique_ptr createQemuCameraImpl( int halVersion, const QemuCameraInfo& cameraInfo, int cameraId, struct hw_module_t* module); /* * Creates a fake camera and adds it to mEmulatedCameras. If backCamera is * true, it will be created as if it were a camera on the back of the phone. * Otherwise, it will be front-facing. */ void createFakeCamera(bool backCamera); std::unique_ptr createFakeCameraImpl( bool backCamera, int halVersion, int cameraId, struct hw_module_t* module); /* * Waits till qemu-props has done setup, timeout after 500ms. */ void waitForQemuSfFakeCameraPropertyAvailable(); /* * Checks if fake camera emulation is on for the camera facing back. */ bool isFakeCameraEmulationOn(bool backCamera); /* * Gets camera device version number to use for back camera emulation. */ int getCameraHalVersion(bool backCamera); private: /**************************************************************************** * Data members. ***************************************************************************/ // Connection to the camera service in the emulator. FactoryQemuClient mQemuClient; // Array of cameras available for the emulation. std::vector> mEmulatedCameras; // Flags whether or not constructor has succeeded. bool mConstructedOK; GraphicBufferMapper *mGBM; // Camera callbacks (for status changing). const camera_module_callbacks_t *mCallbacks; // Hotplug thread (to call onStatusChanged). sp mHotplugThread; public: // Contains device open entry point, as required by HAL API. static struct hw_module_methods_t mCameraModuleMethods; }; }; // end of namespace android // References the global EmulatedCameraFactory instance. extern android::EmulatedCameraFactory gEmulatedCameraFactory; #endif // HW_EMULATOR_CAMERA_EMULATED_CAMERA_FACTORY_H