1/* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved. 2* 3* Redistribution and use in source and binary forms, with or without 4* modification, are permitted provided that the following conditions are 5* met: 6* * Redistributions of source code must retain the above copyright 7* notice, this list of conditions and the following disclaimer. 8* * Redistributions in binary form must reproduce the above 9* copyright notice, this list of conditions and the following 10* disclaimer in the documentation and/or other materials provided 11* with the distribution. 12* * Neither the name of The Linux Foundation nor the names of its 13* contributors may be used to endorse or promote products derived 14* from this software without specific prior written permission. 15* 16* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 17* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 19* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 20* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 23* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 25* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 26* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27* 28*/ 29 30#define LOG_TAG "QCameraStateMachine" 31 32// System dependencies 33#include <utils/Errors.h> 34#include <stdio.h> 35 36// Camera dependencies 37#include "QCamera2HWI.h" 38#include "QCameraStateMachine.h" 39 40extern "C" { 41#include "mm_camera_dbg.h" 42} 43 44namespace qcamera { 45 46/*=========================================================================== 47 * FUNCTION : smEvtProcRoutine 48 * 49 * DESCRIPTION: Statemachine process thread routine to handle events 50 * in different state. 51 * 52 * PARAMETERS : 53 * @data : ptr to QCameraStateMachine object 54 * 55 * RETURN : none 56 *==========================================================================*/ 57void *QCameraStateMachine::smEvtProcRoutine(void *data) 58{ 59 int running = 1, ret; 60 QCameraStateMachine *pme = (QCameraStateMachine *)data; 61 62 LOGH("E"); 63 do { 64 do { 65 ret = cam_sem_wait(&pme->cmd_sem); 66 if (ret != 0 && errno != EINVAL) { 67 LOGE("cam_sem_wait error (%s)", 68 strerror(errno)); 69 return NULL; 70 } 71 } while (ret != 0); 72 73 // we got notified about new cmd avail in cmd queue 74 // first check API cmd queue 75 qcamera_sm_cmd_t *node = (qcamera_sm_cmd_t *)pme->api_queue.dequeue(); 76 if (node == NULL) { 77 // no API cmd, then check evt cmd queue 78 node = (qcamera_sm_cmd_t *)pme->evt_queue.dequeue(); 79 } 80 if (node != NULL) { 81 switch (node->cmd) { 82 case QCAMERA_SM_CMD_TYPE_API: 83 pme->stateMachine(node->evt, node->evt_payload); 84 // API is in a way sync call, so evt_payload is managed by HWI 85 // no need to free payload for API 86 break; 87 case QCAMERA_SM_CMD_TYPE_EVT: 88 pme->stateMachine(node->evt, node->evt_payload); 89 90 // EVT is async call, so payload need to be free after use 91 free(node->evt_payload); 92 node->evt_payload = NULL; 93 break; 94 case QCAMERA_SM_CMD_TYPE_EXIT: 95 running = 0; 96 break; 97 default: 98 break; 99 } 100 free(node); 101 node = NULL; 102 } 103 } while (running); 104 LOGH("X"); 105 return NULL; 106} 107 108/*=========================================================================== 109 * FUNCTION : QCameraStateMachine 110 * 111 * DESCRIPTION: constructor of QCameraStateMachine. Will start process thread 112 * 113 * PARAMETERS : 114 * @ctrl : ptr to HWI object 115 * 116 * RETURN : none 117 *==========================================================================*/ 118QCameraStateMachine::QCameraStateMachine(QCamera2HardwareInterface *ctrl) : 119 api_queue(), 120 evt_queue() 121{ 122 m_parent = ctrl; 123 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 124 cmd_pid = 0; 125 cam_sem_init(&cmd_sem, 0); 126 pthread_create(&cmd_pid, 127 NULL, 128 smEvtProcRoutine, 129 this); 130 pthread_setname_np(cmd_pid, "CAM_stMachine"); 131 m_bDelayPreviewMsgs = false; 132 m_DelayedMsgs = 0; 133 m_RestoreZSL = TRUE; 134 m_bPreviewCallbackNeeded = TRUE; 135} 136 137/*=========================================================================== 138 * FUNCTION : ~QCameraStateMachine 139 * 140 * DESCRIPTION: desctructor of QCameraStateMachine. Will stop process thread. 141 * 142 * PARAMETERS : none 143 * 144 * RETURN : none 145 *==========================================================================*/ 146QCameraStateMachine::~QCameraStateMachine() 147{ 148 cam_sem_destroy(&cmd_sem); 149} 150 151/*=========================================================================== 152 * FUNCTION : releaseThread 153 * 154 * DESCRIPTION: Sends an exit command and terminates the state machine thread 155 * 156 * PARAMETERS : none 157 * 158 * RETURN : none 159 *==========================================================================*/ 160void QCameraStateMachine::releaseThread() 161{ 162 if (cmd_pid != 0) { 163 qcamera_sm_cmd_t *node = 164 (qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t)); 165 if (NULL != node) { 166 memset(node, 0, sizeof(qcamera_sm_cmd_t)); 167 node->cmd = QCAMERA_SM_CMD_TYPE_EXIT; 168 169 if (api_queue.enqueue((void *)node)) { 170 cam_sem_post(&cmd_sem); 171 } else { 172 free(node); 173 node = NULL; 174 } 175 176 /* wait until cmd thread exits */ 177 if (pthread_join(cmd_pid, NULL) != 0) { 178 LOGW("pthread dead already\n"); 179 } 180 } 181 cmd_pid = 0; 182 } 183} 184 185/*=========================================================================== 186 * FUNCTION : applyDelayedMsgs 187 * 188 * DESCRIPTION: Enable if needed any delayed message types 189 * 190 * PARAMETERS : None 191 * RETURN : int32_t type of status 192 * NO_ERROR -- success 193 * none-zero failure code 194 *==========================================================================*/ 195int32_t QCameraStateMachine::applyDelayedMsgs() 196{ 197 int32_t rc = NO_ERROR; 198 199 if (m_bDelayPreviewMsgs && m_DelayedMsgs) { 200 rc = m_parent->enableMsgType(m_DelayedMsgs); 201 m_bDelayPreviewMsgs = false; 202 m_DelayedMsgs = 0; 203 } else if (m_bDelayPreviewMsgs) { 204 m_bDelayPreviewMsgs = false; 205 } 206 207 return rc; 208} 209 210/*=========================================================================== 211 * FUNCTION : procAPI 212 * 213 * DESCRIPTION: process incoming API request from framework layer. 214 * 215 * PARAMETERS : 216 * @evt : event to be processed 217 * @api_payload : API payload. Can be NULL if not needed. 218 * 219 * RETURN : int32_t type of status 220 * NO_ERROR -- success 221 * none-zero failure code 222 *==========================================================================*/ 223int32_t QCameraStateMachine::procAPI(qcamera_sm_evt_enum_t evt, 224 void *api_payload) 225{ 226 qcamera_sm_cmd_t *node = 227 (qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t)); 228 if (NULL == node) { 229 LOGE("No memory for qcamera_sm_cmd_t"); 230 return NO_MEMORY; 231 } 232 233 memset(node, 0, sizeof(qcamera_sm_cmd_t)); 234 node->cmd = QCAMERA_SM_CMD_TYPE_API; 235 node->evt = evt; 236 node->evt_payload = api_payload; 237 if (api_queue.enqueue((void *)node)) { 238 cam_sem_post(&cmd_sem); 239 return NO_ERROR; 240 } else { 241 LOGE("API enqueue failed API = %d", evt); 242 free(node); 243 return UNKNOWN_ERROR; 244 } 245} 246 247/*=========================================================================== 248 * FUNCTION : procEvt 249 * 250 * DESCRIPTION: process incoming envent from mm-camera-interface and 251 * mm-jpeg-interface. 252 * 253 * PARAMETERS : 254 * @evt : event to be processed 255 * @evt_payload : event payload. Can be NULL if not needed. 256 * 257 * RETURN : int32_t type of status 258 * NO_ERROR -- success 259 * none-zero failure code 260 *==========================================================================*/ 261int32_t QCameraStateMachine::procEvt(qcamera_sm_evt_enum_t evt, 262 void *evt_payload) 263{ 264 qcamera_sm_cmd_t *node = 265 (qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t)); 266 if (NULL == node) { 267 LOGE("No memory for qcamera_sm_cmd_t"); 268 return NO_MEMORY; 269 } 270 271 memset(node, 0, sizeof(qcamera_sm_cmd_t)); 272 node->cmd = QCAMERA_SM_CMD_TYPE_EVT; 273 node->evt = evt; 274 node->evt_payload = evt_payload; 275 if (evt_queue.enqueue((void *)node)) { 276 cam_sem_post(&cmd_sem); 277 return NO_ERROR; 278 } else { 279 LOGE("EVENT enqueue failed Event = %d", evt); 280 free(node); 281 return UNKNOWN_ERROR; 282 } 283} 284 285/*=========================================================================== 286 * FUNCTION : stateMachine 287 * 288 * DESCRIPTION: finite state machine entry function. Depends on state, 289 * incoming event will be handled differently. 290 * 291 * PARAMETERS : 292 * @evt : event to be processed 293 * @payload : event payload. Can be NULL if not needed. 294 * 295 * RETURN : int32_t type of status 296 * NO_ERROR -- success 297 * none-zero failure code 298 *==========================================================================*/ 299int32_t QCameraStateMachine::stateMachine(qcamera_sm_evt_enum_t evt, void *payload) 300{ 301 int32_t rc = NO_ERROR; 302 LOGL("m_state %d, event (%d)", m_state, evt); 303 switch (m_state) { 304 case QCAMERA_SM_STATE_PREVIEW_STOPPED: 305 rc = procEvtPreviewStoppedState(evt, payload); 306 break; 307 case QCAMERA_SM_STATE_PREVIEW_READY: 308 rc = procEvtPreviewReadyState(evt, payload); 309 break; 310 case QCAMERA_SM_STATE_PREVIEWING: 311 rc = procEvtPreviewingState(evt, payload); 312 break; 313 case QCAMERA_SM_STATE_PREPARE_SNAPSHOT: 314 rc = procEvtPrepareSnapshotState(evt, payload); 315 break; 316 case QCAMERA_SM_STATE_PIC_TAKING: 317 rc = procEvtPicTakingState(evt, payload); 318 break; 319 case QCAMERA_SM_STATE_RECORDING: 320 rc = procEvtRecordingState(evt, payload); 321 break; 322 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 323 rc = procEvtVideoPicTakingState(evt, payload); 324 break; 325 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING: 326 rc = procEvtPreviewPicTakingState(evt, payload); 327 break; 328 default: 329 break; 330 } 331 332 return rc; 333} 334 335/*=========================================================================== 336 * FUNCTION : procEvtPreviewStoppedState 337 * 338 * DESCRIPTION: finite state machine function to handle event in state of 339 * QCAMERA_SM_STATE_PREVIEW_STOPPED. 340 * 341 * PARAMETERS : 342 * @evt : event to be processed 343 * @payload : event payload. Can be NULL if not needed. 344 * 345 * RETURN : int32_t type of status 346 * NO_ERROR -- success 347 * none-zero failure code 348 *==========================================================================*/ 349int32_t QCameraStateMachine::procEvtPreviewStoppedState(qcamera_sm_evt_enum_t evt, 350 void *payload) 351{ 352 int32_t rc = NO_ERROR; 353 qcamera_api_result_t result; 354 memset(&result, 0, sizeof(qcamera_api_result_t)); 355 356 LOGL("event (%d)", evt); 357 switch (evt) { 358 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 359 { 360 rc = m_parent->setPreviewWindow((struct preview_stream_ops *)payload); 361 result.status = rc; 362 result.request_api = evt; 363 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 364 m_parent->signalAPIResult(&result); 365 } 366 break; 367 case QCAMERA_SM_EVT_SET_CALLBACKS: 368 { 369 qcamera_sm_evt_setcb_payload_t *setcbs = 370 (qcamera_sm_evt_setcb_payload_t *)payload; 371 rc = m_parent->setCallBacks(setcbs->notify_cb, 372 setcbs->data_cb, 373 setcbs->data_cb_timestamp, 374 setcbs->get_memory, 375 setcbs->user); 376 result.status = rc; 377 result.request_api = evt; 378 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 379 m_parent->signalAPIResult(&result); 380 } 381 break; 382 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 383 { 384 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 385 if (NO_ERROR != rc) { 386 LOGE("Param init deferred work failed"); 387 } else { 388 rc = m_parent->enableMsgType(*((int32_t *)payload)); 389 } 390 result.status = rc; 391 result.request_api = evt; 392 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 393 m_parent->signalAPIResult(&result); 394 } 395 break; 396 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 397 { 398 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 399 if (NO_ERROR != rc) { 400 LOGE("Param init deferred work failed"); 401 } else { 402 rc = m_parent->disableMsgType(*((int32_t *)payload)); 403 } 404 result.status = rc; 405 result.request_api = evt; 406 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 407 m_parent->signalAPIResult(&result); 408 } 409 break; 410 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 411 { 412 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 413 result.status = rc; 414 result.request_api = evt; 415 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 416 result.enabled = enabled; 417 m_parent->signalAPIResult(&result); 418 } 419 break; 420 case QCAMERA_SM_EVT_SET_PARAMS: 421 { 422 bool needRestart = false; 423 424 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 425 if (NO_ERROR != rc) { 426 LOGE("Param init deferred work failed"); 427 } else { 428 rc = m_parent->updateParameters((char*)payload, needRestart); 429 } 430 result.status = rc; 431 result.request_api = evt; 432 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 433 m_parent->signalAPIResult(&result); 434 } 435 break; 436 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 437 { 438 m_parent->m_memoryPool.clear(); 439 result.status = rc; 440 result.request_api = evt; 441 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 442 m_parent->signalAPIResult(&result); 443 } 444 break; 445 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 446 { 447 rc = m_parent->commitParameterChanges(); 448 result.status = rc; 449 result.request_api = evt; 450 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 451 m_parent->signalAPIResult(&result); 452 } 453 break; 454 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 455 { 456 m_parent->setNeedRestart(false); 457 result.status = rc; 458 result.request_api = evt; 459 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 460 m_parent->signalAPIResult(&result); 461 } 462 break; 463 case QCAMERA_SM_EVT_GET_PARAMS: 464 { 465 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 466 if (NO_ERROR != rc) { 467 LOGE("Param init deferred work failed"); 468 char* nullParams = (char *)malloc(1); 469 if (nullParams) { 470 memset(nullParams, 0, 1); 471 } 472 result.params = nullParams; 473 } else { 474 result.params = m_parent->getParameters(); 475 } 476 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 477 result.status = rc; 478 result.request_api = evt; 479 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 480 m_parent->signalAPIResult(&result); 481 } 482 break; 483 case QCAMERA_SM_EVT_PUT_PARAMS: 484 { 485 rc = m_parent->putParameters((char*)payload); 486 result.status = rc; 487 result.request_api = evt; 488 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 489 m_parent->signalAPIResult(&result); 490 } 491 break; 492 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 493 { 494 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 495 if (NO_ERROR != rc) { 496 LOGE("Param init deferred work failed"); 497 } else { 498 rc = m_parent->preparePreview(); 499 } 500 if (rc == NO_ERROR) { 501 //prepare preview success, move to ready state 502 m_state = QCAMERA_SM_STATE_PREVIEW_READY; 503 } 504 result.status = rc; 505 result.request_api = evt; 506 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 507 m_parent->signalAPIResult(&result); 508 } 509 break; 510 case QCAMERA_SM_EVT_START_PREVIEW: 511 { 512 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 513 if (NO_ERROR != rc) { 514 LOGE("Param init deferred work failed"); 515 } else if (m_parent->mPreviewWindow == NULL) { 516 rc = m_parent->preparePreview(); 517 if(rc == NO_ERROR) { 518 // preview window is not set yet, move to previewReady state 519 m_state = QCAMERA_SM_STATE_PREVIEW_READY; 520 } else { 521 LOGE("preparePreview failed"); 522 } 523 } else { 524 rc = m_parent->preparePreview(); 525 if (rc == NO_ERROR) { 526 applyDelayedMsgs(); 527 rc = m_parent->startPreview(); 528 if (rc != NO_ERROR) { 529 m_parent->unpreparePreview(); 530 } else { 531 // start preview success, move to previewing state 532 m_state = QCAMERA_SM_STATE_PREVIEWING; 533 } 534 } 535 } 536 result.status = rc; 537 result.request_api = evt; 538 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 539 m_parent->signalAPIResult(&result); 540 } 541 break; 542 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 543 { 544 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 545 if (NO_ERROR != rc) { 546 LOGE("Param init deferred work failed"); 547 } else { 548 rc = m_parent->preparePreview(); 549 } 550 if (rc == NO_ERROR) { 551 applyDelayedMsgs(); 552 rc = m_parent->startPreview(); 553 if (rc != NO_ERROR) { 554 m_parent->unpreparePreview(); 555 } else { 556 m_state = QCAMERA_SM_STATE_PREVIEWING; 557 } 558 } 559 result.status = rc; 560 result.request_api = evt; 561 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 562 m_parent->signalAPIResult(&result); 563 } 564 break; 565 case QCAMERA_SM_EVT_STOP_PREVIEW: 566 { 567 // no op needed here 568 LOGW("already in preview stopped state, do nothing"); 569 result.status = NO_ERROR; 570 result.request_api = evt; 571 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 572 m_parent->signalAPIResult(&result); 573 } 574 break; 575 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 576 case QCAMERA_SM_EVT_RECORDING_ENABLED: 577 { 578 result.status = NO_ERROR; 579 result.request_api = evt; 580 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 581 result.enabled = 0; 582 m_parent->signalAPIResult(&result); 583 } 584 break; 585 case QCAMERA_SM_EVT_RELEASE: 586 { 587 rc = m_parent->release(); 588 result.status = rc; 589 result.request_api = evt; 590 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 591 m_parent->signalAPIResult(&result); 592 } 593 break; 594 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 595 { 596 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 597 result.status = rc; 598 result.request_api = evt; 599 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 600 m_parent->signalAPIResult(&result); 601 } 602 break; 603 case QCAMERA_SM_EVT_DUMP: 604 { 605 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 606 if (NO_ERROR != rc) { 607 LOGE("Param init deferred work failed"); 608 } else { 609 rc = m_parent->dump(*((int *)payload)); 610 } 611 result.status = rc; 612 result.request_api = evt; 613 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 614 m_parent->signalAPIResult(&result); 615 } 616 break; 617 case QCAMERA_SM_EVT_SEND_COMMAND: 618 { 619 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 620 if (NO_ERROR != rc) { 621 LOGE("Param init deferred work failed"); 622 } else { 623 qcamera_sm_evt_command_payload_t *cmd_payload = 624 (qcamera_sm_evt_command_payload_t *)payload; 625 rc = m_parent->sendCommand(cmd_payload->cmd, 626 cmd_payload->arg1, 627 cmd_payload->arg2); 628 } 629 result.status = rc; 630 result.request_api = evt; 631 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 632 m_parent->signalAPIResult(&result); 633 } 634 break; 635 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 636 { 637 LOGW("Free video handle %d %d", evt, m_state); 638 QCameraVideoMemory::closeNativeHandle((const void *)payload); 639 } 640 case QCAMERA_SM_EVT_PRE_START_RECORDING: 641 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 642 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 643 case QCAMERA_SM_EVT_START_RECORDING: 644 case QCAMERA_SM_EVT_STOP_RECORDING: 645 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 646 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 647 case QCAMERA_SM_EVT_TAKE_PICTURE: 648 { 649 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 650 rc = INVALID_OPERATION; 651 result.status = rc; 652 result.request_api = evt; 653 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 654 m_parent->signalAPIResult(&result); 655 } 656 break; 657 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 658 case QCAMERA_SM_EVT_CANCEL_PICTURE: 659 { 660 // no op needed here 661 LOGW("No ops for evt(%d) in state(%d)", evt, m_state); 662 result.status = NO_ERROR; 663 result.request_api = evt; 664 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 665 m_parent->signalAPIResult(&result); 666 } 667 break; 668 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 669 { 670 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 671 if (NO_ERROR != rc) { 672 LOGE("Param init deferred work failed"); 673 } else { 674 rc = m_parent->cancelAutoFocus(); 675 } 676 result.status = rc; 677 result.request_api = evt; 678 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 679 m_parent->signalAPIResult(&result); 680 } 681 break; 682 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 683 { 684 int32_t faceID = 0; 685 qcamera_sm_evt_reg_face_payload_t *reg_payload = 686 (qcamera_sm_evt_reg_face_payload_t *)payload; 687 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 688 reg_payload->config, 689 faceID); 690 result.status = rc; 691 result.request_api = evt; 692 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 693 result.handle = faceID; 694 m_parent->signalAPIResult(&result); 695 } 696 break; 697 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 698 { 699 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 700 if (NO_ERROR != rc) { 701 LOGE("Param init deferred work failed"); 702 } else { 703 rc = m_parent->updateThermalLevel(payload); 704 } 705 } 706 break; 707 case QCAMERA_SM_EVT_EVT_NOTIFY: 708 { 709 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 710 switch (cam_evt->server_event_type) { 711 case CAM_EVENT_TYPE_DAEMON_DIED: 712 { 713 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 714 CAMERA_ERROR_SERVER_DIED, 715 0); 716 } 717 break; 718 default: 719 LOGE("Invalid internal event %d in state(%d)", 720 cam_evt->server_event_type, m_state); 721 break; 722 } 723 } 724 break; 725 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 726 { 727 // No ops, but need to notify 728 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 729 result.status = rc; 730 result.request_api = evt; 731 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 732 m_parent->signalEvtResult(&result); 733 } 734 break; 735 case QCAMERA_SM_EVT_EVT_INTERNAL: 736 { 737 qcamera_sm_internal_evt_payload_t *internal_evt = 738 (qcamera_sm_internal_evt_payload_t *)payload; 739 switch (internal_evt->evt_type) { 740 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 741 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 742 if (NO_ERROR != rc) { 743 LOGE("Param init deferred work failed"); 744 } else { 745 rc = m_parent->mParameters.updateFlashMode(internal_evt->led_data); 746 } 747 break; 748 default: 749 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 750 break; 751 } 752 } 753 break; 754 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 755 default: 756 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 757 break; 758 } 759 760 return rc; 761} 762 763/*=========================================================================== 764 * FUNCTION : procEvtPreviewReadyState 765 * 766 * DESCRIPTION: finite state machine function to handle event in state of 767 * QCAMERA_SM_STATE_PREVIEW_READY. 768 * 769 * PARAMETERS : 770 * @evt : event to be processed 771 * @payload : event payload. Can be NULL if not needed. 772 * 773 * RETURN : int32_t type of status 774 * NO_ERROR -- success 775 * none-zero failure code 776 *==========================================================================*/ 777int32_t QCameraStateMachine::procEvtPreviewReadyState(qcamera_sm_evt_enum_t evt, 778 void *payload) 779{ 780 int32_t rc = NO_ERROR; 781 qcamera_api_result_t result; 782 memset(&result, 0, sizeof(qcamera_api_result_t)); 783 784 LOGL("event (%d)", evt); 785 switch (evt) { 786 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 787 { 788 m_parent->setPreviewWindow((struct preview_stream_ops *)payload); 789 if (m_parent->mPreviewWindow != NULL) { 790 applyDelayedMsgs(); 791 rc = m_parent->startPreview(); 792 if (rc != NO_ERROR) { 793 m_parent->unpreparePreview(); 794 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 795 } else { 796 m_state = QCAMERA_SM_STATE_PREVIEWING; 797 } 798 } 799 800 result.status = rc; 801 result.request_api = evt; 802 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 803 m_parent->signalAPIResult(&result); 804 } 805 break; 806 case QCAMERA_SM_EVT_SET_CALLBACKS: 807 { 808 qcamera_sm_evt_setcb_payload_t *setcbs = 809 (qcamera_sm_evt_setcb_payload_t *)payload; 810 rc = m_parent->setCallBacks(setcbs->notify_cb, 811 setcbs->data_cb, 812 setcbs->data_cb_timestamp, 813 setcbs->get_memory, 814 setcbs->user); 815 result.status = rc; 816 result.request_api = evt; 817 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 818 m_parent->signalAPIResult(&result); 819 } 820 break; 821 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 822 { 823 rc = m_parent->enableMsgType(*((int32_t *)payload)); 824 result.status = rc; 825 result.request_api = evt; 826 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 827 m_parent->signalAPIResult(&result); 828 } 829 break; 830 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 831 { 832 rc = m_parent->disableMsgType(*((int32_t *)payload)); 833 result.status = rc; 834 result.request_api = evt; 835 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 836 m_parent->signalAPIResult(&result); 837 } 838 break; 839 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 840 { 841 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 842 result.status = rc; 843 result.request_api = evt; 844 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 845 result.enabled = enabled; 846 m_parent->signalAPIResult(&result); 847 } 848 break; 849 case QCAMERA_SM_EVT_SET_PARAMS: 850 { 851 bool needRestart = false; 852 rc = m_parent->updateParameters((char*)payload, needRestart); 853 result.status = rc; 854 result.request_api = evt; 855 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 856 m_parent->signalAPIResult(&result); 857 } 858 break; 859 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 860 { 861 LOGD("Stopping preview..."); 862 // need restart preview for parameters to take effect 863 m_parent->unpreparePreview(); 864 // Clear memory pools 865 m_parent->m_memoryPool.clear(); 866 result.status = rc; 867 result.request_api = evt; 868 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 869 m_parent->signalAPIResult(&result); 870 } 871 break; 872 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 873 { 874 rc = m_parent->commitParameterChanges(); 875 result.status = rc; 876 result.request_api = evt; 877 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 878 m_parent->signalAPIResult(&result); 879 } 880 break; 881 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 882 { 883 // prepare preview again 884 rc = m_parent->preparePreview(); 885 if (rc != NO_ERROR) { 886 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 887 } 888 m_parent->setNeedRestart(false); 889 result.status = rc; 890 result.request_api = evt; 891 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 892 m_parent->signalAPIResult(&result); 893 } 894 break; 895 case QCAMERA_SM_EVT_GET_PARAMS: 896 { 897 result.params = m_parent->getParameters(); 898 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 899 result.status = rc; 900 result.request_api = evt; 901 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 902 m_parent->signalAPIResult(&result); 903 } 904 break; 905 case QCAMERA_SM_EVT_PUT_PARAMS: 906 { 907 rc = m_parent->putParameters((char*)payload); 908 result.status = rc; 909 result.request_api = evt; 910 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 911 m_parent->signalAPIResult(&result); 912 } 913 break; 914 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 915 { 916 // no ops here 917 rc = NO_ERROR; 918 result.status = rc; 919 result.request_api = evt; 920 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 921 m_parent->signalAPIResult(&result); 922 } 923 break; 924 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 925 { 926 rc = m_parent->startPreview(); 927 if (rc != NO_ERROR) { 928 m_parent->unpreparePreview(); 929 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 930 } else { 931 m_state = QCAMERA_SM_STATE_PREVIEWING; 932 } 933 // no ops here 934 rc = NO_ERROR; 935 result.status = rc; 936 result.request_api = evt; 937 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 938 m_parent->signalAPIResult(&result); 939 } 940 break; 941 case QCAMERA_SM_EVT_START_PREVIEW: 942 { 943 if (m_parent->mPreviewWindow != NULL) { 944 rc = m_parent->startPreview(); 945 if (rc != NO_ERROR) { 946 m_parent->unpreparePreview(); 947 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 948 } else { 949 m_state = QCAMERA_SM_STATE_PREVIEWING; 950 } 951 } 952 // no ops here 953 rc = NO_ERROR; 954 result.status = rc; 955 result.request_api = evt; 956 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 957 m_parent->signalAPIResult(&result); 958 } 959 break; 960 case QCAMERA_SM_EVT_STOP_PREVIEW: 961 { 962 m_parent->unpreparePreview(); 963 rc = 0; 964 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 965 result.status = rc; 966 result.request_api = evt; 967 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 968 m_parent->signalAPIResult(&result); 969 } 970 break; 971 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 972 { 973 rc = NO_ERROR; 974 result.status = rc; 975 result.request_api = evt; 976 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 977 result.enabled = 1; 978 m_parent->signalAPIResult(&result); 979 } 980 break; 981 case QCAMERA_SM_EVT_RECORDING_ENABLED: 982 { 983 rc = 0; 984 result.status = rc; 985 result.request_api = evt; 986 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 987 result.enabled = 0; 988 m_parent->signalAPIResult(&result); 989 } 990 break; 991 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 992 { 993 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 994 result.status = rc; 995 result.request_api = evt; 996 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 997 m_parent->signalAPIResult(&result); 998 } 999 break; 1000 case QCAMERA_SM_EVT_DUMP: 1001 { 1002 rc = m_parent->dump(*((int *)payload)); 1003 result.status = rc; 1004 result.request_api = evt; 1005 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1006 m_parent->signalAPIResult(&result); 1007 } 1008 break; 1009 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 1010 { 1011 rc = m_parent->autoFocus(); 1012 result.status = rc; 1013 result.request_api = evt; 1014 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1015 m_parent->signalAPIResult(&result); 1016 } 1017 break; 1018 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 1019 { 1020 rc = m_parent->cancelAutoFocus(); 1021 result.status = rc; 1022 result.request_api = evt; 1023 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1024 m_parent->signalAPIResult(&result); 1025 } 1026 break; 1027 case QCAMERA_SM_EVT_SEND_COMMAND: 1028 { 1029 qcamera_sm_evt_command_payload_t *cmd_payload = 1030 (qcamera_sm_evt_command_payload_t *)payload; 1031 rc = m_parent->sendCommand(cmd_payload->cmd, 1032 cmd_payload->arg1, 1033 cmd_payload->arg2); 1034 result.status = rc; 1035 result.request_api = evt; 1036 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1037 m_parent->signalAPIResult(&result); 1038 } 1039 break; 1040 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 1041 { 1042 int32_t faceID = 0; 1043 qcamera_sm_evt_reg_face_payload_t *reg_payload = 1044 (qcamera_sm_evt_reg_face_payload_t *)payload; 1045 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 1046 reg_payload->config, 1047 faceID); 1048 result.status = rc; 1049 result.request_api = evt; 1050 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 1051 result.handle = faceID; 1052 m_parent->signalAPIResult(&result); 1053 } 1054 break; 1055 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 1056 { 1057 LOGW("Free video handle %d %d", evt, m_state); 1058 QCameraVideoMemory::closeNativeHandle((const void *)payload); 1059 } 1060 case QCAMERA_SM_EVT_PRE_START_RECORDING: 1061 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 1062 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 1063 case QCAMERA_SM_EVT_START_RECORDING: 1064 case QCAMERA_SM_EVT_STOP_RECORDING: 1065 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 1066 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 1067 case QCAMERA_SM_EVT_TAKE_PICTURE: 1068 case QCAMERA_SM_EVT_CANCEL_PICTURE: 1069 case QCAMERA_SM_EVT_RELEASE: 1070 { 1071 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 1072 rc = INVALID_OPERATION; 1073 result.status = rc; 1074 result.request_api = evt; 1075 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1076 m_parent->signalAPIResult(&result); 1077 } 1078 break; 1079 case QCAMERA_SM_EVT_EVT_NOTIFY: 1080 { 1081 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 1082 switch (cam_evt->server_event_type) { 1083 case CAM_EVENT_TYPE_DAEMON_DIED: 1084 { 1085 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 1086 CAMERA_ERROR_SERVER_DIED, 1087 0); 1088 } 1089 break; 1090 default: 1091 LOGE("Invalid internal event %d in state(%d)", 1092 cam_evt->server_event_type, m_state); 1093 break; 1094 } 1095 } 1096 break; 1097 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 1098 { 1099 // No ops, but need to notify 1100 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1101 result.status = rc; 1102 result.request_api = evt; 1103 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1104 m_parent->signalEvtResult(&result); 1105 } 1106 break; 1107 case QCAMERA_SM_EVT_EVT_INTERNAL: 1108 { 1109 qcamera_sm_internal_evt_payload_t *internal_evt = 1110 (qcamera_sm_internal_evt_payload_t *)payload; 1111 switch (internal_evt->evt_type) { 1112 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 1113 rc = m_parent->mParameters.updateFlashMode(internal_evt->led_data); 1114 break; 1115 default: 1116 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1117 break; 1118 } 1119 } 1120 break; 1121 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 1122 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 1123 default: 1124 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1125 break; 1126 } 1127 1128 return rc; 1129} 1130 1131/*=========================================================================== 1132 * FUNCTION : procEvtPreviewingState 1133 * 1134 * DESCRIPTION: finite state machine function to handle event in state of 1135 * QCAMERA_SM_STATE_PREVIEWING. 1136 * 1137 * PARAMETERS : 1138 * @evt : event to be processed 1139 * @payload : event payload. Can be NULL if not needed. 1140 * 1141 * RETURN : int32_t type of status 1142 * NO_ERROR -- success 1143 * none-zero failure code 1144 *==========================================================================*/ 1145int32_t QCameraStateMachine::procEvtPreviewingState(qcamera_sm_evt_enum_t evt, 1146 void *payload) 1147{ 1148 int32_t rc = NO_ERROR; 1149 qcamera_api_result_t result; 1150 memset(&result, 0, sizeof(qcamera_api_result_t)); 1151 1152 LOGL("event (%d)", evt); 1153 switch (evt) { 1154 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 1155 { 1156 // Error setting preview window during previewing 1157 LOGE("Error!! cannot set preview window when preview is running"); 1158 rc = INVALID_OPERATION; 1159 result.status = rc; 1160 result.request_api = evt; 1161 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1162 m_parent->signalAPIResult(&result); 1163 } 1164 break; 1165 case QCAMERA_SM_EVT_SET_CALLBACKS: 1166 { 1167 qcamera_sm_evt_setcb_payload_t *setcbs = 1168 (qcamera_sm_evt_setcb_payload_t *)payload; 1169 rc = m_parent->setCallBacks(setcbs->notify_cb, 1170 setcbs->data_cb, 1171 setcbs->data_cb_timestamp, 1172 setcbs->get_memory, 1173 setcbs->user); 1174 result.status = rc; 1175 result.request_api = evt; 1176 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1177 m_parent->signalAPIResult(&result); 1178 } 1179 break; 1180 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 1181 { 1182 int32_t enable_msgs = *((int32_t *)payload); 1183 if (m_bDelayPreviewMsgs && 1184 (enable_msgs & CAMERA_MSG_PREVIEW_FRAME)) { 1185 enable_msgs &= ~CAMERA_MSG_PREVIEW_FRAME; 1186 m_DelayedMsgs = CAMERA_MSG_PREVIEW_FRAME; 1187 } 1188 rc = m_parent->enableMsgType(enable_msgs); 1189 result.status = rc; 1190 result.request_api = evt; 1191 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1192 m_parent->signalAPIResult(&result); 1193 } 1194 break; 1195 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 1196 { 1197 int32_t disable_msgs = *((int32_t *)payload); 1198 if (m_bDelayPreviewMsgs && m_DelayedMsgs) { 1199 m_DelayedMsgs &= ~disable_msgs; 1200 if (0 == m_DelayedMsgs) { 1201 m_bDelayPreviewMsgs = false; 1202 } 1203 } 1204 rc = m_parent->disableMsgType(disable_msgs); 1205 result.status = rc; 1206 result.request_api = evt; 1207 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1208 m_parent->signalAPIResult(&result); 1209 } 1210 break; 1211 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 1212 { 1213 int32_t msgs = *((int32_t *)payload); 1214 int enabled = m_parent->msgTypeEnabled(msgs); 1215 if (m_bDelayPreviewMsgs && m_DelayedMsgs) { 1216 enabled |= (msgs & m_DelayedMsgs); 1217 } 1218 result.status = rc; 1219 result.request_api = evt; 1220 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1221 result.enabled = enabled; 1222 m_parent->signalAPIResult(&result); 1223 } 1224 break; 1225 case QCAMERA_SM_EVT_SET_PARAMS: 1226 { 1227 bool needRestart = false; 1228 rc = m_parent->updateParameters((char*)payload, needRestart); 1229 result.status = rc; 1230 result.request_api = evt; 1231 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1232 m_parent->signalAPIResult(&result); 1233 } 1234 break; 1235 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 1236 { 1237 LOGD("Stopping preview..."); 1238 // stop preview 1239 rc = m_parent->stopPreview(); 1240 // Clear memory pools 1241 m_parent->m_memoryPool.clear(); 1242 result.status = rc; 1243 result.request_api = evt; 1244 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1245 m_parent->signalAPIResult(&result); 1246 } 1247 break; 1248 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 1249 { 1250 rc = m_parent->commitParameterChanges(); 1251 result.status = rc; 1252 result.request_api = evt; 1253 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1254 m_parent->signalAPIResult(&result); 1255 } 1256 break; 1257 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 1258 { 1259 // start preview again 1260 rc = m_parent->preparePreview(); 1261 if (rc == NO_ERROR) { 1262 applyDelayedMsgs(); 1263 rc = m_parent->startPreview(); 1264 if (rc != NO_ERROR) { 1265 m_parent->unpreparePreview(); 1266 } 1267 if (rc != NO_ERROR) { 1268 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 1269 } 1270 } 1271 m_parent->setNeedRestart(false); 1272 result.status = rc; 1273 result.request_api = evt; 1274 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1275 m_parent->signalAPIResult(&result); 1276 } 1277 break; 1278 case QCAMERA_SM_EVT_GET_PARAMS: 1279 { 1280 result.params = m_parent->getParameters(); 1281 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 1282 result.status = rc; 1283 result.request_api = evt; 1284 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 1285 m_parent->signalAPIResult(&result); 1286 } 1287 break; 1288 case QCAMERA_SM_EVT_PUT_PARAMS: 1289 { 1290 rc = m_parent->putParameters((char*)payload); 1291 result.status = rc; 1292 result.request_api = evt; 1293 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1294 m_parent->signalAPIResult(&result); 1295 } 1296 break; 1297 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 1298 { 1299 // no ops here 1300 LOGW("Already in preview ready state, no ops here"); 1301 rc = NO_ERROR; 1302 result.status = rc; 1303 result.request_api = evt; 1304 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1305 m_parent->signalAPIResult(&result); 1306 } 1307 break; 1308 case QCAMERA_SM_EVT_START_PREVIEW: 1309 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 1310 { 1311 // no ops here 1312 LOGW("Already in previewing, no ops here to start preview"); 1313 applyDelayedMsgs(); 1314 rc = NO_ERROR; 1315 result.status = rc; 1316 result.request_api = evt; 1317 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1318 m_parent->signalAPIResult(&result); 1319 } 1320 break; 1321 case QCAMERA_SM_EVT_STOP_PREVIEW: 1322 { 1323 rc = m_parent->stopPreview(); 1324 applyDelayedMsgs(); 1325 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 1326 result.status = rc; 1327 result.request_api = evt; 1328 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1329 m_parent->signalAPIResult(&result); 1330 } 1331 break; 1332 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 1333 { 1334 applyDelayedMsgs(); 1335 rc = NO_ERROR; 1336 result.status = rc; 1337 result.request_api = evt; 1338 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1339 result.enabled = 1; 1340 m_parent->signalAPIResult(&result); 1341 } 1342 break; 1343 case QCAMERA_SM_EVT_RECORDING_ENABLED: 1344 { 1345 rc = NO_ERROR; 1346 result.status = rc; 1347 result.request_api = evt; 1348 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1349 result.enabled = 0; 1350 m_parent->signalAPIResult(&result); 1351 } 1352 break; 1353 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 1354 { 1355 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 1356 result.status = rc; 1357 result.request_api = evt; 1358 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1359 m_parent->signalAPIResult(&result); 1360 } 1361 break; 1362 case QCAMERA_SM_EVT_DUMP: 1363 { 1364 rc = m_parent->dump(*((int *)payload)); 1365 result.status = rc; 1366 result.request_api = evt; 1367 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1368 m_parent->signalAPIResult(&result); 1369 } 1370 break; 1371 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 1372 { 1373 rc = m_parent->autoFocus(); 1374 result.status = rc; 1375 result.request_api = evt; 1376 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1377 m_parent->signalAPIResult(&result); 1378 } 1379 break; 1380 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 1381 { 1382 rc = m_parent->cancelAutoFocus(); 1383 result.status = rc; 1384 result.request_api = evt; 1385 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1386 m_parent->signalAPIResult(&result); 1387 } 1388 break; 1389 case QCAMERA_SM_EVT_PRE_START_RECORDING: 1390 { 1391 rc = m_parent->preStartRecording(); 1392 result.status = rc; 1393 result.request_api = evt; 1394 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1395 m_parent->signalAPIResult(&result); 1396 } 1397 break; 1398 case QCAMERA_SM_EVT_START_RECORDING: 1399 { 1400 rc = m_parent->startRecording(); 1401 if (rc == NO_ERROR) { 1402 // move state to recording state 1403 m_state = QCAMERA_SM_STATE_RECORDING; 1404 applyDelayedMsgs(); 1405 } 1406 result.status = rc; 1407 result.request_api = evt; 1408 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1409 m_parent->signalAPIResult(&result); 1410 } 1411 break; 1412 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 1413 { 1414 rc = m_parent->prepareHardwareForSnapshot(FALSE); 1415 if (rc == NO_ERROR) { 1416 // Do not signal API result in this case. 1417 // Need to wait for snapshot done in metadta. 1418 m_state = QCAMERA_SM_STATE_PREPARE_SNAPSHOT; 1419 applyDelayedMsgs(); 1420 } else { 1421 // Do not change state in this case. 1422 LOGE("prepareHardwareForSnapshot failed %d", 1423 rc); 1424 1425 result.status = rc; 1426 result.request_api = evt; 1427 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1428 m_parent->signalAPIResult(&result); 1429 } 1430 } 1431 break; 1432 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 1433 { 1434 rc = m_parent->preTakePicture(); 1435 result.status = rc; 1436 result.request_api = evt; 1437 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1438 m_parent->signalAPIResult(&result); 1439 } 1440 break; 1441 case QCAMERA_SM_EVT_TAKE_PICTURE: 1442 { 1443 LOGL("QCAMERA_SM_EVT_TAKE_PICTURE "); 1444 if ( m_parent->mParameters.getRecordingHintValue() == true) { 1445 m_parent->stopPreview(); 1446 m_parent->mParameters.updateRecordingHintValue(FALSE); 1447 // start preview again 1448 rc = m_parent->preparePreview(); 1449 if (rc == NO_ERROR) { 1450 rc = m_parent->startPreview(); 1451 if (rc != NO_ERROR) { 1452 m_parent->unpreparePreview(); 1453 } 1454 } 1455 } 1456 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) { 1457 bool restartPreview = m_parent->isPreviewRestartEnabled(); 1458 if ((restartPreview) && (m_parent->mParameters.getManualCaptureMode() 1459 >= CAM_MANUAL_CAPTURE_TYPE_3)) { 1460 /* stop preview and disable ZSL now */ 1461 m_parent->stopPreview(); 1462 m_parent->mParameters.updateZSLModeValue(FALSE); 1463 m_RestoreZSL = TRUE; 1464 m_bDelayPreviewMsgs = true; 1465 m_state = QCAMERA_SM_STATE_PIC_TAKING; 1466 } else { 1467 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING; 1468 m_bDelayPreviewMsgs = true; 1469 } 1470 1471 rc = m_parent->takePicture(); 1472 if (rc != NO_ERROR) { 1473 // move state to previewing state 1474 m_parent->unconfigureAdvancedCapture(); 1475 m_state = QCAMERA_SM_STATE_PREVIEWING; 1476 } 1477 if (!(m_parent->isRetroPicture()) || (rc != NO_ERROR)) { 1478 LOGD("signal API result, m_state = %d", 1479 m_state); 1480 result.status = rc; 1481 result.request_api = evt; 1482 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1483 m_parent->signalAPIResult(&result); 1484 } 1485 } else { 1486 m_state = QCAMERA_SM_STATE_PIC_TAKING; 1487 rc = m_parent->takePicture(); 1488 if (rc != NO_ERROR) { 1489 int32_t temp_rc = NO_ERROR; 1490 // move state to preview stopped state 1491 m_parent->unconfigureAdvancedCapture(); 1492 m_parent->stopPreview(); 1493 // start preview again 1494 temp_rc = m_parent->preparePreview(); 1495 if (temp_rc == NO_ERROR) { 1496 temp_rc = m_parent->startPreview(); 1497 if (temp_rc != NO_ERROR) { 1498 m_parent->unpreparePreview(); 1499 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 1500 } else { 1501 m_state = QCAMERA_SM_STATE_PREVIEWING; 1502 } 1503 } else { 1504 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 1505 } 1506 } 1507 result.status = rc; 1508 result.request_api = evt; 1509 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1510 m_parent->signalAPIResult(&result); 1511 } 1512 } 1513 break; 1514 case QCAMERA_SM_EVT_SEND_COMMAND: 1515 { 1516 qcamera_sm_evt_command_payload_t *cmd_payload = 1517 (qcamera_sm_evt_command_payload_t *)payload; 1518 rc = m_parent->sendCommand(cmd_payload->cmd, 1519 cmd_payload->arg1, 1520 cmd_payload->arg2); 1521 m_bPreviewNeedsRestart = 1522 (QCAMERA_SM_EVT_RESTART_PERVIEW == cmd_payload->arg1); 1523 m_bPreviewDelayedRestart = 1524 (QCAMERA_SM_EVT_DELAYED_RESTART == cmd_payload->arg2); 1525 1526#ifndef VANILLA_HAL 1527 if ((CAMERA_CMD_LONGSHOT_ON == cmd_payload->cmd) && 1528 (m_bPreviewNeedsRestart)) { 1529 m_parent->stopPreview(); 1530 // Clear memory pools 1531 m_parent->m_memoryPool.clear(); 1532 1533 if (!m_bPreviewDelayedRestart) { 1534 // start preview again 1535 rc = m_parent->preparePreview(); 1536 if (rc == NO_ERROR) { 1537 applyDelayedMsgs(); 1538 rc = m_parent->startPreview(); 1539 if (rc != NO_ERROR) { 1540 m_parent->unpreparePreview(); 1541 } 1542 } 1543 } 1544 } 1545#endif 1546 result.status = rc; 1547 result.request_api = evt; 1548 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1549 m_parent->signalAPIResult(&result); 1550 } 1551 break; 1552 case QCAMERA_SM_EVT_SEND_COMMAND_RESTART: 1553 { 1554#ifndef VANILLA_HAL 1555 qcamera_sm_evt_command_payload_t *cmd_payload = 1556 (qcamera_sm_evt_command_payload_t *)payload; 1557 if ((CAMERA_CMD_LONGSHOT_ON == cmd_payload->cmd) && 1558 (m_bPreviewNeedsRestart) && 1559 (m_bPreviewDelayedRestart)) { 1560 // start preview again 1561 rc = m_parent->preparePreview(); 1562 if (rc == NO_ERROR) { 1563 rc = m_parent->startPreview(); 1564 if (rc != NO_ERROR) { 1565 m_parent->unpreparePreview(); 1566 } 1567 } 1568 } 1569#endif 1570 result.status = rc; 1571 result.request_api = evt; 1572 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1573 m_parent->signalAPIResult(&result); 1574 } 1575 break; 1576 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 1577 { 1578 int32_t faceID = 0; 1579 qcamera_sm_evt_reg_face_payload_t *reg_payload = 1580 (qcamera_sm_evt_reg_face_payload_t *)payload; 1581 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 1582 reg_payload->config, 1583 faceID); 1584 result.status = rc; 1585 result.request_api = evt; 1586 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 1587 result.handle = faceID; 1588 m_parent->signalAPIResult(&result); 1589 } 1590 break; 1591 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 1592 { 1593 LOGW("Free video handle %d %d", evt, m_state); 1594 QCameraVideoMemory::closeNativeHandle((const void *)payload); 1595 } 1596 case QCAMERA_SM_EVT_CANCEL_PICTURE: 1597 case QCAMERA_SM_EVT_STOP_RECORDING: 1598 case QCAMERA_SM_EVT_RELEASE: 1599 { 1600 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 1601 rc = INVALID_OPERATION; 1602 result.status = rc; 1603 result.request_api = evt; 1604 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1605 m_parent->signalAPIResult(&result); 1606 } 1607 break; 1608 case QCAMERA_SM_EVT_EVT_INTERNAL: 1609 { 1610 qcamera_sm_internal_evt_payload_t *internal_evt = 1611 (qcamera_sm_internal_evt_payload_t *)payload; 1612 switch (internal_evt->evt_type) { 1613 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 1614 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 1615 break; 1616 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 1617 break; 1618 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 1619 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 1620 break; 1621 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 1622 rc = m_parent->processHistogramStats(internal_evt->stats_data); 1623 break; 1624 case QCAMERA_INTERNAL_EVT_CROP_INFO: 1625 rc = m_parent->processZoomEvent(internal_evt->crop_data); 1626 break; 1627 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 1628 rc = m_parent->processASDUpdate(internal_evt->asd_data); 1629 break; 1630 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 1631 rc = m_parent->mParameters.updateFlashMode(internal_evt->led_data); 1632 break; 1633 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 1634 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 1635 break; 1636 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 1637 rc = m_parent->processAEInfo(internal_evt->ae_data); 1638 break; 1639 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 1640 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 1641 break; 1642 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 1643 rc = m_parent->processHDRData(internal_evt->hdr_data); 1644 break; 1645 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 1646 rc = m_parent->processRetroAECUnlock(); 1647 break; 1648 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 1649 rc = m_parent->processZSLCaptureDone(); 1650 break; 1651 case QCAMERA_INTERNAL_EVT_DUAL_CAMERA_FOV_CONTROL: 1652 m_parent->processDualCamFovControl(); 1653 break; 1654 case QCAMERA_INTERNAL_EVT_LED_CALIB_UPDATE: 1655 rc = m_parent->processLEDCalibration(internal_evt->led_calib_result); 1656 break; 1657 default: 1658 LOGE("Invalid internal event %d in state(%d)", 1659 internal_evt->evt_type, m_state); 1660 break; 1661 } 1662 } 1663 break; 1664 case QCAMERA_SM_EVT_EVT_NOTIFY: 1665 { 1666 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 1667 switch (cam_evt->server_event_type) { 1668 case CAM_EVENT_TYPE_DAEMON_DIED: 1669 { 1670 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 1671 CAMERA_ERROR_SERVER_DIED, 1672 0); 1673 } 1674 break; 1675 default: 1676 LOGW("no handling for server evt (%d) at this state", 1677 cam_evt->server_event_type); 1678 break; 1679 } 1680 } 1681 break; 1682 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 1683 { 1684 rc = m_parent->updateThermalLevel(payload); 1685 } 1686 break; 1687 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 1688 { 1689 // No ops, but need to notify 1690 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1691 result.status = rc; 1692 result.request_api = evt; 1693 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1694 m_parent->signalEvtResult(&result); 1695 } 1696 break; 1697 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 1698 { 1699 m_parent->stopPreview(); 1700 result.status = rc; 1701 result.request_api = evt; 1702 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1703 m_parent->signalAPIResult(&result); 1704 } 1705 break; 1706 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 1707 { 1708 rc = m_parent->preparePreview(); 1709 if (rc == NO_ERROR) { 1710 rc = m_parent->startPreview(); 1711 } 1712 result.status = rc; 1713 result.request_api = evt; 1714 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1715 m_parent->signalAPIResult(&result); 1716 } 1717 break; 1718 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 1719 default: 1720 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1721 break; 1722 } 1723 1724 return rc; 1725} 1726 1727/*=========================================================================== 1728 * FUNCTION : procEvtPrepareSnapshotState 1729 * 1730 * DESCRIPTION: finite state machine function to handle event in state of 1731 * QCAMERA_SM_STATE_PREPARE_SNAPSHOT. 1732 * 1733 * PARAMETERS : 1734 * @evt : event to be processed 1735 * @payload : event payload. Can be NULL if not needed. 1736 * 1737 * RETURN : int32_t type of status 1738 * NO_ERROR -- success 1739 * none-zero failure code 1740 *==========================================================================*/ 1741int32_t QCameraStateMachine::procEvtPrepareSnapshotState(qcamera_sm_evt_enum_t evt, 1742 void *payload) 1743{ 1744 int32_t rc = NO_ERROR; 1745 qcamera_api_result_t result; 1746 memset(&result, 0, sizeof(qcamera_api_result_t)); 1747 1748 LOGL("event (%d)", evt); 1749 switch (evt) { 1750 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 1751 case QCAMERA_SM_EVT_SET_CALLBACKS: 1752 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 1753 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 1754 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 1755 case QCAMERA_SM_EVT_SET_PARAMS: 1756 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 1757 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 1758 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 1759 case QCAMERA_SM_EVT_GET_PARAMS: 1760 case QCAMERA_SM_EVT_PUT_PARAMS: 1761 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 1762 case QCAMERA_SM_EVT_START_PREVIEW: 1763 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 1764 case QCAMERA_SM_EVT_STOP_PREVIEW: 1765 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 1766 case QCAMERA_SM_EVT_RECORDING_ENABLED: 1767 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 1768 case QCAMERA_SM_EVT_DUMP: 1769 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 1770 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 1771 case QCAMERA_SM_EVT_PRE_START_RECORDING: 1772 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 1773 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 1774 case QCAMERA_SM_EVT_START_RECORDING: 1775 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 1776 case QCAMERA_SM_EVT_TAKE_PICTURE: 1777 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 1778 case QCAMERA_SM_EVT_SEND_COMMAND: 1779 case QCAMERA_SM_EVT_CANCEL_PICTURE: 1780 case QCAMERA_SM_EVT_STOP_RECORDING: 1781 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 1782 case QCAMERA_SM_EVT_RELEASE: 1783 { 1784 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 1785 rc = INVALID_OPERATION; 1786 result.status = rc; 1787 result.request_api = evt; 1788 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1789 m_parent->signalAPIResult(&result); 1790 } 1791 break; 1792 case QCAMERA_SM_EVT_EVT_INTERNAL: 1793 { 1794 qcamera_sm_internal_evt_payload_t *internal_evt = 1795 (qcamera_sm_internal_evt_payload_t *)payload; 1796 switch (internal_evt->evt_type) { 1797 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 1798 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 1799 break; 1800 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 1801 m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state); 1802 m_state = QCAMERA_SM_STATE_PREVIEWING; 1803 1804 result.status = NO_ERROR; 1805 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 1806 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1807 m_parent->signalAPIResult(&result); 1808 break; 1809 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 1810 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 1811 break; 1812 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 1813 rc = m_parent->processHistogramStats(internal_evt->stats_data); 1814 break; 1815 case QCAMERA_INTERNAL_EVT_CROP_INFO: 1816 rc = m_parent->processZoomEvent(internal_evt->crop_data); 1817 break; 1818 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 1819 rc = m_parent->processASDUpdate(internal_evt->asd_data); 1820 break; 1821 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 1822 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1823 break; 1824 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 1825 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 1826 break; 1827 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 1828 rc = m_parent->processAEInfo(internal_evt->ae_data); 1829 break; 1830 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 1831 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 1832 break; 1833 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 1834 rc = m_parent->processHDRData(internal_evt->hdr_data); 1835 break; 1836 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 1837 rc = m_parent->processRetroAECUnlock(); 1838 break; 1839 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 1840 rc = m_parent->processZSLCaptureDone(); 1841 break; 1842 case QCAMERA_INTERNAL_EVT_DUAL_CAMERA_FOV_CONTROL: 1843 m_parent->processDualCamFovControl(); 1844 break; 1845 case QCAMERA_INTERNAL_EVT_LED_CALIB_UPDATE: 1846 rc = m_parent->processLEDCalibration(internal_evt->led_calib_result); 1847 break; 1848 default: 1849 LOGE("Invalid internal event %d in state(%d)", 1850 internal_evt->evt_type, m_state); 1851 break; 1852 } 1853 } 1854 break; 1855 case QCAMERA_SM_EVT_EVT_NOTIFY: 1856 { 1857 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 1858 switch (cam_evt->server_event_type) { 1859 case CAM_EVENT_TYPE_DAEMON_DIED: 1860 { 1861 // Send internal events to stop indefinite wait on prepare 1862 // snapshot done event. 1863 m_state = QCAMERA_SM_STATE_PREVIEWING; 1864 1865 result.status = rc; 1866 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 1867 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1868 m_parent->signalAPIResult(&result); 1869 1870 result.status = rc; 1871 result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE; 1872 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1873 m_parent->signalAPIResult(&result); 1874 1875 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 1876 CAMERA_ERROR_SERVER_DIED, 1877 0); 1878 } 1879 break; 1880 default: 1881 LOGE("Invalid internal event %d in state(%d)", 1882 cam_evt->server_event_type, m_state); 1883 break; 1884 } 1885 } 1886 break; 1887 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 1888 { 1889 // No ops, but need to notify 1890 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1891 result.status = rc; 1892 result.request_api = evt; 1893 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1894 m_parent->signalEvtResult(&result); 1895 } 1896 break; 1897 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 1898 { 1899 rc = m_parent->updateThermalLevel(payload); 1900 } 1901 break; 1902 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 1903 default: 1904 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1905 break; 1906 } 1907 1908 return rc; 1909} 1910 1911/*=========================================================================== 1912 * FUNCTION : procEvtPicTakingState 1913 * 1914 * DESCRIPTION: finite state machine function to handle event in state of 1915 * QCAMERA_SM_STATE_PIC_TAKING. 1916 * 1917 * PARAMETERS : 1918 * @evt : event to be processed 1919 * @payload : event payload. Can be NULL if not needed. 1920 * 1921 * RETURN : int32_t type of status 1922 * NO_ERROR -- success 1923 * none-zero failure code 1924 *==========================================================================*/ 1925int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt, 1926 void *payload) 1927{ 1928 int32_t rc = NO_ERROR; 1929 qcamera_api_result_t result; 1930 memset(&result, 0, sizeof(qcamera_api_result_t)); 1931 1932 LOGL("event (%d)", evt); 1933 switch (evt) { 1934 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 1935 { 1936 // Error setting preview window during previewing 1937 LOGE("Error!! cannot set preview window when preview is running"); 1938 rc = INVALID_OPERATION; 1939 result.status = rc; 1940 result.request_api = evt; 1941 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1942 m_parent->signalAPIResult(&result); 1943 } 1944 break; 1945 case QCAMERA_SM_EVT_SET_CALLBACKS: 1946 { 1947 qcamera_sm_evt_setcb_payload_t *setcbs = 1948 (qcamera_sm_evt_setcb_payload_t *)payload; 1949 rc = m_parent->setCallBacks(setcbs->notify_cb, 1950 setcbs->data_cb, 1951 setcbs->data_cb_timestamp, 1952 setcbs->get_memory, 1953 setcbs->user); 1954 result.status = rc; 1955 result.request_api = evt; 1956 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1957 m_parent->signalAPIResult(&result); 1958 } 1959 break; 1960 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 1961 { 1962 rc = m_parent->enableMsgType(*((int32_t *)payload)); 1963 result.status = rc; 1964 result.request_api = evt; 1965 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1966 m_parent->signalAPIResult(&result); 1967 } 1968 break; 1969 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 1970 { 1971 rc = m_parent->disableMsgType(*((int32_t *)payload)); 1972 result.status = rc; 1973 result.request_api = evt; 1974 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1975 m_parent->signalAPIResult(&result); 1976 } 1977 break; 1978 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 1979 { 1980 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 1981 result.status = rc; 1982 result.request_api = evt; 1983 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1984 result.enabled = enabled; 1985 m_parent->signalAPIResult(&result); 1986 } 1987 break; 1988 case QCAMERA_SM_EVT_SET_PARAMS: 1989 { 1990 bool needRestart = false; 1991 rc = m_parent->updateParameters((char*)payload, needRestart); 1992 result.status = rc; 1993 result.request_api = evt; 1994 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1995 m_parent->signalAPIResult(&result); 1996 } 1997 break; 1998 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 1999 { 2000 result.status = rc; 2001 result.request_api = evt; 2002 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2003 m_parent->signalAPIResult(&result); 2004 } 2005 break; 2006 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 2007 { 2008 rc = m_parent->commitParameterChanges(); 2009 result.status = rc; 2010 result.request_api = evt; 2011 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2012 m_parent->signalAPIResult(&result); 2013 } 2014 break; 2015 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 2016 { 2017 m_parent->setNeedRestart(false); 2018 result.status = rc; 2019 result.request_api = evt; 2020 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2021 m_parent->signalAPIResult(&result); 2022 } 2023 break; 2024 case QCAMERA_SM_EVT_GET_PARAMS: 2025 { 2026 result.params = m_parent->getParameters(); 2027 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 2028 result.status = rc; 2029 result.request_api = evt; 2030 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 2031 m_parent->signalAPIResult(&result); 2032 } 2033 break; 2034 case QCAMERA_SM_EVT_PUT_PARAMS: 2035 { 2036 rc = m_parent->putParameters((char*)payload); 2037 result.status = rc; 2038 result.request_api = evt; 2039 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2040 m_parent->signalAPIResult(&result); 2041 } 2042 break; 2043 case QCAMERA_SM_EVT_STOP_PREVIEW: 2044 { 2045 // cancel picture first 2046 rc = m_parent->cancelPicture(); 2047 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 2048 2049 result.status = rc; 2050 result.request_api = evt; 2051 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2052 m_parent->signalAPIResult(&result); 2053 } 2054 break; 2055 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 2056 { 2057 rc = NO_ERROR; 2058 result.status = rc; 2059 result.request_api = evt; 2060 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2061 result.enabled = 0; 2062 m_parent->signalAPIResult(&result); 2063 } 2064 break; 2065 case QCAMERA_SM_EVT_RECORDING_ENABLED: 2066 { 2067 rc = NO_ERROR; 2068 result.status = rc; 2069 result.request_api = evt; 2070 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2071 result.enabled = 0; 2072 m_parent->signalAPIResult(&result); 2073 } 2074 break; 2075 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 2076 { 2077 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 2078 result.status = rc; 2079 result.request_api = evt; 2080 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2081 m_parent->signalAPIResult(&result); 2082 } 2083 break; 2084 case QCAMERA_SM_EVT_DUMP: 2085 { 2086 rc = m_parent->dump(*((int *)payload)); 2087 result.status = rc; 2088 result.request_api = evt; 2089 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2090 m_parent->signalAPIResult(&result); 2091 } 2092 break; 2093 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 2094 { 2095 rc = m_parent->autoFocus(); 2096 result.status = rc; 2097 result.request_api = evt; 2098 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2099 m_parent->signalAPIResult(&result); 2100 } 2101 break; 2102 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 2103 { 2104 rc = m_parent->cancelAutoFocus(); 2105 result.status = rc; 2106 result.request_api = evt; 2107 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2108 m_parent->signalAPIResult(&result); 2109 } 2110 break; 2111 case QCAMERA_SM_EVT_SEND_COMMAND: 2112 { 2113 qcamera_sm_evt_command_payload_t *cmd_payload = 2114 (qcamera_sm_evt_command_payload_t *)payload; 2115 rc = m_parent->sendCommand(cmd_payload->cmd, 2116 cmd_payload->arg1, 2117 cmd_payload->arg2); 2118#ifndef VANILLA_HAL 2119 if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) { 2120 // move state to previewing state 2121 m_state = QCAMERA_SM_STATE_PREVIEWING; 2122 } 2123#endif 2124 result.status = rc; 2125 result.request_api = evt; 2126 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2127 m_parent->signalAPIResult(&result); 2128 } 2129 break; 2130 case QCAMERA_SM_EVT_CANCEL_PICTURE: 2131 { 2132 rc = m_parent->cancelPicture(); 2133 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 2134 result.status = rc; 2135 result.request_api = evt; 2136 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2137 m_parent->signalAPIResult(&result); 2138 } 2139 break; 2140 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 2141 { 2142 int32_t faceID = 0; 2143 qcamera_sm_evt_reg_face_payload_t *reg_payload = 2144 (qcamera_sm_evt_reg_face_payload_t *)payload; 2145 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 2146 reg_payload->config, 2147 faceID); 2148 result.status = rc; 2149 result.request_api = evt; 2150 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 2151 result.handle = faceID; 2152 m_parent->signalAPIResult(&result); 2153 } 2154 break; 2155 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 2156 { 2157 if ( m_parent->isLongshotEnabled() ) { 2158 // no ops here, need to singal NO_ERROR 2159 rc = NO_ERROR; 2160 } else { 2161 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 2162 rc = INVALID_OPERATION; 2163 } 2164 2165 result.status = rc; 2166 result.request_api = evt; 2167 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2168 m_parent->signalAPIResult(&result); 2169 } 2170 break; 2171 case QCAMERA_SM_EVT_TAKE_PICTURE: 2172 { 2173 if ( m_parent->isLongshotEnabled() ) { 2174 rc = m_parent->longShot(); 2175 } else { 2176 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 2177 rc = INVALID_OPERATION; 2178 } 2179 2180 result.status = rc; 2181 result.request_api = evt; 2182 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2183 m_parent->signalAPIResult(&result); 2184 } 2185 break; 2186 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 2187 case QCAMERA_SM_EVT_PRE_START_RECORDING: 2188 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 2189 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 2190 case QCAMERA_SM_EVT_START_RECORDING: 2191 case QCAMERA_SM_EVT_STOP_RECORDING: 2192 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 2193 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 2194 case QCAMERA_SM_EVT_START_PREVIEW: 2195 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 2196 case QCAMERA_SM_EVT_RELEASE: 2197 { 2198 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 2199 rc = INVALID_OPERATION; 2200 result.status = rc; 2201 result.request_api = evt; 2202 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2203 m_parent->signalAPIResult(&result); 2204 } 2205 break; 2206 case QCAMERA_SM_EVT_EVT_INTERNAL: 2207 { 2208 qcamera_sm_internal_evt_payload_t *internal_evt = 2209 (qcamera_sm_internal_evt_payload_t *)payload; 2210 switch (internal_evt->evt_type) { 2211 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 2212 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 2213 break; 2214 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 2215 break; 2216 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 2217 break; 2218 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 2219 break; 2220 case QCAMERA_INTERNAL_EVT_CROP_INFO: 2221 rc = m_parent->processZoomEvent(internal_evt->crop_data); 2222 break; 2223 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 2224 rc = m_parent->processASDUpdate(internal_evt->asd_data); 2225 break; 2226 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 2227 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2228 break; 2229 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 2230 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 2231 break; 2232 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 2233 rc = m_parent->processAEInfo(internal_evt->ae_data); 2234 break; 2235 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 2236 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 2237 break; 2238 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 2239 rc = m_parent->processHDRData(internal_evt->hdr_data); 2240 break; 2241 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 2242 rc = m_parent->processRetroAECUnlock(); 2243 break; 2244 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 2245 rc = m_parent->processZSLCaptureDone(); 2246 break; 2247 case QCAMERA_INTERNAL_EVT_DUAL_CAMERA_FOV_CONTROL: 2248 m_parent->processDualCamFovControl(); 2249 break; 2250 case QCAMERA_INTERNAL_EVT_LED_CALIB_UPDATE: 2251 rc = m_parent->processLEDCalibration(internal_evt->led_calib_result); 2252 break; 2253 default: 2254 break; 2255 } 2256 } 2257 break; 2258 case QCAMERA_SM_EVT_EVT_NOTIFY: 2259 { 2260 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 2261 switch (cam_evt->server_event_type) { 2262 case CAM_EVENT_TYPE_DAEMON_DIED: 2263 { 2264 // Send internal events to stop indefinite wait on prepare 2265 // snapshot done event. 2266 result.status = rc; 2267 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 2268 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2269 m_parent->signalAPIResult(&result); 2270 2271 result.status = rc; 2272 result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE; 2273 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2274 m_parent->signalAPIResult(&result); 2275 2276 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 2277 CAMERA_ERROR_SERVER_DIED, 2278 0); 2279 } 2280 break; 2281 case CAM_EVENT_TYPE_CAC_DONE: 2282 if (m_parent->isCACEnabled() || m_parent->mParameters.isOEMFeatEnabled()) { 2283 LOGD("[LONG_SHOT_DBG] : Received CAC Done"); 2284 if (m_parent->isLongshotEnabled() 2285 && !m_parent->isCaptureShutterEnabled()) { 2286 // play shutter sound for longshot 2287 // after CAC stage is done 2288 m_parent->playShutter(); 2289 } 2290 m_parent->mCACDoneReceived = TRUE; 2291 } 2292 break; 2293 default: 2294 LOGH("no handling for server evt (%d) at this state", 2295 cam_evt->server_event_type); 2296 break; 2297 } 2298 } 2299 break; 2300 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 2301 { 2302 qcamera_jpeg_evt_payload_t *jpeg_job = 2303 (qcamera_jpeg_evt_payload_t *)payload; 2304 rc = m_parent->processJpegNotify(jpeg_job); 2305 } 2306 break; 2307 case QCAMERA_SM_EVT_STOP_CAPTURE_CHANNEL: 2308 { 2309 bool restartPreview = m_parent->isPreviewRestartEnabled(); 2310 rc = m_parent->stopCaptureChannel(restartPreview); 2311 2312 if (restartPreview && (NO_ERROR == rc)) { 2313 m_parent->unconfigureAdvancedCapture(); 2314 rc = m_parent->preparePreview(); 2315 if (NO_ERROR == rc) { 2316 m_parent->m_bPreviewStarted = true; 2317 applyDelayedMsgs(); 2318 rc = m_parent->startPreview(); 2319 } 2320 } 2321 2322 result.status = rc; 2323 result.request_api = evt; 2324 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2325 m_parent->signalAPIResult(&result); 2326 } 2327 break; 2328 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 2329 { 2330 rc = m_parent->cancelPicture(); 2331 2332 bool restartPreview = m_parent->isPreviewRestartEnabled(); 2333 if (restartPreview) { 2334 if (m_parent->mParameters.getManualCaptureMode() 2335 >= CAM_MANUAL_CAPTURE_TYPE_3) { 2336 m_parent->mParameters.updateZSLModeValue(m_RestoreZSL); 2337 m_RestoreZSL = FALSE; 2338 rc = m_parent->preparePreview(); 2339 if (NO_ERROR == rc) { 2340 m_parent->m_bPreviewStarted = true; 2341 applyDelayedMsgs(); 2342 rc = m_parent->startPreview(); 2343 } 2344 } 2345 m_state = QCAMERA_SM_STATE_PREVIEWING; 2346 } else { 2347 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 2348 } 2349 2350 result.status = rc; 2351 result.request_api = evt; 2352 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2353 m_parent->signalEvtResult(&result); 2354 } 2355 break; 2356 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 2357 { 2358 rc = m_parent->updateThermalLevel(payload); 2359 } 2360 break; 2361 default: 2362 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2363 break; 2364 } 2365 2366 return rc; 2367} 2368 2369/*=========================================================================== 2370 * FUNCTION : procEvtRecordingState 2371 * 2372 * DESCRIPTION: finite state machine function to handle event in state of 2373 * QCAMERA_SM_STATE_RECORDING. 2374 * 2375 * PARAMETERS : 2376 * @evt : event to be processed 2377 * @payload : event payload. Can be NULL if not needed. 2378 * 2379 * RETURN : int32_t type of status 2380 * NO_ERROR -- success 2381 * none-zero failure code 2382 *==========================================================================*/ 2383int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt, 2384 void *payload) 2385{ 2386 int32_t rc = NO_ERROR; 2387 qcamera_api_result_t result; 2388 memset(&result, 0, sizeof(qcamera_api_result_t)); 2389 2390 LOGL("event (%d)", evt); 2391 switch (evt) { 2392 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 2393 case QCAMERA_SM_EVT_START_PREVIEW: 2394 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 2395 { 2396 // WA: CTS test VideoSnapshot will try to 2397 // start preview during video recording. 2398 LOGH("CTS video restart op"); 2399 rc = NO_ERROR; 2400 result.status = rc; 2401 result.request_api = evt; 2402 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2403 m_parent->signalAPIResult(&result); 2404 } 2405 break; 2406 case QCAMERA_SM_EVT_SET_CALLBACKS: 2407 { 2408 qcamera_sm_evt_setcb_payload_t *setcbs = 2409 (qcamera_sm_evt_setcb_payload_t *)payload; 2410 rc = m_parent->setCallBacks(setcbs->notify_cb, 2411 setcbs->data_cb, 2412 setcbs->data_cb_timestamp, 2413 setcbs->get_memory, 2414 setcbs->user); 2415 result.status = rc; 2416 result.request_api = evt; 2417 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2418 m_parent->signalAPIResult(&result); 2419 } 2420 break; 2421 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 2422 { 2423 rc = m_parent->enableMsgType(*((int32_t *)payload)); 2424 result.status = rc; 2425 result.request_api = evt; 2426 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2427 m_parent->signalAPIResult(&result); 2428 } 2429 break; 2430 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 2431 { 2432 rc = m_parent->disableMsgType(*((int32_t *)payload)); 2433 result.status = rc; 2434 result.request_api = evt; 2435 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2436 m_parent->signalAPIResult(&result); 2437 } 2438 break; 2439 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 2440 { 2441 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 2442 result.status = rc; 2443 result.request_api = evt; 2444 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2445 result.enabled = enabled; 2446 m_parent->signalAPIResult(&result); 2447 } 2448 break; 2449 case QCAMERA_SM_EVT_SET_PARAMS: 2450 { 2451 bool needRestart = false; 2452 rc = m_parent->updateParameters((char*)payload, needRestart); 2453 if (rc == NO_ERROR) { 2454 if (needRestart) { 2455 // cannot set parameters that requires restart during recording 2456 LOGE("Error!! cannot set parameters that requires restart during recording"); 2457 rc = BAD_VALUE; 2458 } 2459 } 2460 if (rc != NO_ERROR) { 2461 m_parent->setNeedRestart(false); 2462 } 2463 result.status = rc; 2464 result.request_api = evt; 2465 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2466 m_parent->signalAPIResult(&result); 2467 } 2468 break; 2469 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 2470 { 2471 rc = m_parent->commitParameterChanges(); 2472 result.status = rc; 2473 result.request_api = evt; 2474 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2475 m_parent->signalAPIResult(&result); 2476 } 2477 break; 2478 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 2479 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 2480 { 2481 ALOGE("%s: Error!! cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 2482 rc = INVALID_OPERATION; 2483 result.status = rc; 2484 result.request_api = evt; 2485 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2486 m_parent->signalAPIResult(&result); 2487 } 2488 break; 2489 case QCAMERA_SM_EVT_GET_PARAMS: 2490 { 2491 result.params = m_parent->getParameters(); 2492 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 2493 result.status = rc; 2494 result.request_api = evt; 2495 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 2496 m_parent->signalAPIResult(&result); 2497 } 2498 break; 2499 case QCAMERA_SM_EVT_PUT_PARAMS: 2500 { 2501 rc = m_parent->putParameters((char*)payload); 2502 result.status = rc; 2503 result.request_api = evt; 2504 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2505 m_parent->signalAPIResult(&result); 2506 } 2507 break; 2508 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 2509 { 2510 rc = NO_ERROR; 2511 result.status = rc; 2512 result.request_api = evt; 2513 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2514 result.enabled = 0; 2515 m_parent->signalAPIResult(&result); 2516 } 2517 break; 2518 case QCAMERA_SM_EVT_RECORDING_ENABLED: 2519 { 2520 rc = NO_ERROR; 2521 result.status = rc; 2522 result.request_api = evt; 2523 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2524 result.enabled = 1; 2525 m_parent->signalAPIResult(&result); 2526 } 2527 break; 2528 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 2529 { 2530 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 2531 result.status = rc; 2532 result.request_api = evt; 2533 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2534 m_parent->signalAPIResult(&result); 2535 } 2536 break; 2537 case QCAMERA_SM_EVT_DUMP: 2538 { 2539 rc = m_parent->dump(*((int *)payload)); 2540 result.status = rc; 2541 result.request_api = evt; 2542 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2543 m_parent->signalAPIResult(&result); 2544 } 2545 break; 2546 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 2547 { 2548 rc = m_parent->autoFocus(); 2549 result.status = rc; 2550 result.request_api = evt; 2551 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2552 m_parent->signalAPIResult(&result); 2553 } 2554 break; 2555 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 2556 { 2557 rc = m_parent->cancelAutoFocus(); 2558 result.status = rc; 2559 result.request_api = evt; 2560 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2561 m_parent->signalAPIResult(&result); 2562 } 2563 break; 2564 case QCAMERA_SM_EVT_SEND_COMMAND: 2565 { 2566 qcamera_sm_evt_command_payload_t *cmd_payload = 2567 (qcamera_sm_evt_command_payload_t *)payload; 2568 rc = m_parent->sendCommand(cmd_payload->cmd, 2569 cmd_payload->arg1, 2570 cmd_payload->arg2); 2571 result.status = rc; 2572 result.request_api = evt; 2573 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2574 m_parent->signalAPIResult(&result); 2575 } 2576 break; 2577 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 2578 { 2579 // No ops here, send NO_ERROR. 2580 rc = NO_ERROR; 2581 result.status = rc; 2582 result.request_api = evt; 2583 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2584 m_parent->signalAPIResult(&result); 2585 } 2586 break; 2587 case QCAMERA_SM_EVT_TAKE_PICTURE: 2588 { 2589 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING; 2590 rc = m_parent->takeLiveSnapshot(); 2591 if (rc != NO_ERROR) { 2592 m_parent->unconfigureAdvancedCapture(); 2593 m_state = QCAMERA_SM_STATE_RECORDING; 2594 } 2595 result.status = rc; 2596 result.request_api = evt; 2597 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2598 m_parent->signalAPIResult(&result); 2599 } 2600 break; 2601 case QCAMERA_SM_EVT_PRE_START_RECORDING: 2602 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 2603 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 2604 case QCAMERA_SM_EVT_START_RECORDING: 2605 { 2606 // no ops here 2607 LOGW("already in recording state, no ops for start_recording"); 2608 rc = 0; 2609 result.status = rc; 2610 result.request_api = evt; 2611 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2612 m_parent->signalAPIResult(&result); 2613 } 2614 break; 2615 case QCAMERA_SM_EVT_STOP_RECORDING: 2616 { 2617 rc = m_parent->stopRecording(); 2618 m_state = QCAMERA_SM_STATE_PREVIEWING; 2619 result.status = rc; 2620 result.request_api = evt; 2621 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2622 m_parent->signalAPIResult(&result); 2623 } 2624 break; 2625 case QCAMERA_SM_EVT_STOP_PREVIEW: 2626 { 2627 rc = m_parent->stopRecording(); 2628 m_state = QCAMERA_SM_STATE_PREVIEWING; 2629 2630 rc = m_parent->stopPreview(); 2631 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 2632 2633 result.status = rc; 2634 result.request_api = evt; 2635 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2636 m_parent->signalAPIResult(&result); 2637 } 2638 break; 2639 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 2640 { 2641 rc = m_parent->releaseRecordingFrame((const void *)payload); 2642 result.status = rc; 2643 result.request_api = evt; 2644 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2645 m_parent->signalAPIResult(&result); 2646 } 2647 break; 2648 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 2649 { 2650 int32_t faceID = 0; 2651 qcamera_sm_evt_reg_face_payload_t *reg_payload = 2652 (qcamera_sm_evt_reg_face_payload_t *)payload; 2653 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 2654 reg_payload->config, 2655 faceID); 2656 result.status = rc; 2657 result.request_api = evt; 2658 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 2659 result.handle = faceID; 2660 m_parent->signalAPIResult(&result); 2661 } 2662 break; 2663 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 2664 { 2665 //In Video snapshot, prepare hardware is a no-op. 2666 result.status = NO_ERROR; 2667 result.request_api = evt; 2668 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2669 m_parent->signalAPIResult(&result); 2670 } 2671 break; 2672 case QCAMERA_SM_EVT_CANCEL_PICTURE: 2673 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 2674 case QCAMERA_SM_EVT_RELEASE: 2675 { 2676 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 2677 rc = INVALID_OPERATION; 2678 result.status = rc; 2679 result.request_api = evt; 2680 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2681 m_parent->signalAPIResult(&result); 2682 } 2683 break; 2684 case QCAMERA_SM_EVT_EVT_INTERNAL: 2685 { 2686 qcamera_sm_internal_evt_payload_t *internal_evt = 2687 (qcamera_sm_internal_evt_payload_t *)payload; 2688 switch (internal_evt->evt_type) { 2689 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 2690 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 2691 break; 2692 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 2693 break; 2694 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 2695 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 2696 break; 2697 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 2698 rc = m_parent->processHistogramStats(internal_evt->stats_data); 2699 break; 2700 case QCAMERA_INTERNAL_EVT_CROP_INFO: 2701 rc = m_parent->processZoomEvent(internal_evt->crop_data); 2702 break; 2703 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 2704 rc = m_parent->processASDUpdate(internal_evt->asd_data); 2705 break; 2706 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 2707 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2708 break; 2709 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 2710 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 2711 break; 2712 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 2713 rc = m_parent->processAEInfo(internal_evt->ae_data); 2714 break; 2715 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 2716 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 2717 break; 2718 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 2719 rc = m_parent->processHDRData(internal_evt->hdr_data); 2720 break; 2721 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 2722 rc = m_parent->processRetroAECUnlock(); 2723 break; 2724 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 2725 rc = m_parent->processZSLCaptureDone(); 2726 break; 2727 case QCAMERA_INTERNAL_EVT_DUAL_CAMERA_FOV_CONTROL: 2728 m_parent->processDualCamFovControl(); 2729 break; 2730 case QCAMERA_INTERNAL_EVT_LED_CALIB_UPDATE: 2731 rc = m_parent->processLEDCalibration(internal_evt->led_calib_result); 2732 break; 2733 default: 2734 break; 2735 } 2736 } 2737 break; 2738 case QCAMERA_SM_EVT_EVT_NOTIFY: 2739 { 2740 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 2741 switch (cam_evt->server_event_type) { 2742 case CAM_EVENT_TYPE_DAEMON_DIED: 2743 { 2744 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 2745 CAMERA_ERROR_SERVER_DIED, 2746 0); 2747 } 2748 break; 2749 default: 2750 LOGE("Invalid internal event %d in state(%d)", 2751 cam_evt->server_event_type, m_state); 2752 break; 2753 } 2754 } 2755 break; 2756 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 2757 { 2758 rc = m_parent->updateThermalLevel(payload); 2759 } 2760 break; 2761 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 2762 { 2763 // No ops, but need to notify 2764 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2765 result.status = rc; 2766 result.request_api = evt; 2767 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2768 m_parent->signalEvtResult(&result); 2769 } 2770 break; 2771 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 2772 default: 2773 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2774 break; 2775 } 2776 2777 return rc; 2778} 2779 2780/*=========================================================================== 2781 * FUNCTION : procEvtVideoPicTakingState 2782 * 2783 * DESCRIPTION: finite state machine function to handle event in state of 2784 * QCAMERA_SM_STATE_VIDEO_PIC_TAKING. 2785 * 2786 * PARAMETERS : 2787 * @evt : event to be processed 2788 * @payload : event payload. Can be NULL if not needed. 2789 * 2790 * RETURN : int32_t type of status 2791 * NO_ERROR -- success 2792 * none-zero failure code 2793 *==========================================================================*/ 2794int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt, 2795 void *payload) 2796{ 2797 int32_t rc = NO_ERROR; 2798 qcamera_api_result_t result; 2799 memset(&result, 0, sizeof(qcamera_api_result_t)); 2800 2801 LOGL("event (%d)", evt); 2802 switch (evt) { 2803 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 2804 { 2805 // Error setting preview window during previewing 2806 LOGE("Error!! cannot set preview window when preview is running"); 2807 rc = INVALID_OPERATION; 2808 result.status = rc; 2809 result.request_api = evt; 2810 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2811 m_parent->signalAPIResult(&result); 2812 } 2813 break; 2814 case QCAMERA_SM_EVT_SET_CALLBACKS: 2815 { 2816 qcamera_sm_evt_setcb_payload_t *setcbs = 2817 (qcamera_sm_evt_setcb_payload_t *)payload; 2818 rc = m_parent->setCallBacks(setcbs->notify_cb, 2819 setcbs->data_cb, 2820 setcbs->data_cb_timestamp, 2821 setcbs->get_memory, 2822 setcbs->user); 2823 result.status = rc; 2824 result.request_api = evt; 2825 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2826 m_parent->signalAPIResult(&result); 2827 } 2828 break; 2829 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 2830 { 2831 rc = m_parent->enableMsgType(*((int32_t *)payload)); 2832 result.status = rc; 2833 result.request_api = evt; 2834 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2835 m_parent->signalAPIResult(&result); 2836 } 2837 break; 2838 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 2839 { 2840 rc = m_parent->disableMsgType(*((int32_t *)payload)); 2841 result.status = rc; 2842 result.request_api = evt; 2843 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2844 m_parent->signalAPIResult(&result); 2845 } 2846 break; 2847 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 2848 { 2849 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 2850 result.status = rc; 2851 result.request_api = evt; 2852 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2853 result.enabled = enabled; 2854 m_parent->signalAPIResult(&result); 2855 } 2856 break; 2857 case QCAMERA_SM_EVT_SET_PARAMS: 2858 { 2859 bool needRestart = false; 2860 rc = m_parent->updateParameters((char*)payload, needRestart); 2861 if (rc == NO_ERROR) { 2862 if (needRestart) { 2863 // cannot set parameters that requires restart during recording 2864 LOGE("Error!! cannot set parameters that requires restart during recording"); 2865 rc = BAD_VALUE; 2866 } 2867 } 2868 if (rc != NO_ERROR) { 2869 m_parent->setNeedRestart(false); 2870 } 2871 result.status = rc; 2872 result.request_api = evt; 2873 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2874 m_parent->signalAPIResult(&result); 2875 } 2876 break; 2877 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 2878 { 2879 rc = m_parent->commitParameterChanges(); 2880 result.status = rc; 2881 result.request_api = evt; 2882 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2883 m_parent->signalAPIResult(&result); 2884 } 2885 break; 2886 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 2887 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 2888 { 2889 ALOGE("%s: Error!! cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 2890 rc = INVALID_OPERATION; 2891 result.status = rc; 2892 result.request_api = evt; 2893 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2894 m_parent->signalAPIResult(&result); 2895 } 2896 break; 2897 case QCAMERA_SM_EVT_GET_PARAMS: 2898 { 2899 result.params = m_parent->getParameters(); 2900 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 2901 result.status = rc; 2902 result.request_api = evt; 2903 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 2904 m_parent->signalAPIResult(&result); 2905 } 2906 break; 2907 case QCAMERA_SM_EVT_PUT_PARAMS: 2908 { 2909 rc = m_parent->putParameters((char*)payload); 2910 result.status = rc; 2911 result.request_api = evt; 2912 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2913 m_parent->signalAPIResult(&result); 2914 } 2915 break; 2916 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 2917 { 2918 rc = NO_ERROR; 2919 result.status = rc; 2920 result.request_api = evt; 2921 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2922 result.enabled = 1; 2923 m_parent->signalAPIResult(&result); 2924 } 2925 break; 2926 case QCAMERA_SM_EVT_RECORDING_ENABLED: 2927 { 2928 rc = NO_ERROR; 2929 result.status = rc; 2930 result.request_api = evt; 2931 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2932 result.enabled = 1; 2933 m_parent->signalAPIResult(&result); 2934 } 2935 break; 2936 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 2937 { 2938 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 2939 result.status = rc; 2940 result.request_api = evt; 2941 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2942 m_parent->signalAPIResult(&result); 2943 } 2944 break; 2945 case QCAMERA_SM_EVT_DUMP: 2946 { 2947 rc = m_parent->dump(*((int *)payload)); 2948 result.status = rc; 2949 result.request_api = evt; 2950 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2951 m_parent->signalAPIResult(&result); 2952 } 2953 break; 2954 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 2955 { 2956 rc = m_parent->autoFocus(); 2957 result.status = rc; 2958 result.request_api = evt; 2959 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2960 m_parent->signalAPIResult(&result); 2961 } 2962 break; 2963 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 2964 { 2965 rc = m_parent->cancelAutoFocus(); 2966 result.status = rc; 2967 result.request_api = evt; 2968 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2969 m_parent->signalAPIResult(&result); 2970 } 2971 break; 2972 case QCAMERA_SM_EVT_SEND_COMMAND: 2973 { 2974 qcamera_sm_evt_command_payload_t *cmd_payload = 2975 (qcamera_sm_evt_command_payload_t *)payload; 2976 rc = m_parent->sendCommand(cmd_payload->cmd, 2977 cmd_payload->arg1, 2978 cmd_payload->arg2); 2979 result.status = rc; 2980 result.request_api = evt; 2981 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2982 m_parent->signalAPIResult(&result); 2983 } 2984 break; 2985 case QCAMERA_SM_EVT_STOP_RECORDING: 2986 { 2987 rc = m_parent->cancelLiveSnapshot(); 2988 m_state = QCAMERA_SM_STATE_RECORDING; 2989 2990 rc = m_parent->stopRecording(); 2991 m_state = QCAMERA_SM_STATE_PREVIEWING; 2992 2993 result.status = rc; 2994 result.request_api = evt; 2995 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2996 m_parent->signalAPIResult(&result); 2997 } 2998 break; 2999 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 3000 { 3001 rc = m_parent->releaseRecordingFrame((const void *)payload); 3002 result.status = rc; 3003 result.request_api = evt; 3004 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3005 m_parent->signalAPIResult(&result); 3006 } 3007 break; 3008 case QCAMERA_SM_EVT_CANCEL_PICTURE: 3009 { 3010 rc = m_parent->cancelLiveSnapshot(); 3011 m_state = QCAMERA_SM_STATE_RECORDING; 3012 result.status = rc; 3013 result.request_api = evt; 3014 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3015 m_parent->signalAPIResult(&result); 3016 } 3017 break; 3018 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 3019 { 3020 int32_t faceID = 0; 3021 qcamera_sm_evt_reg_face_payload_t *reg_payload = 3022 (qcamera_sm_evt_reg_face_payload_t *)payload; 3023 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 3024 reg_payload->config, 3025 faceID); 3026 result.status = rc; 3027 result.request_api = evt; 3028 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 3029 result.handle = faceID; 3030 m_parent->signalAPIResult(&result); 3031 } 3032 break; 3033 case QCAMERA_SM_EVT_STOP_PREVIEW: 3034 { 3035 rc = m_parent->cancelLiveSnapshot(); 3036 m_state = QCAMERA_SM_STATE_RECORDING; 3037 3038 rc = m_parent->stopRecording(); 3039 m_state = QCAMERA_SM_STATE_PREVIEWING; 3040 3041 rc = m_parent->stopPreview(); 3042 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 3043 3044 result.status = rc; 3045 result.request_api = evt; 3046 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3047 m_parent->signalAPIResult(&result); 3048 } 3049 break; 3050 case QCAMERA_SM_EVT_PRE_START_RECORDING: 3051 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 3052 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 3053 case QCAMERA_SM_EVT_START_RECORDING: 3054 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 3055 case QCAMERA_SM_EVT_START_PREVIEW: 3056 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 3057 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 3058 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 3059 case QCAMERA_SM_EVT_TAKE_PICTURE: 3060 case QCAMERA_SM_EVT_RELEASE: 3061 { 3062 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 3063 rc = INVALID_OPERATION; 3064 result.status = rc; 3065 result.request_api = evt; 3066 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3067 m_parent->signalAPIResult(&result); 3068 } 3069 break; 3070 case QCAMERA_SM_EVT_EVT_INTERNAL: 3071 { 3072 qcamera_sm_internal_evt_payload_t *internal_evt = 3073 (qcamera_sm_internal_evt_payload_t *)payload; 3074 switch (internal_evt->evt_type) { 3075 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 3076 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 3077 break; 3078 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 3079 break; 3080 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 3081 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 3082 break; 3083 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 3084 rc = m_parent->processHistogramStats(internal_evt->stats_data); 3085 break; 3086 case QCAMERA_INTERNAL_EVT_CROP_INFO: 3087 rc = m_parent->processZoomEvent(internal_evt->crop_data); 3088 break; 3089 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 3090 rc = m_parent->processASDUpdate(internal_evt->asd_data); 3091 break; 3092 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 3093 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 3094 break; 3095 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 3096 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 3097 break; 3098 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 3099 rc = m_parent->processAEInfo(internal_evt->ae_data); 3100 break; 3101 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 3102 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 3103 break; 3104 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 3105 rc = m_parent->processHDRData(internal_evt->hdr_data); 3106 break; 3107 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 3108 rc = m_parent->processRetroAECUnlock(); 3109 break; 3110 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 3111 rc = m_parent->processZSLCaptureDone(); 3112 break; 3113 case QCAMERA_INTERNAL_EVT_DUAL_CAMERA_FOV_CONTROL: 3114 m_parent->processDualCamFovControl(); 3115 break; 3116 case QCAMERA_INTERNAL_EVT_LED_CALIB_UPDATE: 3117 rc = m_parent->processLEDCalibration(internal_evt->led_calib_result); 3118 break; 3119 default: 3120 break; 3121 } 3122 } 3123 break; 3124 case QCAMERA_SM_EVT_EVT_NOTIFY: 3125 { 3126 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 3127 switch (cam_evt->server_event_type) { 3128 case CAM_EVENT_TYPE_DAEMON_DIED: 3129 { 3130 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 3131 CAMERA_ERROR_SERVER_DIED, 3132 0); 3133 } 3134 break; 3135 default: 3136 LOGE("Invalid internal event %d in state(%d)", 3137 cam_evt->server_event_type, m_state); 3138 break; 3139 } 3140 } 3141 break; 3142 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 3143 { 3144 qcamera_jpeg_evt_payload_t *jpeg_job = 3145 (qcamera_jpeg_evt_payload_t *)payload; 3146 rc = m_parent->processJpegNotify(jpeg_job); 3147 } 3148 break; 3149 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 3150 { 3151 rc = m_parent->cancelLiveSnapshot(); 3152 m_state = QCAMERA_SM_STATE_RECORDING; 3153 result.status = rc; 3154 result.request_api = evt; 3155 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3156 m_parent->signalEvtResult(&result); 3157 } 3158 break; 3159 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 3160 { 3161 rc = m_parent->updateThermalLevel(payload); 3162 } 3163 break; 3164 default: 3165 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 3166 break; 3167 } 3168 3169 return rc; 3170} 3171 3172/*=========================================================================== 3173 * FUNCTION : procEvtPreviewPicTakingState 3174 * 3175 * DESCRIPTION: finite state machine function to handle event in state of 3176 * QCAMERA_SM_STATE_PREVIEW_PIC_TAKING. 3177 * 3178 * PARAMETERS : 3179 * @evt : event to be processed 3180 * @payload : event payload. Can be NULL if not needed. 3181 * 3182 * RETURN : int32_t type of status 3183 * NO_ERROR -- success 3184 * none-zero failure code 3185 *==========================================================================*/ 3186int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt, 3187 void *payload) 3188{ 3189 int32_t rc = NO_ERROR; 3190 qcamera_api_result_t result; 3191 memset(&result, 0, sizeof(qcamera_api_result_t)); 3192 3193 LOGL("event (%d)", evt); 3194 switch (evt) { 3195 case QCAMERA_SM_EVT_SET_CALLBACKS: 3196 { 3197 qcamera_sm_evt_setcb_payload_t *setcbs = 3198 (qcamera_sm_evt_setcb_payload_t *)payload; 3199 rc = m_parent->setCallBacks(setcbs->notify_cb, 3200 setcbs->data_cb, 3201 setcbs->data_cb_timestamp, 3202 setcbs->get_memory, 3203 setcbs->user); 3204 result.status = rc; 3205 result.request_api = evt; 3206 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3207 m_parent->signalAPIResult(&result); 3208 } 3209 break; 3210 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 3211 { 3212 rc = m_parent->enableMsgType(*((int32_t *)payload)); 3213 result.status = rc; 3214 result.request_api = evt; 3215 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3216 m_parent->signalAPIResult(&result); 3217 } 3218 break; 3219 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 3220 { 3221 rc = m_parent->disableMsgType(*((int32_t *)payload)); 3222 result.status = rc; 3223 result.request_api = evt; 3224 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3225 m_parent->signalAPIResult(&result); 3226 } 3227 break; 3228 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 3229 { 3230 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 3231 result.status = rc; 3232 result.request_api = evt; 3233 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 3234 result.enabled = enabled; 3235 m_parent->signalAPIResult(&result); 3236 } 3237 break; 3238 case QCAMERA_SM_EVT_SET_PARAMS: 3239 { 3240 bool needRestart = false; 3241 rc = m_parent->updateParameters((char*)payload, needRestart); 3242 result.status = rc; 3243 result.request_api = evt; 3244 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3245 m_parent->signalAPIResult(&result); 3246 } 3247 break; 3248 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 3249 { 3250 // need restart preview for parameters to take effect 3251 LOGD("Stopping preview..."); 3252 // stop preview 3253 rc = m_parent->stopPreview(); 3254 // Clear memory pools 3255 m_parent->m_memoryPool.clear(); 3256 result.status = rc; 3257 result.request_api = evt; 3258 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3259 m_parent->signalAPIResult(&result); 3260 } 3261 break; 3262 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 3263 { 3264 // commit parameter changes to server 3265 rc = m_parent->commitParameterChanges(); 3266 result.status = rc; 3267 result.request_api = evt; 3268 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3269 m_parent->signalAPIResult(&result); 3270 } 3271 break; 3272 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 3273 { 3274 // start preview again 3275 rc = m_parent->preparePreview(); 3276 if (rc == NO_ERROR) { 3277 applyDelayedMsgs(); 3278 rc = m_parent->startPreview(); 3279 if (rc != NO_ERROR) { 3280 m_parent->unpreparePreview(); 3281 } 3282 } 3283 if (rc != NO_ERROR) { 3284 m_state = QCAMERA_SM_STATE_PIC_TAKING; 3285 } 3286 m_parent->setNeedRestart(false); 3287 result.status = rc; 3288 result.request_api = evt; 3289 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3290 m_parent->signalAPIResult(&result); 3291 } 3292 break; 3293 case QCAMERA_SM_EVT_GET_PARAMS: 3294 { 3295 result.params = m_parent->getParameters(); 3296 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 3297 result.status = rc; 3298 result.request_api = evt; 3299 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 3300 m_parent->signalAPIResult(&result); 3301 } 3302 break; 3303 case QCAMERA_SM_EVT_PUT_PARAMS: 3304 { 3305 rc = m_parent->putParameters((char*)payload); 3306 result.status = rc; 3307 result.request_api = evt; 3308 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3309 m_parent->signalAPIResult(&result); 3310 } 3311 break; 3312 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 3313 { 3314 rc = NO_ERROR; 3315 result.status = rc; 3316 result.request_api = evt; 3317 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 3318 result.enabled = 1; 3319 m_parent->signalAPIResult(&result); 3320 } 3321 break; 3322 case QCAMERA_SM_EVT_RECORDING_ENABLED: 3323 { 3324 rc = NO_ERROR; 3325 result.status = rc; 3326 result.request_api = evt; 3327 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 3328 result.enabled = 0; 3329 m_parent->signalAPIResult(&result); 3330 } 3331 break; 3332 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 3333 { 3334 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 3335 result.status = rc; 3336 result.request_api = evt; 3337 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3338 m_parent->signalAPIResult(&result); 3339 } 3340 break; 3341 case QCAMERA_SM_EVT_DUMP: 3342 { 3343 rc = m_parent->dump(*((int *)payload)); 3344 result.status = rc; 3345 result.request_api = evt; 3346 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3347 m_parent->signalAPIResult(&result); 3348 } 3349 break; 3350 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 3351 { 3352 rc = m_parent->autoFocus(); 3353 result.status = rc; 3354 result.request_api = evt; 3355 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3356 m_parent->signalAPIResult(&result); 3357 } 3358 break; 3359 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 3360 { 3361 rc = m_parent->cancelAutoFocus(); 3362 result.status = rc; 3363 result.request_api = evt; 3364 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3365 m_parent->signalAPIResult(&result); 3366 } 3367 break; 3368 case QCAMERA_SM_EVT_SEND_COMMAND: 3369 { 3370 qcamera_sm_evt_command_payload_t *cmd_payload = 3371 (qcamera_sm_evt_command_payload_t *)payload; 3372 rc = m_parent->sendCommand(cmd_payload->cmd, 3373 cmd_payload->arg1, 3374 cmd_payload->arg2); 3375#ifndef VANILLA_HAL 3376 if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) { 3377 // move state to previewing state 3378 m_state = QCAMERA_SM_STATE_PREVIEWING; 3379 } 3380#endif 3381 result.status = rc; 3382 result.request_api = evt; 3383 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3384 m_parent->signalAPIResult(&result); 3385 } 3386 break; 3387 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 3388 { 3389 rc = m_parent->releaseRecordingFrame((const void *)payload); 3390 result.status = rc; 3391 result.request_api = evt; 3392 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3393 m_parent->signalAPIResult(&result); 3394 } 3395 break; 3396 case QCAMERA_SM_EVT_CANCEL_PICTURE: 3397 { 3398 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) { 3399 rc = m_parent->cancelPicture(); 3400 } else { 3401 rc = m_parent->cancelLiveSnapshot(); 3402 } 3403 m_state = QCAMERA_SM_STATE_PREVIEWING; 3404 result.status = rc; 3405 result.request_api = evt; 3406 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3407 m_parent->signalAPIResult(&result); 3408 } 3409 break; 3410 case QCAMERA_SM_EVT_STOP_PREVIEW: 3411 { 3412 if (m_parent->isZSLMode()) { 3413 // cancel picture first 3414 rc = m_parent->cancelPicture(); 3415 m_parent->stopChannel(QCAMERA_CH_TYPE_ZSL); 3416 } else if (m_parent->isLongshotEnabled()) { 3417 // just cancel picture 3418 rc = m_parent->cancelPicture(); 3419 } else { 3420 rc = m_parent->cancelLiveSnapshot(); 3421 m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW); 3422 } 3423 // unprepare preview 3424 m_parent->unpreparePreview(); 3425 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 3426 result.status = rc; 3427 result.request_api = evt; 3428 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3429 m_parent->signalAPIResult(&result); 3430 } 3431 break; 3432 case QCAMERA_SM_EVT_PRE_START_RECORDING: 3433 { 3434 if (m_parent->isZSLMode()) { 3435 LOGE("Error!! cannot handle evt(%d) in state(%d) in ZSL mode", evt, m_state); 3436 rc = INVALID_OPERATION; 3437 } else if (m_parent->isLongshotEnabled()) { 3438 LOGE("Error!! cannot handle evt(%d) in state(%d) in Longshot mode", evt, m_state); 3439 rc = INVALID_OPERATION; 3440 } else { 3441 rc = m_parent->preStartRecording(); 3442 } 3443 result.status = rc; 3444 result.request_api = evt; 3445 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3446 m_parent->signalAPIResult(&result); 3447 } 3448 break; 3449 case QCAMERA_SM_EVT_START_RECORDING: 3450 { 3451 if (m_parent->isZSLMode()) { 3452 LOGE("Error!! cannot handle evt(%d) in state(%d) in ZSL mode", 3453 evt, m_state); 3454 rc = INVALID_OPERATION; 3455 } else if (m_parent->isLongshotEnabled()) { 3456 LOGE("Error!! cannot handle evt(%d) in state(%d) in Longshot mode", 3457 evt, m_state); 3458 rc = INVALID_OPERATION; 3459 } else { 3460 rc = m_parent->startRecording(); 3461 if (rc == NO_ERROR) { 3462 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING; 3463 } 3464 } 3465 result.status = rc; 3466 result.request_api = evt; 3467 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3468 m_parent->signalAPIResult(&result); 3469 } 3470 break; 3471 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 3472 { 3473 int32_t faceID = 0; 3474 qcamera_sm_evt_reg_face_payload_t *reg_payload = 3475 (qcamera_sm_evt_reg_face_payload_t *)payload; 3476 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 3477 reg_payload->config, 3478 faceID); 3479 result.status = rc; 3480 result.request_api = evt; 3481 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 3482 result.handle = faceID; 3483 m_parent->signalAPIResult(&result); 3484 } 3485 break; 3486 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 3487 { 3488 if ( m_parent->isLongshotEnabled() ) { 3489 // no ops here, need to singal NO_ERROR 3490 rc = NO_ERROR; 3491 } else { 3492 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 3493 rc = INVALID_OPERATION; 3494 } 3495 3496 result.status = rc; 3497 result.request_api = evt; 3498 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3499 m_parent->signalAPIResult(&result); 3500 } 3501 break; 3502 case QCAMERA_SM_EVT_TAKE_PICTURE: 3503 { 3504 if ( m_parent->isLongshotEnabled() ) { 3505 rc = m_parent->longShot(); 3506 } else { 3507 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 3508 rc = INVALID_OPERATION; 3509 } 3510 3511 result.status = rc; 3512 result.request_api = evt; 3513 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3514 m_parent->signalAPIResult(&result); 3515 } 3516 break; 3517 3518 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 3519 { 3520 LOGD("Prepare Snapshot"); 3521 if (m_parent->isRetroPicture()) { 3522 LOGD("Prepare Snapshot in Retro Mode"); 3523 rc = m_parent->prepareHardwareForSnapshot(FALSE); 3524 if (rc != NO_ERROR) { 3525 LOGE("prepareHardwareForSnapshot failed %d", 3526 rc); 3527 result.status = rc; 3528 result.request_api = evt; 3529 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3530 m_parent->signalAPIResult(&result); 3531 } 3532 } 3533 else { 3534 LOGE("Error!! cannot handle evt(%d) in state(%d)", 3535 evt, m_state); 3536 rc = INVALID_OPERATION; 3537 result.status = rc; 3538 result.request_api = evt; 3539 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3540 m_parent->signalAPIResult(&result); 3541 } 3542 } 3543 break; 3544 case QCAMERA_SM_EVT_STOP_RECORDING: 3545 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 3546 case QCAMERA_SM_EVT_START_PREVIEW: 3547 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 3548 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 3549 case QCAMERA_SM_EVT_RELEASE: 3550 { 3551 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 3552 rc = INVALID_OPERATION; 3553 result.status = rc; 3554 result.request_api = evt; 3555 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3556 m_parent->signalAPIResult(&result); 3557 } 3558 break; 3559 case QCAMERA_SM_EVT_EVT_INTERNAL: 3560 { 3561 qcamera_sm_internal_evt_payload_t *internal_evt = 3562 (qcamera_sm_internal_evt_payload_t *)payload; 3563 switch (internal_evt->evt_type) { 3564 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 3565 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 3566 break; 3567 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 3568 LOGD("Received QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE event"); 3569 if (m_parent->isRetroPicture()) { 3570 m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state); 3571 LOGD("Retro picture"); 3572 result.status = NO_ERROR; 3573 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 3574 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3575 m_parent->signalAPIResult(&result); 3576 } 3577 else { 3578 LOGE("Invalid Case for " 3579 "QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT event"); 3580 } 3581 break; 3582 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 3583 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 3584 break; 3585 case QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT: 3586 // This is valid only in Retro picture Mode 3587 if (m_parent->isRetroPicture()) { 3588 LOGD("Received QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT event"); 3589 result.status = NO_ERROR; 3590 result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE; 3591 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3592 m_parent->signalAPIResult(&result); 3593 } 3594 else { 3595 LOGD("Wrong Case for QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT event"); 3596 } 3597 break; 3598 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 3599 rc = m_parent->processHistogramStats(internal_evt->stats_data); 3600 break; 3601 case QCAMERA_INTERNAL_EVT_CROP_INFO: 3602 rc = m_parent->processZoomEvent(internal_evt->crop_data); 3603 break; 3604 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 3605 rc = m_parent->processASDUpdate(internal_evt->asd_data); 3606 break; 3607 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 3608 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 3609 break; 3610 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 3611 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 3612 break; 3613 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 3614 rc = m_parent->processAEInfo(internal_evt->ae_data); 3615 break; 3616 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 3617 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 3618 break; 3619 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 3620 rc = m_parent->processHDRData(internal_evt->hdr_data); 3621 break; 3622 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 3623 rc = m_parent->processRetroAECUnlock(); 3624 break; 3625 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 3626 rc = m_parent->processZSLCaptureDone(); 3627 break; 3628 case QCAMERA_INTERNAL_EVT_DUAL_CAMERA_FOV_CONTROL: 3629 m_parent->processDualCamFovControl(); 3630 break; 3631 case QCAMERA_INTERNAL_EVT_LED_CALIB_UPDATE: 3632 rc = m_parent->processLEDCalibration(internal_evt->led_calib_result); 3633 break; 3634 default: 3635 break; 3636 } 3637 } 3638 break; 3639 case QCAMERA_SM_EVT_EVT_NOTIFY: 3640 { 3641 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 3642 switch (cam_evt->server_event_type) { 3643 case CAM_EVENT_TYPE_DAEMON_DIED: 3644 { 3645 // Send internal events to stop indefinite wait on prepare 3646 // snapshot done event. 3647 result.status = rc; 3648 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 3649 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3650 m_parent->signalAPIResult(&result); 3651 3652 result.status = rc; 3653 result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE; 3654 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3655 m_parent->signalAPIResult(&result); 3656 3657 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 3658 CAMERA_ERROR_SERVER_DIED, 3659 0); 3660 } 3661 break; 3662 case CAM_EVENT_TYPE_CAC_DONE: 3663 if (m_parent->isCACEnabled() || m_parent->mParameters.isOEMFeatEnabled()) { 3664 LOGD("[LONG_SHOT_DBG] : Received CAC Done"); 3665 if ((m_parent->isLongshotEnabled()) 3666 && (!m_parent->isCaptureShutterEnabled())) { 3667 // play shutter sound for longshot 3668 // after CAC stage is done 3669 m_parent->playShutter(); 3670 } 3671 m_parent->mCACDoneReceived = TRUE; 3672 } 3673 break; 3674 default: 3675 LOGE("Invalid internal event %d in state(%d)", 3676 cam_evt->server_event_type, m_state); 3677 break; 3678 } 3679 } 3680 break; 3681 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 3682 { 3683 LOGL("Calling Process Jpeg Notify"); 3684 qcamera_jpeg_evt_payload_t *jpeg_job = 3685 (qcamera_jpeg_evt_payload_t *)payload; 3686 rc = m_parent->processJpegNotify(jpeg_job); 3687 } 3688 break; 3689 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 3690 { 3691 LOGL("Snapshot Done"); 3692 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) { 3693 rc = m_parent->cancelPicture(); 3694 } else { 3695 rc = m_parent->cancelLiveSnapshot(); 3696 } 3697 m_state = QCAMERA_SM_STATE_PREVIEWING; 3698 if (m_parent->isRetroPicture()){ 3699 result.status = rc; 3700 result.request_api = evt; 3701 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3702 LOGL("\n Signalling for JPEG snapshot done!!"); 3703 m_parent->signalAPIResult(&result); 3704 3705 } 3706 result.status = rc; 3707 result.request_api = evt; 3708 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3709 m_parent->signalEvtResult(&result); 3710 } 3711 break; 3712 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 3713 { 3714 rc = m_parent->updateThermalLevel(payload); 3715 } 3716 break; 3717 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 3718 { 3719 m_parent->stopPreview(); 3720 result.status = rc; 3721 result.request_api = evt; 3722 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3723 m_parent->signalAPIResult(&result); 3724 } 3725 break; 3726 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 3727 { 3728 rc = m_parent->preparePreview(); 3729 if (rc == NO_ERROR) { 3730 rc = m_parent->startPreview(); 3731 } 3732 result.status = rc; 3733 result.request_api = evt; 3734 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3735 m_parent->signalAPIResult(&result); 3736 } 3737 break; 3738 default: 3739 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 3740 break; 3741 } 3742 3743 return rc; 3744} 3745 3746/*=========================================================================== 3747 * FUNCTION : isRecording 3748 * 3749 * DESCRIPTION: check if recording is in process. 3750 * 3751 * PARAMETERS : None 3752 * 3753 * RETURN : true -- recording 3754 * false -- not in recording mode 3755 *==========================================================================*/ 3756bool QCameraStateMachine::isRecording() 3757{ 3758 switch (m_state) { 3759 case QCAMERA_SM_STATE_RECORDING: 3760 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 3761 return true; 3762 default: 3763 return false; 3764 } 3765} 3766 3767/*=========================================================================== 3768 * FUNCTION : isPreviewRunning 3769 * 3770 * DESCRIPTION: check if preview is in process. 3771 * 3772 * PARAMETERS : None 3773 * 3774 * RETURN : true -- preview running 3775 * false -- preview stopped 3776 *==========================================================================*/ 3777bool QCameraStateMachine::isPreviewRunning() 3778{ 3779 switch (m_state) { 3780 case QCAMERA_SM_STATE_PREVIEWING: 3781 case QCAMERA_SM_STATE_RECORDING: 3782 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 3783 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING: 3784 case QCAMERA_SM_STATE_PREPARE_SNAPSHOT: 3785 case QCAMERA_SM_STATE_PREVIEW_READY: 3786 return true; 3787 default: 3788 return false; 3789 } 3790} 3791 3792/*=========================================================================== 3793 * FUNCTION : isPreviewReady 3794 * 3795 * DESCRIPTION: check if preview is in ready state. 3796 * 3797 * PARAMETERS : None 3798 * 3799 * RETURN : true -- preview is in ready state 3800 * false -- preview is stopped 3801 *==========================================================================*/ 3802bool QCameraStateMachine::isPreviewReady() 3803{ 3804 switch (m_state) { 3805 case QCAMERA_SM_STATE_PREVIEW_READY: 3806 return true; 3807 default: 3808 return false; 3809 } 3810} 3811 3812/*=========================================================================== 3813 * FUNCTION : isCaptureRunning 3814 * 3815 * DESCRIPTION: check if image capture is in process. 3816 * 3817 * PARAMETERS : None 3818 * 3819 * RETURN : true -- capture running 3820 * false -- capture stopped 3821 *==========================================================================*/ 3822bool QCameraStateMachine::isCaptureRunning() 3823{ 3824 switch (m_state) { 3825 case QCAMERA_SM_STATE_PIC_TAKING: 3826 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 3827 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING: 3828 return true; 3829 default: 3830 return false; 3831 } 3832} 3833/*=========================================================================== 3834 * FUNCTION : isNonZSLCaptureRunning 3835 * 3836 * DESCRIPTION: check if image capture is in process in non ZSL mode. 3837 * 3838 * PARAMETERS : None 3839 * 3840 * RETURN : true -- capture running in non ZSL mode 3841 * false -- Either in not capture mode or captur is not in non ZSL mode 3842 *==========================================================================*/ 3843bool QCameraStateMachine::isNonZSLCaptureRunning() 3844{ 3845 switch (m_state) { 3846 case QCAMERA_SM_STATE_PIC_TAKING: 3847 return true; 3848 default: 3849 return false; 3850 } 3851} 3852 3853/*=========================================================================== 3854 * FUNCTION : dump 3855 * 3856 * DESCRIPTION: Composes a string based on current configuration 3857 * 3858 * PARAMETERS : none 3859 * 3860 * RETURN : Formatted string 3861 *==========================================================================*/ 3862String8 QCameraStateMachine::dump() 3863{ 3864 String8 str("\n"); 3865 char s[128]; 3866 3867 snprintf(s, 128, "Is Preview Running: %d\n", isPreviewRunning()); 3868 str += s; 3869 3870 snprintf(s, 128, "Is Capture Running: %d\n", isCaptureRunning()); 3871 str += s; 3872 3873 snprintf(s, 128, "Is Non ZSL Capture Running: %d\n", 3874 isNonZSLCaptureRunning()); 3875 str += s; 3876 3877 snprintf(s, 128, "Current State: %d \n", m_state); 3878 str += s; 3879 3880 switch(m_state){ 3881 case QCAMERA_SM_STATE_PREVIEW_STOPPED: 3882 snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEW_STOPPED \n"); 3883 break; 3884 3885 case QCAMERA_SM_STATE_PREVIEW_READY: 3886 snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEW_READY \n"); 3887 break; 3888 3889 case QCAMERA_SM_STATE_PREVIEWING: 3890 snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEWING \n"); 3891 break; 3892 3893 case QCAMERA_SM_STATE_PREPARE_SNAPSHOT: 3894 snprintf(s, 128, " QCAMERA_SM_STATE_PREPARE_SNAPSHOT \n"); 3895 break; 3896 3897 case QCAMERA_SM_STATE_PIC_TAKING: 3898 snprintf(s, 128, " QCAMERA_SM_STATE_PIC_TAKING \n"); 3899 break; 3900 3901 case QCAMERA_SM_STATE_RECORDING: 3902 snprintf(s, 128, " QCAMERA_SM_STATE_RECORDING \n"); 3903 break; 3904 3905 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 3906 snprintf(s, 128, " QCAMERA_SM_STATE_VIDEO_PIC_TAKING \n"); 3907 break; 3908 3909 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING: 3910 snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEW_PIC_TAKING \n"); 3911 break; 3912 } 3913 str += s; 3914 3915 return str; 3916} 3917 3918}; // namespace qcamera 3919