3844 lines
138 KiB
C++
3844 lines
138 KiB
C++
|
/* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
|
||
|
|
*
|
||
|
|
* Redistribution and use in source and binary forms, with or without
|
||
|
|
* modification, are permitted provided that the following conditions are
|
||
|
|
* met:
|
||
|
|
* * Redistributions of source code must retain the above copyright
|
||
|
|
* notice, this list of conditions and the following disclaimer.
|
||
|
|
* * Redistributions in binary form must reproduce the above
|
||
|
|
* copyright notice, this list of conditions and the following
|
||
|
|
* disclaimer in the documentation and/or other materials provided
|
||
|
|
* with the distribution.
|
||
|
|
* * Neither the name of The Linux Foundation nor the names of its
|
||
|
|
* contributors may be used to endorse or promote products derived
|
||
|
|
* from this software without specific prior written permission.
|
||
|
|
*
|
||
|
|
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
||
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
||
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
||
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
||
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
||
|
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
||
|
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
#define LOG_TAG "QCameraStateMachine"
|
||
|
|
|
||
|
|
// System dependencies
|
||
|
|
#include <utils/Errors.h>
|
||
|
|
#include <stdio.h>
|
||
|
|
|
||
|
|
// Camera dependencies
|
||
|
|
#include "QCamera2HWI.h"
|
||
|
|
#include "QCameraStateMachine.h"
|
||
|
|
|
||
|
|
extern "C" {
|
||
|
|
#include "mm_camera_dbg.h"
|
||
|
|
}
|
||
|
|
|
||
|
|
namespace qcamera {
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : smEvtProcRoutine
|
||
|
|
*
|
||
|
|
* DESCRIPTION: Statemachine process thread routine to handle events
|
||
|
|
* in different state.
|
||
|
|
*
|
||
|
|
* PARAMETERS :
|
||
|
|
* @data : ptr to QCameraStateMachine object
|
||
|
|
*
|
||
|
|
* RETURN : none
|
||
|
|
*==========================================================================*/
|
||
|
|
void *QCameraStateMachine::smEvtProcRoutine(void *data)
|
||
|
|
{
|
||
|
|
int running = 1, ret;
|
||
|
|
QCameraStateMachine *pme = (QCameraStateMachine *)data;
|
||
|
|
|
||
|
|
LOGH("E");
|
||
|
|
do {
|
||
|
|
do {
|
||
|
|
ret = cam_sem_wait(&pme->cmd_sem);
|
||
|
|
if (ret != 0 && errno != EINVAL) {
|
||
|
|
LOGE("cam_sem_wait error (%s)",
|
||
|
|
strerror(errno));
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
} while (ret != 0);
|
||
|
|
|
||
|
|
// we got notified about new cmd avail in cmd queue
|
||
|
|
// first check API cmd queue
|
||
|
|
qcamera_sm_cmd_t *node = (qcamera_sm_cmd_t *)pme->api_queue.dequeue();
|
||
|
|
if (node == NULL) {
|
||
|
|
// no API cmd, then check evt cmd queue
|
||
|
|
node = (qcamera_sm_cmd_t *)pme->evt_queue.dequeue();
|
||
|
|
}
|
||
|
|
if (node != NULL) {
|
||
|
|
switch (node->cmd) {
|
||
|
|
case QCAMERA_SM_CMD_TYPE_API:
|
||
|
|
pme->stateMachine(node->evt, node->evt_payload);
|
||
|
|
// API is in a way sync call, so evt_payload is managed by HWI
|
||
|
|
// no need to free payload for API
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_CMD_TYPE_EVT:
|
||
|
|
pme->stateMachine(node->evt, node->evt_payload);
|
||
|
|
|
||
|
|
// EVT is async call, so payload need to be free after use
|
||
|
|
free(node->evt_payload);
|
||
|
|
node->evt_payload = NULL;
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_CMD_TYPE_EXIT:
|
||
|
|
running = 0;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
free(node);
|
||
|
|
node = NULL;
|
||
|
|
}
|
||
|
|
} while (running);
|
||
|
|
LOGH("X");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : QCameraStateMachine
|
||
|
|
*
|
||
|
|
* DESCRIPTION: constructor of QCameraStateMachine. Will start process thread
|
||
|
|
*
|
||
|
|
* PARAMETERS :
|
||
|
|
* @ctrl : ptr to HWI object
|
||
|
|
*
|
||
|
|
* RETURN : none
|
||
|
|
*==========================================================================*/
|
||
|
|
QCameraStateMachine::QCameraStateMachine(QCamera2HardwareInterface *ctrl) :
|
||
|
|
api_queue(),
|
||
|
|
evt_queue()
|
||
|
|
{
|
||
|
|
m_parent = ctrl;
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
cmd_pid = 0;
|
||
|
|
cam_sem_init(&cmd_sem, 0);
|
||
|
|
pthread_create(&cmd_pid,
|
||
|
|
NULL,
|
||
|
|
smEvtProcRoutine,
|
||
|
|
this);
|
||
|
|
pthread_setname_np(cmd_pid, "CAM_stMachine");
|
||
|
|
m_bDelayPreviewMsgs = false;
|
||
|
|
m_DelayedMsgs = 0;
|
||
|
|
m_RestoreZSL = TRUE;
|
||
|
|
|
||
|
|
m_bDisplayFrame = TRUE;
|
||
|
|
m_bPreviewCallbackNeeded = TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : ~QCameraStateMachine
|
||
|
|
*
|
||
|
|
* DESCRIPTION: desctructor of QCameraStateMachine. Will stop process thread.
|
||
|
|
*
|
||
|
|
* PARAMETERS : none
|
||
|
|
*
|
||
|
|
* RETURN : none
|
||
|
|
*==========================================================================*/
|
||
|
|
QCameraStateMachine::~QCameraStateMachine()
|
||
|
|
{
|
||
|
|
cam_sem_destroy(&cmd_sem);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : releaseThread
|
||
|
|
*
|
||
|
|
* DESCRIPTION: Sends an exit command and terminates the state machine thread
|
||
|
|
*
|
||
|
|
* PARAMETERS : none
|
||
|
|
*
|
||
|
|
* RETURN : none
|
||
|
|
*==========================================================================*/
|
||
|
|
void QCameraStateMachine::releaseThread()
|
||
|
|
{
|
||
|
|
if (cmd_pid != 0) {
|
||
|
|
qcamera_sm_cmd_t *node =
|
||
|
|
(qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t));
|
||
|
|
if (NULL != node) {
|
||
|
|
memset(node, 0, sizeof(qcamera_sm_cmd_t));
|
||
|
|
node->cmd = QCAMERA_SM_CMD_TYPE_EXIT;
|
||
|
|
|
||
|
|
if (api_queue.enqueue((void *)node)) {
|
||
|
|
cam_sem_post(&cmd_sem);
|
||
|
|
} else {
|
||
|
|
free(node);
|
||
|
|
node = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* wait until cmd thread exits */
|
||
|
|
if (pthread_join(cmd_pid, NULL) != 0) {
|
||
|
|
LOGW("pthread dead already\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
cmd_pid = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : applyDelayedMsgs
|
||
|
|
*
|
||
|
|
* DESCRIPTION: Enable if needed any delayed message types
|
||
|
|
*
|
||
|
|
* PARAMETERS : None
|
||
|
|
* RETURN : int32_t type of status
|
||
|
|
* NO_ERROR -- success
|
||
|
|
* none-zero failure code
|
||
|
|
*==========================================================================*/
|
||
|
|
int32_t QCameraStateMachine::applyDelayedMsgs()
|
||
|
|
{
|
||
|
|
int32_t rc = NO_ERROR;
|
||
|
|
|
||
|
|
if (m_bDelayPreviewMsgs && m_DelayedMsgs) {
|
||
|
|
rc = m_parent->enableMsgType(m_DelayedMsgs);
|
||
|
|
m_bDelayPreviewMsgs = false;
|
||
|
|
m_DelayedMsgs = 0;
|
||
|
|
} else if (m_bDelayPreviewMsgs) {
|
||
|
|
m_bDelayPreviewMsgs = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : procAPI
|
||
|
|
*
|
||
|
|
* DESCRIPTION: process incoming API request from framework layer.
|
||
|
|
*
|
||
|
|
* PARAMETERS :
|
||
|
|
* @evt : event to be processed
|
||
|
|
* @api_payload : API payload. Can be NULL if not needed.
|
||
|
|
*
|
||
|
|
* RETURN : int32_t type of status
|
||
|
|
* NO_ERROR -- success
|
||
|
|
* none-zero failure code
|
||
|
|
*==========================================================================*/
|
||
|
|
int32_t QCameraStateMachine::procAPI(qcamera_sm_evt_enum_t evt,
|
||
|
|
void *api_payload)
|
||
|
|
{
|
||
|
|
qcamera_sm_cmd_t *node =
|
||
|
|
(qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t));
|
||
|
|
if (NULL == node) {
|
||
|
|
LOGE("No memory for qcamera_sm_cmd_t");
|
||
|
|
return NO_MEMORY;
|
||
|
|
}
|
||
|
|
|
||
|
|
memset(node, 0, sizeof(qcamera_sm_cmd_t));
|
||
|
|
node->cmd = QCAMERA_SM_CMD_TYPE_API;
|
||
|
|
node->evt = evt;
|
||
|
|
node->evt_payload = api_payload;
|
||
|
|
if (api_queue.enqueue((void *)node)) {
|
||
|
|
cam_sem_post(&cmd_sem);
|
||
|
|
return NO_ERROR;
|
||
|
|
} else {
|
||
|
|
LOGE("API enqueue failed API = %d", evt);
|
||
|
|
free(node);
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : procEvt
|
||
|
|
*
|
||
|
|
* DESCRIPTION: process incoming envent from mm-camera-interface and
|
||
|
|
* mm-jpeg-interface.
|
||
|
|
*
|
||
|
|
* PARAMETERS :
|
||
|
|
* @evt : event to be processed
|
||
|
|
* @evt_payload : event payload. Can be NULL if not needed.
|
||
|
|
*
|
||
|
|
* RETURN : int32_t type of status
|
||
|
|
* NO_ERROR -- success
|
||
|
|
* none-zero failure code
|
||
|
|
*==========================================================================*/
|
||
|
|
int32_t QCameraStateMachine::procEvt(qcamera_sm_evt_enum_t evt,
|
||
|
|
void *evt_payload)
|
||
|
|
{
|
||
|
|
qcamera_sm_cmd_t *node =
|
||
|
|
(qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t));
|
||
|
|
if (NULL == node) {
|
||
|
|
LOGE("No memory for qcamera_sm_cmd_t");
|
||
|
|
return NO_MEMORY;
|
||
|
|
}
|
||
|
|
|
||
|
|
memset(node, 0, sizeof(qcamera_sm_cmd_t));
|
||
|
|
node->cmd = QCAMERA_SM_CMD_TYPE_EVT;
|
||
|
|
node->evt = evt;
|
||
|
|
node->evt_payload = evt_payload;
|
||
|
|
if (evt_queue.enqueue((void *)node)) {
|
||
|
|
cam_sem_post(&cmd_sem);
|
||
|
|
return NO_ERROR;
|
||
|
|
} else {
|
||
|
|
LOGE("EVENT enqueue failed Event = %d", evt);
|
||
|
|
free(node);
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : stateMachine
|
||
|
|
*
|
||
|
|
* DESCRIPTION: finite state machine entry function. Depends on state,
|
||
|
|
* incoming event will be handled differently.
|
||
|
|
*
|
||
|
|
* PARAMETERS :
|
||
|
|
* @evt : event to be processed
|
||
|
|
* @payload : event payload. Can be NULL if not needed.
|
||
|
|
*
|
||
|
|
* RETURN : int32_t type of status
|
||
|
|
* NO_ERROR -- success
|
||
|
|
* none-zero failure code
|
||
|
|
*==========================================================================*/
|
||
|
|
int32_t QCameraStateMachine::stateMachine(qcamera_sm_evt_enum_t evt, void *payload)
|
||
|
|
{
|
||
|
|
int32_t rc = NO_ERROR;
|
||
|
|
LOGL("m_state %d, event (%d)", m_state, evt);
|
||
|
|
switch (m_state) {
|
||
|
|
case QCAMERA_SM_STATE_PREVIEW_STOPPED:
|
||
|
|
rc = procEvtPreviewStoppedState(evt, payload);
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_STATE_PREVIEW_READY:
|
||
|
|
rc = procEvtPreviewReadyState(evt, payload);
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_STATE_PREVIEWING:
|
||
|
|
rc = procEvtPreviewingState(evt, payload);
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_STATE_PREPARE_SNAPSHOT:
|
||
|
|
rc = procEvtPrepareSnapshotState(evt, payload);
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_STATE_PIC_TAKING:
|
||
|
|
rc = procEvtPicTakingState(evt, payload);
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_STATE_RECORDING:
|
||
|
|
rc = procEvtRecordingState(evt, payload);
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
|
||
|
|
rc = procEvtVideoPicTakingState(evt, payload);
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
|
||
|
|
rc = procEvtPreviewPicTakingState(evt, payload);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : procEvtPreviewStoppedState
|
||
|
|
*
|
||
|
|
* DESCRIPTION: finite state machine function to handle event in state of
|
||
|
|
* QCAMERA_SM_STATE_PREVIEW_STOPPED.
|
||
|
|
*
|
||
|
|
* PARAMETERS :
|
||
|
|
* @evt : event to be processed
|
||
|
|
* @payload : event payload. Can be NULL if not needed.
|
||
|
|
*
|
||
|
|
* RETURN : int32_t type of status
|
||
|
|
* NO_ERROR -- success
|
||
|
|
* none-zero failure code
|
||
|
|
*==========================================================================*/
|
||
|
|
int32_t QCameraStateMachine::procEvtPreviewStoppedState(qcamera_sm_evt_enum_t evt,
|
||
|
|
void *payload)
|
||
|
|
{
|
||
|
|
int32_t rc = NO_ERROR;
|
||
|
|
qcamera_api_result_t result;
|
||
|
|
memset(&result, 0, sizeof(qcamera_api_result_t));
|
||
|
|
|
||
|
|
LOGL("event (%d)", evt);
|
||
|
|
switch (evt) {
|
||
|
|
case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
|
||
|
|
{
|
||
|
|
rc = m_parent->setPreviewWindow((struct preview_stream_ops *)payload);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_CALLBACKS:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_setcb_payload_t *setcbs =
|
||
|
|
(qcamera_sm_evt_setcb_payload_t *)payload;
|
||
|
|
rc = m_parent->setCallBacks(setcbs->notify_cb,
|
||
|
|
setcbs->data_cb,
|
||
|
|
setcbs->data_cb_timestamp,
|
||
|
|
setcbs->get_memory,
|
||
|
|
setcbs->user);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
rc = m_parent->waitDeferredWork(m_parent->mParamInitJob);
|
||
|
|
if (NO_ERROR != rc) {
|
||
|
|
LOGE("Param init deferred work failed");
|
||
|
|
} else {
|
||
|
|
rc = m_parent->enableMsgType(*((int32_t *)payload));
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
rc = m_parent->waitDeferredWork(m_parent->mParamInitJob);
|
||
|
|
if (NO_ERROR != rc) {
|
||
|
|
LOGE("Param init deferred work failed");
|
||
|
|
} else {
|
||
|
|
rc = m_parent->disableMsgType(*((int32_t *)payload));
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
|
||
|
|
{
|
||
|
|
int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = enabled;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS:
|
||
|
|
{
|
||
|
|
bool needRestart = false;
|
||
|
|
|
||
|
|
rc = m_parent->waitDeferredWork(m_parent->mParamInitJob);
|
||
|
|
if (NO_ERROR != rc) {
|
||
|
|
LOGE("Param init deferred work failed");
|
||
|
|
} else {
|
||
|
|
rc = m_parent->updateParameters((char*)payload, needRestart);
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_STOP:
|
||
|
|
{
|
||
|
|
m_parent->m_memoryPool.clear();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_COMMIT:
|
||
|
|
{
|
||
|
|
rc = m_parent->commitParameterChanges();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_RESTART:
|
||
|
|
{
|
||
|
|
m_parent->setNeedRestart(false);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_GET_PARAMS:
|
||
|
|
{
|
||
|
|
rc = m_parent->waitDeferredWork(m_parent->mParamInitJob);
|
||
|
|
if (NO_ERROR != rc) {
|
||
|
|
LOGE("Param init deferred work failed");
|
||
|
|
char* nullParams = (char *)malloc(1);
|
||
|
|
if (nullParams) {
|
||
|
|
memset(nullParams, 0, 1);
|
||
|
|
}
|
||
|
|
result.params = nullParams;
|
||
|
|
} else {
|
||
|
|
result.params = m_parent->getParameters();
|
||
|
|
}
|
||
|
|
rc = result.params ? NO_ERROR : UNKNOWN_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PUT_PARAMS:
|
||
|
|
{
|
||
|
|
rc = m_parent->putParameters((char*)payload);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_PREVIEW:
|
||
|
|
{
|
||
|
|
rc = m_parent->waitDeferredWork(m_parent->mParamInitJob);
|
||
|
|
if (NO_ERROR != rc) {
|
||
|
|
LOGE("Param init deferred work failed");
|
||
|
|
} else {
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
}
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
//prepare preview success, move to ready state
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_READY;
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_PREVIEW:
|
||
|
|
{
|
||
|
|
rc = m_parent->waitDeferredWork(m_parent->mParamInitJob);
|
||
|
|
if (NO_ERROR != rc) {
|
||
|
|
LOGE("Param init deferred work failed");
|
||
|
|
} else if (m_parent->mPreviewWindow == NULL) {
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
if(rc == NO_ERROR) {
|
||
|
|
// preview window is not set yet, move to previewReady state
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_READY;
|
||
|
|
} else {
|
||
|
|
LOGE("preparePreview failed");
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
applyDelayedMsgs();
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
} else {
|
||
|
|
// start preview success, move to previewing state
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
|
||
|
|
{
|
||
|
|
rc = m_parent->waitDeferredWork(m_parent->mParamInitJob);
|
||
|
|
if (NO_ERROR != rc) {
|
||
|
|
LOGE("Param init deferred work failed");
|
||
|
|
} else {
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
}
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
applyDelayedMsgs();
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
} else {
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_PREVIEW:
|
||
|
|
{
|
||
|
|
// no op needed here
|
||
|
|
LOGW("already in preview stopped state, do nothing");
|
||
|
|
result.status = NO_ERROR;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PREVIEW_ENABLED:
|
||
|
|
case QCAMERA_SM_EVT_RECORDING_ENABLED:
|
||
|
|
{
|
||
|
|
result.status = NO_ERROR;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = 0;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RELEASE:
|
||
|
|
{
|
||
|
|
rc = m_parent->release();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
|
||
|
|
{
|
||
|
|
rc = m_parent->storeMetaDataInBuffers(*((int *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DUMP:
|
||
|
|
{
|
||
|
|
rc = m_parent->waitDeferredWork(m_parent->mParamInitJob);
|
||
|
|
if (NO_ERROR != rc) {
|
||
|
|
LOGE("Param init deferred work failed");
|
||
|
|
} else {
|
||
|
|
rc = m_parent->dump(*((int *)payload));
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SEND_COMMAND:
|
||
|
|
{
|
||
|
|
rc = m_parent->waitDeferredWork(m_parent->mParamInitJob);
|
||
|
|
if (NO_ERROR != rc) {
|
||
|
|
LOGE("Param init deferred work failed");
|
||
|
|
} else {
|
||
|
|
qcamera_sm_evt_command_payload_t *cmd_payload =
|
||
|
|
(qcamera_sm_evt_command_payload_t *)payload;
|
||
|
|
rc = m_parent->sendCommand(cmd_payload->cmd,
|
||
|
|
cmd_payload->arg1,
|
||
|
|
cmd_payload->arg2);
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PRE_START_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_RESTART_START_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_STOP_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
|
||
|
|
case QCAMERA_SM_EVT_PRE_TAKE_PICTURE:
|
||
|
|
case QCAMERA_SM_EVT_TAKE_PICTURE:
|
||
|
|
{
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_AUTO_FOCUS:
|
||
|
|
case QCAMERA_SM_EVT_CANCEL_PICTURE:
|
||
|
|
{
|
||
|
|
// no op needed here
|
||
|
|
LOGW("No ops for evt(%d) in state(%d)", evt, m_state);
|
||
|
|
result.status = NO_ERROR;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
|
||
|
|
{
|
||
|
|
rc = m_parent->waitDeferredWork(m_parent->mParamInitJob);
|
||
|
|
if (NO_ERROR != rc) {
|
||
|
|
LOGE("Param init deferred work failed");
|
||
|
|
} else {
|
||
|
|
rc = m_parent->cancelAutoFocus();
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_REG_FACE_IMAGE:
|
||
|
|
{
|
||
|
|
int32_t faceID = 0;
|
||
|
|
qcamera_sm_evt_reg_face_payload_t *reg_payload =
|
||
|
|
(qcamera_sm_evt_reg_face_payload_t *)payload;
|
||
|
|
rc = m_parent->registerFaceImage(reg_payload->img_ptr,
|
||
|
|
reg_payload->config,
|
||
|
|
faceID);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
|
||
|
|
result.handle = faceID;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_THERMAL_NOTIFY:
|
||
|
|
{
|
||
|
|
rc = m_parent->waitDeferredWork(m_parent->mParamInitJob);
|
||
|
|
if (NO_ERROR != rc) {
|
||
|
|
LOGE("Param init deferred work failed");
|
||
|
|
} else {
|
||
|
|
rc = m_parent->updateThermalLevel(payload);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_NOTIFY:
|
||
|
|
{
|
||
|
|
mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
|
||
|
|
switch (cam_evt->server_event_type) {
|
||
|
|
case CAM_EVENT_TYPE_DAEMON_DIED:
|
||
|
|
{
|
||
|
|
m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
|
||
|
|
CAMERA_ERROR_SERVER_DIED,
|
||
|
|
0);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGE("Invalid internal event %d in state(%d)",
|
||
|
|
cam_evt->server_event_type, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SNAPSHOT_DONE:
|
||
|
|
{
|
||
|
|
// No ops, but need to notify
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalEvtResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_INTERNAL:
|
||
|
|
{
|
||
|
|
qcamera_sm_internal_evt_payload_t *internal_evt =
|
||
|
|
(qcamera_sm_internal_evt_payload_t *)payload;
|
||
|
|
switch (internal_evt->evt_type) {
|
||
|
|
case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE:
|
||
|
|
rc = m_parent->waitDeferredWork(m_parent->mParamInitJob);
|
||
|
|
if (NO_ERROR != rc) {
|
||
|
|
LOGE("Param init deferred work failed");
|
||
|
|
} else {
|
||
|
|
rc = m_parent->mParameters.updateFlashMode(internal_evt->led_data);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
|
||
|
|
default:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : procEvtPreviewReadyState
|
||
|
|
*
|
||
|
|
* DESCRIPTION: finite state machine function to handle event in state of
|
||
|
|
* QCAMERA_SM_STATE_PREVIEW_READY.
|
||
|
|
*
|
||
|
|
* PARAMETERS :
|
||
|
|
* @evt : event to be processed
|
||
|
|
* @payload : event payload. Can be NULL if not needed.
|
||
|
|
*
|
||
|
|
* RETURN : int32_t type of status
|
||
|
|
* NO_ERROR -- success
|
||
|
|
* none-zero failure code
|
||
|
|
*==========================================================================*/
|
||
|
|
int32_t QCameraStateMachine::procEvtPreviewReadyState(qcamera_sm_evt_enum_t evt,
|
||
|
|
void *payload)
|
||
|
|
{
|
||
|
|
int32_t rc = NO_ERROR;
|
||
|
|
qcamera_api_result_t result;
|
||
|
|
memset(&result, 0, sizeof(qcamera_api_result_t));
|
||
|
|
|
||
|
|
LOGL("event (%d)", evt);
|
||
|
|
switch (evt) {
|
||
|
|
case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
|
||
|
|
{
|
||
|
|
m_parent->setPreviewWindow((struct preview_stream_ops *)payload);
|
||
|
|
if (m_parent->mPreviewWindow != NULL) {
|
||
|
|
applyDelayedMsgs();
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
} else {
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_CALLBACKS:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_setcb_payload_t *setcbs =
|
||
|
|
(qcamera_sm_evt_setcb_payload_t *)payload;
|
||
|
|
rc = m_parent->setCallBacks(setcbs->notify_cb,
|
||
|
|
setcbs->data_cb,
|
||
|
|
setcbs->data_cb_timestamp,
|
||
|
|
setcbs->get_memory,
|
||
|
|
setcbs->user);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
rc = m_parent->enableMsgType(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
rc = m_parent->disableMsgType(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
|
||
|
|
{
|
||
|
|
int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = enabled;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS:
|
||
|
|
{
|
||
|
|
bool needRestart = false;
|
||
|
|
rc = m_parent->updateParameters((char*)payload, needRestart);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_STOP:
|
||
|
|
{
|
||
|
|
LOGD("Stopping preview...");
|
||
|
|
// need restart preview for parameters to take effect
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
// Clear memory pools
|
||
|
|
m_parent->m_memoryPool.clear();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_COMMIT:
|
||
|
|
{
|
||
|
|
rc = m_parent->commitParameterChanges();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_RESTART:
|
||
|
|
{
|
||
|
|
// prepare preview again
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
}
|
||
|
|
m_parent->setNeedRestart(false);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_GET_PARAMS:
|
||
|
|
{
|
||
|
|
result.params = m_parent->getParameters();
|
||
|
|
rc = result.params ? NO_ERROR : UNKNOWN_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PUT_PARAMS:
|
||
|
|
{
|
||
|
|
rc = m_parent->putParameters((char*)payload);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_PREVIEW:
|
||
|
|
{
|
||
|
|
// no ops here
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
|
||
|
|
{
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
} else {
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
}
|
||
|
|
// no ops here
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_PREVIEW:
|
||
|
|
{
|
||
|
|
if (m_parent->mPreviewWindow != NULL) {
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
} else {
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// no ops here
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_PREVIEW:
|
||
|
|
{
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
rc = 0;
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PREVIEW_ENABLED:
|
||
|
|
{
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = 1;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RECORDING_ENABLED:
|
||
|
|
{
|
||
|
|
rc = 0;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = 0;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
|
||
|
|
{
|
||
|
|
rc = m_parent->storeMetaDataInBuffers(*((int *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DUMP:
|
||
|
|
{
|
||
|
|
rc = m_parent->dump(*((int *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_AUTO_FOCUS:
|
||
|
|
{
|
||
|
|
rc = m_parent->autoFocus();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
|
||
|
|
{
|
||
|
|
rc = m_parent->cancelAutoFocus();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SEND_COMMAND:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_command_payload_t *cmd_payload =
|
||
|
|
(qcamera_sm_evt_command_payload_t *)payload;
|
||
|
|
rc = m_parent->sendCommand(cmd_payload->cmd,
|
||
|
|
cmd_payload->arg1,
|
||
|
|
cmd_payload->arg2);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_REG_FACE_IMAGE:
|
||
|
|
{
|
||
|
|
int32_t faceID = 0;
|
||
|
|
qcamera_sm_evt_reg_face_payload_t *reg_payload =
|
||
|
|
(qcamera_sm_evt_reg_face_payload_t *)payload;
|
||
|
|
rc = m_parent->registerFaceImage(reg_payload->img_ptr,
|
||
|
|
reg_payload->config,
|
||
|
|
faceID);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
|
||
|
|
result.handle = faceID;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PRE_START_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_RESTART_START_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_STOP_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
|
||
|
|
case QCAMERA_SM_EVT_PRE_TAKE_PICTURE:
|
||
|
|
case QCAMERA_SM_EVT_TAKE_PICTURE:
|
||
|
|
case QCAMERA_SM_EVT_CANCEL_PICTURE:
|
||
|
|
case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
|
||
|
|
case QCAMERA_SM_EVT_RELEASE:
|
||
|
|
{
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_NOTIFY:
|
||
|
|
{
|
||
|
|
mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
|
||
|
|
switch (cam_evt->server_event_type) {
|
||
|
|
case CAM_EVENT_TYPE_DAEMON_DIED:
|
||
|
|
{
|
||
|
|
m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
|
||
|
|
CAMERA_ERROR_SERVER_DIED,
|
||
|
|
0);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGE("Invalid internal event %d in state(%d)",
|
||
|
|
cam_evt->server_event_type, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SNAPSHOT_DONE:
|
||
|
|
{
|
||
|
|
// No ops, but need to notify
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalEvtResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_INTERNAL:
|
||
|
|
{
|
||
|
|
qcamera_sm_internal_evt_payload_t *internal_evt =
|
||
|
|
(qcamera_sm_internal_evt_payload_t *)payload;
|
||
|
|
switch (internal_evt->evt_type) {
|
||
|
|
case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE:
|
||
|
|
rc = m_parent->mParameters.updateFlashMode(internal_evt->led_data);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
|
||
|
|
case QCAMERA_SM_EVT_THERMAL_NOTIFY:
|
||
|
|
default:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : procEvtPreviewingState
|
||
|
|
*
|
||
|
|
* DESCRIPTION: finite state machine function to handle event in state of
|
||
|
|
* QCAMERA_SM_STATE_PREVIEWING.
|
||
|
|
*
|
||
|
|
* PARAMETERS :
|
||
|
|
* @evt : event to be processed
|
||
|
|
* @payload : event payload. Can be NULL if not needed.
|
||
|
|
*
|
||
|
|
* RETURN : int32_t type of status
|
||
|
|
* NO_ERROR -- success
|
||
|
|
* none-zero failure code
|
||
|
|
*==========================================================================*/
|
||
|
|
int32_t QCameraStateMachine::procEvtPreviewingState(qcamera_sm_evt_enum_t evt,
|
||
|
|
void *payload)
|
||
|
|
{
|
||
|
|
int32_t rc = NO_ERROR;
|
||
|
|
qcamera_api_result_t result;
|
||
|
|
memset(&result, 0, sizeof(qcamera_api_result_t));
|
||
|
|
|
||
|
|
LOGL("event (%d)", evt);
|
||
|
|
switch (evt) {
|
||
|
|
case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
|
||
|
|
{
|
||
|
|
// Error setting preview window during previewing
|
||
|
|
LOGE("Error!! cannot set preview window when preview is running");
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_CALLBACKS:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_setcb_payload_t *setcbs =
|
||
|
|
(qcamera_sm_evt_setcb_payload_t *)payload;
|
||
|
|
rc = m_parent->setCallBacks(setcbs->notify_cb,
|
||
|
|
setcbs->data_cb,
|
||
|
|
setcbs->data_cb_timestamp,
|
||
|
|
setcbs->get_memory,
|
||
|
|
setcbs->user);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
int32_t enable_msgs = *((int32_t *)payload);
|
||
|
|
if (m_bDelayPreviewMsgs &&
|
||
|
|
(enable_msgs & CAMERA_MSG_PREVIEW_FRAME)) {
|
||
|
|
enable_msgs &= ~CAMERA_MSG_PREVIEW_FRAME;
|
||
|
|
m_DelayedMsgs = CAMERA_MSG_PREVIEW_FRAME;
|
||
|
|
}
|
||
|
|
rc = m_parent->enableMsgType(enable_msgs);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
int32_t disable_msgs = *((int32_t *)payload);
|
||
|
|
if (m_bDelayPreviewMsgs && m_DelayedMsgs) {
|
||
|
|
m_DelayedMsgs &= ~disable_msgs;
|
||
|
|
if (0 == m_DelayedMsgs) {
|
||
|
|
m_bDelayPreviewMsgs = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
rc = m_parent->disableMsgType(disable_msgs);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
|
||
|
|
{
|
||
|
|
int32_t msgs = *((int32_t *)payload);
|
||
|
|
int enabled = m_parent->msgTypeEnabled(msgs);
|
||
|
|
if (m_bDelayPreviewMsgs && m_DelayedMsgs) {
|
||
|
|
enabled |= (msgs & m_DelayedMsgs);
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = enabled;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS:
|
||
|
|
{
|
||
|
|
bool needRestart = false;
|
||
|
|
rc = m_parent->updateParameters((char*)payload, needRestart);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_STOP:
|
||
|
|
{
|
||
|
|
LOGD("Stopping preview...");
|
||
|
|
// stop preview
|
||
|
|
rc = m_parent->stopPreview();
|
||
|
|
// Clear memory pools
|
||
|
|
m_parent->m_memoryPool.clear();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_COMMIT:
|
||
|
|
{
|
||
|
|
rc = m_parent->commitParameterChanges();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_RESTART:
|
||
|
|
{
|
||
|
|
// start preview again
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
applyDelayedMsgs();
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
}
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
m_parent->setNeedRestart(false);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_GET_PARAMS:
|
||
|
|
{
|
||
|
|
result.params = m_parent->getParameters();
|
||
|
|
rc = result.params ? NO_ERROR : UNKNOWN_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PUT_PARAMS:
|
||
|
|
{
|
||
|
|
rc = m_parent->putParameters((char*)payload);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_PREVIEW:
|
||
|
|
{
|
||
|
|
// no ops here
|
||
|
|
LOGW("Already in preview ready state, no ops here");
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
|
||
|
|
{
|
||
|
|
// no ops here
|
||
|
|
LOGW("Already in previewing, no ops here to start preview");
|
||
|
|
applyDelayedMsgs();
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_PREVIEW:
|
||
|
|
{
|
||
|
|
rc = m_parent->stopPreview();
|
||
|
|
applyDelayedMsgs();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PREVIEW_ENABLED:
|
||
|
|
{
|
||
|
|
applyDelayedMsgs();
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = 1;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RECORDING_ENABLED:
|
||
|
|
{
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = 0;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
|
||
|
|
{
|
||
|
|
rc = m_parent->storeMetaDataInBuffers(*((int *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DUMP:
|
||
|
|
{
|
||
|
|
rc = m_parent->dump(*((int *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_AUTO_FOCUS:
|
||
|
|
{
|
||
|
|
rc = m_parent->autoFocus();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
|
||
|
|
{
|
||
|
|
rc = m_parent->cancelAutoFocus();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PRE_START_RECORDING:
|
||
|
|
{
|
||
|
|
rc = m_parent->preStartRecording();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_RECORDING:
|
||
|
|
{
|
||
|
|
rc = m_parent->startRecording();
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
// move state to recording state
|
||
|
|
m_state = QCAMERA_SM_STATE_RECORDING;
|
||
|
|
applyDelayedMsgs();
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
|
||
|
|
{
|
||
|
|
rc = m_parent->prepareHardwareForSnapshot(FALSE);
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
// Do not signal API result in this case.
|
||
|
|
// Need to wait for snapshot done in metadta.
|
||
|
|
m_state = QCAMERA_SM_STATE_PREPARE_SNAPSHOT;
|
||
|
|
applyDelayedMsgs();
|
||
|
|
} else {
|
||
|
|
// Do not change state in this case.
|
||
|
|
LOGE("prepareHardwareForSnapshot failed %d",
|
||
|
|
rc);
|
||
|
|
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PRE_TAKE_PICTURE:
|
||
|
|
{
|
||
|
|
rc = m_parent->preTakePicture();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_TAKE_PICTURE:
|
||
|
|
{
|
||
|
|
LOGL("QCAMERA_SM_EVT_TAKE_PICTURE ");
|
||
|
|
if ( m_parent->mParameters.getRecordingHintValue() == true) {
|
||
|
|
m_parent->stopPreview();
|
||
|
|
m_parent->mParameters.updateRecordingHintValue(FALSE);
|
||
|
|
// start preview again
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) {
|
||
|
|
bool restartPreview = m_parent->isPreviewRestartEnabled();
|
||
|
|
if ((restartPreview) && (m_parent->mParameters.getManualCaptureMode()
|
||
|
|
>= CAM_MANUAL_CAPTURE_TYPE_3)) {
|
||
|
|
/* stop preview and disable ZSL now */
|
||
|
|
m_parent->stopPreview();
|
||
|
|
m_parent->mParameters.updateZSLModeValue(FALSE);
|
||
|
|
m_RestoreZSL = TRUE;
|
||
|
|
m_bDelayPreviewMsgs = true;
|
||
|
|
m_state = QCAMERA_SM_STATE_PIC_TAKING;
|
||
|
|
} else {
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
|
||
|
|
m_bDelayPreviewMsgs = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
rc = m_parent->takePicture();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
// move state to previewing state
|
||
|
|
m_parent->unconfigureAdvancedCapture();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
}
|
||
|
|
if (!(m_parent->isRetroPicture()) || (rc != NO_ERROR)) {
|
||
|
|
LOGD("signal API result, m_state = %d",
|
||
|
|
m_state);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
m_state = QCAMERA_SM_STATE_PIC_TAKING;
|
||
|
|
rc = m_parent->takePicture();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
int32_t temp_rc = NO_ERROR;
|
||
|
|
// move state to preview stopped state
|
||
|
|
m_parent->unconfigureAdvancedCapture();
|
||
|
|
m_parent->stopPreview();
|
||
|
|
// start preview again
|
||
|
|
temp_rc = m_parent->preparePreview();
|
||
|
|
if (temp_rc == NO_ERROR) {
|
||
|
|
temp_rc = m_parent->startPreview();
|
||
|
|
if (temp_rc != NO_ERROR) {
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
} else {
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SEND_COMMAND:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_command_payload_t *cmd_payload =
|
||
|
|
(qcamera_sm_evt_command_payload_t *)payload;
|
||
|
|
rc = m_parent->sendCommand(cmd_payload->cmd,
|
||
|
|
cmd_payload->arg1,
|
||
|
|
cmd_payload->arg2);
|
||
|
|
m_bPreviewNeedsRestart =
|
||
|
|
(QCAMERA_SM_EVT_RESTART_PERVIEW == cmd_payload->arg1);
|
||
|
|
m_bPreviewDelayedRestart =
|
||
|
|
(QCAMERA_SM_EVT_DELAYED_RESTART == cmd_payload->arg2);
|
||
|
|
|
||
|
|
#ifndef VANILLA_HAL
|
||
|
|
if ((CAMERA_CMD_LONGSHOT_ON == cmd_payload->cmd) &&
|
||
|
|
(m_bPreviewNeedsRestart)) {
|
||
|
|
m_parent->stopPreview();
|
||
|
|
// Clear memory pools
|
||
|
|
m_parent->m_memoryPool.clear();
|
||
|
|
|
||
|
|
if (!m_bPreviewDelayedRestart) {
|
||
|
|
// start preview again
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
applyDelayedMsgs();
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SEND_COMMAND_RESTART:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_command_payload_t *cmd_payload =
|
||
|
|
(qcamera_sm_evt_command_payload_t *)payload;
|
||
|
|
if ((CAMERA_CMD_LONGSHOT_ON == cmd_payload->cmd) &&
|
||
|
|
(m_bPreviewNeedsRestart) &&
|
||
|
|
(m_bPreviewDelayedRestart)) {
|
||
|
|
// start preview again
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_REG_FACE_IMAGE:
|
||
|
|
{
|
||
|
|
int32_t faceID = 0;
|
||
|
|
qcamera_sm_evt_reg_face_payload_t *reg_payload =
|
||
|
|
(qcamera_sm_evt_reg_face_payload_t *)payload;
|
||
|
|
rc = m_parent->registerFaceImage(reg_payload->img_ptr,
|
||
|
|
reg_payload->config,
|
||
|
|
faceID);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
|
||
|
|
result.handle = faceID;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_CANCEL_PICTURE:
|
||
|
|
case QCAMERA_SM_EVT_STOP_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
|
||
|
|
case QCAMERA_SM_EVT_RELEASE:
|
||
|
|
{
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_INTERNAL:
|
||
|
|
{
|
||
|
|
qcamera_sm_internal_evt_payload_t *internal_evt =
|
||
|
|
(qcamera_sm_internal_evt_payload_t *)payload;
|
||
|
|
switch (internal_evt->evt_type) {
|
||
|
|
case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
|
||
|
|
rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
|
||
|
|
rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
|
||
|
|
rc = m_parent->processHistogramStats(internal_evt->stats_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_CROP_INFO:
|
||
|
|
rc = m_parent->processZoomEvent(internal_evt->crop_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
|
||
|
|
rc = m_parent->processASDUpdate(internal_evt->asd_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE:
|
||
|
|
rc = m_parent->mParameters.updateFlashMode(internal_evt->led_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_AWB_UPDATE:
|
||
|
|
rc = m_parent->transAwbMetaToParams(internal_evt->awb_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_AE_UPDATE:
|
||
|
|
rc = m_parent->processAEInfo(internal_evt->ae_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE:
|
||
|
|
rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_HDR_UPDATE:
|
||
|
|
rc = m_parent->processHDRData(internal_evt->hdr_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK:
|
||
|
|
rc = m_parent->processRetroAECUnlock();
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE:
|
||
|
|
rc = m_parent->processZSLCaptureDone();
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGE("Invalid internal event %d in state(%d)",
|
||
|
|
internal_evt->evt_type, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_NOTIFY:
|
||
|
|
{
|
||
|
|
mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
|
||
|
|
switch (cam_evt->server_event_type) {
|
||
|
|
case CAM_EVENT_TYPE_DAEMON_DIED:
|
||
|
|
{
|
||
|
|
m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
|
||
|
|
CAMERA_ERROR_SERVER_DIED,
|
||
|
|
0);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGW("no handling for server evt (%d) at this state",
|
||
|
|
cam_evt->server_event_type);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_THERMAL_NOTIFY:
|
||
|
|
{
|
||
|
|
rc = m_parent->updateThermalLevel(payload);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SNAPSHOT_DONE:
|
||
|
|
{
|
||
|
|
// No ops, but need to notify
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalEvtResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW:
|
||
|
|
{
|
||
|
|
m_parent->stopPreview();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RESTART_START_PREVIEW:
|
||
|
|
{
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
|
||
|
|
default:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : procEvtPrepareSnapshotState
|
||
|
|
*
|
||
|
|
* DESCRIPTION: finite state machine function to handle event in state of
|
||
|
|
* QCAMERA_SM_STATE_PREPARE_SNAPSHOT.
|
||
|
|
*
|
||
|
|
* PARAMETERS :
|
||
|
|
* @evt : event to be processed
|
||
|
|
* @payload : event payload. Can be NULL if not needed.
|
||
|
|
*
|
||
|
|
* RETURN : int32_t type of status
|
||
|
|
* NO_ERROR -- success
|
||
|
|
* none-zero failure code
|
||
|
|
*==========================================================================*/
|
||
|
|
int32_t QCameraStateMachine::procEvtPrepareSnapshotState(qcamera_sm_evt_enum_t evt,
|
||
|
|
void *payload)
|
||
|
|
{
|
||
|
|
int32_t rc = NO_ERROR;
|
||
|
|
qcamera_api_result_t result;
|
||
|
|
memset(&result, 0, sizeof(qcamera_api_result_t));
|
||
|
|
|
||
|
|
LOGL("event (%d)", evt);
|
||
|
|
switch (evt) {
|
||
|
|
case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
|
||
|
|
case QCAMERA_SM_EVT_SET_CALLBACKS:
|
||
|
|
case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
|
||
|
|
case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
|
||
|
|
case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS:
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_STOP:
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_COMMIT:
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_RESTART:
|
||
|
|
case QCAMERA_SM_EVT_GET_PARAMS:
|
||
|
|
case QCAMERA_SM_EVT_PUT_PARAMS:
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_STOP_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_PREVIEW_ENABLED:
|
||
|
|
case QCAMERA_SM_EVT_RECORDING_ENABLED:
|
||
|
|
case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
|
||
|
|
case QCAMERA_SM_EVT_DUMP:
|
||
|
|
case QCAMERA_SM_EVT_START_AUTO_FOCUS:
|
||
|
|
case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
|
||
|
|
case QCAMERA_SM_EVT_PRE_START_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_RESTART_START_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_PRE_TAKE_PICTURE:
|
||
|
|
case QCAMERA_SM_EVT_TAKE_PICTURE:
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
|
||
|
|
case QCAMERA_SM_EVT_SEND_COMMAND:
|
||
|
|
case QCAMERA_SM_EVT_CANCEL_PICTURE:
|
||
|
|
case QCAMERA_SM_EVT_STOP_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
|
||
|
|
case QCAMERA_SM_EVT_RELEASE:
|
||
|
|
{
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_INTERNAL:
|
||
|
|
{
|
||
|
|
qcamera_sm_internal_evt_payload_t *internal_evt =
|
||
|
|
(qcamera_sm_internal_evt_payload_t *)payload;
|
||
|
|
switch (internal_evt->evt_type) {
|
||
|
|
case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
|
||
|
|
rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
|
||
|
|
m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state);
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
|
||
|
|
result.status = NO_ERROR;
|
||
|
|
result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
|
||
|
|
rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
|
||
|
|
rc = m_parent->processHistogramStats(internal_evt->stats_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_CROP_INFO:
|
||
|
|
rc = m_parent->processZoomEvent(internal_evt->crop_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
|
||
|
|
rc = m_parent->processASDUpdate(internal_evt->asd_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_AWB_UPDATE:
|
||
|
|
rc = m_parent->transAwbMetaToParams(internal_evt->awb_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_AE_UPDATE:
|
||
|
|
rc = m_parent->processAEInfo(internal_evt->ae_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE:
|
||
|
|
rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_HDR_UPDATE:
|
||
|
|
rc = m_parent->processHDRData(internal_evt->hdr_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK:
|
||
|
|
rc = m_parent->processRetroAECUnlock();
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE:
|
||
|
|
rc = m_parent->processZSLCaptureDone();
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGE("Invalid internal event %d in state(%d)",
|
||
|
|
internal_evt->evt_type, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_NOTIFY:
|
||
|
|
{
|
||
|
|
mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
|
||
|
|
switch (cam_evt->server_event_type) {
|
||
|
|
case CAM_EVENT_TYPE_DAEMON_DIED:
|
||
|
|
{
|
||
|
|
m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
|
||
|
|
CAMERA_ERROR_SERVER_DIED,
|
||
|
|
0);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGE("Invalid internal event %d in state(%d)",
|
||
|
|
cam_evt->server_event_type, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SNAPSHOT_DONE:
|
||
|
|
{
|
||
|
|
// No ops, but need to notify
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalEvtResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_THERMAL_NOTIFY:
|
||
|
|
{
|
||
|
|
rc = m_parent->updateThermalLevel(payload);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
|
||
|
|
default:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : procEvtPicTakingState
|
||
|
|
*
|
||
|
|
* DESCRIPTION: finite state machine function to handle event in state of
|
||
|
|
* QCAMERA_SM_STATE_PIC_TAKING.
|
||
|
|
*
|
||
|
|
* PARAMETERS :
|
||
|
|
* @evt : event to be processed
|
||
|
|
* @payload : event payload. Can be NULL if not needed.
|
||
|
|
*
|
||
|
|
* RETURN : int32_t type of status
|
||
|
|
* NO_ERROR -- success
|
||
|
|
* none-zero failure code
|
||
|
|
*==========================================================================*/
|
||
|
|
int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt,
|
||
|
|
void *payload)
|
||
|
|
{
|
||
|
|
int32_t rc = NO_ERROR;
|
||
|
|
qcamera_api_result_t result;
|
||
|
|
memset(&result, 0, sizeof(qcamera_api_result_t));
|
||
|
|
|
||
|
|
LOGL("event (%d)", evt);
|
||
|
|
switch (evt) {
|
||
|
|
case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
|
||
|
|
{
|
||
|
|
// Error setting preview window during previewing
|
||
|
|
LOGE("Error!! cannot set preview window when preview is running");
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_CALLBACKS:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_setcb_payload_t *setcbs =
|
||
|
|
(qcamera_sm_evt_setcb_payload_t *)payload;
|
||
|
|
rc = m_parent->setCallBacks(setcbs->notify_cb,
|
||
|
|
setcbs->data_cb,
|
||
|
|
setcbs->data_cb_timestamp,
|
||
|
|
setcbs->get_memory,
|
||
|
|
setcbs->user);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
rc = m_parent->enableMsgType(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
rc = m_parent->disableMsgType(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
|
||
|
|
{
|
||
|
|
int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = enabled;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS:
|
||
|
|
{
|
||
|
|
bool needRestart = false;
|
||
|
|
rc = m_parent->updateParameters((char*)payload, needRestart);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_STOP:
|
||
|
|
{
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_COMMIT:
|
||
|
|
{
|
||
|
|
rc = m_parent->commitParameterChanges();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_RESTART:
|
||
|
|
{
|
||
|
|
m_parent->setNeedRestart(false);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_GET_PARAMS:
|
||
|
|
{
|
||
|
|
result.params = m_parent->getParameters();
|
||
|
|
rc = result.params ? NO_ERROR : UNKNOWN_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PUT_PARAMS:
|
||
|
|
{
|
||
|
|
rc = m_parent->putParameters((char*)payload);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_PREVIEW:
|
||
|
|
{
|
||
|
|
// cancel picture first
|
||
|
|
rc = m_parent->cancelPicture();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PREVIEW_ENABLED:
|
||
|
|
{
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = 0;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RECORDING_ENABLED:
|
||
|
|
{
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = 0;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
|
||
|
|
{
|
||
|
|
rc = m_parent->storeMetaDataInBuffers(*((int *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DUMP:
|
||
|
|
{
|
||
|
|
rc = m_parent->dump(*((int *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_AUTO_FOCUS:
|
||
|
|
{
|
||
|
|
rc = m_parent->autoFocus();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
|
||
|
|
{
|
||
|
|
rc = m_parent->cancelAutoFocus();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SEND_COMMAND:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_command_payload_t *cmd_payload =
|
||
|
|
(qcamera_sm_evt_command_payload_t *)payload;
|
||
|
|
rc = m_parent->sendCommand(cmd_payload->cmd,
|
||
|
|
cmd_payload->arg1,
|
||
|
|
cmd_payload->arg2);
|
||
|
|
#ifndef VANILLA_HAL
|
||
|
|
if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) {
|
||
|
|
// move state to previewing state
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_CANCEL_PICTURE:
|
||
|
|
{
|
||
|
|
rc = m_parent->cancelPicture();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_REG_FACE_IMAGE:
|
||
|
|
{
|
||
|
|
int32_t faceID = 0;
|
||
|
|
qcamera_sm_evt_reg_face_payload_t *reg_payload =
|
||
|
|
(qcamera_sm_evt_reg_face_payload_t *)payload;
|
||
|
|
rc = m_parent->registerFaceImage(reg_payload->img_ptr,
|
||
|
|
reg_payload->config,
|
||
|
|
faceID);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
|
||
|
|
result.handle = faceID;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PRE_TAKE_PICTURE:
|
||
|
|
{
|
||
|
|
if ( m_parent->isLongshotEnabled() ) {
|
||
|
|
// no ops here, need to singal NO_ERROR
|
||
|
|
rc = NO_ERROR;
|
||
|
|
} else {
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_TAKE_PICTURE:
|
||
|
|
{
|
||
|
|
if ( m_parent->isLongshotEnabled() ) {
|
||
|
|
rc = m_parent->longShot();
|
||
|
|
} else {
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
|
||
|
|
case QCAMERA_SM_EVT_PRE_START_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_RESTART_START_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_STOP_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_RELEASE:
|
||
|
|
{
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_INTERNAL:
|
||
|
|
{
|
||
|
|
qcamera_sm_internal_evt_payload_t *internal_evt =
|
||
|
|
(qcamera_sm_internal_evt_payload_t *)payload;
|
||
|
|
switch (internal_evt->evt_type) {
|
||
|
|
case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
|
||
|
|
rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_CROP_INFO:
|
||
|
|
rc = m_parent->processZoomEvent(internal_evt->crop_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
|
||
|
|
rc = m_parent->processASDUpdate(internal_evt->asd_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_AWB_UPDATE:
|
||
|
|
rc = m_parent->transAwbMetaToParams(internal_evt->awb_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_AE_UPDATE:
|
||
|
|
rc = m_parent->processAEInfo(internal_evt->ae_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE:
|
||
|
|
rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_HDR_UPDATE:
|
||
|
|
rc = m_parent->processHDRData(internal_evt->hdr_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK:
|
||
|
|
rc = m_parent->processRetroAECUnlock();
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE:
|
||
|
|
rc = m_parent->processZSLCaptureDone();
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_NOTIFY:
|
||
|
|
{
|
||
|
|
mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
|
||
|
|
switch (cam_evt->server_event_type) {
|
||
|
|
case CAM_EVENT_TYPE_DAEMON_DIED:
|
||
|
|
{
|
||
|
|
// Send internal events to release statemachine
|
||
|
|
// thread to process CAMERA_ERROR_SERVER_DIED error
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
|
||
|
|
m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
|
||
|
|
CAMERA_ERROR_SERVER_DIED,
|
||
|
|
0);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case CAM_EVENT_TYPE_CAC_DONE:
|
||
|
|
if (m_parent->isCACEnabled() || m_parent->mParameters.isOEMFeatEnabled()) {
|
||
|
|
LOGD("[LONG_SHOT_DBG] : Received CAC Done");
|
||
|
|
if (m_parent->isLongshotEnabled()
|
||
|
|
&& !m_parent->isCaptureShutterEnabled()) {
|
||
|
|
// play shutter sound for longshot
|
||
|
|
// after CAC stage is done
|
||
|
|
m_parent->playShutter();
|
||
|
|
}
|
||
|
|
m_parent->mCACDoneReceived = TRUE;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGH("no handling for server evt (%d) at this state",
|
||
|
|
cam_evt->server_event_type);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
|
||
|
|
{
|
||
|
|
qcamera_jpeg_evt_payload_t *jpeg_job =
|
||
|
|
(qcamera_jpeg_evt_payload_t *)payload;
|
||
|
|
rc = m_parent->processJpegNotify(jpeg_job);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_CAPTURE_CHANNEL:
|
||
|
|
{
|
||
|
|
bool restartPreview = m_parent->isPreviewRestartEnabled();
|
||
|
|
rc = m_parent->stopCaptureChannel(restartPreview);
|
||
|
|
|
||
|
|
if (restartPreview && (NO_ERROR == rc)) {
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
if (NO_ERROR == rc) {
|
||
|
|
m_parent->m_bPreviewStarted = true;
|
||
|
|
applyDelayedMsgs();
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SNAPSHOT_DONE:
|
||
|
|
{
|
||
|
|
rc = m_parent->cancelPicture();
|
||
|
|
|
||
|
|
bool restartPreview = m_parent->isPreviewRestartEnabled();
|
||
|
|
if (restartPreview) {
|
||
|
|
if (m_parent->mParameters.getManualCaptureMode()
|
||
|
|
>= CAM_MANUAL_CAPTURE_TYPE_3) {
|
||
|
|
m_parent->mParameters.updateZSLModeValue(m_RestoreZSL);
|
||
|
|
m_RestoreZSL = FALSE;
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
if (NO_ERROR == rc) {
|
||
|
|
m_parent->m_bPreviewStarted = true;
|
||
|
|
applyDelayedMsgs();
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
} else {
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
}
|
||
|
|
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalEvtResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_THERMAL_NOTIFY:
|
||
|
|
{
|
||
|
|
rc = m_parent->updateThermalLevel(payload);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : procEvtRecordingState
|
||
|
|
*
|
||
|
|
* DESCRIPTION: finite state machine function to handle event in state of
|
||
|
|
* QCAMERA_SM_STATE_RECORDING.
|
||
|
|
*
|
||
|
|
* PARAMETERS :
|
||
|
|
* @evt : event to be processed
|
||
|
|
* @payload : event payload. Can be NULL if not needed.
|
||
|
|
*
|
||
|
|
* RETURN : int32_t type of status
|
||
|
|
* NO_ERROR -- success
|
||
|
|
* none-zero failure code
|
||
|
|
*==========================================================================*/
|
||
|
|
int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt,
|
||
|
|
void *payload)
|
||
|
|
{
|
||
|
|
int32_t rc = NO_ERROR;
|
||
|
|
qcamera_api_result_t result;
|
||
|
|
memset(&result, 0, sizeof(qcamera_api_result_t));
|
||
|
|
|
||
|
|
LOGL("event (%d)", evt);
|
||
|
|
switch (evt) {
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
|
||
|
|
{
|
||
|
|
// WA: CTS test VideoSnapshot will try to
|
||
|
|
// start preview during video recording.
|
||
|
|
LOGH("CTS video restart op");
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_CALLBACKS:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_setcb_payload_t *setcbs =
|
||
|
|
(qcamera_sm_evt_setcb_payload_t *)payload;
|
||
|
|
rc = m_parent->setCallBacks(setcbs->notify_cb,
|
||
|
|
setcbs->data_cb,
|
||
|
|
setcbs->data_cb_timestamp,
|
||
|
|
setcbs->get_memory,
|
||
|
|
setcbs->user);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
rc = m_parent->enableMsgType(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
rc = m_parent->disableMsgType(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
|
||
|
|
{
|
||
|
|
int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = enabled;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS:
|
||
|
|
{
|
||
|
|
bool needRestart = false;
|
||
|
|
rc = m_parent->updateParameters((char*)payload, needRestart);
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
if (needRestart) {
|
||
|
|
// cannot set parameters that requires restart during recording
|
||
|
|
LOGE("Error!! cannot set parameters that requires restart during recording");
|
||
|
|
rc = BAD_VALUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_parent->setNeedRestart(false);
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_COMMIT:
|
||
|
|
{
|
||
|
|
rc = m_parent->commitParameterChanges();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_STOP:
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_RESTART:
|
||
|
|
{
|
||
|
|
ALOGE("%s: Error!! cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_GET_PARAMS:
|
||
|
|
{
|
||
|
|
result.params = m_parent->getParameters();
|
||
|
|
rc = result.params ? NO_ERROR : UNKNOWN_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PUT_PARAMS:
|
||
|
|
{
|
||
|
|
rc = m_parent->putParameters((char*)payload);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PREVIEW_ENABLED:
|
||
|
|
{
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = 0;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RECORDING_ENABLED:
|
||
|
|
{
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = 1;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
|
||
|
|
{
|
||
|
|
rc = m_parent->storeMetaDataInBuffers(*((int *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DUMP:
|
||
|
|
{
|
||
|
|
rc = m_parent->dump(*((int *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_AUTO_FOCUS:
|
||
|
|
{
|
||
|
|
rc = m_parent->autoFocus();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
|
||
|
|
{
|
||
|
|
rc = m_parent->cancelAutoFocus();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SEND_COMMAND:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_command_payload_t *cmd_payload =
|
||
|
|
(qcamera_sm_evt_command_payload_t *)payload;
|
||
|
|
rc = m_parent->sendCommand(cmd_payload->cmd,
|
||
|
|
cmd_payload->arg1,
|
||
|
|
cmd_payload->arg2);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PRE_TAKE_PICTURE:
|
||
|
|
{
|
||
|
|
// No ops here, send NO_ERROR.
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_TAKE_PICTURE:
|
||
|
|
{
|
||
|
|
m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
|
||
|
|
rc = m_parent->takeLiveSnapshot();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_parent->unconfigureAdvancedCapture();
|
||
|
|
m_state = QCAMERA_SM_STATE_RECORDING;
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PRE_START_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_RESTART_START_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_RECORDING:
|
||
|
|
{
|
||
|
|
// no ops here
|
||
|
|
LOGW("already in recording state, no ops for start_recording");
|
||
|
|
rc = 0;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_RECORDING:
|
||
|
|
{
|
||
|
|
rc = m_parent->stopRecording();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_PREVIEW:
|
||
|
|
{
|
||
|
|
rc = m_parent->stopRecording();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
|
||
|
|
rc = m_parent->stopPreview();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
|
||
|
|
{
|
||
|
|
rc = m_parent->releaseRecordingFrame((const void *)payload);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_REG_FACE_IMAGE:
|
||
|
|
{
|
||
|
|
int32_t faceID = 0;
|
||
|
|
qcamera_sm_evt_reg_face_payload_t *reg_payload =
|
||
|
|
(qcamera_sm_evt_reg_face_payload_t *)payload;
|
||
|
|
rc = m_parent->registerFaceImage(reg_payload->img_ptr,
|
||
|
|
reg_payload->config,
|
||
|
|
faceID);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
|
||
|
|
result.handle = faceID;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
|
||
|
|
{
|
||
|
|
//In Video snapshot, prepare hardware is a no-op.
|
||
|
|
result.status = NO_ERROR;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_CANCEL_PICTURE:
|
||
|
|
case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_RELEASE:
|
||
|
|
{
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_INTERNAL:
|
||
|
|
{
|
||
|
|
qcamera_sm_internal_evt_payload_t *internal_evt =
|
||
|
|
(qcamera_sm_internal_evt_payload_t *)payload;
|
||
|
|
switch (internal_evt->evt_type) {
|
||
|
|
case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
|
||
|
|
rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
|
||
|
|
rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
|
||
|
|
rc = m_parent->processHistogramStats(internal_evt->stats_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_CROP_INFO:
|
||
|
|
rc = m_parent->processZoomEvent(internal_evt->crop_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
|
||
|
|
rc = m_parent->processASDUpdate(internal_evt->asd_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_AWB_UPDATE:
|
||
|
|
rc = m_parent->transAwbMetaToParams(internal_evt->awb_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_AE_UPDATE:
|
||
|
|
rc = m_parent->processAEInfo(internal_evt->ae_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE:
|
||
|
|
rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_HDR_UPDATE:
|
||
|
|
rc = m_parent->processHDRData(internal_evt->hdr_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK:
|
||
|
|
rc = m_parent->processRetroAECUnlock();
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE:
|
||
|
|
rc = m_parent->processZSLCaptureDone();
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_NOTIFY:
|
||
|
|
{
|
||
|
|
mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
|
||
|
|
switch (cam_evt->server_event_type) {
|
||
|
|
case CAM_EVENT_TYPE_DAEMON_DIED:
|
||
|
|
{
|
||
|
|
m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
|
||
|
|
CAMERA_ERROR_SERVER_DIED,
|
||
|
|
0);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGE("Invalid internal event %d in state(%d)",
|
||
|
|
cam_evt->server_event_type, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_THERMAL_NOTIFY:
|
||
|
|
{
|
||
|
|
rc = m_parent->updateThermalLevel(payload);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SNAPSHOT_DONE:
|
||
|
|
{
|
||
|
|
// No ops, but need to notify
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalEvtResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
|
||
|
|
default:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : procEvtVideoPicTakingState
|
||
|
|
*
|
||
|
|
* DESCRIPTION: finite state machine function to handle event in state of
|
||
|
|
* QCAMERA_SM_STATE_VIDEO_PIC_TAKING.
|
||
|
|
*
|
||
|
|
* PARAMETERS :
|
||
|
|
* @evt : event to be processed
|
||
|
|
* @payload : event payload. Can be NULL if not needed.
|
||
|
|
*
|
||
|
|
* RETURN : int32_t type of status
|
||
|
|
* NO_ERROR -- success
|
||
|
|
* none-zero failure code
|
||
|
|
*==========================================================================*/
|
||
|
|
int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt,
|
||
|
|
void *payload)
|
||
|
|
{
|
||
|
|
int32_t rc = NO_ERROR;
|
||
|
|
qcamera_api_result_t result;
|
||
|
|
memset(&result, 0, sizeof(qcamera_api_result_t));
|
||
|
|
|
||
|
|
LOGL("event (%d)", evt);
|
||
|
|
switch (evt) {
|
||
|
|
case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
|
||
|
|
{
|
||
|
|
// Error setting preview window during previewing
|
||
|
|
LOGE("Error!! cannot set preview window when preview is running");
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_CALLBACKS:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_setcb_payload_t *setcbs =
|
||
|
|
(qcamera_sm_evt_setcb_payload_t *)payload;
|
||
|
|
rc = m_parent->setCallBacks(setcbs->notify_cb,
|
||
|
|
setcbs->data_cb,
|
||
|
|
setcbs->data_cb_timestamp,
|
||
|
|
setcbs->get_memory,
|
||
|
|
setcbs->user);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
rc = m_parent->enableMsgType(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
rc = m_parent->disableMsgType(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
|
||
|
|
{
|
||
|
|
int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = enabled;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS:
|
||
|
|
{
|
||
|
|
bool needRestart = false;
|
||
|
|
rc = m_parent->updateParameters((char*)payload, needRestart);
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
if (needRestart) {
|
||
|
|
// cannot set parameters that requires restart during recording
|
||
|
|
LOGE("Error!! cannot set parameters that requires restart during recording");
|
||
|
|
rc = BAD_VALUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_parent->setNeedRestart(false);
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_COMMIT:
|
||
|
|
{
|
||
|
|
rc = m_parent->commitParameterChanges();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_STOP:
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_RESTART:
|
||
|
|
{
|
||
|
|
ALOGE("%s: Error!! cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_GET_PARAMS:
|
||
|
|
{
|
||
|
|
result.params = m_parent->getParameters();
|
||
|
|
rc = result.params ? NO_ERROR : UNKNOWN_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PUT_PARAMS:
|
||
|
|
{
|
||
|
|
rc = m_parent->putParameters((char*)payload);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PREVIEW_ENABLED:
|
||
|
|
{
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = 1;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RECORDING_ENABLED:
|
||
|
|
{
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = 1;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
|
||
|
|
{
|
||
|
|
rc = m_parent->storeMetaDataInBuffers(*((int *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DUMP:
|
||
|
|
{
|
||
|
|
rc = m_parent->dump(*((int *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_AUTO_FOCUS:
|
||
|
|
{
|
||
|
|
rc = m_parent->autoFocus();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
|
||
|
|
{
|
||
|
|
rc = m_parent->cancelAutoFocus();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SEND_COMMAND:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_command_payload_t *cmd_payload =
|
||
|
|
(qcamera_sm_evt_command_payload_t *)payload;
|
||
|
|
rc = m_parent->sendCommand(cmd_payload->cmd,
|
||
|
|
cmd_payload->arg1,
|
||
|
|
cmd_payload->arg2);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_RECORDING:
|
||
|
|
{
|
||
|
|
rc = m_parent->cancelLiveSnapshot();
|
||
|
|
m_state = QCAMERA_SM_STATE_RECORDING;
|
||
|
|
|
||
|
|
rc = m_parent->stopRecording();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
|
||
|
|
{
|
||
|
|
rc = m_parent->releaseRecordingFrame((const void *)payload);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_CANCEL_PICTURE:
|
||
|
|
{
|
||
|
|
rc = m_parent->cancelLiveSnapshot();
|
||
|
|
m_state = QCAMERA_SM_STATE_RECORDING;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_REG_FACE_IMAGE:
|
||
|
|
{
|
||
|
|
int32_t faceID = 0;
|
||
|
|
qcamera_sm_evt_reg_face_payload_t *reg_payload =
|
||
|
|
(qcamera_sm_evt_reg_face_payload_t *)payload;
|
||
|
|
rc = m_parent->registerFaceImage(reg_payload->img_ptr,
|
||
|
|
reg_payload->config,
|
||
|
|
faceID);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
|
||
|
|
result.handle = faceID;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_PREVIEW:
|
||
|
|
{
|
||
|
|
rc = m_parent->cancelLiveSnapshot();
|
||
|
|
m_state = QCAMERA_SM_STATE_RECORDING;
|
||
|
|
|
||
|
|
rc = m_parent->stopRecording();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
|
||
|
|
rc = m_parent->stopPreview();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PRE_START_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_RESTART_START_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
|
||
|
|
case QCAMERA_SM_EVT_PRE_TAKE_PICTURE:
|
||
|
|
case QCAMERA_SM_EVT_TAKE_PICTURE:
|
||
|
|
case QCAMERA_SM_EVT_RELEASE:
|
||
|
|
{
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_INTERNAL:
|
||
|
|
{
|
||
|
|
qcamera_sm_internal_evt_payload_t *internal_evt =
|
||
|
|
(qcamera_sm_internal_evt_payload_t *)payload;
|
||
|
|
switch (internal_evt->evt_type) {
|
||
|
|
case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
|
||
|
|
rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
|
||
|
|
rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
|
||
|
|
rc = m_parent->processHistogramStats(internal_evt->stats_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_CROP_INFO:
|
||
|
|
rc = m_parent->processZoomEvent(internal_evt->crop_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
|
||
|
|
rc = m_parent->processASDUpdate(internal_evt->asd_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_AWB_UPDATE:
|
||
|
|
rc = m_parent->transAwbMetaToParams(internal_evt->awb_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_AE_UPDATE:
|
||
|
|
rc = m_parent->processAEInfo(internal_evt->ae_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE:
|
||
|
|
rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_HDR_UPDATE:
|
||
|
|
rc = m_parent->processHDRData(internal_evt->hdr_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK:
|
||
|
|
rc = m_parent->processRetroAECUnlock();
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE:
|
||
|
|
rc = m_parent->processZSLCaptureDone();
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_NOTIFY:
|
||
|
|
{
|
||
|
|
mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
|
||
|
|
switch (cam_evt->server_event_type) {
|
||
|
|
case CAM_EVENT_TYPE_DAEMON_DIED:
|
||
|
|
{
|
||
|
|
m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
|
||
|
|
CAMERA_ERROR_SERVER_DIED,
|
||
|
|
0);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGE("Invalid internal event %d in state(%d)",
|
||
|
|
cam_evt->server_event_type, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
|
||
|
|
{
|
||
|
|
qcamera_jpeg_evt_payload_t *jpeg_job =
|
||
|
|
(qcamera_jpeg_evt_payload_t *)payload;
|
||
|
|
rc = m_parent->processJpegNotify(jpeg_job);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SNAPSHOT_DONE:
|
||
|
|
{
|
||
|
|
rc = m_parent->cancelLiveSnapshot();
|
||
|
|
m_state = QCAMERA_SM_STATE_RECORDING;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalEvtResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_THERMAL_NOTIFY:
|
||
|
|
{
|
||
|
|
rc = m_parent->updateThermalLevel(payload);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : procEvtPreviewPicTakingState
|
||
|
|
*
|
||
|
|
* DESCRIPTION: finite state machine function to handle event in state of
|
||
|
|
* QCAMERA_SM_STATE_PREVIEW_PIC_TAKING.
|
||
|
|
*
|
||
|
|
* PARAMETERS :
|
||
|
|
* @evt : event to be processed
|
||
|
|
* @payload : event payload. Can be NULL if not needed.
|
||
|
|
*
|
||
|
|
* RETURN : int32_t type of status
|
||
|
|
* NO_ERROR -- success
|
||
|
|
* none-zero failure code
|
||
|
|
*==========================================================================*/
|
||
|
|
int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt,
|
||
|
|
void *payload)
|
||
|
|
{
|
||
|
|
int32_t rc = NO_ERROR;
|
||
|
|
qcamera_api_result_t result;
|
||
|
|
memset(&result, 0, sizeof(qcamera_api_result_t));
|
||
|
|
|
||
|
|
LOGL("event (%d)", evt);
|
||
|
|
switch (evt) {
|
||
|
|
case QCAMERA_SM_EVT_SET_CALLBACKS:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_setcb_payload_t *setcbs =
|
||
|
|
(qcamera_sm_evt_setcb_payload_t *)payload;
|
||
|
|
rc = m_parent->setCallBacks(setcbs->notify_cb,
|
||
|
|
setcbs->data_cb,
|
||
|
|
setcbs->data_cb_timestamp,
|
||
|
|
setcbs->get_memory,
|
||
|
|
setcbs->user);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
rc = m_parent->enableMsgType(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
|
||
|
|
{
|
||
|
|
rc = m_parent->disableMsgType(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
|
||
|
|
{
|
||
|
|
int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = enabled;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS:
|
||
|
|
{
|
||
|
|
bool needRestart = false;
|
||
|
|
rc = m_parent->updateParameters((char*)payload, needRestart);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_STOP:
|
||
|
|
{
|
||
|
|
// need restart preview for parameters to take effect
|
||
|
|
LOGD("Stopping preview...");
|
||
|
|
// stop preview
|
||
|
|
rc = m_parent->stopPreview();
|
||
|
|
// Clear memory pools
|
||
|
|
m_parent->m_memoryPool.clear();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_COMMIT:
|
||
|
|
{
|
||
|
|
// commit parameter changes to server
|
||
|
|
rc = m_parent->commitParameterChanges();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SET_PARAMS_RESTART:
|
||
|
|
{
|
||
|
|
// start preview again
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
applyDelayedMsgs();
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
m_state = QCAMERA_SM_STATE_PIC_TAKING;
|
||
|
|
}
|
||
|
|
m_parent->setNeedRestart(false);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_GET_PARAMS:
|
||
|
|
{
|
||
|
|
result.params = m_parent->getParameters();
|
||
|
|
rc = result.params ? NO_ERROR : UNKNOWN_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PUT_PARAMS:
|
||
|
|
{
|
||
|
|
rc = m_parent->putParameters((char*)payload);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PREVIEW_ENABLED:
|
||
|
|
{
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = 1;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RECORDING_ENABLED:
|
||
|
|
{
|
||
|
|
rc = NO_ERROR;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
|
||
|
|
result.enabled = 0;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
|
||
|
|
{
|
||
|
|
rc = m_parent->storeMetaDataInBuffers(*((int *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_DUMP:
|
||
|
|
{
|
||
|
|
rc = m_parent->dump(*((int *)payload));
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_AUTO_FOCUS:
|
||
|
|
{
|
||
|
|
rc = m_parent->autoFocus();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
|
||
|
|
{
|
||
|
|
rc = m_parent->cancelAutoFocus();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SEND_COMMAND:
|
||
|
|
{
|
||
|
|
qcamera_sm_evt_command_payload_t *cmd_payload =
|
||
|
|
(qcamera_sm_evt_command_payload_t *)payload;
|
||
|
|
rc = m_parent->sendCommand(cmd_payload->cmd,
|
||
|
|
cmd_payload->arg1,
|
||
|
|
cmd_payload->arg2);
|
||
|
|
#ifndef VANILLA_HAL
|
||
|
|
if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) {
|
||
|
|
// move state to previewing state
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
|
||
|
|
{
|
||
|
|
rc = m_parent->releaseRecordingFrame((const void *)payload);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_CANCEL_PICTURE:
|
||
|
|
{
|
||
|
|
if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) {
|
||
|
|
rc = m_parent->cancelPicture();
|
||
|
|
} else {
|
||
|
|
rc = m_parent->cancelLiveSnapshot();
|
||
|
|
}
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_PREVIEW:
|
||
|
|
{
|
||
|
|
if (m_parent->isZSLMode()) {
|
||
|
|
// cancel picture first
|
||
|
|
rc = m_parent->cancelPicture();
|
||
|
|
m_parent->stopChannel(QCAMERA_CH_TYPE_ZSL);
|
||
|
|
} else if (m_parent->isLongshotEnabled()) {
|
||
|
|
// just cancel picture
|
||
|
|
rc = m_parent->cancelPicture();
|
||
|
|
} else {
|
||
|
|
rc = m_parent->cancelLiveSnapshot();
|
||
|
|
m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW);
|
||
|
|
}
|
||
|
|
// unprepare preview
|
||
|
|
m_parent->unpreparePreview();
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PRE_START_RECORDING:
|
||
|
|
{
|
||
|
|
if (m_parent->isZSLMode()) {
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d) in ZSL mode", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
} else if (m_parent->isLongshotEnabled()) {
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d) in Longshot mode", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
} else {
|
||
|
|
rc = m_parent->preStartRecording();
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_START_RECORDING:
|
||
|
|
{
|
||
|
|
if (m_parent->isZSLMode()) {
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d) in ZSL mode",
|
||
|
|
evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
} else if (m_parent->isLongshotEnabled()) {
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d) in Longshot mode",
|
||
|
|
evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
} else {
|
||
|
|
rc = m_parent->startRecording();
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_REG_FACE_IMAGE:
|
||
|
|
{
|
||
|
|
int32_t faceID = 0;
|
||
|
|
qcamera_sm_evt_reg_face_payload_t *reg_payload =
|
||
|
|
(qcamera_sm_evt_reg_face_payload_t *)payload;
|
||
|
|
rc = m_parent->registerFaceImage(reg_payload->img_ptr,
|
||
|
|
reg_payload->config,
|
||
|
|
faceID);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
|
||
|
|
result.handle = faceID;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_PRE_TAKE_PICTURE:
|
||
|
|
{
|
||
|
|
if ( m_parent->isLongshotEnabled() ) {
|
||
|
|
// no ops here, need to singal NO_ERROR
|
||
|
|
rc = NO_ERROR;
|
||
|
|
} else {
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_TAKE_PICTURE:
|
||
|
|
{
|
||
|
|
if ( m_parent->isLongshotEnabled() ) {
|
||
|
|
rc = m_parent->longShot();
|
||
|
|
} else {
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
|
||
|
|
{
|
||
|
|
LOGD("Prepare Snapshot");
|
||
|
|
if (m_parent->isRetroPicture()) {
|
||
|
|
LOGD("Prepare Snapshot in Retro Mode");
|
||
|
|
rc = m_parent->prepareHardwareForSnapshot(FALSE);
|
||
|
|
if (rc != NO_ERROR) {
|
||
|
|
LOGE("prepareHardwareForSnapshot failed %d",
|
||
|
|
rc);
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)",
|
||
|
|
evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_STOP_RECORDING:
|
||
|
|
case QCAMERA_SM_EVT_PREPARE_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
|
||
|
|
case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
|
||
|
|
case QCAMERA_SM_EVT_RELEASE:
|
||
|
|
{
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
rc = INVALID_OPERATION;
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_INTERNAL:
|
||
|
|
{
|
||
|
|
qcamera_sm_internal_evt_payload_t *internal_evt =
|
||
|
|
(qcamera_sm_internal_evt_payload_t *)payload;
|
||
|
|
switch (internal_evt->evt_type) {
|
||
|
|
case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
|
||
|
|
rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
|
||
|
|
LOGD("Received QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE event");
|
||
|
|
if (m_parent->isRetroPicture()) {
|
||
|
|
m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state);
|
||
|
|
LOGD("Retro picture");
|
||
|
|
result.status = NO_ERROR;
|
||
|
|
result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
LOGE("Invalid Case for "
|
||
|
|
"QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT event");
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
|
||
|
|
rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT:
|
||
|
|
// This is valid only in Retro picture Mode
|
||
|
|
if (m_parent->isRetroPicture()) {
|
||
|
|
LOGD("Received QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT event");
|
||
|
|
result.status = NO_ERROR;
|
||
|
|
result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
LOGD("Wrong Case for QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT event");
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
|
||
|
|
rc = m_parent->processHistogramStats(internal_evt->stats_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_CROP_INFO:
|
||
|
|
rc = m_parent->processZoomEvent(internal_evt->crop_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
|
||
|
|
rc = m_parent->processASDUpdate(internal_evt->asd_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_AWB_UPDATE:
|
||
|
|
rc = m_parent->transAwbMetaToParams(internal_evt->awb_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_AE_UPDATE:
|
||
|
|
rc = m_parent->processAEInfo(internal_evt->ae_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE:
|
||
|
|
rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_HDR_UPDATE:
|
||
|
|
rc = m_parent->processHDRData(internal_evt->hdr_data);
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK:
|
||
|
|
rc = m_parent->processRetroAECUnlock();
|
||
|
|
break;
|
||
|
|
case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE:
|
||
|
|
rc = m_parent->processZSLCaptureDone();
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_EVT_NOTIFY:
|
||
|
|
{
|
||
|
|
mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
|
||
|
|
switch (cam_evt->server_event_type) {
|
||
|
|
case CAM_EVENT_TYPE_DAEMON_DIED:
|
||
|
|
{
|
||
|
|
m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
|
||
|
|
CAMERA_ERROR_SERVER_DIED,
|
||
|
|
0);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case CAM_EVENT_TYPE_CAC_DONE:
|
||
|
|
if (m_parent->isCACEnabled() || m_parent->mParameters.isOEMFeatEnabled()) {
|
||
|
|
LOGD("[LONG_SHOT_DBG] : Received CAC Done");
|
||
|
|
if ((m_parent->isLongshotEnabled())
|
||
|
|
&& (!m_parent->isCaptureShutterEnabled())) {
|
||
|
|
// play shutter sound for longshot
|
||
|
|
// after CAC stage is done
|
||
|
|
m_parent->playShutter();
|
||
|
|
}
|
||
|
|
m_parent->mCACDoneReceived = TRUE;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGE("Invalid internal event %d in state(%d)",
|
||
|
|
cam_evt->server_event_type, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
|
||
|
|
{
|
||
|
|
LOGL("Calling Process Jpeg Notify");
|
||
|
|
qcamera_jpeg_evt_payload_t *jpeg_job =
|
||
|
|
(qcamera_jpeg_evt_payload_t *)payload;
|
||
|
|
rc = m_parent->processJpegNotify(jpeg_job);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_SNAPSHOT_DONE:
|
||
|
|
{
|
||
|
|
LOGL("Snapshot Done");
|
||
|
|
if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) {
|
||
|
|
rc = m_parent->cancelPicture();
|
||
|
|
} else {
|
||
|
|
rc = m_parent->cancelLiveSnapshot();
|
||
|
|
}
|
||
|
|
m_state = QCAMERA_SM_STATE_PREVIEWING;
|
||
|
|
if (m_parent->isRetroPicture()){
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
LOGL("\n Signalling for JPEG snapshot done!!");
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalEvtResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_THERMAL_NOTIFY:
|
||
|
|
{
|
||
|
|
rc = m_parent->updateThermalLevel(payload);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW:
|
||
|
|
{
|
||
|
|
m_parent->stopPreview();
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case QCAMERA_SM_EVT_RESTART_START_PREVIEW:
|
||
|
|
{
|
||
|
|
rc = m_parent->preparePreview();
|
||
|
|
if (rc == NO_ERROR) {
|
||
|
|
rc = m_parent->startPreview();
|
||
|
|
}
|
||
|
|
result.status = rc;
|
||
|
|
result.request_api = evt;
|
||
|
|
result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
|
||
|
|
m_parent->signalAPIResult(&result);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : isRecording
|
||
|
|
*
|
||
|
|
* DESCRIPTION: check if recording is in process.
|
||
|
|
*
|
||
|
|
* PARAMETERS : None
|
||
|
|
*
|
||
|
|
* RETURN : true -- recording
|
||
|
|
* false -- not in recording mode
|
||
|
|
*==========================================================================*/
|
||
|
|
bool QCameraStateMachine::isRecording()
|
||
|
|
{
|
||
|
|
switch (m_state) {
|
||
|
|
case QCAMERA_SM_STATE_RECORDING:
|
||
|
|
case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
|
||
|
|
return true;
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : isPreviewRunning
|
||
|
|
*
|
||
|
|
* DESCRIPTION: check if preview is in process.
|
||
|
|
*
|
||
|
|
* PARAMETERS : None
|
||
|
|
*
|
||
|
|
* RETURN : true -- preview running
|
||
|
|
* false -- preview stopped
|
||
|
|
*==========================================================================*/
|
||
|
|
bool QCameraStateMachine::isPreviewRunning()
|
||
|
|
{
|
||
|
|
switch (m_state) {
|
||
|
|
case QCAMERA_SM_STATE_PREVIEWING:
|
||
|
|
case QCAMERA_SM_STATE_RECORDING:
|
||
|
|
case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
|
||
|
|
case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
|
||
|
|
case QCAMERA_SM_STATE_PREPARE_SNAPSHOT:
|
||
|
|
case QCAMERA_SM_STATE_PREVIEW_READY:
|
||
|
|
return true;
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : isPreviewReady
|
||
|
|
*
|
||
|
|
* DESCRIPTION: check if preview is in ready state.
|
||
|
|
*
|
||
|
|
* PARAMETERS : None
|
||
|
|
*
|
||
|
|
* RETURN : true -- preview is in ready state
|
||
|
|
* false -- preview is stopped
|
||
|
|
*==========================================================================*/
|
||
|
|
bool QCameraStateMachine::isPreviewReady()
|
||
|
|
{
|
||
|
|
switch (m_state) {
|
||
|
|
case QCAMERA_SM_STATE_PREVIEW_READY:
|
||
|
|
return true;
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : isCaptureRunning
|
||
|
|
*
|
||
|
|
* DESCRIPTION: check if image capture is in process.
|
||
|
|
*
|
||
|
|
* PARAMETERS : None
|
||
|
|
*
|
||
|
|
* RETURN : true -- capture running
|
||
|
|
* false -- capture stopped
|
||
|
|
*==========================================================================*/
|
||
|
|
bool QCameraStateMachine::isCaptureRunning()
|
||
|
|
{
|
||
|
|
switch (m_state) {
|
||
|
|
case QCAMERA_SM_STATE_PIC_TAKING:
|
||
|
|
case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
|
||
|
|
case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
|
||
|
|
return true;
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : isNonZSLCaptureRunning
|
||
|
|
*
|
||
|
|
* DESCRIPTION: check if image capture is in process in non ZSL mode.
|
||
|
|
*
|
||
|
|
* PARAMETERS : None
|
||
|
|
*
|
||
|
|
* RETURN : true -- capture running in non ZSL mode
|
||
|
|
* false -- Either in not capture mode or captur is not in non ZSL mode
|
||
|
|
*==========================================================================*/
|
||
|
|
bool QCameraStateMachine::isNonZSLCaptureRunning()
|
||
|
|
{
|
||
|
|
switch (m_state) {
|
||
|
|
case QCAMERA_SM_STATE_PIC_TAKING:
|
||
|
|
return true;
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*===========================================================================
|
||
|
|
* FUNCTION : dump
|
||
|
|
*
|
||
|
|
* DESCRIPTION: Composes a string based on current configuration
|
||
|
|
*
|
||
|
|
* PARAMETERS : none
|
||
|
|
*
|
||
|
|
* RETURN : Formatted string
|
||
|
|
*==========================================================================*/
|
||
|
|
String8 QCameraStateMachine::dump()
|
||
|
|
{
|
||
|
|
String8 str("\n");
|
||
|
|
char s[128];
|
||
|
|
|
||
|
|
snprintf(s, 128, "Is Preview Running: %d\n", isPreviewRunning());
|
||
|
|
str += s;
|
||
|
|
|
||
|
|
snprintf(s, 128, "Is Capture Running: %d\n", isCaptureRunning());
|
||
|
|
str += s;
|
||
|
|
|
||
|
|
snprintf(s, 128, "Is Non ZSL Capture Running: %d\n",
|
||
|
|
isNonZSLCaptureRunning());
|
||
|
|
str += s;
|
||
|
|
|
||
|
|
snprintf(s, 128, "Current State: %d \n", m_state);
|
||
|
|
str += s;
|
||
|
|
|
||
|
|
switch(m_state){
|
||
|
|
case QCAMERA_SM_STATE_PREVIEW_STOPPED:
|
||
|
|
snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEW_STOPPED \n");
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QCAMERA_SM_STATE_PREVIEW_READY:
|
||
|
|
snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEW_READY \n");
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QCAMERA_SM_STATE_PREVIEWING:
|
||
|
|
snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEWING \n");
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QCAMERA_SM_STATE_PREPARE_SNAPSHOT:
|
||
|
|
snprintf(s, 128, " QCAMERA_SM_STATE_PREPARE_SNAPSHOT \n");
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QCAMERA_SM_STATE_PIC_TAKING:
|
||
|
|
snprintf(s, 128, " QCAMERA_SM_STATE_PIC_TAKING \n");
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QCAMERA_SM_STATE_RECORDING:
|
||
|
|
snprintf(s, 128, " QCAMERA_SM_STATE_RECORDING \n");
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
|
||
|
|
snprintf(s, 128, " QCAMERA_SM_STATE_VIDEO_PIC_TAKING \n");
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
|
||
|
|
snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEW_PIC_TAKING \n");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
str += s;
|
||
|
|
|
||
|
|
return str;
|
||
|
|
}
|
||
|
|
|
||
|
|
}; // namespace qcamera
|