| /* |
| * 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 <cutils/properties.h> |
| |
| #include <ui/GraphicBufferMapper.h> |
| #include <utils/RefBase.h> |
| #include <vector> |
| |
| 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<QemuCameraInfo> *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<QemuCameraInfo> &qemuCameras); |
| |
| std::unique_ptr<EmulatedBaseCamera> 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<EmulatedBaseCamera> 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<std::unique_ptr<EmulatedBaseCamera>> 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<EmulatedCameraHotplugThread> 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 |