You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
295 lines
9.1 KiB
295 lines
9.1 KiB
/*
|
|
* 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
|