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 default: 1640 LOGE("Invalid internal event %d in state(%d)", 1641 internal_evt->evt_type, m_state); 1642 break; 1643 } 1644 } 1645 break; 1646 case QCAMERA_SM_EVT_EVT_NOTIFY: 1647 { 1648 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 1649 switch (cam_evt->server_event_type) { 1650 case CAM_EVENT_TYPE_DAEMON_DIED: 1651 { 1652 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 1653 CAMERA_ERROR_SERVER_DIED, 1654 0); 1655 } 1656 break; 1657 default: 1658 LOGW("no handling for server evt (%d) at this state", 1659 cam_evt->server_event_type); 1660 break; 1661 } 1662 } 1663 break; 1664 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 1665 { 1666 rc = m_parent->updateThermalLevel(payload); 1667 } 1668 break; 1669 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 1670 { 1671 // No ops, but need to notify 1672 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1673 result.status = rc; 1674 result.request_api = evt; 1675 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1676 m_parent->signalEvtResult(&result); 1677 } 1678 break; 1679 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 1680 { 1681 m_parent->stopPreview(); 1682 result.status = rc; 1683 result.request_api = evt; 1684 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1685 m_parent->signalAPIResult(&result); 1686 } 1687 break; 1688 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 1689 { 1690 rc = m_parent->preparePreview(); 1691 if (rc == NO_ERROR) { 1692 rc = m_parent->startPreview(); 1693 } 1694 result.status = rc; 1695 result.request_api = evt; 1696 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1697 m_parent->signalAPIResult(&result); 1698 } 1699 break; 1700 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 1701 default: 1702 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1703 break; 1704 } 1705 1706 return rc; 1707 } 1708 1709 /*=========================================================================== 1710 * FUNCTION : procEvtPrepareSnapshotState 1711 * 1712 * DESCRIPTION: finite state machine function to handle event in state of 1713 * QCAMERA_SM_STATE_PREPARE_SNAPSHOT. 1714 * 1715 * PARAMETERS : 1716 * @evt : event to be processed 1717 * @payload : event payload. Can be NULL if not needed. 1718 * 1719 * RETURN : int32_t type of status 1720 * NO_ERROR -- success 1721 * none-zero failure code 1722 *==========================================================================*/ 1723 int32_t QCameraStateMachine::procEvtPrepareSnapshotState(qcamera_sm_evt_enum_t evt, 1724 void *payload) 1725 { 1726 int32_t rc = NO_ERROR; 1727 qcamera_api_result_t result; 1728 memset(&result, 0, sizeof(qcamera_api_result_t)); 1729 1730 LOGL("event (%d)", evt); 1731 switch (evt) { 1732 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 1733 case QCAMERA_SM_EVT_SET_CALLBACKS: 1734 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 1735 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 1736 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 1737 case QCAMERA_SM_EVT_SET_PARAMS: 1738 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 1739 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 1740 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 1741 case QCAMERA_SM_EVT_GET_PARAMS: 1742 case QCAMERA_SM_EVT_PUT_PARAMS: 1743 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 1744 case QCAMERA_SM_EVT_START_PREVIEW: 1745 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 1746 case QCAMERA_SM_EVT_STOP_PREVIEW: 1747 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 1748 case QCAMERA_SM_EVT_RECORDING_ENABLED: 1749 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 1750 case QCAMERA_SM_EVT_DUMP: 1751 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 1752 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 1753 case QCAMERA_SM_EVT_PRE_START_RECORDING: 1754 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 1755 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 1756 case QCAMERA_SM_EVT_START_RECORDING: 1757 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 1758 case QCAMERA_SM_EVT_TAKE_PICTURE: 1759 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 1760 case QCAMERA_SM_EVT_SEND_COMMAND: 1761 case QCAMERA_SM_EVT_CANCEL_PICTURE: 1762 case QCAMERA_SM_EVT_STOP_RECORDING: 1763 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 1764 case QCAMERA_SM_EVT_RELEASE: 1765 { 1766 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 1767 rc = INVALID_OPERATION; 1768 result.status = rc; 1769 result.request_api = evt; 1770 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1771 m_parent->signalAPIResult(&result); 1772 } 1773 break; 1774 case QCAMERA_SM_EVT_EVT_INTERNAL: 1775 { 1776 qcamera_sm_internal_evt_payload_t *internal_evt = 1777 (qcamera_sm_internal_evt_payload_t *)payload; 1778 switch (internal_evt->evt_type) { 1779 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 1780 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 1781 break; 1782 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 1783 m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state); 1784 m_state = QCAMERA_SM_STATE_PREVIEWING; 1785 1786 result.status = NO_ERROR; 1787 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 1788 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1789 m_parent->signalAPIResult(&result); 1790 break; 1791 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 1792 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 1793 break; 1794 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 1795 rc = m_parent->processHistogramStats(internal_evt->stats_data); 1796 break; 1797 case QCAMERA_INTERNAL_EVT_CROP_INFO: 1798 rc = m_parent->processZoomEvent(internal_evt->crop_data); 1799 break; 1800 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 1801 rc = m_parent->processASDUpdate(internal_evt->asd_data); 1802 break; 1803 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 1804 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1805 break; 1806 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 1807 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 1808 break; 1809 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 1810 rc = m_parent->processAEInfo(internal_evt->ae_data); 1811 break; 1812 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 1813 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 1814 break; 1815 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 1816 rc = m_parent->processHDRData(internal_evt->hdr_data); 1817 break; 1818 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 1819 rc = m_parent->processRetroAECUnlock(); 1820 break; 1821 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 1822 rc = m_parent->processZSLCaptureDone(); 1823 break; 1824 default: 1825 LOGE("Invalid internal event %d in state(%d)", 1826 internal_evt->evt_type, m_state); 1827 break; 1828 } 1829 } 1830 break; 1831 case QCAMERA_SM_EVT_EVT_NOTIFY: 1832 { 1833 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 1834 switch (cam_evt->server_event_type) { 1835 case CAM_EVENT_TYPE_DAEMON_DIED: 1836 { 1837 // Send internal events to stop indefinite wait on prepare 1838 // snapshot done event. 1839 result.status = rc; 1840 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 1841 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1842 m_parent->signalAPIResult(&result); 1843 1844 result.status = rc; 1845 result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE; 1846 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1847 m_parent->signalAPIResult(&result); 1848 1849 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 1850 CAMERA_ERROR_SERVER_DIED, 1851 0); 1852 } 1853 break; 1854 default: 1855 LOGE("Invalid internal event %d in state(%d)", 1856 cam_evt->server_event_type, m_state); 1857 break; 1858 } 1859 } 1860 break; 1861 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 1862 { 1863 // No ops, but need to notify 1864 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1865 result.status = rc; 1866 result.request_api = evt; 1867 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1868 m_parent->signalEvtResult(&result); 1869 } 1870 break; 1871 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 1872 { 1873 rc = m_parent->updateThermalLevel(payload); 1874 } 1875 break; 1876 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 1877 default: 1878 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 1879 break; 1880 } 1881 1882 return rc; 1883 } 1884 1885 /*=========================================================================== 1886 * FUNCTION : procEvtPicTakingState 1887 * 1888 * DESCRIPTION: finite state machine function to handle event in state of 1889 * QCAMERA_SM_STATE_PIC_TAKING. 1890 * 1891 * PARAMETERS : 1892 * @evt : event to be processed 1893 * @payload : event payload. Can be NULL if not needed. 1894 * 1895 * RETURN : int32_t type of status 1896 * NO_ERROR -- success 1897 * none-zero failure code 1898 *==========================================================================*/ 1899 int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt, 1900 void *payload) 1901 { 1902 int32_t rc = NO_ERROR; 1903 qcamera_api_result_t result; 1904 memset(&result, 0, sizeof(qcamera_api_result_t)); 1905 1906 LOGL("event (%d)", evt); 1907 switch (evt) { 1908 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 1909 { 1910 // Error setting preview window during previewing 1911 LOGE("Error!! cannot set preview window when preview is running"); 1912 rc = INVALID_OPERATION; 1913 result.status = rc; 1914 result.request_api = evt; 1915 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1916 m_parent->signalAPIResult(&result); 1917 } 1918 break; 1919 case QCAMERA_SM_EVT_SET_CALLBACKS: 1920 { 1921 qcamera_sm_evt_setcb_payload_t *setcbs = 1922 (qcamera_sm_evt_setcb_payload_t *)payload; 1923 rc = m_parent->setCallBacks(setcbs->notify_cb, 1924 setcbs->data_cb, 1925 setcbs->data_cb_timestamp, 1926 setcbs->get_memory, 1927 setcbs->user); 1928 result.status = rc; 1929 result.request_api = evt; 1930 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1931 m_parent->signalAPIResult(&result); 1932 } 1933 break; 1934 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 1935 { 1936 rc = m_parent->enableMsgType(*((int32_t *)payload)); 1937 result.status = rc; 1938 result.request_api = evt; 1939 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1940 m_parent->signalAPIResult(&result); 1941 } 1942 break; 1943 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 1944 { 1945 rc = m_parent->disableMsgType(*((int32_t *)payload)); 1946 result.status = rc; 1947 result.request_api = evt; 1948 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1949 m_parent->signalAPIResult(&result); 1950 } 1951 break; 1952 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 1953 { 1954 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 1955 result.status = rc; 1956 result.request_api = evt; 1957 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1958 result.enabled = enabled; 1959 m_parent->signalAPIResult(&result); 1960 } 1961 break; 1962 case QCAMERA_SM_EVT_SET_PARAMS: 1963 { 1964 bool needRestart = false; 1965 rc = m_parent->updateParameters((char*)payload, needRestart); 1966 result.status = rc; 1967 result.request_api = evt; 1968 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1969 m_parent->signalAPIResult(&result); 1970 } 1971 break; 1972 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 1973 { 1974 result.status = rc; 1975 result.request_api = evt; 1976 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1977 m_parent->signalAPIResult(&result); 1978 } 1979 break; 1980 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 1981 { 1982 rc = m_parent->commitParameterChanges(); 1983 result.status = rc; 1984 result.request_api = evt; 1985 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1986 m_parent->signalAPIResult(&result); 1987 } 1988 break; 1989 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 1990 { 1991 m_parent->setNeedRestart(false); 1992 result.status = rc; 1993 result.request_api = evt; 1994 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1995 m_parent->signalAPIResult(&result); 1996 } 1997 break; 1998 case QCAMERA_SM_EVT_GET_PARAMS: 1999 { 2000 result.params = m_parent->getParameters(); 2001 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 2002 result.status = rc; 2003 result.request_api = evt; 2004 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 2005 m_parent->signalAPIResult(&result); 2006 } 2007 break; 2008 case QCAMERA_SM_EVT_PUT_PARAMS: 2009 { 2010 rc = m_parent->putParameters((char*)payload); 2011 result.status = rc; 2012 result.request_api = evt; 2013 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2014 m_parent->signalAPIResult(&result); 2015 } 2016 break; 2017 case QCAMERA_SM_EVT_STOP_PREVIEW: 2018 { 2019 // cancel picture first 2020 rc = m_parent->cancelPicture(); 2021 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 2022 2023 result.status = rc; 2024 result.request_api = evt; 2025 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2026 m_parent->signalAPIResult(&result); 2027 } 2028 break; 2029 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 2030 { 2031 rc = NO_ERROR; 2032 result.status = rc; 2033 result.request_api = evt; 2034 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2035 result.enabled = 0; 2036 m_parent->signalAPIResult(&result); 2037 } 2038 break; 2039 case QCAMERA_SM_EVT_RECORDING_ENABLED: 2040 { 2041 rc = NO_ERROR; 2042 result.status = rc; 2043 result.request_api = evt; 2044 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2045 result.enabled = 0; 2046 m_parent->signalAPIResult(&result); 2047 } 2048 break; 2049 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 2050 { 2051 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 2052 result.status = rc; 2053 result.request_api = evt; 2054 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2055 m_parent->signalAPIResult(&result); 2056 } 2057 break; 2058 case QCAMERA_SM_EVT_DUMP: 2059 { 2060 rc = m_parent->dump(*((int *)payload)); 2061 result.status = rc; 2062 result.request_api = evt; 2063 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2064 m_parent->signalAPIResult(&result); 2065 } 2066 break; 2067 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 2068 { 2069 rc = m_parent->autoFocus(); 2070 result.status = rc; 2071 result.request_api = evt; 2072 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2073 m_parent->signalAPIResult(&result); 2074 } 2075 break; 2076 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 2077 { 2078 rc = m_parent->cancelAutoFocus(); 2079 result.status = rc; 2080 result.request_api = evt; 2081 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2082 m_parent->signalAPIResult(&result); 2083 } 2084 break; 2085 case QCAMERA_SM_EVT_SEND_COMMAND: 2086 { 2087 qcamera_sm_evt_command_payload_t *cmd_payload = 2088 (qcamera_sm_evt_command_payload_t *)payload; 2089 rc = m_parent->sendCommand(cmd_payload->cmd, 2090 cmd_payload->arg1, 2091 cmd_payload->arg2); 2092 #ifndef VANILLA_HAL 2093 if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) { 2094 // move state to previewing state 2095 m_state = QCAMERA_SM_STATE_PREVIEWING; 2096 } 2097 #endif 2098 result.status = rc; 2099 result.request_api = evt; 2100 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2101 m_parent->signalAPIResult(&result); 2102 } 2103 break; 2104 case QCAMERA_SM_EVT_CANCEL_PICTURE: 2105 { 2106 rc = m_parent->cancelPicture(); 2107 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 2108 result.status = rc; 2109 result.request_api = evt; 2110 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2111 m_parent->signalAPIResult(&result); 2112 } 2113 break; 2114 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 2115 { 2116 int32_t faceID = 0; 2117 qcamera_sm_evt_reg_face_payload_t *reg_payload = 2118 (qcamera_sm_evt_reg_face_payload_t *)payload; 2119 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 2120 reg_payload->config, 2121 faceID); 2122 result.status = rc; 2123 result.request_api = evt; 2124 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 2125 result.handle = faceID; 2126 m_parent->signalAPIResult(&result); 2127 } 2128 break; 2129 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 2130 { 2131 if ( m_parent->isLongshotEnabled() ) { 2132 // no ops here, need to singal NO_ERROR 2133 rc = NO_ERROR; 2134 } else { 2135 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 2136 rc = INVALID_OPERATION; 2137 } 2138 2139 result.status = rc; 2140 result.request_api = evt; 2141 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2142 m_parent->signalAPIResult(&result); 2143 } 2144 break; 2145 case QCAMERA_SM_EVT_TAKE_PICTURE: 2146 { 2147 if ( m_parent->isLongshotEnabled() ) { 2148 rc = m_parent->longShot(); 2149 } else { 2150 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 2151 rc = INVALID_OPERATION; 2152 } 2153 2154 result.status = rc; 2155 result.request_api = evt; 2156 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2157 m_parent->signalAPIResult(&result); 2158 } 2159 break; 2160 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 2161 case QCAMERA_SM_EVT_PRE_START_RECORDING: 2162 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 2163 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 2164 case QCAMERA_SM_EVT_START_RECORDING: 2165 case QCAMERA_SM_EVT_STOP_RECORDING: 2166 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 2167 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 2168 case QCAMERA_SM_EVT_START_PREVIEW: 2169 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 2170 case QCAMERA_SM_EVT_RELEASE: 2171 { 2172 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 2173 rc = INVALID_OPERATION; 2174 result.status = rc; 2175 result.request_api = evt; 2176 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2177 m_parent->signalAPIResult(&result); 2178 } 2179 break; 2180 case QCAMERA_SM_EVT_EVT_INTERNAL: 2181 { 2182 qcamera_sm_internal_evt_payload_t *internal_evt = 2183 (qcamera_sm_internal_evt_payload_t *)payload; 2184 switch (internal_evt->evt_type) { 2185 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 2186 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 2187 break; 2188 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 2189 break; 2190 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 2191 break; 2192 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 2193 break; 2194 case QCAMERA_INTERNAL_EVT_CROP_INFO: 2195 rc = m_parent->processZoomEvent(internal_evt->crop_data); 2196 break; 2197 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 2198 rc = m_parent->processASDUpdate(internal_evt->asd_data); 2199 break; 2200 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 2201 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2202 break; 2203 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 2204 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 2205 break; 2206 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 2207 rc = m_parent->processAEInfo(internal_evt->ae_data); 2208 break; 2209 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 2210 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 2211 break; 2212 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 2213 rc = m_parent->processHDRData(internal_evt->hdr_data); 2214 break; 2215 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 2216 rc = m_parent->processRetroAECUnlock(); 2217 break; 2218 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 2219 rc = m_parent->processZSLCaptureDone(); 2220 break; 2221 default: 2222 break; 2223 } 2224 } 2225 break; 2226 case QCAMERA_SM_EVT_EVT_NOTIFY: 2227 { 2228 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 2229 switch (cam_evt->server_event_type) { 2230 case CAM_EVENT_TYPE_DAEMON_DIED: 2231 { 2232 // Send internal events to stop indefinite wait on prepare 2233 // snapshot done event. 2234 result.status = rc; 2235 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 2236 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2237 m_parent->signalAPIResult(&result); 2238 2239 result.status = rc; 2240 result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE; 2241 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2242 m_parent->signalAPIResult(&result); 2243 2244 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 2245 CAMERA_ERROR_SERVER_DIED, 2246 0); 2247 } 2248 break; 2249 case CAM_EVENT_TYPE_CAC_DONE: 2250 if (m_parent->isCACEnabled() || m_parent->mParameters.isOEMFeatEnabled()) { 2251 LOGD("[LONG_SHOT_DBG] : Received CAC Done"); 2252 if (m_parent->isLongshotEnabled() 2253 && !m_parent->isCaptureShutterEnabled()) { 2254 // play shutter sound for longshot 2255 // after CAC stage is done 2256 m_parent->playShutter(); 2257 } 2258 m_parent->mCACDoneReceived = TRUE; 2259 } 2260 break; 2261 default: 2262 LOGH("no handling for server evt (%d) at this state", 2263 cam_evt->server_event_type); 2264 break; 2265 } 2266 } 2267 break; 2268 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 2269 { 2270 qcamera_jpeg_evt_payload_t *jpeg_job = 2271 (qcamera_jpeg_evt_payload_t *)payload; 2272 rc = m_parent->processJpegNotify(jpeg_job); 2273 } 2274 break; 2275 case QCAMERA_SM_EVT_STOP_CAPTURE_CHANNEL: 2276 { 2277 bool restartPreview = m_parent->isPreviewRestartEnabled(); 2278 rc = m_parent->stopCaptureChannel(restartPreview); 2279 2280 if (restartPreview && (NO_ERROR == rc)) { 2281 rc = m_parent->preparePreview(); 2282 if (NO_ERROR == rc) { 2283 m_parent->m_bPreviewStarted = true; 2284 applyDelayedMsgs(); 2285 rc = m_parent->startPreview(); 2286 } 2287 } 2288 2289 result.status = rc; 2290 result.request_api = evt; 2291 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2292 m_parent->signalAPIResult(&result); 2293 } 2294 break; 2295 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 2296 { 2297 rc = m_parent->cancelPicture(); 2298 2299 bool restartPreview = m_parent->isPreviewRestartEnabled(); 2300 if (restartPreview) { 2301 if (m_parent->mParameters.getManualCaptureMode() 2302 >= CAM_MANUAL_CAPTURE_TYPE_3) { 2303 m_parent->mParameters.updateZSLModeValue(m_RestoreZSL); 2304 m_RestoreZSL = FALSE; 2305 rc = m_parent->preparePreview(); 2306 if (NO_ERROR == rc) { 2307 m_parent->m_bPreviewStarted = true; 2308 applyDelayedMsgs(); 2309 rc = m_parent->startPreview(); 2310 } 2311 } 2312 m_state = QCAMERA_SM_STATE_PREVIEWING; 2313 } else { 2314 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 2315 } 2316 2317 result.status = rc; 2318 result.request_api = evt; 2319 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2320 m_parent->signalEvtResult(&result); 2321 } 2322 break; 2323 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 2324 { 2325 rc = m_parent->updateThermalLevel(payload); 2326 } 2327 break; 2328 default: 2329 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2330 break; 2331 } 2332 2333 return rc; 2334 } 2335 2336 /*=========================================================================== 2337 * FUNCTION : procEvtRecordingState 2338 * 2339 * DESCRIPTION: finite state machine function to handle event in state of 2340 * QCAMERA_SM_STATE_RECORDING. 2341 * 2342 * PARAMETERS : 2343 * @evt : event to be processed 2344 * @payload : event payload. Can be NULL if not needed. 2345 * 2346 * RETURN : int32_t type of status 2347 * NO_ERROR -- success 2348 * none-zero failure code 2349 *==========================================================================*/ 2350 int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt, 2351 void *payload) 2352 { 2353 int32_t rc = NO_ERROR; 2354 qcamera_api_result_t result; 2355 memset(&result, 0, sizeof(qcamera_api_result_t)); 2356 2357 LOGL("event (%d)", evt); 2358 switch (evt) { 2359 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 2360 case QCAMERA_SM_EVT_START_PREVIEW: 2361 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 2362 { 2363 // WA: CTS test VideoSnapshot will try to 2364 // start preview during video recording. 2365 LOGH("CTS video restart op"); 2366 rc = NO_ERROR; 2367 result.status = rc; 2368 result.request_api = evt; 2369 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2370 m_parent->signalAPIResult(&result); 2371 } 2372 break; 2373 case QCAMERA_SM_EVT_SET_CALLBACKS: 2374 { 2375 qcamera_sm_evt_setcb_payload_t *setcbs = 2376 (qcamera_sm_evt_setcb_payload_t *)payload; 2377 rc = m_parent->setCallBacks(setcbs->notify_cb, 2378 setcbs->data_cb, 2379 setcbs->data_cb_timestamp, 2380 setcbs->get_memory, 2381 setcbs->user); 2382 result.status = rc; 2383 result.request_api = evt; 2384 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2385 m_parent->signalAPIResult(&result); 2386 } 2387 break; 2388 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 2389 { 2390 rc = m_parent->enableMsgType(*((int32_t *)payload)); 2391 result.status = rc; 2392 result.request_api = evt; 2393 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2394 m_parent->signalAPIResult(&result); 2395 } 2396 break; 2397 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 2398 { 2399 rc = m_parent->disableMsgType(*((int32_t *)payload)); 2400 result.status = rc; 2401 result.request_api = evt; 2402 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2403 m_parent->signalAPIResult(&result); 2404 } 2405 break; 2406 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 2407 { 2408 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 2409 result.status = rc; 2410 result.request_api = evt; 2411 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2412 result.enabled = enabled; 2413 m_parent->signalAPIResult(&result); 2414 } 2415 break; 2416 case QCAMERA_SM_EVT_SET_PARAMS: 2417 { 2418 bool needRestart = false; 2419 rc = m_parent->updateParameters((char*)payload, needRestart); 2420 if (rc == NO_ERROR) { 2421 if (needRestart) { 2422 // cannot set parameters that requires restart during recording 2423 LOGE("Error!! cannot set parameters that requires restart during recording"); 2424 rc = BAD_VALUE; 2425 } 2426 } 2427 if (rc != NO_ERROR) { 2428 m_parent->setNeedRestart(false); 2429 } 2430 result.status = rc; 2431 result.request_api = evt; 2432 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2433 m_parent->signalAPIResult(&result); 2434 } 2435 break; 2436 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 2437 { 2438 rc = m_parent->commitParameterChanges(); 2439 result.status = rc; 2440 result.request_api = evt; 2441 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2442 m_parent->signalAPIResult(&result); 2443 } 2444 break; 2445 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 2446 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 2447 { 2448 ALOGE("%s: Error!! cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 2449 rc = INVALID_OPERATION; 2450 result.status = rc; 2451 result.request_api = evt; 2452 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2453 m_parent->signalAPIResult(&result); 2454 } 2455 break; 2456 case QCAMERA_SM_EVT_GET_PARAMS: 2457 { 2458 result.params = m_parent->getParameters(); 2459 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 2460 result.status = rc; 2461 result.request_api = evt; 2462 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 2463 m_parent->signalAPIResult(&result); 2464 } 2465 break; 2466 case QCAMERA_SM_EVT_PUT_PARAMS: 2467 { 2468 rc = m_parent->putParameters((char*)payload); 2469 result.status = rc; 2470 result.request_api = evt; 2471 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2472 m_parent->signalAPIResult(&result); 2473 } 2474 break; 2475 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 2476 { 2477 rc = NO_ERROR; 2478 result.status = rc; 2479 result.request_api = evt; 2480 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2481 result.enabled = 0; 2482 m_parent->signalAPIResult(&result); 2483 } 2484 break; 2485 case QCAMERA_SM_EVT_RECORDING_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 = 1; 2492 m_parent->signalAPIResult(&result); 2493 } 2494 break; 2495 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 2496 { 2497 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 2498 result.status = rc; 2499 result.request_api = evt; 2500 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2501 m_parent->signalAPIResult(&result); 2502 } 2503 break; 2504 case QCAMERA_SM_EVT_DUMP: 2505 { 2506 rc = m_parent->dump(*((int *)payload)); 2507 result.status = rc; 2508 result.request_api = evt; 2509 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2510 m_parent->signalAPIResult(&result); 2511 } 2512 break; 2513 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 2514 { 2515 rc = m_parent->autoFocus(); 2516 result.status = rc; 2517 result.request_api = evt; 2518 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2519 m_parent->signalAPIResult(&result); 2520 } 2521 break; 2522 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 2523 { 2524 rc = m_parent->cancelAutoFocus(); 2525 result.status = rc; 2526 result.request_api = evt; 2527 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2528 m_parent->signalAPIResult(&result); 2529 } 2530 break; 2531 case QCAMERA_SM_EVT_SEND_COMMAND: 2532 { 2533 qcamera_sm_evt_command_payload_t *cmd_payload = 2534 (qcamera_sm_evt_command_payload_t *)payload; 2535 rc = m_parent->sendCommand(cmd_payload->cmd, 2536 cmd_payload->arg1, 2537 cmd_payload->arg2); 2538 result.status = rc; 2539 result.request_api = evt; 2540 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2541 m_parent->signalAPIResult(&result); 2542 } 2543 break; 2544 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 2545 { 2546 // No ops here, send NO_ERROR. 2547 rc = NO_ERROR; 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_TAKE_PICTURE: 2555 { 2556 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING; 2557 rc = m_parent->takeLiveSnapshot(); 2558 if (rc != NO_ERROR) { 2559 m_parent->unconfigureAdvancedCapture(); 2560 m_state = QCAMERA_SM_STATE_RECORDING; 2561 } 2562 result.status = rc; 2563 result.request_api = evt; 2564 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2565 m_parent->signalAPIResult(&result); 2566 } 2567 break; 2568 case QCAMERA_SM_EVT_PRE_START_RECORDING: 2569 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 2570 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 2571 case QCAMERA_SM_EVT_START_RECORDING: 2572 { 2573 // no ops here 2574 LOGW("already in recording state, no ops for start_recording"); 2575 rc = 0; 2576 result.status = rc; 2577 result.request_api = evt; 2578 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2579 m_parent->signalAPIResult(&result); 2580 } 2581 break; 2582 case QCAMERA_SM_EVT_STOP_RECORDING: 2583 { 2584 rc = m_parent->stopRecording(); 2585 m_state = QCAMERA_SM_STATE_PREVIEWING; 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_PREVIEW: 2593 { 2594 rc = m_parent->stopRecording(); 2595 m_state = QCAMERA_SM_STATE_PREVIEWING; 2596 2597 rc = m_parent->stopPreview(); 2598 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 2599 2600 result.status = rc; 2601 result.request_api = evt; 2602 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2603 m_parent->signalAPIResult(&result); 2604 } 2605 break; 2606 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 2607 { 2608 rc = m_parent->releaseRecordingFrame((const void *)payload); 2609 result.status = rc; 2610 result.request_api = evt; 2611 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2612 m_parent->signalAPIResult(&result); 2613 } 2614 break; 2615 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 2616 { 2617 int32_t faceID = 0; 2618 qcamera_sm_evt_reg_face_payload_t *reg_payload = 2619 (qcamera_sm_evt_reg_face_payload_t *)payload; 2620 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 2621 reg_payload->config, 2622 faceID); 2623 result.status = rc; 2624 result.request_api = evt; 2625 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 2626 result.handle = faceID; 2627 m_parent->signalAPIResult(&result); 2628 } 2629 break; 2630 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 2631 { 2632 //In Video snapshot, prepare hardware is a no-op. 2633 result.status = NO_ERROR; 2634 result.request_api = evt; 2635 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2636 m_parent->signalAPIResult(&result); 2637 } 2638 break; 2639 case QCAMERA_SM_EVT_CANCEL_PICTURE: 2640 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 2641 case QCAMERA_SM_EVT_RELEASE: 2642 { 2643 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 2644 rc = INVALID_OPERATION; 2645 result.status = rc; 2646 result.request_api = evt; 2647 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2648 m_parent->signalAPIResult(&result); 2649 } 2650 break; 2651 case QCAMERA_SM_EVT_EVT_INTERNAL: 2652 { 2653 qcamera_sm_internal_evt_payload_t *internal_evt = 2654 (qcamera_sm_internal_evt_payload_t *)payload; 2655 switch (internal_evt->evt_type) { 2656 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 2657 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 2658 break; 2659 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 2660 break; 2661 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 2662 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 2663 break; 2664 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 2665 rc = m_parent->processHistogramStats(internal_evt->stats_data); 2666 break; 2667 case QCAMERA_INTERNAL_EVT_CROP_INFO: 2668 rc = m_parent->processZoomEvent(internal_evt->crop_data); 2669 break; 2670 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 2671 rc = m_parent->processASDUpdate(internal_evt->asd_data); 2672 break; 2673 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 2674 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2675 break; 2676 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 2677 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 2678 break; 2679 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 2680 rc = m_parent->processAEInfo(internal_evt->ae_data); 2681 break; 2682 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 2683 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 2684 break; 2685 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 2686 rc = m_parent->processHDRData(internal_evt->hdr_data); 2687 break; 2688 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 2689 rc = m_parent->processRetroAECUnlock(); 2690 break; 2691 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 2692 rc = m_parent->processZSLCaptureDone(); 2693 break; 2694 default: 2695 break; 2696 } 2697 } 2698 break; 2699 case QCAMERA_SM_EVT_EVT_NOTIFY: 2700 { 2701 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 2702 switch (cam_evt->server_event_type) { 2703 case CAM_EVENT_TYPE_DAEMON_DIED: 2704 { 2705 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 2706 CAMERA_ERROR_SERVER_DIED, 2707 0); 2708 } 2709 break; 2710 default: 2711 LOGE("Invalid internal event %d in state(%d)", 2712 cam_evt->server_event_type, m_state); 2713 break; 2714 } 2715 } 2716 break; 2717 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 2718 { 2719 rc = m_parent->updateThermalLevel(payload); 2720 } 2721 break; 2722 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 2723 { 2724 // No ops, but need to notify 2725 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2726 result.status = rc; 2727 result.request_api = evt; 2728 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2729 m_parent->signalEvtResult(&result); 2730 } 2731 break; 2732 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 2733 default: 2734 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 2735 break; 2736 } 2737 2738 return rc; 2739 } 2740 2741 /*=========================================================================== 2742 * FUNCTION : procEvtVideoPicTakingState 2743 * 2744 * DESCRIPTION: finite state machine function to handle event in state of 2745 * QCAMERA_SM_STATE_VIDEO_PIC_TAKING. 2746 * 2747 * PARAMETERS : 2748 * @evt : event to be processed 2749 * @payload : event payload. Can be NULL if not needed. 2750 * 2751 * RETURN : int32_t type of status 2752 * NO_ERROR -- success 2753 * none-zero failure code 2754 *==========================================================================*/ 2755 int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt, 2756 void *payload) 2757 { 2758 int32_t rc = NO_ERROR; 2759 qcamera_api_result_t result; 2760 memset(&result, 0, sizeof(qcamera_api_result_t)); 2761 2762 LOGL("event (%d)", evt); 2763 switch (evt) { 2764 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 2765 { 2766 // Error setting preview window during previewing 2767 LOGE("Error!! cannot set preview window when preview is running"); 2768 rc = INVALID_OPERATION; 2769 result.status = rc; 2770 result.request_api = evt; 2771 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2772 m_parent->signalAPIResult(&result); 2773 } 2774 break; 2775 case QCAMERA_SM_EVT_SET_CALLBACKS: 2776 { 2777 qcamera_sm_evt_setcb_payload_t *setcbs = 2778 (qcamera_sm_evt_setcb_payload_t *)payload; 2779 rc = m_parent->setCallBacks(setcbs->notify_cb, 2780 setcbs->data_cb, 2781 setcbs->data_cb_timestamp, 2782 setcbs->get_memory, 2783 setcbs->user); 2784 result.status = rc; 2785 result.request_api = evt; 2786 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2787 m_parent->signalAPIResult(&result); 2788 } 2789 break; 2790 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 2791 { 2792 rc = m_parent->enableMsgType(*((int32_t *)payload)); 2793 result.status = rc; 2794 result.request_api = evt; 2795 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2796 m_parent->signalAPIResult(&result); 2797 } 2798 break; 2799 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 2800 { 2801 rc = m_parent->disableMsgType(*((int32_t *)payload)); 2802 result.status = rc; 2803 result.request_api = evt; 2804 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2805 m_parent->signalAPIResult(&result); 2806 } 2807 break; 2808 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 2809 { 2810 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 2811 result.status = rc; 2812 result.request_api = evt; 2813 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2814 result.enabled = enabled; 2815 m_parent->signalAPIResult(&result); 2816 } 2817 break; 2818 case QCAMERA_SM_EVT_SET_PARAMS: 2819 { 2820 bool needRestart = false; 2821 rc = m_parent->updateParameters((char*)payload, needRestart); 2822 if (rc == NO_ERROR) { 2823 if (needRestart) { 2824 // cannot set parameters that requires restart during recording 2825 LOGE("Error!! cannot set parameters that requires restart during recording"); 2826 rc = BAD_VALUE; 2827 } 2828 } 2829 if (rc != NO_ERROR) { 2830 m_parent->setNeedRestart(false); 2831 } 2832 result.status = rc; 2833 result.request_api = evt; 2834 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2835 m_parent->signalAPIResult(&result); 2836 } 2837 break; 2838 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 2839 { 2840 rc = m_parent->commitParameterChanges(); 2841 result.status = rc; 2842 result.request_api = evt; 2843 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2844 m_parent->signalAPIResult(&result); 2845 } 2846 break; 2847 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 2848 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 2849 { 2850 ALOGE("%s: Error!! cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 2851 rc = INVALID_OPERATION; 2852 result.status = rc; 2853 result.request_api = evt; 2854 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2855 m_parent->signalAPIResult(&result); 2856 } 2857 break; 2858 case QCAMERA_SM_EVT_GET_PARAMS: 2859 { 2860 result.params = m_parent->getParameters(); 2861 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 2862 result.status = rc; 2863 result.request_api = evt; 2864 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 2865 m_parent->signalAPIResult(&result); 2866 } 2867 break; 2868 case QCAMERA_SM_EVT_PUT_PARAMS: 2869 { 2870 rc = m_parent->putParameters((char*)payload); 2871 result.status = rc; 2872 result.request_api = evt; 2873 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2874 m_parent->signalAPIResult(&result); 2875 } 2876 break; 2877 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 2878 { 2879 rc = NO_ERROR; 2880 result.status = rc; 2881 result.request_api = evt; 2882 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2883 result.enabled = 1; 2884 m_parent->signalAPIResult(&result); 2885 } 2886 break; 2887 case QCAMERA_SM_EVT_RECORDING_ENABLED: 2888 { 2889 rc = NO_ERROR; 2890 result.status = rc; 2891 result.request_api = evt; 2892 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2893 result.enabled = 1; 2894 m_parent->signalAPIResult(&result); 2895 } 2896 break; 2897 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 2898 { 2899 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 2900 result.status = rc; 2901 result.request_api = evt; 2902 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2903 m_parent->signalAPIResult(&result); 2904 } 2905 break; 2906 case QCAMERA_SM_EVT_DUMP: 2907 { 2908 rc = m_parent->dump(*((int *)payload)); 2909 result.status = rc; 2910 result.request_api = evt; 2911 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2912 m_parent->signalAPIResult(&result); 2913 } 2914 break; 2915 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 2916 { 2917 rc = m_parent->autoFocus(); 2918 result.status = rc; 2919 result.request_api = evt; 2920 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2921 m_parent->signalAPIResult(&result); 2922 } 2923 break; 2924 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 2925 { 2926 rc = m_parent->cancelAutoFocus(); 2927 result.status = rc; 2928 result.request_api = evt; 2929 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2930 m_parent->signalAPIResult(&result); 2931 } 2932 break; 2933 case QCAMERA_SM_EVT_SEND_COMMAND: 2934 { 2935 qcamera_sm_evt_command_payload_t *cmd_payload = 2936 (qcamera_sm_evt_command_payload_t *)payload; 2937 rc = m_parent->sendCommand(cmd_payload->cmd, 2938 cmd_payload->arg1, 2939 cmd_payload->arg2); 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_STOP_RECORDING: 2947 { 2948 rc = m_parent->cancelLiveSnapshot(); 2949 m_state = QCAMERA_SM_STATE_RECORDING; 2950 2951 rc = m_parent->stopRecording(); 2952 m_state = QCAMERA_SM_STATE_PREVIEWING; 2953 2954 result.status = rc; 2955 result.request_api = evt; 2956 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2957 m_parent->signalAPIResult(&result); 2958 } 2959 break; 2960 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 2961 { 2962 rc = m_parent->releaseRecordingFrame((const void *)payload); 2963 result.status = rc; 2964 result.request_api = evt; 2965 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2966 m_parent->signalAPIResult(&result); 2967 } 2968 break; 2969 case QCAMERA_SM_EVT_CANCEL_PICTURE: 2970 { 2971 rc = m_parent->cancelLiveSnapshot(); 2972 m_state = QCAMERA_SM_STATE_RECORDING; 2973 result.status = rc; 2974 result.request_api = evt; 2975 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2976 m_parent->signalAPIResult(&result); 2977 } 2978 break; 2979 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 2980 { 2981 int32_t faceID = 0; 2982 qcamera_sm_evt_reg_face_payload_t *reg_payload = 2983 (qcamera_sm_evt_reg_face_payload_t *)payload; 2984 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 2985 reg_payload->config, 2986 faceID); 2987 result.status = rc; 2988 result.request_api = evt; 2989 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 2990 result.handle = faceID; 2991 m_parent->signalAPIResult(&result); 2992 } 2993 break; 2994 case QCAMERA_SM_EVT_STOP_PREVIEW: 2995 { 2996 rc = m_parent->cancelLiveSnapshot(); 2997 m_state = QCAMERA_SM_STATE_RECORDING; 2998 2999 rc = m_parent->stopRecording(); 3000 m_state = QCAMERA_SM_STATE_PREVIEWING; 3001 3002 rc = m_parent->stopPreview(); 3003 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 3004 3005 result.status = rc; 3006 result.request_api = evt; 3007 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3008 m_parent->signalAPIResult(&result); 3009 } 3010 break; 3011 case QCAMERA_SM_EVT_PRE_START_RECORDING: 3012 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 3013 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 3014 case QCAMERA_SM_EVT_START_RECORDING: 3015 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 3016 case QCAMERA_SM_EVT_START_PREVIEW: 3017 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 3018 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 3019 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 3020 case QCAMERA_SM_EVT_TAKE_PICTURE: 3021 case QCAMERA_SM_EVT_RELEASE: 3022 { 3023 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 3024 rc = INVALID_OPERATION; 3025 result.status = rc; 3026 result.request_api = evt; 3027 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3028 m_parent->signalAPIResult(&result); 3029 } 3030 break; 3031 case QCAMERA_SM_EVT_EVT_INTERNAL: 3032 { 3033 qcamera_sm_internal_evt_payload_t *internal_evt = 3034 (qcamera_sm_internal_evt_payload_t *)payload; 3035 switch (internal_evt->evt_type) { 3036 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 3037 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 3038 break; 3039 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 3040 break; 3041 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 3042 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 3043 break; 3044 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 3045 rc = m_parent->processHistogramStats(internal_evt->stats_data); 3046 break; 3047 case QCAMERA_INTERNAL_EVT_CROP_INFO: 3048 rc = m_parent->processZoomEvent(internal_evt->crop_data); 3049 break; 3050 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 3051 rc = m_parent->processASDUpdate(internal_evt->asd_data); 3052 break; 3053 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 3054 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 3055 break; 3056 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 3057 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 3058 break; 3059 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 3060 rc = m_parent->processAEInfo(internal_evt->ae_data); 3061 break; 3062 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 3063 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 3064 break; 3065 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 3066 rc = m_parent->processHDRData(internal_evt->hdr_data); 3067 break; 3068 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 3069 rc = m_parent->processRetroAECUnlock(); 3070 break; 3071 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 3072 rc = m_parent->processZSLCaptureDone(); 3073 break; 3074 default: 3075 break; 3076 } 3077 } 3078 break; 3079 case QCAMERA_SM_EVT_EVT_NOTIFY: 3080 { 3081 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 3082 switch (cam_evt->server_event_type) { 3083 case CAM_EVENT_TYPE_DAEMON_DIED: 3084 { 3085 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 3086 CAMERA_ERROR_SERVER_DIED, 3087 0); 3088 } 3089 break; 3090 default: 3091 LOGE("Invalid internal event %d in state(%d)", 3092 cam_evt->server_event_type, m_state); 3093 break; 3094 } 3095 } 3096 break; 3097 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 3098 { 3099 qcamera_jpeg_evt_payload_t *jpeg_job = 3100 (qcamera_jpeg_evt_payload_t *)payload; 3101 rc = m_parent->processJpegNotify(jpeg_job); 3102 } 3103 break; 3104 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 3105 { 3106 rc = m_parent->cancelLiveSnapshot(); 3107 m_state = QCAMERA_SM_STATE_RECORDING; 3108 result.status = rc; 3109 result.request_api = evt; 3110 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3111 m_parent->signalEvtResult(&result); 3112 } 3113 break; 3114 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 3115 { 3116 rc = m_parent->updateThermalLevel(payload); 3117 } 3118 break; 3119 default: 3120 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 3121 break; 3122 } 3123 3124 return rc; 3125 } 3126 3127 /*=========================================================================== 3128 * FUNCTION : procEvtPreviewPicTakingState 3129 * 3130 * DESCRIPTION: finite state machine function to handle event in state of 3131 * QCAMERA_SM_STATE_PREVIEW_PIC_TAKING. 3132 * 3133 * PARAMETERS : 3134 * @evt : event to be processed 3135 * @payload : event payload. Can be NULL if not needed. 3136 * 3137 * RETURN : int32_t type of status 3138 * NO_ERROR -- success 3139 * none-zero failure code 3140 *==========================================================================*/ 3141 int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt, 3142 void *payload) 3143 { 3144 int32_t rc = NO_ERROR; 3145 qcamera_api_result_t result; 3146 memset(&result, 0, sizeof(qcamera_api_result_t)); 3147 3148 LOGL("event (%d)", evt); 3149 switch (evt) { 3150 case QCAMERA_SM_EVT_SET_CALLBACKS: 3151 { 3152 qcamera_sm_evt_setcb_payload_t *setcbs = 3153 (qcamera_sm_evt_setcb_payload_t *)payload; 3154 rc = m_parent->setCallBacks(setcbs->notify_cb, 3155 setcbs->data_cb, 3156 setcbs->data_cb_timestamp, 3157 setcbs->get_memory, 3158 setcbs->user); 3159 result.status = rc; 3160 result.request_api = evt; 3161 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3162 m_parent->signalAPIResult(&result); 3163 } 3164 break; 3165 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 3166 { 3167 rc = m_parent->enableMsgType(*((int32_t *)payload)); 3168 result.status = rc; 3169 result.request_api = evt; 3170 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3171 m_parent->signalAPIResult(&result); 3172 } 3173 break; 3174 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 3175 { 3176 rc = m_parent->disableMsgType(*((int32_t *)payload)); 3177 result.status = rc; 3178 result.request_api = evt; 3179 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3180 m_parent->signalAPIResult(&result); 3181 } 3182 break; 3183 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 3184 { 3185 int enabled = m_parent->msgTypeEnabled(*((int32_t *)payload)); 3186 result.status = rc; 3187 result.request_api = evt; 3188 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 3189 result.enabled = enabled; 3190 m_parent->signalAPIResult(&result); 3191 } 3192 break; 3193 case QCAMERA_SM_EVT_SET_PARAMS: 3194 { 3195 bool needRestart = false; 3196 rc = m_parent->updateParameters((char*)payload, needRestart); 3197 result.status = rc; 3198 result.request_api = evt; 3199 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3200 m_parent->signalAPIResult(&result); 3201 } 3202 break; 3203 case QCAMERA_SM_EVT_SET_PARAMS_STOP: 3204 { 3205 // need restart preview for parameters to take effect 3206 LOGD("Stopping preview..."); 3207 // stop preview 3208 rc = m_parent->stopPreview(); 3209 // Clear memory pools 3210 m_parent->m_memoryPool.clear(); 3211 result.status = rc; 3212 result.request_api = evt; 3213 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3214 m_parent->signalAPIResult(&result); 3215 } 3216 break; 3217 case QCAMERA_SM_EVT_SET_PARAMS_COMMIT: 3218 { 3219 // commit parameter changes to server 3220 rc = m_parent->commitParameterChanges(); 3221 result.status = rc; 3222 result.request_api = evt; 3223 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3224 m_parent->signalAPIResult(&result); 3225 } 3226 break; 3227 case QCAMERA_SM_EVT_SET_PARAMS_RESTART: 3228 { 3229 // start preview again 3230 rc = m_parent->preparePreview(); 3231 if (rc == NO_ERROR) { 3232 applyDelayedMsgs(); 3233 rc = m_parent->startPreview(); 3234 if (rc != NO_ERROR) { 3235 m_parent->unpreparePreview(); 3236 } 3237 } 3238 if (rc != NO_ERROR) { 3239 m_state = QCAMERA_SM_STATE_PIC_TAKING; 3240 } 3241 m_parent->setNeedRestart(false); 3242 result.status = rc; 3243 result.request_api = evt; 3244 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3245 m_parent->signalAPIResult(&result); 3246 } 3247 break; 3248 case QCAMERA_SM_EVT_GET_PARAMS: 3249 { 3250 result.params = m_parent->getParameters(); 3251 rc = result.params ? NO_ERROR : UNKNOWN_ERROR; 3252 result.status = rc; 3253 result.request_api = evt; 3254 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 3255 m_parent->signalAPIResult(&result); 3256 } 3257 break; 3258 case QCAMERA_SM_EVT_PUT_PARAMS: 3259 { 3260 rc = m_parent->putParameters((char*)payload); 3261 result.status = rc; 3262 result.request_api = evt; 3263 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3264 m_parent->signalAPIResult(&result); 3265 } 3266 break; 3267 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 3268 { 3269 rc = NO_ERROR; 3270 result.status = rc; 3271 result.request_api = evt; 3272 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 3273 result.enabled = 1; 3274 m_parent->signalAPIResult(&result); 3275 } 3276 break; 3277 case QCAMERA_SM_EVT_RECORDING_ENABLED: 3278 { 3279 rc = NO_ERROR; 3280 result.status = rc; 3281 result.request_api = evt; 3282 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 3283 result.enabled = 0; 3284 m_parent->signalAPIResult(&result); 3285 } 3286 break; 3287 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 3288 { 3289 rc = m_parent->storeMetaDataInBuffers(*((int *)payload)); 3290 result.status = rc; 3291 result.request_api = evt; 3292 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3293 m_parent->signalAPIResult(&result); 3294 } 3295 break; 3296 case QCAMERA_SM_EVT_DUMP: 3297 { 3298 rc = m_parent->dump(*((int *)payload)); 3299 result.status = rc; 3300 result.request_api = evt; 3301 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3302 m_parent->signalAPIResult(&result); 3303 } 3304 break; 3305 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 3306 { 3307 rc = m_parent->autoFocus(); 3308 result.status = rc; 3309 result.request_api = evt; 3310 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3311 m_parent->signalAPIResult(&result); 3312 } 3313 break; 3314 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 3315 { 3316 rc = m_parent->cancelAutoFocus(); 3317 result.status = rc; 3318 result.request_api = evt; 3319 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3320 m_parent->signalAPIResult(&result); 3321 } 3322 break; 3323 case QCAMERA_SM_EVT_SEND_COMMAND: 3324 { 3325 qcamera_sm_evt_command_payload_t *cmd_payload = 3326 (qcamera_sm_evt_command_payload_t *)payload; 3327 rc = m_parent->sendCommand(cmd_payload->cmd, 3328 cmd_payload->arg1, 3329 cmd_payload->arg2); 3330 #ifndef VANILLA_HAL 3331 if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) { 3332 // move state to previewing state 3333 m_state = QCAMERA_SM_STATE_PREVIEWING; 3334 } 3335 #endif 3336 result.status = rc; 3337 result.request_api = evt; 3338 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3339 m_parent->signalAPIResult(&result); 3340 } 3341 break; 3342 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 3343 { 3344 rc = m_parent->releaseRecordingFrame((const void *)payload); 3345 result.status = rc; 3346 result.request_api = evt; 3347 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3348 m_parent->signalAPIResult(&result); 3349 } 3350 break; 3351 case QCAMERA_SM_EVT_CANCEL_PICTURE: 3352 { 3353 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) { 3354 rc = m_parent->cancelPicture(); 3355 } else { 3356 rc = m_parent->cancelLiveSnapshot(); 3357 } 3358 m_state = QCAMERA_SM_STATE_PREVIEWING; 3359 result.status = rc; 3360 result.request_api = evt; 3361 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3362 m_parent->signalAPIResult(&result); 3363 } 3364 break; 3365 case QCAMERA_SM_EVT_STOP_PREVIEW: 3366 { 3367 if (m_parent->isZSLMode()) { 3368 // cancel picture first 3369 rc = m_parent->cancelPicture(); 3370 m_parent->stopChannel(QCAMERA_CH_TYPE_ZSL); 3371 } else if (m_parent->isLongshotEnabled()) { 3372 // just cancel picture 3373 rc = m_parent->cancelPicture(); 3374 } else { 3375 rc = m_parent->cancelLiveSnapshot(); 3376 m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW); 3377 } 3378 // unprepare preview 3379 m_parent->unpreparePreview(); 3380 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 3381 result.status = rc; 3382 result.request_api = evt; 3383 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3384 m_parent->signalAPIResult(&result); 3385 } 3386 break; 3387 case QCAMERA_SM_EVT_PRE_START_RECORDING: 3388 { 3389 if (m_parent->isZSLMode()) { 3390 LOGE("Error!! cannot handle evt(%d) in state(%d) in ZSL mode", evt, m_state); 3391 rc = INVALID_OPERATION; 3392 } else if (m_parent->isLongshotEnabled()) { 3393 LOGE("Error!! cannot handle evt(%d) in state(%d) in Longshot mode", evt, m_state); 3394 rc = INVALID_OPERATION; 3395 } else { 3396 rc = m_parent->preStartRecording(); 3397 } 3398 result.status = rc; 3399 result.request_api = evt; 3400 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3401 m_parent->signalAPIResult(&result); 3402 } 3403 break; 3404 case QCAMERA_SM_EVT_START_RECORDING: 3405 { 3406 if (m_parent->isZSLMode()) { 3407 LOGE("Error!! cannot handle evt(%d) in state(%d) in ZSL mode", 3408 evt, m_state); 3409 rc = INVALID_OPERATION; 3410 } else if (m_parent->isLongshotEnabled()) { 3411 LOGE("Error!! cannot handle evt(%d) in state(%d) in Longshot mode", 3412 evt, m_state); 3413 rc = INVALID_OPERATION; 3414 } else { 3415 rc = m_parent->startRecording(); 3416 if (rc == NO_ERROR) { 3417 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING; 3418 } 3419 } 3420 result.status = rc; 3421 result.request_api = evt; 3422 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3423 m_parent->signalAPIResult(&result); 3424 } 3425 break; 3426 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 3427 { 3428 int32_t faceID = 0; 3429 qcamera_sm_evt_reg_face_payload_t *reg_payload = 3430 (qcamera_sm_evt_reg_face_payload_t *)payload; 3431 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 3432 reg_payload->config, 3433 faceID); 3434 result.status = rc; 3435 result.request_api = evt; 3436 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 3437 result.handle = faceID; 3438 m_parent->signalAPIResult(&result); 3439 } 3440 break; 3441 case QCAMERA_SM_EVT_PRE_TAKE_PICTURE: 3442 { 3443 if ( m_parent->isLongshotEnabled() ) { 3444 // no ops here, need to singal NO_ERROR 3445 rc = NO_ERROR; 3446 } else { 3447 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 3448 rc = INVALID_OPERATION; 3449 } 3450 3451 result.status = rc; 3452 result.request_api = evt; 3453 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3454 m_parent->signalAPIResult(&result); 3455 } 3456 break; 3457 case QCAMERA_SM_EVT_TAKE_PICTURE: 3458 { 3459 if ( m_parent->isLongshotEnabled() ) { 3460 rc = m_parent->longShot(); 3461 } else { 3462 LOGE("Error!! cannot handle evt(%d) in state(%d)", evt, m_state); 3463 rc = INVALID_OPERATION; 3464 } 3465 3466 result.status = rc; 3467 result.request_api = evt; 3468 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3469 m_parent->signalAPIResult(&result); 3470 } 3471 break; 3472 3473 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 3474 { 3475 LOGD("Prepare Snapshot"); 3476 if (m_parent->isRetroPicture()) { 3477 LOGD("Prepare Snapshot in Retro Mode"); 3478 rc = m_parent->prepareHardwareForSnapshot(FALSE); 3479 if (rc != NO_ERROR) { 3480 LOGE("prepareHardwareForSnapshot failed %d", 3481 rc); 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 } 3488 else { 3489 LOGE("Error!! cannot handle evt(%d) in state(%d)", 3490 evt, m_state); 3491 rc = INVALID_OPERATION; 3492 result.status = rc; 3493 result.request_api = evt; 3494 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3495 m_parent->signalAPIResult(&result); 3496 } 3497 } 3498 break; 3499 case QCAMERA_SM_EVT_STOP_RECORDING: 3500 case QCAMERA_SM_EVT_PREPARE_PREVIEW: 3501 case QCAMERA_SM_EVT_START_PREVIEW: 3502 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 3503 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 3504 case QCAMERA_SM_EVT_RELEASE: 3505 { 3506 LOGE("Error!! cannot handle evt(%d) in state(%d)", 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 break; 3514 case QCAMERA_SM_EVT_EVT_INTERNAL: 3515 { 3516 qcamera_sm_internal_evt_payload_t *internal_evt = 3517 (qcamera_sm_internal_evt_payload_t *)payload; 3518 switch (internal_evt->evt_type) { 3519 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 3520 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 3521 break; 3522 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 3523 LOGD("Received QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE event"); 3524 if (m_parent->isRetroPicture()) { 3525 m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state); 3526 LOGD("Retro picture"); 3527 result.status = NO_ERROR; 3528 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 3529 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3530 m_parent->signalAPIResult(&result); 3531 } 3532 else { 3533 LOGE("Invalid Case for " 3534 "QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT event"); 3535 } 3536 break; 3537 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT: 3538 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data); 3539 break; 3540 case QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT: 3541 // This is valid only in Retro picture Mode 3542 if (m_parent->isRetroPicture()) { 3543 LOGD("Received QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT event"); 3544 result.status = NO_ERROR; 3545 result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE; 3546 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3547 m_parent->signalAPIResult(&result); 3548 } 3549 else { 3550 LOGD("Wrong Case for QCAMERA_INTERNAL_EVT_READY_FOR_SNAPSHOT event"); 3551 } 3552 break; 3553 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS: 3554 rc = m_parent->processHistogramStats(internal_evt->stats_data); 3555 break; 3556 case QCAMERA_INTERNAL_EVT_CROP_INFO: 3557 rc = m_parent->processZoomEvent(internal_evt->crop_data); 3558 break; 3559 case QCAMERA_INTERNAL_EVT_ASD_UPDATE: 3560 rc = m_parent->processASDUpdate(internal_evt->asd_data); 3561 break; 3562 case QCAMERA_INTERNAL_EVT_LED_MODE_OVERRIDE: 3563 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 3564 break; 3565 case QCAMERA_INTERNAL_EVT_AWB_UPDATE: 3566 rc = m_parent->transAwbMetaToParams(internal_evt->awb_data); 3567 break; 3568 case QCAMERA_INTERNAL_EVT_AE_UPDATE: 3569 rc = m_parent->processAEInfo(internal_evt->ae_data); 3570 break; 3571 case QCAMERA_INTERNAL_EVT_FOCUS_POS_UPDATE: 3572 rc = m_parent->processFocusPositionInfo(internal_evt->focus_pos); 3573 break; 3574 case QCAMERA_INTERNAL_EVT_HDR_UPDATE: 3575 rc = m_parent->processHDRData(internal_evt->hdr_data); 3576 break; 3577 case QCAMERA_INTERNAL_EVT_RETRO_AEC_UNLOCK: 3578 rc = m_parent->processRetroAECUnlock(); 3579 break; 3580 case QCAMERA_INTERNAL_EVT_ZSL_CAPTURE_DONE: 3581 rc = m_parent->processZSLCaptureDone(); 3582 break; 3583 default: 3584 break; 3585 } 3586 } 3587 break; 3588 case QCAMERA_SM_EVT_EVT_NOTIFY: 3589 { 3590 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 3591 switch (cam_evt->server_event_type) { 3592 case CAM_EVENT_TYPE_DAEMON_DIED: 3593 { 3594 // Send internal events to stop indefinite wait on prepare 3595 // snapshot done event. 3596 result.status = rc; 3597 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 3598 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3599 m_parent->signalAPIResult(&result); 3600 3601 result.status = rc; 3602 result.request_api = QCAMERA_SM_EVT_TAKE_PICTURE; 3603 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3604 m_parent->signalAPIResult(&result); 3605 3606 m_parent->sendEvtNotify(CAMERA_MSG_ERROR, 3607 CAMERA_ERROR_SERVER_DIED, 3608 0); 3609 } 3610 break; 3611 case CAM_EVENT_TYPE_CAC_DONE: 3612 if (m_parent->isCACEnabled() || m_parent->mParameters.isOEMFeatEnabled()) { 3613 LOGD("[LONG_SHOT_DBG] : Received CAC Done"); 3614 if ((m_parent->isLongshotEnabled()) 3615 && (!m_parent->isCaptureShutterEnabled())) { 3616 // play shutter sound for longshot 3617 // after CAC stage is done 3618 m_parent->playShutter(); 3619 } 3620 m_parent->mCACDoneReceived = TRUE; 3621 } 3622 break; 3623 default: 3624 LOGE("Invalid internal event %d in state(%d)", 3625 cam_evt->server_event_type, m_state); 3626 break; 3627 } 3628 } 3629 break; 3630 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 3631 { 3632 LOGL("Calling Process Jpeg Notify"); 3633 qcamera_jpeg_evt_payload_t *jpeg_job = 3634 (qcamera_jpeg_evt_payload_t *)payload; 3635 rc = m_parent->processJpegNotify(jpeg_job); 3636 } 3637 break; 3638 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 3639 { 3640 LOGL("Snapshot Done"); 3641 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) { 3642 rc = m_parent->cancelPicture(); 3643 } else { 3644 rc = m_parent->cancelLiveSnapshot(); 3645 } 3646 m_state = QCAMERA_SM_STATE_PREVIEWING; 3647 if (m_parent->isRetroPicture()){ 3648 result.status = rc; 3649 result.request_api = evt; 3650 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3651 LOGL("\n Signalling for JPEG snapshot done!!"); 3652 m_parent->signalAPIResult(&result); 3653 3654 } 3655 result.status = rc; 3656 result.request_api = evt; 3657 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3658 m_parent->signalEvtResult(&result); 3659 } 3660 break; 3661 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 3662 { 3663 rc = m_parent->updateThermalLevel(payload); 3664 } 3665 break; 3666 case QCAMERA_SM_EVT_RESTART_STOP_PREVIEW: 3667 { 3668 m_parent->stopPreview(); 3669 result.status = rc; 3670 result.request_api = evt; 3671 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3672 m_parent->signalAPIResult(&result); 3673 } 3674 break; 3675 case QCAMERA_SM_EVT_RESTART_START_PREVIEW: 3676 { 3677 rc = m_parent->preparePreview(); 3678 if (rc == NO_ERROR) { 3679 rc = m_parent->startPreview(); 3680 } 3681 result.status = rc; 3682 result.request_api = evt; 3683 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 3684 m_parent->signalAPIResult(&result); 3685 } 3686 break; 3687 default: 3688 LOGW("Cannot handle evt(%d) in state(%d)", evt, m_state); 3689 break; 3690 } 3691 3692 return rc; 3693 } 3694 3695 /*=========================================================================== 3696 * FUNCTION : isRecording 3697 * 3698 * DESCRIPTION: check if recording is in process. 3699 * 3700 * PARAMETERS : None 3701 * 3702 * RETURN : true -- recording 3703 * false -- not in recording mode 3704 *==========================================================================*/ 3705 bool QCameraStateMachine::isRecording() 3706 { 3707 switch (m_state) { 3708 case QCAMERA_SM_STATE_RECORDING: 3709 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 3710 return true; 3711 default: 3712 return false; 3713 } 3714 } 3715 3716 /*=========================================================================== 3717 * FUNCTION : isPreviewRunning 3718 * 3719 * DESCRIPTION: check if preview is in process. 3720 * 3721 * PARAMETERS : None 3722 * 3723 * RETURN : true -- preview running 3724 * false -- preview stopped 3725 *==========================================================================*/ 3726 bool QCameraStateMachine::isPreviewRunning() 3727 { 3728 switch (m_state) { 3729 case QCAMERA_SM_STATE_PREVIEWING: 3730 case QCAMERA_SM_STATE_RECORDING: 3731 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 3732 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING: 3733 case QCAMERA_SM_STATE_PREPARE_SNAPSHOT: 3734 case QCAMERA_SM_STATE_PREVIEW_READY: 3735 return true; 3736 default: 3737 return false; 3738 } 3739 } 3740 3741 /*=========================================================================== 3742 * FUNCTION : isPreviewReady 3743 * 3744 * DESCRIPTION: check if preview is in ready state. 3745 * 3746 * PARAMETERS : None 3747 * 3748 * RETURN : true -- preview is in ready state 3749 * false -- preview is stopped 3750 *==========================================================================*/ 3751 bool QCameraStateMachine::isPreviewReady() 3752 { 3753 switch (m_state) { 3754 case QCAMERA_SM_STATE_PREVIEW_READY: 3755 return true; 3756 default: 3757 return false; 3758 } 3759 } 3760 3761 /*=========================================================================== 3762 * FUNCTION : isCaptureRunning 3763 * 3764 * DESCRIPTION: check if image capture is in process. 3765 * 3766 * PARAMETERS : None 3767 * 3768 * RETURN : true -- capture running 3769 * false -- capture stopped 3770 *==========================================================================*/ 3771 bool QCameraStateMachine::isCaptureRunning() 3772 { 3773 switch (m_state) { 3774 case QCAMERA_SM_STATE_PIC_TAKING: 3775 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 3776 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING: 3777 return true; 3778 default: 3779 return false; 3780 } 3781 } 3782 /*=========================================================================== 3783 * FUNCTION : isNonZSLCaptureRunning 3784 * 3785 * DESCRIPTION: check if image capture is in process in non ZSL mode. 3786 * 3787 * PARAMETERS : None 3788 * 3789 * RETURN : true -- capture running in non ZSL mode 3790 * false -- Either in not capture mode or captur is not in non ZSL mode 3791 *==========================================================================*/ 3792 bool QCameraStateMachine::isNonZSLCaptureRunning() 3793 { 3794 switch (m_state) { 3795 case QCAMERA_SM_STATE_PIC_TAKING: 3796 return true; 3797 default: 3798 return false; 3799 } 3800 } 3801 3802 /*=========================================================================== 3803 * FUNCTION : dump 3804 * 3805 * DESCRIPTION: Composes a string based on current configuration 3806 * 3807 * PARAMETERS : none 3808 * 3809 * RETURN : Formatted string 3810 *==========================================================================*/ 3811 String8 QCameraStateMachine::dump() 3812 { 3813 String8 str("\n"); 3814 char s[128]; 3815 3816 snprintf(s, 128, "Is Preview Running: %d\n", isPreviewRunning()); 3817 str += s; 3818 3819 snprintf(s, 128, "Is Capture Running: %d\n", isCaptureRunning()); 3820 str += s; 3821 3822 snprintf(s, 128, "Is Non ZSL Capture Running: %d\n", 3823 isNonZSLCaptureRunning()); 3824 str += s; 3825 3826 snprintf(s, 128, "Current State: %d \n", m_state); 3827 str += s; 3828 3829 switch(m_state){ 3830 case QCAMERA_SM_STATE_PREVIEW_STOPPED: 3831 snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEW_STOPPED \n"); 3832 break; 3833 3834 case QCAMERA_SM_STATE_PREVIEW_READY: 3835 snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEW_READY \n"); 3836 break; 3837 3838 case QCAMERA_SM_STATE_PREVIEWING: 3839 snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEWING \n"); 3840 break; 3841 3842 case QCAMERA_SM_STATE_PREPARE_SNAPSHOT: 3843 snprintf(s, 128, " QCAMERA_SM_STATE_PREPARE_SNAPSHOT \n"); 3844 break; 3845 3846 case QCAMERA_SM_STATE_PIC_TAKING: 3847 snprintf(s, 128, " QCAMERA_SM_STATE_PIC_TAKING \n"); 3848 break; 3849 3850 case QCAMERA_SM_STATE_RECORDING: 3851 snprintf(s, 128, " QCAMERA_SM_STATE_RECORDING \n"); 3852 break; 3853 3854 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 3855 snprintf(s, 128, " QCAMERA_SM_STATE_VIDEO_PIC_TAKING \n"); 3856 break; 3857 3858 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING: 3859 snprintf(s, 128, " QCAMERA_SM_STATE_PREVIEW_PIC_TAKING \n"); 3860 break; 3861 } 3862 str += s; 3863 3864 return str; 3865 } 3866 3867 }; // namespace qcamera 3868
