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 40 extern "C" { 41 #include "mm_camera_dbg.h" 42 } 43 44 namespace 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 *==========================================================================*/ 57 void *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 *==========================================================================*/ 118 QCameraStateMachine::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 *==========================================================================*/ 146 QCameraStateMachine::~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 *==========================================================================*/ 160 void 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 *==========================================================================*/ 195 int32_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 *==========================================================================*/ 223 int32_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 *==========================================================================*/ 261 int32_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 *==========================================================================*/ 299 int32_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 *==========================================================================*/ 349 int32_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_PRE_START_RECORDING: 636 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 637 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 638 case QCAMERA_SM_EVT_START_RECORDING: 639 case QCAMERA_SM_EVT_STOP_RECORDING: 640 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 641 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 642 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 643 case QCAMERA_SM_EVT_TAKE_PICTURE: 644 { 645 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 646 rc = INVALID_OPERATION; 647 result.status = rc; 648 result.request_api = evt; 649 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 650 m_parent->signalAPIResult(&result); 651 } 652 break; 653 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 654 case QCAMERA_SM_EVT_CANCEL_PICTURE: 655 { 656 // no op needed here 657 LOGW("No ops for evt(%d) in state(%d)", evt, m_state); 658 result.status = NO_ERROR; 659 result.request_api = evt; 660 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 661 m_parent->signalAPIResult(&result); 662 } 663 break; 664 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 665 { 666 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 667 if (NO_ERROR != rc) { 668 LOGE("Param init deferred work failed"); 669 } else { 670 rc = m_parent->cancelAutoFocus(); 671 } 672 result.status = rc; 673 result.request_api = evt; 674 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 675 m_parent->signalAPIResult(&result); 676 } 677 break; 678 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 679 { 680 int32_t faceID = 0; 681 qcamera_sm_evt_reg_face_payload_t *reg_payload = 682 (qcamera_sm_evt_reg_face_payload_t *)payload; 683 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 684 reg_payload->config, 685 faceID); 686 result.status = rc; 687 result.request_api = evt; 688 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 689 result.handle = faceID; 690 m_parent->signalAPIResult(&result); 691 } 692 break; 693 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 694 { 695 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 696 if (NO_ERROR != rc) { 697 LOGE("Param init deferred work failed"); 698 } else { 699 rc = m_parent->updateThermalLevel(payload); 700 } 701 } 702 break; 703 case QCAMERA_SM_EVT_EVT_NOTIFY: 704 { 705 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 706 switch (cam_evt->server_event_type) { 707 case CAM_EVENT_TYPE_DAEMON_DIED: 708 { 709 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 710 CAMERA_ERROR_SERVER_DIED, 711 0); 712 } 713 break; 714 default: 715 LOGE("Invalid internal event %d in state(%d)", 716 cam_evt->server_event_type, m_state); 717 break; 718 } 719 } 720 break; 721 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 722 { 723 // No ops, but need to notify 724 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 725 result.status = rc; 726 result.request_api = evt; 727 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 728 m_parent->signalEvtResult(&result); 729 } 730 break; 731 case QCAMERA_SM_EVT_EVT_INTERNAL: 732 { 733 qcamera_sm_internal_evt_payload_t *internal_evt = 734 (qcamera_sm_internal_evt_payload_t *)payload; 735 switch (internal_evt->evt_type) { 736 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 737 rc = m_parent->waitDeferredWork(m_parent->mParamInitJob); 738 if (NO_ERROR != rc) { 739 LOGE("Param init deferred work failed"); 740 } else { 741 rc = m_parent->mParameters.updateFlashMode(internal_evt->led_data); 742 } 743 break; 744 default: 745 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 746 break; 747 } 748 } 749 break; 750 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 751 default: 752 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 753 break; 754 } 755 756 return rc; 757 } 758 759 /*=========================================================================== 760 * FUNCTION : procEvtPreviewReadyState 761 * 762 * DESCRIPTION: finite state machine function to handle event in state of 763 * QCAMERA_SM_STATE_PREVIEW_READY. 764 * 765 * PARAMETERS : 766 * @evt : event to be processed 767 * @payload : event payload. Can be NULL if not needed. 768 * 769 * RETURN : int32_t type of status 770 * NO_ERROR -- success 771 * none-zero failure code 772 *==========================================================================*/ 773 int32_t QCameraStateMachine::procEvtPreviewReadyState(qcamera_sm_evt_enum_t evt, 774 void *payload) 775 { 776 int32_t rc = NO_ERROR; 777 qcamera_api_result_t result; 778 memset(&result, 0, sizeof(qcamera_api_result_t)); 779 780 LOGL("event (%d)", evt); 781 switch (evt) { 782 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 783 { 784 m_parent->setPreviewWindow((struct preview_stream_ops *)payload); 785 if (m_parent->mPreviewWindow != NULL) { 786 applyDelayedMsgs(); 787 rc = m_parent->startPreview(); 788 if (rc != NO_ERROR) { 789 m_parent->unpreparePreview(); 790 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 791 } else { 792 m_state = QCAMERA_SM_STATE_PREVIEWING; 793 } 794 } 795 796 result.status = rc; 797 result.request_api = evt; 798 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 799 m_parent->signalAPIResult(&result); 800 } 801 break; 802 case QCAMERA_SM_EVT_SET_CALLBACKS: 803 { 804 qcamera_sm_evt_setcb_payload_t *setcbs = 805 (qcamera_sm_evt_setcb_payload_t *)payload; 806 rc = m_parent->setCallBacks(setcbs->notify_cb, 807 setcbs->data_cb, 808 setcbs->data_cb_timestamp, 809 setcbs->get_memory, 810 setcbs->user); 811 result.status = rc; 812 result.request_api = evt; 813 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 814 m_parent->signalAPIResult(&result); 815 } 816 break; 817 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 818 { 819 rc = m_parent->enableMsgType(*((int32_t *)payload)); 820 result.status = rc; 821 result.request_api = evt; 822 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 823 m_parent->signalAPIResult(&result); 824 } 825 break; 826 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 827 { 828 rc = m_parent->disableMsgType(*((int32_t *)payload)); 829 result.status = rc; 830 result.request_api = evt; 831 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 832 m_parent->signalAPIResult(&result); 833 } 834 break; 835 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 836 { 837 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 838 result.status = rc; 839 result.request_api = evt; 840 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 841 result.enabled = enabled; 842 m_parent->signalAPIResult(&result); 843 } 844 break; 845 case QCAMERA_SM_EVT_SET_PARAMS: 846 { 847 bool needRestart = false; 848 rc = m_parent->updateParameters((char*)payload, needRestart); 849 result.status = rc; 850 result.request_api = evt; 851 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 852 m_parent->signalAPIResult(&result); 853 } 854 break; 855 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 856 { 857 LOGD("Stopping preview..."); 858 // need restart preview for parameters to take effect 859 m_parent->unpreparePreview(); 860 // Clear memory pools 861 m_parent->m_memoryPool.clear(); 862 result.status = rc; 863 result.request_api = evt; 864 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 865 m_parent->signalAPIResult(&result); 866 } 867 break; 868 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 869 { 870 rc = m_parent->commitParameterChanges(); 871 result.status = rc; 872 result.request_api = evt; 873 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 874 m_parent->signalAPIResult(&result); 875 } 876 break; 877 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 878 { 879 // prepare preview again 880 rc = m_parent->preparePreview(); 881 if (rc != NO_ERROR) { 882 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 883 } 884 m_parent->setNeedRestart(false); 885 result.status = rc; 886 result.request_api = evt; 887 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 888 m_parent->signalAPIResult(&result); 889 } 890 break; 891 case QCAMERA_SM_EVT_GET_PARAMS: 892 { 893 result.params = m_parent->getParameters(); 894 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 895 result.status = rc; 896 result.request_api = evt; 897 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 898 m_parent->signalAPIResult(&result); 899 } 900 break; 901 case QCAMERA_SM_EVT_PUT_PARAMS: 902 { 903 rc = m_parent->putParameters((char*)payload); 904 result.status = rc; 905 result.request_api = evt; 906 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 907 m_parent->signalAPIResult(&result); 908 } 909 break; 910 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 911 { 912 // no ops here 913 rc = NO_ERROR; 914 result.status = rc; 915 result.request_api = evt; 916 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 917 m_parent->signalAPIResult(&result); 918 } 919 break; 920 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 921 { 922 rc = m_parent->startPreview(); 923 if (rc != NO_ERROR) { 924 m_parent->unpreparePreview(); 925 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 926 } else { 927 m_state = QCAMERA_SM_STATE_PREVIEWING; 928 } 929 // no ops here 930 rc = NO_ERROR; 931 result.status = rc; 932 result.request_api = evt; 933 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 934 m_parent->signalAPIResult(&result); 935 } 936 break; 937 case QCAMERA_SM_EVT_START_PREVIEW: 938 { 939 if (m_parent->mPreviewWindow != NULL) { 940 rc = m_parent->startPreview(); 941 if (rc != NO_ERROR) { 942 m_parent->unpreparePreview(); 943 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 944 } else { 945 m_state = QCAMERA_SM_STATE_PREVIEWING; 946 } 947 } 948 // no ops here 949 rc = NO_ERROR; 950 result.status = rc; 951 result.request_api = evt; 952 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 953 m_parent->signalAPIResult(&result); 954 } 955 break; 956 case QCAMERA_SM_EVT_STOP_PREVIEW: 957 { 958 m_parent->unpreparePreview(); 959 rc = 0; 960 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 961 result.status = rc; 962 result.request_api = evt; 963 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 964 m_parent->signalAPIResult(&result); 965 } 966 break; 967 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 968 { 969 rc = NO_ERROR; 970 result.status = rc; 971 result.request_api = evt; 972 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 973 result.enabled = 1; 974 m_parent->signalAPIResult(&result); 975 } 976 break; 977 case QCAMERA_SM_EVT_RECORDING_ENABLED: 978 { 979 rc = 0; 980 result.status = rc; 981 result.request_api = evt; 982 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 983 result.enabled = 0; 984 m_parent->signalAPIResult(&result); 985 } 986 break; 987 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 988 { 989 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 990 result.status = rc; 991 result.request_api = evt; 992 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 993 m_parent->signalAPIResult(&result); 994 } 995 break; 996 case QCAMERA_SM_EVT_DUMP: 997 { 998 rc = m_parent->dump(*((int *)payload)); 999 result.status = rc; 1000 result.request_api = evt; 1001 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1002 m_parent->signalAPIResult(&result); 1003 } 1004 break; 1005 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 1006 { 1007 rc = m_parent->autoFocus(); 1008 result.status = rc; 1009 result.request_api = evt; 1010 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1011 m_parent->signalAPIResult(&result); 1012 } 1013 break; 1014 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 1015 { 1016 rc = m_parent->cancelAutoFocus(); 1017 result.status = rc; 1018 result.request_api = evt; 1019 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1020 m_parent->signalAPIResult(&result); 1021 } 1022 break; 1023 case QCAMERA_SM_EVT_SEND_COMMAND: 1024 { 1025 qcamera_sm_evt_command_payload_t *cmd_payload = 1026 (qcamera_sm_evt_command_payload_t *)payload; 1027 rc = m_parent->sendCommand(cmd_payload->cmd, 1028 cmd_payload->arg1, 1029 cmd_payload->arg2); 1030 result.status = rc; 1031 result.request_api = evt; 1032 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1033 m_parent->signalAPIResult(&result); 1034 } 1035 break; 1036 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 1037 { 1038 int32_t faceID = 0; 1039 qcamera_sm_evt_reg_face_payload_t *reg_payload = 1040 (qcamera_sm_evt_reg_face_payload_t *)payload; 1041 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 1042 reg_payload->config, 1043 faceID); 1044 result.status = rc; 1045 result.request_api = evt; 1046 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 1047 result.handle = faceID; 1048 m_parent->signalAPIResult(&result); 1049 } 1050 break; 1051 case QCAMERA_SM_EVT_PRE_START_RECORDING: 1052 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 1053 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 1054 case QCAMERA_SM_EVT_START_RECORDING: 1055 case QCAMERA_SM_EVT_STOP_RECORDING: 1056 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 1057 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 1058 case QCAMERA_SM_EVT_TAKE_PICTURE: 1059 case QCAMERA_SM_EVT_CANCEL_PICTURE: 1060 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 1061 case QCAMERA_SM_EVT_RELEASE: 1062 { 1063 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 1064 rc = INVALID_OPERATION; 1065 result.status = rc; 1066 result.request_api = evt; 1067 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1068 m_parent->signalAPIResult(&result); 1069 } 1070 break; 1071 case QCAMERA_SM_EVT_EVT_NOTIFY: 1072 { 1073 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 1074 switch (cam_evt->server_event_type) { 1075 case CAM_EVENT_TYPE_DAEMON_DIED: 1076 { 1077 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 1078 CAMERA_ERROR_SERVER_DIED, 1079 0); 1080 } 1081 break; 1082 default: 1083 LOGE("Invalid internal event %d in state(%d)", 1084 cam_evt->server_event_type, m_state); 1085 break; 1086 } 1087 } 1088 break; 1089 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 1090 { 1091 // No ops, but need to notify 1092 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1093 result.status = rc; 1094 result.request_api = evt; 1095 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1096 m_parent->signalEvtResult(&result); 1097 } 1098 break; 1099 case QCAMERA_SM_EVT_EVT_INTERNAL: 1100 { 1101 qcamera_sm_internal_evt_payload_t *internal_evt = 1102 (qcamera_sm_internal_evt_payload_t *)payload; 1103 switch (internal_evt->evt_type) { 1104 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 1105 rc = m_parent->mParameters.updateFlashMode(internal_evt->led_data); 1106 break; 1107 default: 1108 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1109 break; 1110 } 1111 } 1112 break; 1113 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 1114 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 1115 default: 1116 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1117 break; 1118 } 1119 1120 return rc; 1121 } 1122 1123 /*=========================================================================== 1124 * FUNCTION : procEvtPreviewingState 1125 * 1126 * DESCRIPTION: finite state machine function to handle event in state of 1127 * QCAMERA_SM_STATE_PREVIEWING. 1128 * 1129 * PARAMETERS : 1130 * @evt : event to be processed 1131 * @payload : event payload. Can be NULL if not needed. 1132 * 1133 * RETURN : int32_t type of status 1134 * NO_ERROR -- success 1135 * none-zero failure code 1136 *==========================================================================*/ 1137 int32_t QCameraStateMachine::procEvtPreviewingState(qcamera_sm_evt_enum_t evt, 1138 void *payload) 1139 { 1140 int32_t rc = NO_ERROR; 1141 qcamera_api_result_t result; 1142 memset(&result, 0, sizeof(qcamera_api_result_t)); 1143 1144 LOGL("event (%d)", evt); 1145 switch (evt) { 1146 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 1147 { 1148 // Error setting preview window during previewing 1149 LOGE("Error!! cannot set preview window when preview is running"); 1150 rc = INVALID_OPERATION; 1151 result.status = rc; 1152 result.request_api = evt; 1153 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1154 m_parent->signalAPIResult(&result); 1155 } 1156 break; 1157 case QCAMERA_SM_EVT_SET_CALLBACKS: 1158 { 1159 qcamera_sm_evt_setcb_payload_t *setcbs = 1160 (qcamera_sm_evt_setcb_payload_t *)payload; 1161 rc = m_parent->setCallBacks(setcbs->notify_cb, 1162 setcbs->data_cb, 1163 setcbs->data_cb_timestamp, 1164 setcbs->get_memory, 1165 setcbs->user); 1166 result.status = rc; 1167 result.request_api = evt; 1168 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1169 m_parent->signalAPIResult(&result); 1170 } 1171 break; 1172 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 1173 { 1174 int32_t enable_msgs = *((int32_t *)payload); 1175 if (m_bDelayPreviewMsgs && 1176 (enable_msgs & CAMERA_MSG_PREVIEW_FRAME)) { 1177 enable_msgs &= ~CAMERA_MSG_PREVIEW_FRAME; 1178 m_DelayedMsgs = CAMERA_MSG_PREVIEW_FRAME; 1179 } 1180 rc = m_parent->enableMsgType(enable_msgs); 1181 result.status = rc; 1182 result.request_api = evt; 1183 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1184 m_parent->signalAPIResult(&result); 1185 } 1186 break; 1187 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 1188 { 1189 int32_t disable_msgs = *((int32_t *)payload); 1190 if (m_bDelayPreviewMsgs && m_DelayedMsgs) { 1191 m_DelayedMsgs &= ~disable_msgs; 1192 if (0 == m_DelayedMsgs) { 1193 m_bDelayPreviewMsgs = false; 1194 } 1195 } 1196 rc = m_parent->disableMsgType(disable_msgs); 1197 result.status = rc; 1198 result.request_api = evt; 1199 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1200 m_parent->signalAPIResult(&result); 1201 } 1202 break; 1203 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 1204 { 1205 int32_t msgs = *((int32_t *)payload); 1206 int enabled = m_parent->msgTypeEnabled(msgs); 1207 if (m_bDelayPreviewMsgs && m_DelayedMsgs) { 1208 enabled |= (msgs & m_DelayedMsgs); 1209 } 1210 result.status = rc; 1211 result.request_api = evt; 1212 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1213 result.enabled = enabled; 1214 m_parent->signalAPIResult(&result); 1215 } 1216 break; 1217 case QCAMERA_SM_EVT_SET_PARAMS: 1218 { 1219 bool needRestart = false; 1220 rc = m_parent->updateParameters((char*)payload, needRestart); 1221 result.status = rc; 1222 result.request_api = evt; 1223 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1224 m_parent->signalAPIResult(&result); 1225 } 1226 break; 1227 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 1228 { 1229 LOGD("Stopping preview..."); 1230 // stop preview 1231 rc = m_parent->stopPreview(); 1232 // Clear memory pools 1233 m_parent->m_memoryPool.clear(); 1234 result.status = rc; 1235 result.request_api = evt; 1236 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1237 m_parent->signalAPIResult(&result); 1238 } 1239 break; 1240 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 1241 { 1242 rc = m_parent->commitParameterChanges(); 1243 result.status = rc; 1244 result.request_api = evt; 1245 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1246 m_parent->signalAPIResult(&result); 1247 } 1248 break; 1249 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 1250 { 1251 // start preview again 1252 rc = m_parent->preparePreview(); 1253 if (rc == NO_ERROR) { 1254 applyDelayedMsgs(); 1255 rc = m_parent->startPreview(); 1256 if (rc != NO_ERROR) { 1257 m_parent->unpreparePreview(); 1258 } 1259 if (rc != NO_ERROR) { 1260 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 1261 } 1262 } 1263 m_parent->setNeedRestart(false); 1264 result.status = rc; 1265 result.request_api = evt; 1266 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1267 m_parent->signalAPIResult(&result); 1268 } 1269 break; 1270 case QCAMERA_SM_EVT_GET_PARAMS: 1271 { 1272 result.params = m_parent->getParameters(); 1273 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 1274 result.status = rc; 1275 result.request_api = evt; 1276 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 1277 m_parent->signalAPIResult(&result); 1278 } 1279 break; 1280 case QCAMERA_SM_EVT_PUT_PARAMS: 1281 { 1282 rc = m_parent->putParameters((char*)payload); 1283 result.status = rc; 1284 result.request_api = evt; 1285 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1286 m_parent->signalAPIResult(&result); 1287 } 1288 break; 1289 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 1290 { 1291 // no ops here 1292 LOGW("Already in preview ready state, no ops here"); 1293 rc = NO_ERROR; 1294 result.status = rc; 1295 result.request_api = evt; 1296 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1297 m_parent->signalAPIResult(&result); 1298 } 1299 break; 1300 case QCAMERA_SM_EVT_START_PREVIEW: 1301 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 1302 { 1303 // no ops here 1304 LOGW("Already in previewing, no ops here to start preview"); 1305 applyDelayedMsgs(); 1306 rc = NO_ERROR; 1307 result.status = rc; 1308 result.request_api = evt; 1309 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1310 m_parent->signalAPIResult(&result); 1311 } 1312 break; 1313 case QCAMERA_SM_EVT_STOP_PREVIEW: 1314 { 1315 rc = m_parent->stopPreview(); 1316 applyDelayedMsgs(); 1317 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 1318 result.status = rc; 1319 result.request_api = evt; 1320 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1321 m_parent->signalAPIResult(&result); 1322 } 1323 break; 1324 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 1325 { 1326 applyDelayedMsgs(); 1327 rc = NO_ERROR; 1328 result.status = rc; 1329 result.request_api = evt; 1330 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1331 result.enabled = 1; 1332 m_parent->signalAPIResult(&result); 1333 } 1334 break; 1335 case QCAMERA_SM_EVT_RECORDING_ENABLED: 1336 { 1337 rc = NO_ERROR; 1338 result.status = rc; 1339 result.request_api = evt; 1340 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1341 result.enabled = 0; 1342 m_parent->signalAPIResult(&result); 1343 } 1344 break; 1345 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 1346 { 1347 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 1348 result.status = rc; 1349 result.request_api = evt; 1350 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1351 m_parent->signalAPIResult(&result); 1352 } 1353 break; 1354 case QCAMERA_SM_EVT_DUMP: 1355 { 1356 rc = m_parent->dump(*((int *)payload)); 1357 result.status = rc; 1358 result.request_api = evt; 1359 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1360 m_parent->signalAPIResult(&result); 1361 } 1362 break; 1363 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 1364 { 1365 rc = m_parent->autoFocus(); 1366 result.status = rc; 1367 result.request_api = evt; 1368 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1369 m_parent->signalAPIResult(&result); 1370 } 1371 break; 1372 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 1373 { 1374 rc = m_parent->cancelAutoFocus(); 1375 result.status = rc; 1376 result.request_api = evt; 1377 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1378 m_parent->signalAPIResult(&result); 1379 } 1380 break; 1381 case QCAMERA_SM_EVT_PRE_START_RECORDING: 1382 { 1383 rc = m_parent->preStartRecording(); 1384 result.status = rc; 1385 result.request_api = evt; 1386 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1387 m_parent->signalAPIResult(&result); 1388 } 1389 break; 1390 case QCAMERA_SM_EVT_START_RECORDING: 1391 { 1392 rc = m_parent->startRecording(); 1393 if (rc == NO_ERROR) { 1394 // move state to recording state 1395 m_state = QCAMERA_SM_STATE_RECORDING; 1396 applyDelayedMsgs(); 1397 } 1398 result.status = rc; 1399 result.request_api = evt; 1400 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1401 m_parent->signalAPIResult(&result); 1402 } 1403 break; 1404 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 1405 { 1406 rc = m_parent->prepareHardwareForSnapshot(FALSE); 1407 if (rc == NO_ERROR) { 1408 // Do not signal API result in this case. 1409 // Need to wait for snapshot done in metadta. 1410 m_state = QCAMERA_SM_STATE_PREPARE_SNAPSHOT; 1411 applyDelayedMsgs(); 1412 } else { 1413 // Do not change state in this case. 1414 LOGE("prepareHardwareForSnapshot failed %d", 1415 rc); 1416 1417 result.status = rc; 1418 result.request_api = evt; 1419 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1420 m_parent->signalAPIResult(&result); 1421 } 1422 } 1423 break; 1424 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 1425 { 1426 rc = m_parent->preTakePicture(); 1427 result.status = rc; 1428 result.request_api = evt; 1429 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1430 m_parent->signalAPIResult(&result); 1431 } 1432 break; 1433 case QCAMERA_SM_EVT_TAKE_PICTURE: 1434 { 1435 LOGL("QCAMERA_SM_EVT_TAKE_PICTURE "); 1436 if ( m_parent->mParameters.getRecordingHintValue() == true) { 1437 m_parent->stopPreview(); 1438 m_parent->mParameters.updateRecordingHintValue(FALSE); 1439 // start preview again 1440 rc = m_parent->preparePreview(); 1441 if (rc == NO_ERROR) { 1442 rc = m_parent->startPreview(); 1443 if (rc != NO_ERROR) { 1444 m_parent->unpreparePreview(); 1445 } 1446 } 1447 } 1448 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) { 1449 bool restartPreview = m_parent->isPreviewRestartEnabled(); 1450 if ((restartPreview) && (m_parent->mParameters.getManualCaptureMode() 1451 >= CAM_MANUAL_CAPTURE_TYPE_3)) { 1452 /* stop preview and disable ZSL now */ 1453 m_parent->stopPreview(); 1454 m_parent->mParameters.updateZSLModeValue(FALSE); 1455 m_RestoreZSL = TRUE; 1456 m_bDelayPreviewMsgs = true; 1457 m_state = QCAMERA_SM_STATE_PIC_TAKING; 1458 } else { 1459 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING; 1460 m_bDelayPreviewMsgs = true; 1461 } 1462 1463 rc = m_parent->takePicture(); 1464 if (rc != NO_ERROR) { 1465 // move state to previewing state 1466 m_parent->unconfigureAdvancedCapture(); 1467 m_state = QCAMERA_SM_STATE_PREVIEWING; 1468 } 1469 if (!(m_parent->isRetroPicture()) || (rc != NO_ERROR)) { 1470 LOGD("signal API result, m_state = %d", 1471 m_state); 1472 result.status = rc; 1473 result.request_api = evt; 1474 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1475 m_parent->signalAPIResult(&result); 1476 } 1477 } else { 1478 m_state = QCAMERA_SM_STATE_PIC_TAKING; 1479 rc = m_parent->takePicture(); 1480 if (rc != NO_ERROR) { 1481 int32_t temp_rc = NO_ERROR; 1482 // move state to preview stopped state 1483 m_parent->unconfigureAdvancedCapture(); 1484 m_parent->stopPreview(); 1485 // start preview again 1486 temp_rc = m_parent->preparePreview(); 1487 if (temp_rc == NO_ERROR) { 1488 temp_rc = m_parent->startPreview(); 1489 if (temp_rc != NO_ERROR) { 1490 m_parent->unpreparePreview(); 1491 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 1492 } else { 1493 m_state = QCAMERA_SM_STATE_PREVIEWING; 1494 } 1495 } else { 1496 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 1497 } 1498 } 1499 result.status = rc; 1500 result.request_api = evt; 1501 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1502 m_parent->signalAPIResult(&result); 1503 } 1504 } 1505 break; 1506 case QCAMERA_SM_EVT_SEND_COMMAND: 1507 { 1508 qcamera_sm_evt_command_payload_t *cmd_payload = 1509 (qcamera_sm_evt_command_payload_t *)payload; 1510 rc = m_parent->sendCommand(cmd_payload->cmd, 1511 cmd_payload->arg1, 1512 cmd_payload->arg2); 1513 m_bPreviewNeedsRestart = 1514 (QCAMERA_SM_EVT_RESTART_PERVIEW == cmd_payload->arg1); 1515 m_bPreviewDelayedRestart = 1516 (QCAMERA_SM_EVT_DELAYED_RESTART == cmd_payload->arg2); 1517 1518 #ifndef VANILLA_HAL 1519 if ((CAMERA_CMD_LONGSHOT_ON == cmd_payload->cmd) && 1520 (m_bPreviewNeedsRestart)) { 1521 m_parent->stopPreview(); 1522 // Clear memory pools 1523 m_parent->m_memoryPool.clear(); 1524 1525 if (!m_bPreviewDelayedRestart) { 1526 // start preview again 1527 rc = m_parent->preparePreview(); 1528 if (rc == NO_ERROR) { 1529 applyDelayedMsgs(); 1530 rc = m_parent->startPreview(); 1531 if (rc != NO_ERROR) { 1532 m_parent->unpreparePreview(); 1533 } 1534 } 1535 } 1536 } 1537 #endif 1538 result.status = rc; 1539 result.request_api = evt; 1540 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1541 m_parent->signalAPIResult(&result); 1542 } 1543 break; 1544 case QCAMERA_SM_EVT_SEND_COMMAND_RESTART: 1545 { 1546 #ifndef VANILLA_HAL 1547 qcamera_sm_evt_command_payload_t *cmd_payload = 1548 (qcamera_sm_evt_command_payload_t *)payload; 1549 if ((CAMERA_CMD_LONGSHOT_ON == cmd_payload->cmd) && 1550 (m_bPreviewNeedsRestart) && 1551 (m_bPreviewDelayedRestart)) { 1552 // start preview again 1553 rc = m_parent->preparePreview(); 1554 if (rc == NO_ERROR) { 1555 rc = m_parent->startPreview(); 1556 if (rc != NO_ERROR) { 1557 m_parent->unpreparePreview(); 1558 } 1559 } 1560 } 1561 #endif 1562 result.status = rc; 1563 result.request_api = evt; 1564 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1565 m_parent->signalAPIResult(&result); 1566 } 1567 break; 1568 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 1569 { 1570 int32_t faceID = 0; 1571 qcamera_sm_evt_reg_face_payload_t *reg_payload = 1572 (qcamera_sm_evt_reg_face_payload_t *)payload; 1573 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 1574 reg_payload->config, 1575 faceID); 1576 result.status = rc; 1577 result.request_api = evt; 1578 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 1579 result.handle = faceID; 1580 m_parent->signalAPIResult(&result); 1581 } 1582 break; 1583 case QCAMERA_SM_EVT_CANCEL_PICTURE: 1584 case QCAMERA_SM_EVT_STOP_RECORDING: 1585 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 1586 case QCAMERA_SM_EVT_RELEASE: 1587 { 1588 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 1589 rc = INVALID_OPERATION; 1590 result.status = rc; 1591 result.request_api = evt; 1592 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1593 m_parent->signalAPIResult(&result); 1594 } 1595 break; 1596 case QCAMERA_SM_EVT_EVT_INTERNAL: 1597 { 1598 qcamera_sm_internal_evt_payload_t *internal_evt = 1599 (qcamera_sm_internal_evt_payload_t *)payload; 1600 switch (internal_evt->evt_type) { 1601 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 1602 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 1603 break; 1604 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 1605 break; 1606 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 1607 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 1608 break; 1609 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 1610 rc = m_parent->processHistogramStats(internal_evt->stats_data); 1611 break; 1612 case QCAMERA_INTERNAL_EVT_CROP_INFO: 1613 rc = m_parent->processZoomEvent(internal_evt->crop_data); 1614 break; 1615 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 1616 rc = m_parent->processASDUpdate(internal_evt->asd_data); 1617 break; 1618 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 1619 rc = m_parent->mParameters.updateFlashMode(internal_evt->led_data); 1620 break; 1621 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 1622 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 1623 break; 1624 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 1625 rc = m_parent->processAEInfo(internal_evt->ae_data); 1626 break; 1627 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 1628 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 1629 break; 1630 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 1631 rc = m_parent->processHDRData(internal_evt->hdr_data); 1632 break; 1633 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 1634 rc = m_parent->processRetroAECUnlock(); 1635 break; 1636 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 1637 rc = m_parent->processZSLCaptureDone(); 1638 break; 1639 case QCAMERA_INTERNAL_EVT_DUAL_CAMERA_FOV_CONTROL: 1640 rc = m_parent->processDCFOVControl(); 1641 break; 1642 default: 1643 LOGE("Invalid internal event %d in state(%d)", 1644 internal_evt->evt_type, m_state); 1645 break; 1646 } 1647 } 1648 break; 1649 case QCAMERA_SM_EVT_EVT_NOTIFY: 1650 { 1651 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 1652 switch (cam_evt->server_event_type) { 1653 case CAM_EVENT_TYPE_DAEMON_DIED: 1654 { 1655 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 1656 CAMERA_ERROR_SERVER_DIED, 1657 0); 1658 } 1659 break; 1660 default: 1661 LOGW("no handling for server evt (%d) at this state", 1662 cam_evt->server_event_type); 1663 break; 1664 } 1665 } 1666 break; 1667 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 1668 { 1669 rc = m_parent->updateThermalLevel(payload); 1670 } 1671 break; 1672 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 1673 { 1674 // No ops, but need to notify 1675 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1676 result.status = rc; 1677 result.request_api = evt; 1678 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1679 m_parent->signalEvtResult(&result); 1680 } 1681 break; 1682 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 1683 { 1684 m_parent->stopPreview(); 1685 result.status = rc; 1686 result.request_api = evt; 1687 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1688 m_parent->signalAPIResult(&result); 1689 } 1690 break; 1691 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 1692 { 1693 rc = m_parent->preparePreview(); 1694 if (rc == NO_ERROR) { 1695 rc = m_parent->startPreview(); 1696 } 1697 result.status = rc; 1698 result.request_api = evt; 1699 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1700 m_parent->signalAPIResult(&result); 1701 } 1702 break; 1703 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 1704 default: 1705 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1706 break; 1707 } 1708 1709 return rc; 1710 } 1711 1712 /*=========================================================================== 1713 * FUNCTION : procEvtPrepareSnapshotState 1714 * 1715 * DESCRIPTION: finite state machine function to handle event in state of 1716 * QCAMERA_SM_STATE_PREPARE_SNAPSHOT. 1717 * 1718 * PARAMETERS : 1719 * @evt : event to be processed 1720 * @payload : event payload. Can be NULL if not needed. 1721 * 1722 * RETURN : int32_t type of status 1723 * NO_ERROR -- success 1724 * none-zero failure code 1725 *==========================================================================*/ 1726 int32_t QCameraStateMachine::procEvtPrepareSnapshotState(qcamera_sm_evt_enum_t evt, 1727 void *payload) 1728 { 1729 int32_t rc = NO_ERROR; 1730 qcamera_api_result_t result; 1731 memset(&result, 0, sizeof(qcamera_api_result_t)); 1732 1733 LOGL("event (%d)", evt); 1734 switch (evt) { 1735 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 1736 case QCAMERA_SM_EVT_SET_CALLBACKS: 1737 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 1738 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 1739 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 1740 case QCAMERA_SM_EVT_SET_PARAMS: 1741 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 1742 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 1743 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 1744 case QCAMERA_SM_EVT_GET_PARAMS: 1745 case QCAMERA_SM_EVT_PUT_PARAMS: 1746 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 1747 case QCAMERA_SM_EVT_START_PREVIEW: 1748 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 1749 case QCAMERA_SM_EVT_STOP_PREVIEW: 1750 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 1751 case QCAMERA_SM_EVT_RECORDING_ENABLED: 1752 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 1753 case QCAMERA_SM_EVT_DUMP: 1754 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 1755 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 1756 case QCAMERA_SM_EVT_PRE_START_RECORDING: 1757 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 1758 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 1759 case QCAMERA_SM_EVT_START_RECORDING: 1760 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 1761 case QCAMERA_SM_EVT_TAKE_PICTURE: 1762 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 1763 case QCAMERA_SM_EVT_SEND_COMMAND: 1764 case QCAMERA_SM_EVT_CANCEL_PICTURE: 1765 case QCAMERA_SM_EVT_STOP_RECORDING: 1766 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 1767 case QCAMERA_SM_EVT_RELEASE: 1768 { 1769 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 1770 rc = INVALID_OPERATION; 1771 result.status = rc; 1772 result.request_api = evt; 1773 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1774 m_parent->signalAPIResult(&result); 1775 } 1776 break; 1777 case QCAMERA_SM_EVT_EVT_INTERNAL: 1778 { 1779 qcamera_sm_internal_evt_payload_t *internal_evt = 1780 (qcamera_sm_internal_evt_payload_t *)payload; 1781 switch (internal_evt->evt_type) { 1782 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 1783 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 1784 break; 1785 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 1786 m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state); 1787 m_state = QCAMERA_SM_STATE_PREVIEWING; 1788 1789 result.status = NO_ERROR; 1790 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 1791 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1792 m_parent->signalAPIResult(&result); 1793 break; 1794 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 1795 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 1796 break; 1797 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 1798 rc = m_parent->processHistogramStats(internal_evt->stats_data); 1799 break; 1800 case QCAMERA_INTERNAL_EVT_CROP_INFO: 1801 rc = m_parent->processZoomEvent(internal_evt->crop_data); 1802 break; 1803 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 1804 rc = m_parent->processASDUpdate(internal_evt->asd_data); 1805 break; 1806 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 1807 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1808 break; 1809 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 1810 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 1811 break; 1812 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 1813 rc = m_parent->processAEInfo(internal_evt->ae_data); 1814 break; 1815 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 1816 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 1817 break; 1818 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 1819 rc = m_parent->processHDRData(internal_evt->hdr_data); 1820 break; 1821 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 1822 rc = m_parent->processRetroAECUnlock(); 1823 break; 1824 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 1825 rc = m_parent->processZSLCaptureDone(); 1826 break; 1827 case QCAMERA_INTERNAL_EVT_DUAL_CAMERA_FOV_CONTROL: 1828 rc = m_parent->processDCFOVControl(); 1829 break; 1830 default: 1831 LOGE("Invalid internal event %d in state(%d)", 1832 internal_evt->evt_type, m_state); 1833 break; 1834 } 1835 } 1836 break; 1837 case QCAMERA_SM_EVT_EVT_NOTIFY: 1838 { 1839 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 1840 switch (cam_evt->server_event_type) { 1841 case CAM_EVENT_TYPE_DAEMON_DIED: 1842 { 1843 // Send internal events to stop indefinite wait on prepare 1844 // snapshot done event. 1845 result.status = rc; 1846 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 1847 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1848 m_parent->signalAPIResult(&result); 1849 1850 result.status = rc; 1851 result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE; 1852 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1853 m_parent->signalAPIResult(&result); 1854 1855 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 1856 CAMERA_ERROR_SERVER_DIED, 1857 0); 1858 } 1859 break; 1860 default: 1861 LOGE("Invalid internal event %d in state(%d)", 1862 cam_evt->server_event_type, m_state); 1863 break; 1864 } 1865 } 1866 break; 1867 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 1868 { 1869 // No ops, but need to notify 1870 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1871 result.status = rc; 1872 result.request_api = evt; 1873 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1874 m_parent->signalEvtResult(&result); 1875 } 1876 break; 1877 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 1878 { 1879 rc = m_parent->updateThermalLevel(payload); 1880 } 1881 break; 1882 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 1883 default: 1884 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1885 break; 1886 } 1887 1888 return rc; 1889 } 1890 1891 /*=========================================================================== 1892 * FUNCTION : procEvtPicTakingState 1893 * 1894 * DESCRIPTION: finite state machine function to handle event in state of 1895 * QCAMERA_SM_STATE_PIC_TAKING. 1896 * 1897 * PARAMETERS : 1898 * @evt : event to be processed 1899 * @payload : event payload. Can be NULL if not needed. 1900 * 1901 * RETURN : int32_t type of status 1902 * NO_ERROR -- success 1903 * none-zero failure code 1904 *==========================================================================*/ 1905 int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt, 1906 void *payload) 1907 { 1908 int32_t rc = NO_ERROR; 1909 qcamera_api_result_t result; 1910 memset(&result, 0, sizeof(qcamera_api_result_t)); 1911 1912 LOGL("event (%d)", evt); 1913 switch (evt) { 1914 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 1915 { 1916 // Error setting preview window during previewing 1917 LOGE("Error!! cannot set preview window when preview is running"); 1918 rc = INVALID_OPERATION; 1919 result.status = rc; 1920 result.request_api = evt; 1921 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1922 m_parent->signalAPIResult(&result); 1923 } 1924 break; 1925 case QCAMERA_SM_EVT_SET_CALLBACKS: 1926 { 1927 qcamera_sm_evt_setcb_payload_t *setcbs = 1928 (qcamera_sm_evt_setcb_payload_t *)payload; 1929 rc = m_parent->setCallBacks(setcbs->notify_cb, 1930 setcbs->data_cb, 1931 setcbs->data_cb_timestamp, 1932 setcbs->get_memory, 1933 setcbs->user); 1934 result.status = rc; 1935 result.request_api = evt; 1936 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1937 m_parent->signalAPIResult(&result); 1938 } 1939 break; 1940 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 1941 { 1942 rc = m_parent->enableMsgType(*((int32_t *)payload)); 1943 result.status = rc; 1944 result.request_api = evt; 1945 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1946 m_parent->signalAPIResult(&result); 1947 } 1948 break; 1949 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 1950 { 1951 rc = m_parent->disableMsgType(*((int32_t *)payload)); 1952 result.status = rc; 1953 result.request_api = evt; 1954 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1955 m_parent->signalAPIResult(&result); 1956 } 1957 break; 1958 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 1959 { 1960 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 1961 result.status = rc; 1962 result.request_api = evt; 1963 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1964 result.enabled = enabled; 1965 m_parent->signalAPIResult(&result); 1966 } 1967 break; 1968 case QCAMERA_SM_EVT_SET_PARAMS: 1969 { 1970 bool needRestart = false; 1971 rc = m_parent->updateParameters((char*)payload, needRestart); 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_SET_PARAMS_STOP: 1979 { 1980 result.status = rc; 1981 result.request_api = evt; 1982 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1983 m_parent->signalAPIResult(&result); 1984 } 1985 break; 1986 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 1987 { 1988 rc = m_parent->commitParameterChanges(); 1989 result.status = rc; 1990 result.request_api = evt; 1991 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1992 m_parent->signalAPIResult(&result); 1993 } 1994 break; 1995 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 1996 { 1997 m_parent->setNeedRestart(false); 1998 result.status = rc; 1999 result.request_api = evt; 2000 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2001 m_parent->signalAPIResult(&result); 2002 } 2003 break; 2004 case QCAMERA_SM_EVT_GET_PARAMS: 2005 { 2006 result.params = m_parent->getParameters(); 2007 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 2008 result.status = rc; 2009 result.request_api = evt; 2010 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 2011 m_parent->signalAPIResult(&result); 2012 } 2013 break; 2014 case QCAMERA_SM_EVT_PUT_PARAMS: 2015 { 2016 rc = m_parent->putParameters((char*)payload); 2017 result.status = rc; 2018 result.request_api = evt; 2019 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2020 m_parent->signalAPIResult(&result); 2021 } 2022 break; 2023 case QCAMERA_SM_EVT_STOP_PREVIEW: 2024 { 2025 // cancel picture first 2026 rc = m_parent->cancelPicture(); 2027 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 2028 2029 result.status = rc; 2030 result.request_api = evt; 2031 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2032 m_parent->signalAPIResult(&result); 2033 } 2034 break; 2035 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 2036 { 2037 rc = NO_ERROR; 2038 result.status = rc; 2039 result.request_api = evt; 2040 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2041 result.enabled = 0; 2042 m_parent->signalAPIResult(&result); 2043 } 2044 break; 2045 case QCAMERA_SM_EVT_RECORDING_ENABLED: 2046 { 2047 rc = NO_ERROR; 2048 result.status = rc; 2049 result.request_api = evt; 2050 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2051 result.enabled = 0; 2052 m_parent->signalAPIResult(&result); 2053 } 2054 break; 2055 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 2056 { 2057 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 2058 result.status = rc; 2059 result.request_api = evt; 2060 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2061 m_parent->signalAPIResult(&result); 2062 } 2063 break; 2064 case QCAMERA_SM_EVT_DUMP: 2065 { 2066 rc = m_parent->dump(*((int *)payload)); 2067 result.status = rc; 2068 result.request_api = evt; 2069 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2070 m_parent->signalAPIResult(&result); 2071 } 2072 break; 2073 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 2074 { 2075 rc = m_parent->autoFocus(); 2076 result.status = rc; 2077 result.request_api = evt; 2078 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2079 m_parent->signalAPIResult(&result); 2080 } 2081 break; 2082 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 2083 { 2084 rc = m_parent->cancelAutoFocus(); 2085 result.status = rc; 2086 result.request_api = evt; 2087 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2088 m_parent->signalAPIResult(&result); 2089 } 2090 break; 2091 case QCAMERA_SM_EVT_SEND_COMMAND: 2092 { 2093 qcamera_sm_evt_command_payload_t *cmd_payload = 2094 (qcamera_sm_evt_command_payload_t *)payload; 2095 rc = m_parent->sendCommand(cmd_payload->cmd, 2096 cmd_payload->arg1, 2097 cmd_payload->arg2); 2098 #ifndef VANILLA_HAL 2099 if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) { 2100 // move state to previewing state 2101 m_state = QCAMERA_SM_STATE_PREVIEWING; 2102 } 2103 #endif 2104 result.status = rc; 2105 result.request_api = evt; 2106 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2107 m_parent->signalAPIResult(&result); 2108 } 2109 break; 2110 case QCAMERA_SM_EVT_CANCEL_PICTURE: 2111 { 2112 rc = m_parent->cancelPicture(); 2113 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 2114 result.status = rc; 2115 result.request_api = evt; 2116 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2117 m_parent->signalAPIResult(&result); 2118 } 2119 break; 2120 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 2121 { 2122 int32_t faceID = 0; 2123 qcamera_sm_evt_reg_face_payload_t *reg_payload = 2124 (qcamera_sm_evt_reg_face_payload_t *)payload; 2125 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 2126 reg_payload->config, 2127 faceID); 2128 result.status = rc; 2129 result.request_api = evt; 2130 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 2131 result.handle = faceID; 2132 m_parent->signalAPIResult(&result); 2133 } 2134 break; 2135 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 2136 { 2137 if ( m_parent->isLongshotEnabled() ) { 2138 // no ops here, need to singal NO_ERROR 2139 rc = NO_ERROR; 2140 } else { 2141 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 2142 rc = INVALID_OPERATION; 2143 } 2144 2145 result.status = rc; 2146 result.request_api = evt; 2147 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2148 m_parent->signalAPIResult(&result); 2149 } 2150 break; 2151 case QCAMERA_SM_EVT_TAKE_PICTURE: 2152 { 2153 if ( m_parent->isLongshotEnabled() ) { 2154 rc = m_parent->longShot(); 2155 } else { 2156 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 2157 rc = INVALID_OPERATION; 2158 } 2159 2160 result.status = rc; 2161 result.request_api = evt; 2162 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2163 m_parent->signalAPIResult(&result); 2164 } 2165 break; 2166 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 2167 case QCAMERA_SM_EVT_PRE_START_RECORDING: 2168 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 2169 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 2170 case QCAMERA_SM_EVT_START_RECORDING: 2171 case QCAMERA_SM_EVT_STOP_RECORDING: 2172 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 2173 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 2174 case QCAMERA_SM_EVT_START_PREVIEW: 2175 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 2176 case QCAMERA_SM_EVT_RELEASE: 2177 { 2178 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 2179 rc = INVALID_OPERATION; 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_EVT_INTERNAL: 2187 { 2188 qcamera_sm_internal_evt_payload_t *internal_evt = 2189 (qcamera_sm_internal_evt_payload_t *)payload; 2190 switch (internal_evt->evt_type) { 2191 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 2192 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 2193 break; 2194 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 2195 break; 2196 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 2197 break; 2198 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 2199 break; 2200 case QCAMERA_INTERNAL_EVT_CROP_INFO: 2201 rc = m_parent->processZoomEvent(internal_evt->crop_data); 2202 break; 2203 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 2204 rc = m_parent->processASDUpdate(internal_evt->asd_data); 2205 break; 2206 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 2207 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2208 break; 2209 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 2210 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 2211 break; 2212 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 2213 rc = m_parent->processAEInfo(internal_evt->ae_data); 2214 break; 2215 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 2216 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 2217 break; 2218 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 2219 rc = m_parent->processHDRData(internal_evt->hdr_data); 2220 break; 2221 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 2222 rc = m_parent->processRetroAECUnlock(); 2223 break; 2224 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 2225 rc = m_parent->processZSLCaptureDone(); 2226 break; 2227 case QCAMERA_INTERNAL_EVT_DUAL_CAMERA_FOV_CONTROL: 2228 rc = m_parent->processDCFOVControl(); 2229 break; 2230 default: 2231 break; 2232 } 2233 } 2234 break; 2235 case QCAMERA_SM_EVT_EVT_NOTIFY: 2236 { 2237 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 2238 switch (cam_evt->server_event_type) { 2239 case CAM_EVENT_TYPE_DAEMON_DIED: 2240 { 2241 // Send internal events to stop indefinite wait on prepare 2242 // snapshot done event. 2243 result.status = rc; 2244 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 2245 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2246 m_parent->signalAPIResult(&result); 2247 2248 result.status = rc; 2249 result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE; 2250 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2251 m_parent->signalAPIResult(&result); 2252 2253 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 2254 CAMERA_ERROR_SERVER_DIED, 2255 0); 2256 } 2257 break; 2258 case CAM_EVENT_TYPE_CAC_DONE: 2259 if (m_parent->isCACEnabled() || m_parent->mParameters.isOEMFeatEnabled()) { 2260 LOGD("[LONG_SHOT_DBG] : Received CAC Done"); 2261 if (m_parent->isLongshotEnabled() 2262 && !m_parent->isCaptureShutterEnabled()) { 2263 // play shutter sound for longshot 2264 // after CAC stage is done 2265 m_parent->playShutter(); 2266 } 2267 m_parent->mCACDoneReceived = TRUE; 2268 } 2269 break; 2270 default: 2271 LOGH("no handling for server evt (%d) at this state", 2272 cam_evt->server_event_type); 2273 break; 2274 } 2275 } 2276 break; 2277 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 2278 { 2279 qcamera_jpeg_evt_payload_t *jpeg_job = 2280 (qcamera_jpeg_evt_payload_t *)payload; 2281 rc = m_parent->processJpegNotify(jpeg_job); 2282 } 2283 break; 2284 case QCAMERA_SM_EVT_STOP_CAPTURE_CHANNEL: 2285 { 2286 bool restartPreview = m_parent->isPreviewRestartEnabled(); 2287 rc = m_parent->stopCaptureChannel(restartPreview); 2288 2289 if (restartPreview && (NO_ERROR == rc)) { 2290 m_parent->unconfigureAdvancedCapture(); 2291 rc = m_parent->preparePreview(); 2292 if (NO_ERROR == rc) { 2293 m_parent->m_bPreviewStarted = true; 2294 applyDelayedMsgs(); 2295 rc = m_parent->startPreview(); 2296 } 2297 } 2298 2299 result.status = rc; 2300 result.request_api = evt; 2301 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2302 m_parent->signalAPIResult(&result); 2303 } 2304 break; 2305 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 2306 { 2307 rc = m_parent->cancelPicture(); 2308 2309 bool restartPreview = m_parent->isPreviewRestartEnabled(); 2310 if (restartPreview) { 2311 if (m_parent->mParameters.getManualCaptureMode() 2312 >= CAM_MANUAL_CAPTURE_TYPE_3) { 2313 m_parent->mParameters.updateZSLModeValue(m_RestoreZSL); 2314 m_RestoreZSL = FALSE; 2315 rc = m_parent->preparePreview(); 2316 if (NO_ERROR == rc) { 2317 m_parent->m_bPreviewStarted = true; 2318 applyDelayedMsgs(); 2319 rc = m_parent->startPreview(); 2320 } 2321 } 2322 m_state = QCAMERA_SM_STATE_PREVIEWING; 2323 } else { 2324 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 2325 } 2326 2327 result.status = rc; 2328 result.request_api = evt; 2329 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2330 m_parent->signalEvtResult(&result); 2331 } 2332 break; 2333 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 2334 { 2335 rc = m_parent->updateThermalLevel(payload); 2336 } 2337 break; 2338 default: 2339 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2340 break; 2341 } 2342 2343 return rc; 2344 } 2345 2346 /*=========================================================================== 2347 * FUNCTION : procEvtRecordingState 2348 * 2349 * DESCRIPTION: finite state machine function to handle event in state of 2350 * QCAMERA_SM_STATE_RECORDING. 2351 * 2352 * PARAMETERS : 2353 * @evt : event to be processed 2354 * @payload : event payload. Can be NULL if not needed. 2355 * 2356 * RETURN : int32_t type of status 2357 * NO_ERROR -- success 2358 * none-zero failure code 2359 *==========================================================================*/ 2360 int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt, 2361 void *payload) 2362 { 2363 int32_t rc = NO_ERROR; 2364 qcamera_api_result_t result; 2365 memset(&result, 0, sizeof(qcamera_api_result_t)); 2366 2367 LOGL("event (%d)", evt); 2368 switch (evt) { 2369 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 2370 case QCAMERA_SM_EVT_START_PREVIEW: 2371 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 2372 { 2373 // WA: CTS test VideoSnapshot will try to 2374 // start preview during video recording. 2375 LOGH("CTS video restart op"); 2376 rc = NO_ERROR; 2377 result.status = rc; 2378 result.request_api = evt; 2379 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2380 m_parent->signalAPIResult(&result); 2381 } 2382 break; 2383 case QCAMERA_SM_EVT_SET_CALLBACKS: 2384 { 2385 qcamera_sm_evt_setcb_payload_t *setcbs = 2386 (qcamera_sm_evt_setcb_payload_t *)payload; 2387 rc = m_parent->setCallBacks(setcbs->notify_cb, 2388 setcbs->data_cb, 2389 setcbs->data_cb_timestamp, 2390 setcbs->get_memory, 2391 setcbs->user); 2392 result.status = rc; 2393 result.request_api = evt; 2394 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2395 m_parent->signalAPIResult(&result); 2396 } 2397 break; 2398 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 2399 { 2400 rc = m_parent->enableMsgType(*((int32_t *)payload)); 2401 result.status = rc; 2402 result.request_api = evt; 2403 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2404 m_parent->signalAPIResult(&result); 2405 } 2406 break; 2407 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 2408 { 2409 rc = m_parent->disableMsgType(*((int32_t *)payload)); 2410 result.status = rc; 2411 result.request_api = evt; 2412 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2413 m_parent->signalAPIResult(&result); 2414 } 2415 break; 2416 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 2417 { 2418 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 2419 result.status = rc; 2420 result.request_api = evt; 2421 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2422 result.enabled = enabled; 2423 m_parent->signalAPIResult(&result); 2424 } 2425 break; 2426 case QCAMERA_SM_EVT_SET_PARAMS: 2427 { 2428 bool needRestart = false; 2429 rc = m_parent->updateParameters((char*)payload, needRestart); 2430 if (rc == NO_ERROR) { 2431 if (needRestart) { 2432 // cannot set parameters that requires restart during recording 2433 LOGE("Error!! cannot set parameters that requires restart during recording"); 2434 rc = BAD_VALUE; 2435 } 2436 } 2437 if (rc != NO_ERROR) { 2438 m_parent->setNeedRestart(false); 2439 } 2440 result.status = rc; 2441 result.request_api = evt; 2442 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2443 m_parent->signalAPIResult(&result); 2444 } 2445 break; 2446 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 2447 { 2448 rc = m_parent->commitParameterChanges(); 2449 result.status = rc; 2450 result.request_api = evt; 2451 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2452 m_parent->signalAPIResult(&result); 2453 } 2454 break; 2455 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 2456 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 2457 { 2458 ALOGE("%s: Error!! cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 2459 rc = INVALID_OPERATION; 2460 result.status = rc; 2461 result.request_api = evt; 2462 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2463 m_parent->signalAPIResult(&result); 2464 } 2465 break; 2466 case QCAMERA_SM_EVT_GET_PARAMS: 2467 { 2468 result.params = m_parent->getParameters(); 2469 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 2470 result.status = rc; 2471 result.request_api = evt; 2472 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 2473 m_parent->signalAPIResult(&result); 2474 } 2475 break; 2476 case QCAMERA_SM_EVT_PUT_PARAMS: 2477 { 2478 rc = m_parent->putParameters((char*)payload); 2479 result.status = rc; 2480 result.request_api = evt; 2481 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2482 m_parent->signalAPIResult(&result); 2483 } 2484 break; 2485 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 2486 { 2487 rc = NO_ERROR; 2488 result.status = rc; 2489 result.request_api = evt; 2490 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2491 result.enabled = 0; 2492 m_parent->signalAPIResult(&result); 2493 } 2494 break; 2495 case QCAMERA_SM_EVT_RECORDING_ENABLED: 2496 { 2497 rc = NO_ERROR; 2498 result.status = rc; 2499 result.request_api = evt; 2500 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2501 result.enabled = 1; 2502 m_parent->signalAPIResult(&result); 2503 } 2504 break; 2505 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 2506 { 2507 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 2508 result.status = rc; 2509 result.request_api = evt; 2510 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2511 m_parent->signalAPIResult(&result); 2512 } 2513 break; 2514 case QCAMERA_SM_EVT_DUMP: 2515 { 2516 rc = m_parent->dump(*((int *)payload)); 2517 result.status = rc; 2518 result.request_api = evt; 2519 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2520 m_parent->signalAPIResult(&result); 2521 } 2522 break; 2523 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 2524 { 2525 rc = m_parent->autoFocus(); 2526 result.status = rc; 2527 result.request_api = evt; 2528 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2529 m_parent->signalAPIResult(&result); 2530 } 2531 break; 2532 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 2533 { 2534 rc = m_parent->cancelAutoFocus(); 2535 result.status = rc; 2536 result.request_api = evt; 2537 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2538 m_parent->signalAPIResult(&result); 2539 } 2540 break; 2541 case QCAMERA_SM_EVT_SEND_COMMAND: 2542 { 2543 qcamera_sm_evt_command_payload_t *cmd_payload = 2544 (qcamera_sm_evt_command_payload_t *)payload; 2545 rc = m_parent->sendCommand(cmd_payload->cmd, 2546 cmd_payload->arg1, 2547 cmd_payload->arg2); 2548 result.status = rc; 2549 result.request_api = evt; 2550 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2551 m_parent->signalAPIResult(&result); 2552 } 2553 break; 2554 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 2555 { 2556 // No ops here, send NO_ERROR. 2557 rc = NO_ERROR; 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_TAKE_PICTURE: 2565 { 2566 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING; 2567 rc = m_parent->takeLiveSnapshot(); 2568 if (rc != NO_ERROR) { 2569 m_parent->unconfigureAdvancedCapture(); 2570 m_state = QCAMERA_SM_STATE_RECORDING; 2571 } 2572 result.status = rc; 2573 result.request_api = evt; 2574 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2575 m_parent->signalAPIResult(&result); 2576 } 2577 break; 2578 case QCAMERA_SM_EVT_PRE_START_RECORDING: 2579 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 2580 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 2581 case QCAMERA_SM_EVT_START_RECORDING: 2582 { 2583 // no ops here 2584 LOGW("already in recording state, no ops for start_recording"); 2585 rc = 0; 2586 result.status = rc; 2587 result.request_api = evt; 2588 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2589 m_parent->signalAPIResult(&result); 2590 } 2591 break; 2592 case QCAMERA_SM_EVT_STOP_RECORDING: 2593 { 2594 rc = m_parent->stopRecording(); 2595 m_state = QCAMERA_SM_STATE_PREVIEWING; 2596 result.status = rc; 2597 result.request_api = evt; 2598 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2599 m_parent->signalAPIResult(&result); 2600 } 2601 break; 2602 case QCAMERA_SM_EVT_STOP_PREVIEW: 2603 { 2604 rc = m_parent->stopRecording(); 2605 m_state = QCAMERA_SM_STATE_PREVIEWING; 2606 2607 rc = m_parent->stopPreview(); 2608 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 2609 2610 result.status = rc; 2611 result.request_api = evt; 2612 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2613 m_parent->signalAPIResult(&result); 2614 } 2615 break; 2616 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 2617 { 2618 rc = m_parent->releaseRecordingFrame((const void *)payload); 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_REG_FACE_IMAGE: 2626 { 2627 int32_t faceID = 0; 2628 qcamera_sm_evt_reg_face_payload_t *reg_payload = 2629 (qcamera_sm_evt_reg_face_payload_t *)payload; 2630 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 2631 reg_payload->config, 2632 faceID); 2633 result.status = rc; 2634 result.request_api = evt; 2635 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 2636 result.handle = faceID; 2637 m_parent->signalAPIResult(&result); 2638 } 2639 break; 2640 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 2641 { 2642 //In Video snapshot, prepare hardware is a no-op. 2643 result.status = NO_ERROR; 2644 result.request_api = evt; 2645 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2646 m_parent->signalAPIResult(&result); 2647 } 2648 break; 2649 case QCAMERA_SM_EVT_CANCEL_PICTURE: 2650 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 2651 case QCAMERA_SM_EVT_RELEASE: 2652 { 2653 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 2654 rc = INVALID_OPERATION; 2655 result.status = rc; 2656 result.request_api = evt; 2657 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2658 m_parent->signalAPIResult(&result); 2659 } 2660 break; 2661 case QCAMERA_SM_EVT_EVT_INTERNAL: 2662 { 2663 qcamera_sm_internal_evt_payload_t *internal_evt = 2664 (qcamera_sm_internal_evt_payload_t *)payload; 2665 switch (internal_evt->evt_type) { 2666 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 2667 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 2668 break; 2669 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 2670 break; 2671 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 2672 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 2673 break; 2674 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 2675 rc = m_parent->processHistogramStats(internal_evt->stats_data); 2676 break; 2677 case QCAMERA_INTERNAL_EVT_CROP_INFO: 2678 rc = m_parent->processZoomEvent(internal_evt->crop_data); 2679 break; 2680 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 2681 rc = m_parent->processASDUpdate(internal_evt->asd_data); 2682 break; 2683 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 2684 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2685 break; 2686 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 2687 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 2688 break; 2689 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 2690 rc = m_parent->processAEInfo(internal_evt->ae_data); 2691 break; 2692 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 2693 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 2694 break; 2695 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 2696 rc = m_parent->processHDRData(internal_evt->hdr_data); 2697 break; 2698 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 2699 rc = m_parent->processRetroAECUnlock(); 2700 break; 2701 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 2702 rc = m_parent->processZSLCaptureDone(); 2703 break; 2704 case QCAMERA_INTERNAL_EVT_DUAL_CAMERA_FOV_CONTROL: 2705 rc = m_parent->processDCFOVControl(); 2706 break; 2707 default: 2708 break; 2709 } 2710 } 2711 break; 2712 case QCAMERA_SM_EVT_EVT_NOTIFY: 2713 { 2714 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 2715 switch (cam_evt->server_event_type) { 2716 case CAM_EVENT_TYPE_DAEMON_DIED: 2717 { 2718 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 2719 CAMERA_ERROR_SERVER_DIED, 2720 0); 2721 } 2722 break; 2723 default: 2724 LOGE("Invalid internal event %d in state(%d)", 2725 cam_evt->server_event_type, m_state); 2726 break; 2727 } 2728 } 2729 break; 2730 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 2731 { 2732 rc = m_parent->updateThermalLevel(payload); 2733 } 2734 break; 2735 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 2736 { 2737 // No ops, but need to notify 2738 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2739 result.status = rc; 2740 result.request_api = evt; 2741 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2742 m_parent->signalEvtResult(&result); 2743 } 2744 break; 2745 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 2746 default: 2747 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2748 break; 2749 } 2750 2751 return rc; 2752 } 2753 2754 /*=========================================================================== 2755 * FUNCTION : procEvtVideoPicTakingState 2756 * 2757 * DESCRIPTION: finite state machine function to handle event in state of 2758 * QCAMERA_SM_STATE_VIDEO_PIC_TAKING. 2759 * 2760 * PARAMETERS : 2761 * @evt : event to be processed 2762 * @payload : event payload. Can be NULL if not needed. 2763 * 2764 * RETURN : int32_t type of status 2765 * NO_ERROR -- success 2766 * none-zero failure code 2767 *==========================================================================*/ 2768 int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt, 2769 void *payload) 2770 { 2771 int32_t rc = NO_ERROR; 2772 qcamera_api_result_t result; 2773 memset(&result, 0, sizeof(qcamera_api_result_t)); 2774 2775 LOGL("event (%d)", evt); 2776 switch (evt) { 2777 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 2778 { 2779 // Error setting preview window during previewing 2780 LOGE("Error!! cannot set preview window when preview is running"); 2781 rc = INVALID_OPERATION; 2782 result.status = rc; 2783 result.request_api = evt; 2784 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2785 m_parent->signalAPIResult(&result); 2786 } 2787 break; 2788 case QCAMERA_SM_EVT_SET_CALLBACKS: 2789 { 2790 qcamera_sm_evt_setcb_payload_t *setcbs = 2791 (qcamera_sm_evt_setcb_payload_t *)payload; 2792 rc = m_parent->setCallBacks(setcbs->notify_cb, 2793 setcbs->data_cb, 2794 setcbs->data_cb_timestamp, 2795 setcbs->get_memory, 2796 setcbs->user); 2797 result.status = rc; 2798 result.request_api = evt; 2799 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2800 m_parent->signalAPIResult(&result); 2801 } 2802 break; 2803 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 2804 { 2805 rc = m_parent->enableMsgType(*((int32_t *)payload)); 2806 result.status = rc; 2807 result.request_api = evt; 2808 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2809 m_parent->signalAPIResult(&result); 2810 } 2811 break; 2812 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 2813 { 2814 rc = m_parent->disableMsgType(*((int32_t *)payload)); 2815 result.status = rc; 2816 result.request_api = evt; 2817 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2818 m_parent->signalAPIResult(&result); 2819 } 2820 break; 2821 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 2822 { 2823 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 2824 result.status = rc; 2825 result.request_api = evt; 2826 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2827 result.enabled = enabled; 2828 m_parent->signalAPIResult(&result); 2829 } 2830 break; 2831 case QCAMERA_SM_EVT_SET_PARAMS: 2832 { 2833 bool needRestart = false; 2834 rc = m_parent->updateParameters((char*)payload, needRestart); 2835 if (rc == NO_ERROR) { 2836 if (needRestart) { 2837 // cannot set parameters that requires restart during recording 2838 LOGE("Error!! cannot set parameters that requires restart during recording"); 2839 rc = BAD_VALUE; 2840 } 2841 } 2842 if (rc != NO_ERROR) { 2843 m_parent->setNeedRestart(false); 2844 } 2845 result.status = rc; 2846 result.request_api = evt; 2847 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2848 m_parent->signalAPIResult(&result); 2849 } 2850 break; 2851 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 2852 { 2853 rc = m_parent->commitParameterChanges(); 2854 result.status = rc; 2855 result.request_api = evt; 2856 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2857 m_parent->signalAPIResult(&result); 2858 } 2859 break; 2860 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 2861 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 2862 { 2863 ALOGE("%s: Error!! cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 2864 rc = INVALID_OPERATION; 2865 result.status = rc; 2866 result.request_api = evt; 2867 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2868 m_parent->signalAPIResult(&result); 2869 } 2870 break; 2871 case QCAMERA_SM_EVT_GET_PARAMS: 2872 { 2873 result.params = m_parent->getParameters(); 2874 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 2875 result.status = rc; 2876 result.request_api = evt; 2877 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 2878 m_parent->signalAPIResult(&result); 2879 } 2880 break; 2881 case QCAMERA_SM_EVT_PUT_PARAMS: 2882 { 2883 rc = m_parent->putParameters((char*)payload); 2884 result.status = rc; 2885 result.request_api = evt; 2886 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2887 m_parent->signalAPIResult(&result); 2888 } 2889 break; 2890 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 2891 { 2892 rc = NO_ERROR; 2893 result.status = rc; 2894 result.request_api = evt; 2895 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2896 result.enabled = 1; 2897 m_parent->signalAPIResult(&result); 2898 } 2899 break; 2900 case QCAMERA_SM_EVT_RECORDING_ENABLED: 2901 { 2902 rc = NO_ERROR; 2903 result.status = rc; 2904 result.request_api = evt; 2905 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2906 result.enabled = 1; 2907 m_parent->signalAPIResult(&result); 2908 } 2909 break; 2910 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 2911 { 2912 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 2913 result.status = rc; 2914 result.request_api = evt; 2915 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2916 m_parent->signalAPIResult(&result); 2917 } 2918 break; 2919 case QCAMERA_SM_EVT_DUMP: 2920 { 2921 rc = m_parent->dump(*((int *)payload)); 2922 result.status = rc; 2923 result.request_api = evt; 2924 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2925 m_parent->signalAPIResult(&result); 2926 } 2927 break; 2928 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 2929 { 2930 rc = m_parent->autoFocus(); 2931 result.status = rc; 2932 result.request_api = evt; 2933 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2934 m_parent->signalAPIResult(&result); 2935 } 2936 break; 2937 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 2938 { 2939 rc = m_parent->cancelAutoFocus(); 2940 result.status = rc; 2941 result.request_api = evt; 2942 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2943 m_parent->signalAPIResult(&result); 2944 } 2945 break; 2946 case QCAMERA_SM_EVT_SEND_COMMAND: 2947 { 2948 qcamera_sm_evt_command_payload_t *cmd_payload = 2949 (qcamera_sm_evt_command_payload_t *)payload; 2950 rc = m_parent->sendCommand(cmd_payload->cmd, 2951 cmd_payload->arg1, 2952 cmd_payload->arg2); 2953 result.status = rc; 2954 result.request_api = evt; 2955 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2956 m_parent->signalAPIResult(&result); 2957 } 2958 break; 2959 case QCAMERA_SM_EVT_STOP_RECORDING: 2960 { 2961 rc = m_parent->cancelLiveSnapshot(); 2962 m_state = QCAMERA_SM_STATE_RECORDING; 2963 2964 rc = m_parent->stopRecording(); 2965 m_state = QCAMERA_SM_STATE_PREVIEWING; 2966 2967 result.status = rc; 2968 result.request_api = evt; 2969 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2970 m_parent->signalAPIResult(&result); 2971 } 2972 break; 2973 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 2974 { 2975 rc = m_parent->releaseRecordingFrame((const void *)payload); 2976 result.status = rc; 2977 result.request_api = evt; 2978 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2979 m_parent->signalAPIResult(&result); 2980 } 2981 break; 2982 case QCAMERA_SM_EVT_CANCEL_PICTURE: 2983 { 2984 rc = m_parent->cancelLiveSnapshot(); 2985 m_state = QCAMERA_SM_STATE_RECORDING; 2986 result.status = rc; 2987 result.request_api = evt; 2988 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2989 m_parent->signalAPIResult(&result); 2990 } 2991 break; 2992 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 2993 { 2994 int32_t faceID = 0; 2995 qcamera_sm_evt_reg_face_payload_t *reg_payload = 2996 (qcamera_sm_evt_reg_face_payload_t *)payload; 2997 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 2998 reg_payload->config, 2999 faceID); 3000 result.status = rc; 3001 result.request_api = evt; 3002 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 3003 result.handle = faceID; 3004 m_parent->signalAPIResult(&result); 3005 } 3006 break; 3007 case QCAMERA_SM_EVT_STOP_PREVIEW: 3008 { 3009 rc = m_parent->cancelLiveSnapshot(); 3010 m_state = QCAMERA_SM_STATE_RECORDING; 3011 3012 rc = m_parent->stopRecording(); 3013 m_state = QCAMERA_SM_STATE_PREVIEWING; 3014 3015 rc = m_parent->stopPreview(); 3016 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 3017 3018 result.status = rc; 3019 result.request_api = evt; 3020 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3021 m_parent->signalAPIResult(&result); 3022 } 3023 break; 3024 case QCAMERA_SM_EVT_PRE_START_RECORDING: 3025 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 3026 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 3027 case QCAMERA_SM_EVT_START_RECORDING: 3028 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 3029 case QCAMERA_SM_EVT_START_PREVIEW: 3030 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 3031 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 3032 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 3033 case QCAMERA_SM_EVT_TAKE_PICTURE: 3034 case QCAMERA_SM_EVT_RELEASE: 3035 { 3036 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 3037 rc = INVALID_OPERATION; 3038 result.status = rc; 3039 result.request_api = evt; 3040 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3041 m_parent->signalAPIResult(&result); 3042 } 3043 break; 3044 case QCAMERA_SM_EVT_EVT_INTERNAL: 3045 { 3046 qcamera_sm_internal_evt_payload_t *internal_evt = 3047 (qcamera_sm_internal_evt_payload_t *)payload; 3048 switch (internal_evt->evt_type) { 3049 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 3050 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 3051 break; 3052 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 3053 break; 3054 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 3055 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 3056 break; 3057 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 3058 rc = m_parent->processHistogramStats(internal_evt->stats_data); 3059 break; 3060 case QCAMERA_INTERNAL_EVT_CROP_INFO: 3061 rc = m_parent->processZoomEvent(internal_evt->crop_data); 3062 break; 3063 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 3064 rc = m_parent->processASDUpdate(internal_evt->asd_data); 3065 break; 3066 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 3067 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 3068 break; 3069 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 3070 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 3071 break; 3072 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 3073 rc = m_parent->processAEInfo(internal_evt->ae_data); 3074 break; 3075 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 3076 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 3077 break; 3078 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 3079 rc = m_parent->processHDRData(internal_evt->hdr_data); 3080 break; 3081 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 3082 rc = m_parent->processRetroAECUnlock(); 3083 break; 3084 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 3085 rc = m_parent->processZSLCaptureDone(); 3086 break; 3087 case QCAMERA_INTERNAL_EVT_DUAL_CAMERA_FOV_CONTROL: 3088 rc = m_parent->processDCFOVControl(); 3089 break; 3090 default: 3091 break; 3092 } 3093 } 3094 break; 3095 case QCAMERA_SM_EVT_EVT_NOTIFY: 3096 { 3097 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 3098 switch (cam_evt->server_event_type) { 3099 case CAM_EVENT_TYPE_DAEMON_DIED: 3100 { 3101 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 3102 CAMERA_ERROR_SERVER_DIED, 3103 0); 3104 } 3105 break; 3106 default: 3107 LOGE("Invalid internal event %d in state(%d)", 3108 cam_evt->server_event_type, m_state); 3109 break; 3110 } 3111 } 3112 break; 3113 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 3114 { 3115 qcamera_jpeg_evt_payload_t *jpeg_job = 3116 (qcamera_jpeg_evt_payload_t *)payload; 3117 rc = m_parent->processJpegNotify(jpeg_job); 3118 } 3119 break; 3120 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 3121 { 3122 rc = m_parent->cancelLiveSnapshot(); 3123 m_state = QCAMERA_SM_STATE_RECORDING; 3124 result.status = rc; 3125 result.request_api = evt; 3126 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3127 m_parent->signalEvtResult(&result); 3128 } 3129 break; 3130 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 3131 { 3132 rc = m_parent->updateThermalLevel(payload); 3133 } 3134 break; 3135 default: 3136 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 3137 break; 3138 } 3139 3140 return rc; 3141 } 3142 3143 /*=========================================================================== 3144 * FUNCTION : procEvtPreviewPicTakingState 3145 * 3146 * DESCRIPTION: finite state machine function to handle event in state of 3147 * QCAMERA_SM_STATE_PREVIEW_PIC_TAKING. 3148 * 3149 * PARAMETERS : 3150 * @evt : event to be processed 3151 * @payload : event payload. Can be NULL if not needed. 3152 * 3153 * RETURN : int32_t type of status 3154 * NO_ERROR -- success 3155 * none-zero failure code 3156 *==========================================================================*/ 3157 int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt, 3158 void *payload) 3159 { 3160 int32_t rc = NO_ERROR; 3161 qcamera_api_result_t result; 3162 memset(&result, 0, sizeof(qcamera_api_result_t)); 3163 3164 LOGL("event (%d)", evt); 3165 switch (evt) { 3166 case QCAMERA_SM_EVT_SET_CALLBACKS: 3167 { 3168 qcamera_sm_evt_setcb_payload_t *setcbs = 3169 (qcamera_sm_evt_setcb_payload_t *)payload; 3170 rc = m_parent->setCallBacks(setcbs->notify_cb, 3171 setcbs->data_cb, 3172 setcbs->data_cb_timestamp, 3173 setcbs->get_memory, 3174 setcbs->user); 3175 result.status = rc; 3176 result.request_api = evt; 3177 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3178 m_parent->signalAPIResult(&result); 3179 } 3180 break; 3181 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 3182 { 3183 rc = m_parent->enableMsgType(*((int32_t *)payload)); 3184 result.status = rc; 3185 result.request_api = evt; 3186 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3187 m_parent->signalAPIResult(&result); 3188 } 3189 break; 3190 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 3191 { 3192 rc = m_parent->disableMsgType(*((int32_t *)payload)); 3193 result.status = rc; 3194 result.request_api = evt; 3195 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3196 m_parent->signalAPIResult(&result); 3197 } 3198 break; 3199 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 3200 { 3201 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 3202 result.status = rc; 3203 result.request_api = evt; 3204 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 3205 result.enabled = enabled; 3206 m_parent->signalAPIResult(&result); 3207 } 3208 break; 3209 case QCAMERA_SM_EVT_SET_PARAMS: 3210 { 3211 bool needRestart = false; 3212 rc = m_parent->updateParameters((char*)payload, needRestart); 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_SET_PARAMS_STOP: 3220 { 3221 // need restart preview for parameters to take effect 3222 LOGD("Stopping preview..."); 3223 // stop preview 3224 rc = m_parent->stopPreview(); 3225 // Clear memory pools 3226 m_parent->m_memoryPool.clear(); 3227 result.status = rc; 3228 result.request_api = evt; 3229 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3230 m_parent->signalAPIResult(&result); 3231 } 3232 break; 3233 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 3234 { 3235 // commit parameter changes to server 3236 rc = m_parent->commitParameterChanges(); 3237 result.status = rc; 3238 result.request_api = evt; 3239 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3240 m_parent->signalAPIResult(&result); 3241 } 3242 break; 3243 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 3244 { 3245 // start preview again 3246 rc = m_parent->preparePreview(); 3247 if (rc == NO_ERROR) { 3248 applyDelayedMsgs(); 3249 rc = m_parent->startPreview(); 3250 if (rc != NO_ERROR) { 3251 m_parent->unpreparePreview(); 3252 } 3253 } 3254 if (rc != NO_ERROR) { 3255 m_state = QCAMERA_SM_STATE_PIC_TAKING; 3256 } 3257 m_parent->setNeedRestart(false); 3258 result.status = rc; 3259 result.request_api = evt; 3260 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3261 m_parent->signalAPIResult(&result); 3262 } 3263 break; 3264 case QCAMERA_SM_EVT_GET_PARAMS: 3265 { 3266 result.params = m_parent->getParameters(); 3267 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 3268 result.status = rc; 3269 result.request_api = evt; 3270 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 3271 m_parent->signalAPIResult(&result); 3272 } 3273 break; 3274 case QCAMERA_SM_EVT_PUT_PARAMS: 3275 { 3276 rc = m_parent->putParameters((char*)payload); 3277 result.status = rc; 3278 result.request_api = evt; 3279 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3280 m_parent->signalAPIResult(&result); 3281 } 3282 break; 3283 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 3284 { 3285 rc = NO_ERROR; 3286 result.status = rc; 3287 result.request_api = evt; 3288 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 3289 result.enabled = 1; 3290 m_parent->signalAPIResult(&result); 3291 } 3292 break; 3293 case QCAMERA_SM_EVT_RECORDING_ENABLED: 3294 { 3295 rc = NO_ERROR; 3296 result.status = rc; 3297 result.request_api = evt; 3298 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 3299 result.enabled = 0; 3300 m_parent->signalAPIResult(&result); 3301 } 3302 break; 3303 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 3304 { 3305 rc = m_parent->storeMetaDataInBuffers(*((int *)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_DUMP: 3313 { 3314 rc = m_parent->dump(*((int *)payload)); 3315 result.status = rc; 3316 result.request_api = evt; 3317 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3318 m_parent->signalAPIResult(&result); 3319 } 3320 break; 3321 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 3322 { 3323 rc = m_parent->autoFocus(); 3324 result.status = rc; 3325 result.request_api = evt; 3326 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3327 m_parent->signalAPIResult(&result); 3328 } 3329 break; 3330 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 3331 { 3332 rc = m_parent->cancelAutoFocus(); 3333 result.status = rc; 3334 result.request_api = evt; 3335 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3336 m_parent->signalAPIResult(&result); 3337 } 3338 break; 3339 case QCAMERA_SM_EVT_SEND_COMMAND: 3340 { 3341 qcamera_sm_evt_command_payload_t *cmd_payload = 3342 (qcamera_sm_evt_command_payload_t *)payload; 3343 rc = m_parent->sendCommand(cmd_payload->cmd, 3344 cmd_payload->arg1, 3345 cmd_payload->arg2); 3346 #ifndef VANILLA_HAL 3347 if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) { 3348 // move state to previewing state 3349 m_state = QCAMERA_SM_STATE_PREVIEWING; 3350 } 3351 #endif 3352 result.status = rc; 3353 result.request_api = evt; 3354 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3355 m_parent->signalAPIResult(&result); 3356 } 3357 break; 3358 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 3359 { 3360 rc = m_parent->releaseRecordingFrame((const void *)payload); 3361 result.status = rc; 3362 result.request_api = evt; 3363 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3364 m_parent->signalAPIResult(&result); 3365 } 3366 break; 3367 case QCAMERA_SM_EVT_CANCEL_PICTURE: 3368 { 3369 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) { 3370 rc = m_parent->cancelPicture(); 3371 } else { 3372 rc = m_parent->cancelLiveSnapshot(); 3373 } 3374 m_state = QCAMERA_SM_STATE_PREVIEWING; 3375 result.status = rc; 3376 result.request_api = evt; 3377 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3378 m_parent->signalAPIResult(&result); 3379 } 3380 break; 3381 case QCAMERA_SM_EVT_STOP_PREVIEW: 3382 { 3383 if (m_parent->isZSLMode()) { 3384 // cancel picture first 3385 rc = m_parent->cancelPicture(); 3386 m_parent->stopChannel(QCAMERA_CH_TYPE_ZSL); 3387 } else if (m_parent->isLongshotEnabled()) { 3388 // just cancel picture 3389 rc = m_parent->cancelPicture(); 3390 } else { 3391 rc = m_parent->cancelLiveSnapshot(); 3392 m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW); 3393 } 3394 // unprepare preview 3395 m_parent->unpreparePreview(); 3396 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 3397 result.status = rc; 3398 result.request_api = evt; 3399 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3400 m_parent->signalAPIResult(&result); 3401 } 3402 break; 3403 case QCAMERA_SM_EVT_PRE_START_RECORDING: 3404 { 3405 if (m_parent->isZSLMode()) { 3406 LOGE("Error!! cannot handle evt(%d) in state(%d) in ZSL mode", evt, m_state); 3407 rc = INVALID_OPERATION; 3408 } else if (m_parent->isLongshotEnabled()) { 3409 LOGE("Error!! cannot handle evt(%d) in state(%d) in Longshot mode", evt, m_state); 3410 rc = INVALID_OPERATION; 3411 } else { 3412 rc = m_parent->preStartRecording(); 3413 } 3414 result.status = rc; 3415 result.request_api = evt; 3416 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3417 m_parent->signalAPIResult(&result); 3418 } 3419 break; 3420 case QCAMERA_SM_EVT_START_RECORDING: 3421 { 3422 if (m_parent->isZSLMode()) { 3423 LOGE("Error!! cannot handle evt(%d) in state(%d) in ZSL mode", 3424 evt, m_state); 3425 rc = INVALID_OPERATION; 3426 } else if (m_parent->isLongshotEnabled()) { 3427 LOGE("Error!! cannot handle evt(%d) in state(%d) in Longshot mode", 3428 evt, m_state); 3429 rc = INVALID_OPERATION; 3430 } else { 3431 rc = m_parent->startRecording(); 3432 if (rc == NO_ERROR) { 3433 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING; 3434 } 3435 } 3436 result.status = rc; 3437 result.request_api = evt; 3438 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3439 m_parent->signalAPIResult(&result); 3440 } 3441 break; 3442 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 3443 { 3444 int32_t faceID = 0; 3445 qcamera_sm_evt_reg_face_payload_t *reg_payload = 3446 (qcamera_sm_evt_reg_face_payload_t *)payload; 3447 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 3448 reg_payload->config, 3449 faceID); 3450 result.status = rc; 3451 result.request_api = evt; 3452 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 3453 result.handle = faceID; 3454 m_parent->signalAPIResult(&result); 3455 } 3456 break; 3457 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 3458 { 3459 if ( m_parent->isLongshotEnabled() ) { 3460 // no ops here, need to singal NO_ERROR 3461 rc = NO_ERROR; 3462 } else { 3463 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 3464 rc = INVALID_OPERATION; 3465 } 3466 3467 result.status = rc; 3468 result.request_api = evt; 3469 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3470 m_parent->signalAPIResult(&result); 3471 } 3472 break; 3473 case QCAMERA_SM_EVT_TAKE_PICTURE: 3474 { 3475 if ( m_parent->isLongshotEnabled() ) { 3476 rc = m_parent->longShot(); 3477 } else { 3478 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 3479 rc = INVALID_OPERATION; 3480 } 3481 3482 result.status = rc; 3483 result.request_api = evt; 3484 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3485 m_parent->signalAPIResult(&result); 3486 } 3487 break; 3488 3489 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 3490 { 3491 LOGD("Prepare Snapshot"); 3492 if (m_parent->isRetroPicture()) { 3493 LOGD("Prepare Snapshot in Retro Mode"); 3494 rc = m_parent->prepareHardwareForSnapshot(FALSE); 3495 if (rc != NO_ERROR) { 3496 LOGE("prepareHardwareForSnapshot failed %d", 3497 rc); 3498 result.status = rc; 3499 result.request_api = evt; 3500 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3501 m_parent->signalAPIResult(&result); 3502 } 3503 } 3504 else { 3505 LOGE("Error!! cannot handle evt(%d) in state(%d)", 3506 evt, m_state); 3507 rc = INVALID_OPERATION; 3508 result.status = rc; 3509 result.request_api = evt; 3510 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3511 m_parent->signalAPIResult(&result); 3512 } 3513 } 3514 break; 3515 case QCAMERA_SM_EVT_STOP_RECORDING: 3516 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 3517 case QCAMERA_SM_EVT_START_PREVIEW: 3518 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 3519 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 3520 case QCAMERA_SM_EVT_RELEASE: 3521 { 3522 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 3523 rc = INVALID_OPERATION; 3524 result.status = rc; 3525 result.request_api = evt; 3526 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3527 m_parent->signalAPIResult(&result); 3528 } 3529 break; 3530 case QCAMERA_SM_EVT_EVT_INTERNAL: 3531 { 3532 qcamera_sm_internal_evt_payload_t *internal_evt = 3533 (qcamera_sm_internal_evt_payload_t *)payload; 3534 switch (internal_evt->evt_type) { 3535 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 3536 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 3537 break; 3538 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 3539 LOGD("Received QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE event"); 3540 if (m_parent->isRetroPicture()) { 3541 m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state); 3542 LOGD("Retro picture"); 3543 result.status = NO_ERROR; 3544 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 3545 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3546 m_parent->signalAPIResult(&result); 3547 } 3548 else { 3549 LOGE("Invalid Case for " 3550 "QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT event"); 3551 } 3552 break; 3553 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 3554 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 3555 break; 3556 case QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT: 3557 // This is valid only in Retro picture Mode 3558 if (m_parent->isRetroPicture()) { 3559 LOGD("Received QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT event"); 3560 result.status = NO_ERROR; 3561 result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE; 3562 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3563 m_parent->signalAPIResult(&result); 3564 } 3565 else { 3566 LOGD("Wrong Case for QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT event"); 3567 } 3568 break; 3569 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 3570 rc = m_parent->processHistogramStats(internal_evt->stats_data); 3571 break; 3572 case QCAMERA_INTERNAL_EVT_CROP_INFO: 3573 rc = m_parent->processZoomEvent(internal_evt->crop_data); 3574 break; 3575 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 3576 rc = m_parent->processASDUpdate(internal_evt->asd_data); 3577 break; 3578 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 3579 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 3580 break; 3581 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 3582 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 3583 break; 3584 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 3585 rc = m_parent->processAEInfo(internal_evt->ae_data); 3586 break; 3587 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 3588 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 3589 break; 3590 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 3591 rc = m_parent->processHDRData(internal_evt->hdr_data); 3592 break; 3593 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 3594 rc = m_parent->processRetroAECUnlock(); 3595 break; 3596 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 3597 rc = m_parent->processZSLCaptureDone(); 3598 break; 3599 case QCAMERA_INTERNAL_EVT_DUAL_CAMERA_FOV_CONTROL: 3600 rc = m_parent->processDCFOVControl(); 3601 break; 3602 default: 3603 break; 3604 } 3605 } 3606 break; 3607 case QCAMERA_SM_EVT_EVT_NOTIFY: 3608 { 3609 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 3610 switch (cam_evt->server_event_type) { 3611 case CAM_EVENT_TYPE_DAEMON_DIED: 3612 { 3613 // Send internal events to stop indefinite wait on prepare 3614 // snapshot done event. 3615 result.status = rc; 3616 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 3617 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3618 m_parent->signalAPIResult(&result); 3619 3620 result.status = rc; 3621 result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE; 3622 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3623 m_parent->signalAPIResult(&result); 3624 3625 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 3626 CAMERA_ERROR_SERVER_DIED, 3627 0); 3628 } 3629 break; 3630 case CAM_EVENT_TYPE_CAC_DONE: 3631 if (m_parent->isCACEnabled() || m_parent->mParameters.isOEMFeatEnabled()) { 3632 LOGD("[LONG_SHOT_DBG] : Received CAC Done"); 3633 if ((m_parent->isLongshotEnabled()) 3634 && (!m_parent->isCaptureShutterEnabled())) { 3635 // play shutter sound for longshot 3636 // after CAC stage is done 3637 m_parent->playShutter(); 3638 } 3639 m_parent->mCACDoneReceived = TRUE; 3640 } 3641 break; 3642 default: 3643 LOGE("Invalid internal event %d in state(%d)", 3644 cam_evt->server_event_type, m_state); 3645 break; 3646 } 3647 } 3648 break; 3649 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 3650 { 3651 LOGL("Calling Process Jpeg Notify"); 3652 qcamera_jpeg_evt_payload_t *jpeg_job = 3653 (qcamera_jpeg_evt_payload_t *)payload; 3654 rc = m_parent->processJpegNotify(jpeg_job); 3655 } 3656 break; 3657 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 3658 { 3659 LOGL("Snapshot Done"); 3660 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) { 3661 rc = m_parent->cancelPicture(); 3662 } else { 3663 rc = m_parent->cancelLiveSnapshot(); 3664 } 3665 m_state = QCAMERA_SM_STATE_PREVIEWING; 3666 if (m_parent->isRetroPicture()){ 3667 result.status = rc; 3668 result.request_api = evt; 3669 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3670 LOGL("\n Signalling for JPEG snapshot done!!"); 3671 m_parent->signalAPIResult(&result); 3672 3673 } 3674 result.status = rc; 3675 result.request_api = evt; 3676 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3677 m_parent->signalEvtResult(&result); 3678 } 3679 break; 3680 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 3681 { 3682 rc = m_parent->updateThermalLevel(payload); 3683 } 3684 break; 3685 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 3686 { 3687 m_parent->stopPreview(); 3688 result.status = rc; 3689 result.request_api = evt; 3690 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3691 m_parent->signalAPIResult(&result); 3692 } 3693 break; 3694 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 3695 { 3696 rc = m_parent->preparePreview(); 3697 if (rc == NO_ERROR) { 3698 rc = m_parent->startPreview(); 3699 } 3700 result.status = rc; 3701 result.request_api = evt; 3702 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3703 m_parent->signalAPIResult(&result); 3704 } 3705 break; 3706 default: 3707 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 3708 break; 3709 } 3710 3711 return rc; 3712 } 3713 3714 /*=========================================================================== 3715 * FUNCTION : isRecording 3716 * 3717 * DESCRIPTION: check if recording is in process. 3718 * 3719 * PARAMETERS : None 3720 * 3721 * RETURN : true -- recording 3722 * false -- not in recording mode 3723 *==========================================================================*/ 3724 bool QCameraStateMachine::isRecording() 3725 { 3726 switch (m_state) { 3727 case QCAMERA_SM_STATE_RECORDING: 3728 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 3729 return true; 3730 default: 3731 return false; 3732 } 3733 } 3734 3735 /*=========================================================================== 3736 * FUNCTION : isPreviewRunning 3737 * 3738 * DESCRIPTION: check if preview is in process. 3739 * 3740 * PARAMETERS : None 3741 * 3742 * RETURN : true -- preview running 3743 * false -- preview stopped 3744 *==========================================================================*/ 3745 bool QCameraStateMachine::isPreviewRunning() 3746 { 3747 switch (m_state) { 3748 case QCAMERA_SM_STATE_PREVIEWING: 3749 case QCAMERA_SM_STATE_RECORDING: 3750 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 3751 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING: 3752 case QCAMERA_SM_STATE_PREPARE_SNAPSHOT: 3753 case QCAMERA_SM_STATE_PREVIEW_READY: 3754 return true; 3755 default: 3756 return false; 3757 } 3758 } 3759 3760 /*=========================================================================== 3761 * FUNCTION : isPreviewReady 3762 * 3763 * DESCRIPTION: check if preview is in ready state. 3764 * 3765 * PARAMETERS : None 3766 * 3767 * RETURN : true -- preview is in ready state 3768 * false -- preview is stopped 3769 *==========================================================================*/ 3770 bool QCameraStateMachine::isPreviewReady() 3771 { 3772 switch (m_state) { 3773 case QCAMERA_SM_STATE_PREVIEW_READY: 3774 return true; 3775 default: 3776 return false; 3777 } 3778 } 3779 3780 /*=========================================================================== 3781 * FUNCTION : isCaptureRunning 3782 * 3783 * DESCRIPTION: check if image capture is in process. 3784 * 3785 * PARAMETERS : None 3786 * 3787 * RETURN : true -- capture running 3788 * false -- capture stopped 3789 *==========================================================================*/ 3790 bool QCameraStateMachine::isCaptureRunning() 3791 { 3792 switch (m_state) { 3793 case QCAMERA_SM_STATE_PIC_TAKING: 3794 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 3795 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING: 3796 return true; 3797 default: 3798 return false; 3799 } 3800 } 3801 /*=========================================================================== 3802 * FUNCTION : isNonZSLCaptureRunning 3803 * 3804 * DESCRIPTION: check if image capture is in process in non ZSL mode. 3805 * 3806 * PARAMETERS : None 3807 * 3808 * RETURN : true -- capture running in non ZSL mode 3809 * false -- Either in not capture mode or captur is not in non ZSL mode 3810 *==========================================================================*/ 3811 bool QCameraStateMachine::isNonZSLCaptureRunning() 3812 { 3813 switch (m_state) { 3814 case QCAMERA_SM_STATE_PIC_TAKING: 3815 return true; 3816 default: 3817 return false; 3818 } 3819 } 3820 3821 /*=========================================================================== 3822 * FUNCTION : dump 3823 * 3824 * DESCRIPTION: Composes a string based on current configuration 3825 * 3826 * PARAMETERS : none 3827 * 3828 * RETURN : Formatted string 3829 *==========================================================================*/ 3830 String8 QCameraStateMachine::dump() 3831 { 3832 String8 str("\n"); 3833 char s[128]; 3834 3835 snprintf(s, 128, "Is Preview Running: %d\n", isPreviewRunning()); 3836 str += s; 3837 3838 snprintf(s, 128, "Is Capture Running: %d\n", isCaptureRunning()); 3839 str += s; 3840 3841 snprintf(s, 128, "Is Non ZSL Capture Running: %d\n", 3842 isNonZSLCaptureRunning()); 3843 str += s; 3844 3845 snprintf(s, 128, "Current State: %d \n", m_state); 3846 str += s; 3847 3848 switch(m_state){ 3849 case QCAMERA_SM_STATE_PREVIEW_STOPPED: 3850 snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEW_STOPPED \n"); 3851 break; 3852 3853 case QCAMERA_SM_STATE_PREVIEW_READY: 3854 snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEW_READY \n"); 3855 break; 3856 3857 case QCAMERA_SM_STATE_PREVIEWING: 3858 snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEWING \n"); 3859 break; 3860 3861 case QCAMERA_SM_STATE_PREPARE_SNAPSHOT: 3862 snprintf(s, 128, " QCAMERA_SM_STATE_PREPARE_SNAPSHOT \n"); 3863 break; 3864 3865 case QCAMERA_SM_STATE_PIC_TAKING: 3866 snprintf(s, 128, " QCAMERA_SM_STATE_PIC_TAKING \n"); 3867 break; 3868 3869 case QCAMERA_SM_STATE_RECORDING: 3870 snprintf(s, 128, " QCAMERA_SM_STATE_RECORDING \n"); 3871 break; 3872 3873 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 3874 snprintf(s, 128, " QCAMERA_SM_STATE_VIDEO_PIC_TAKING \n"); 3875 break; 3876 3877 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING: 3878 snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEW_PIC_TAKING \n"); 3879 break; 3880 } 3881 str += s; 3882 3883 return str; 3884 } 3885 3886 }; // namespace qcamera 3887
