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