QCameraStateMachine.cpp revision 6f83d735d8e3b918da42e6b559fcd0efb78133e5
1/* Copyright (c) 2012-2013, 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 36namespace 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 *==========================================================================*/ 49void *QCameraStateMachine::smEvtProcRoutine(void *data) 50{ 51 int running = 1, ret; 52 QCameraStateMachine *pme = (QCameraStateMachine *)data; 53 54 ALOGD("%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 ALOGD("%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 *==========================================================================*/ 110QCameraStateMachine::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} 123 124/*=========================================================================== 125 * FUNCTION : ~QCameraStateMachine 126 * 127 * DESCRIPTION: desctructor of QCameraStateMachine. Will stop process thread. 128 * 129 * PARAMETERS : none 130 * 131 * RETURN : none 132 *==========================================================================*/ 133QCameraStateMachine::~QCameraStateMachine() 134{ 135 if (cmd_pid != 0) { 136 qcamera_sm_cmd_t *node = 137 (qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t)); 138 if (NULL != node) { 139 memset(node, 0, sizeof(qcamera_sm_cmd_t)); 140 node->cmd = QCAMERA_SM_CMD_TYPE_EXIT; 141 142 api_queue.enqueue((void *)node); 143 cam_sem_post(&cmd_sem); 144 145 /* wait until cmd thread exits */ 146 if (pthread_join(cmd_pid, NULL) != 0) { 147 ALOGD("%s: pthread dead already\n", __func__); 148 } 149 } 150 cmd_pid = 0; 151 } 152 cam_sem_destroy(&cmd_sem); 153} 154 155/*=========================================================================== 156 * FUNCTION : procAPI 157 * 158 * DESCRIPTION: process incoming API request from framework layer. 159 * 160 * PARAMETERS : 161 * @evt : event to be processed 162 * @api_payload : API payload. Can be NULL if not needed. 163 * 164 * RETURN : int32_t type of status 165 * NO_ERROR -- success 166 * none-zero failure code 167 *==========================================================================*/ 168int32_t QCameraStateMachine::procAPI(qcamera_sm_evt_enum_t evt, 169 void *api_payload) 170{ 171 qcamera_sm_cmd_t *node = 172 (qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t)); 173 if (NULL == node) { 174 ALOGE("%s: No memory for qcamera_sm_cmd_t", __func__); 175 return NO_MEMORY; 176 } 177 178 memset(node, 0, sizeof(qcamera_sm_cmd_t)); 179 node->cmd = QCAMERA_SM_CMD_TYPE_API; 180 node->evt = evt; 181 node->evt_payload = api_payload; 182 if (api_queue.enqueue((void *)node)) { 183 cam_sem_post(&cmd_sem); 184 return NO_ERROR; 185 } else { 186 free(node); 187 return UNKNOWN_ERROR; 188 } 189} 190 191/*=========================================================================== 192 * FUNCTION : procEvt 193 * 194 * DESCRIPTION: process incoming envent from mm-camera-interface and 195 * mm-jpeg-interface. 196 * 197 * PARAMETERS : 198 * @evt : event to be processed 199 * @evt_payload : event payload. Can be NULL if not needed. 200 * 201 * RETURN : int32_t type of status 202 * NO_ERROR -- success 203 * none-zero failure code 204 *==========================================================================*/ 205int32_t QCameraStateMachine::procEvt(qcamera_sm_evt_enum_t evt, 206 void *evt_payload) 207{ 208 qcamera_sm_cmd_t *node = 209 (qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t)); 210 if (NULL == node) { 211 ALOGE("%s: No memory for qcamera_sm_cmd_t", __func__); 212 return NO_MEMORY; 213 } 214 215 memset(node, 0, sizeof(qcamera_sm_cmd_t)); 216 node->cmd = QCAMERA_SM_CMD_TYPE_EVT; 217 node->evt = evt; 218 node->evt_payload = evt_payload; 219 if (evt_queue.enqueue((void *)node)) { 220 cam_sem_post(&cmd_sem); 221 return NO_ERROR; 222 } else { 223 free(node); 224 return UNKNOWN_ERROR; 225 } 226} 227 228/*=========================================================================== 229 * FUNCTION : stateMachine 230 * 231 * DESCRIPTION: finite state machine entry function. Depends on state, 232 * incoming event will be handled differently. 233 * 234 * PARAMETERS : 235 * @evt : event to be processed 236 * @payload : event payload. Can be NULL if not needed. 237 * 238 * RETURN : int32_t type of status 239 * NO_ERROR -- success 240 * none-zero failure code 241 *==========================================================================*/ 242int32_t QCameraStateMachine::stateMachine(qcamera_sm_evt_enum_t evt, void *payload) 243{ 244 int32_t rc = NO_ERROR; 245 switch (m_state) { 246 case QCAMERA_SM_STATE_PREVIEW_STOPPED: 247 rc = procEvtPreviewStoppedState(evt, payload); 248 break; 249 case QCAMERA_SM_STATE_PREVIEW_READY: 250 rc = procEvtPreviewReadyState(evt, payload); 251 break; 252 case QCAMERA_SM_STATE_PREVIEWING: 253 rc = procEvtPreviewingState(evt, payload); 254 break; 255 case QCAMERA_SM_STATE_PREPARE_SNAPSHOT: 256 rc = procEvtPrepareSnapshotState(evt, payload); 257 break; 258 case QCAMERA_SM_STATE_PIC_TAKING: 259 rc = procEvtPicTakingState(evt, payload); 260 break; 261 case QCAMERA_SM_STATE_RECORDING: 262 rc = procEvtRecordingState(evt, payload); 263 break; 264 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 265 rc = procEvtVideoPicTakingState(evt, payload); 266 break; 267 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING: 268 rc = procEvtPreviewPicTakingState(evt, payload); 269 break; 270 default: 271 break; 272 } 273 274 return rc; 275} 276 277/*=========================================================================== 278 * FUNCTION : procEvtPreviewStoppedState 279 * 280 * DESCRIPTION: finite state machine function to handle event in state of 281 * QCAMERA_SM_STATE_PREVIEW_STOPPED. 282 * 283 * PARAMETERS : 284 * @evt : event to be processed 285 * @payload : event payload. Can be NULL if not needed. 286 * 287 * RETURN : int32_t type of status 288 * NO_ERROR -- success 289 * none-zero failure code 290 *==========================================================================*/ 291int32_t QCameraStateMachine::procEvtPreviewStoppedState(qcamera_sm_evt_enum_t evt, 292 void *payload) 293{ 294 int32_t rc = NO_ERROR; 295 qcamera_api_result_t result; 296 memset(&result, 0, sizeof(qcamera_api_result_t)); 297 298 switch (evt) { 299 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 300 { 301 rc = m_parent->setPreviewWindow((struct preview_stream_ops *)payload); 302 result.status = rc; 303 result.request_api = evt; 304 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 305 m_parent->signalAPIResult(&result); 306 } 307 break; 308 case QCAMERA_SM_EVT_SET_CALLBACKS: 309 { 310 qcamera_sm_evt_setcb_payload_t *setcbs = 311 (qcamera_sm_evt_setcb_payload_t *)payload; 312 rc = m_parent->setCallBacks(setcbs->notify_cb, 313 setcbs->data_cb, 314 setcbs->data_cb_timestamp, 315 setcbs->get_memory, 316 setcbs->user); 317 result.status = rc; 318 result.request_api = evt; 319 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 320 m_parent->signalAPIResult(&result); 321 } 322 break; 323 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 324 { 325 rc = m_parent->enableMsgType(int32_t(payload)); 326 result.status = rc; 327 result.request_api = evt; 328 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 329 m_parent->signalAPIResult(&result); 330 } 331 break; 332 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 333 { 334 rc = m_parent->disableMsgType(int32_t(payload)); 335 result.status = rc; 336 result.request_api = evt; 337 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 338 m_parent->signalAPIResult(&result); 339 } 340 break; 341 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 342 { 343 int enabled = m_parent->msgTypeEnabled(int32_t(payload)); 344 result.status = rc; 345 result.request_api = evt; 346 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 347 result.enabled = enabled; 348 m_parent->signalAPIResult(&result); 349 } 350 break; 351 case QCAMERA_SM_EVT_SET_PARAMS: 352 { 353 bool needRestart = false; 354 rc = m_parent->updateParameters((char*)payload, needRestart); 355 if (rc == NO_ERROR) { 356 rc = m_parent->commitParameterChanges(); 357 } 358 result.status = rc; 359 result.request_api = evt; 360 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 361 m_parent->signalAPIResult(&result); 362 } 363 break; 364 case QCAMERA_SM_EVT_GET_PARAMS: 365 { 366 result.params = m_parent->getParameters(); 367 rc = NO_ERROR; 368 result.status = rc; 369 result.request_api = evt; 370 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 371 m_parent->signalAPIResult(&result); 372 } 373 break; 374 case QCAMERA_SM_EVT_PUT_PARAMS: 375 { 376 rc = m_parent->putParameters((char*)payload); 377 result.status = rc; 378 result.request_api = evt; 379 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 380 m_parent->signalAPIResult(&result); 381 } 382 break; 383 case QCAMERA_SM_EVT_START_PREVIEW: 384 { 385 if (m_parent->mPreviewWindow == NULL) { 386 rc = m_parent->preparePreview(); 387 if(rc == NO_ERROR) { 388 // preview window is not set yet, move to previewReady state 389 m_state = QCAMERA_SM_STATE_PREVIEW_READY; 390 } else { 391 ALOGE("%s: preparePreview failed",__func__); 392 } 393 } else { 394 rc = m_parent->preparePreview(); 395 if (rc == NO_ERROR) { 396 rc = m_parent->startPreview(); 397 if (rc != NO_ERROR) { 398 m_parent->unpreparePreview(); 399 } else { 400 // start preview success, move to previewing state 401 m_state = QCAMERA_SM_STATE_PREVIEWING; 402 } 403 } 404 } 405 result.status = rc; 406 result.request_api = evt; 407 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 408 m_parent->signalAPIResult(&result); 409 } 410 break; 411 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 412 { 413 rc = m_parent->preparePreview(); 414 if (rc == NO_ERROR) { 415 rc = m_parent->startPreview(); 416 if (rc != NO_ERROR) { 417 m_parent->unpreparePreview(); 418 } else { 419 m_state = QCAMERA_SM_STATE_PREVIEWING; 420 } 421 } 422 result.status = rc; 423 result.request_api = evt; 424 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 425 m_parent->signalAPIResult(&result); 426 } 427 break; 428 case QCAMERA_SM_EVT_STOP_PREVIEW: 429 { 430 // no op needed here 431 ALOGD("%s: already in preview stopped state, do nothing", __func__); 432 result.status = NO_ERROR; 433 result.request_api = evt; 434 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 435 m_parent->signalAPIResult(&result); 436 } 437 break; 438 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 439 case QCAMERA_SM_EVT_RECORDING_ENABLED: 440 { 441 result.status = NO_ERROR; 442 result.request_api = evt; 443 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 444 result.enabled = 0; 445 m_parent->signalAPIResult(&result); 446 } 447 break; 448 case QCAMERA_SM_EVT_RELEASE: 449 { 450 rc = m_parent->release(); 451 result.status = rc; 452 result.request_api = evt; 453 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 454 m_parent->signalAPIResult(&result); 455 } 456 break; 457 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 458 { 459 rc = m_parent->storeMetaDataInBuffers(int(payload)); 460 result.status = rc; 461 result.request_api = evt; 462 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 463 m_parent->signalAPIResult(&result); 464 } 465 break; 466 case QCAMERA_SM_EVT_DUMP: 467 { 468 rc = m_parent->dump((int)payload); 469 result.status = rc; 470 result.request_api = evt; 471 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 472 m_parent->signalAPIResult(&result); 473 } 474 break; 475 case QCAMERA_SM_EVT_SEND_COMMAND: 476 { 477 qcamera_sm_evt_command_payload_t *cmd_payload = 478 (qcamera_sm_evt_command_payload_t *)payload; 479 rc = m_parent->sendCommand(cmd_payload->cmd, 480 cmd_payload->arg1, 481 cmd_payload->arg2); 482 result.status = rc; 483 result.request_api = evt; 484 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 485 m_parent->signalAPIResult(&result); 486 } 487 break; 488 case QCAMERA_SM_EVT_START_RECORDING: 489 case QCAMERA_SM_EVT_STOP_RECORDING: 490 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 491 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 492 case QCAMERA_SM_EVT_TAKE_PICTURE: 493 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 494 { 495 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 496 rc = INVALID_OPERATION; 497 result.status = rc; 498 result.request_api = evt; 499 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 500 m_parent->signalAPIResult(&result); 501 } 502 break; 503 case QCAMERA_SM_EVT_CANCEL_PICTURE: 504 { 505 // no op needed here 506 ALOGD("%s: No ops for evt(%d) in state(%d)", __func__, evt, m_state); 507 result.status = NO_ERROR; 508 result.request_api = evt; 509 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 510 m_parent->signalAPIResult(&result); 511 } 512 break; 513 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 514 { 515 rc = m_parent->cancelAutoFocus(); 516 result.status = rc; 517 result.request_api = evt; 518 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 519 m_parent->signalAPIResult(&result); 520 } 521 break; 522 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 523 { 524 int32_t faceID = 0; 525 qcamera_sm_evt_reg_face_payload_t *reg_payload = 526 (qcamera_sm_evt_reg_face_payload_t *)payload; 527 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 528 reg_payload->config, 529 faceID); 530 result.status = rc; 531 result.request_api = evt; 532 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 533 result.handle = faceID; 534 m_parent->signalAPIResult(&result); 535 } 536 break; 537 case QCAMERA_SM_EVT_EVT_INTERNAL: 538 case QCAMERA_SM_EVT_EVT_NOTIFY: 539 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 540 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 541 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 542 default: 543 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 544 break; 545 } 546 547 return rc; 548} 549 550/*=========================================================================== 551 * FUNCTION : procEvtPreviewReadyState 552 * 553 * DESCRIPTION: finite state machine function to handle event in state of 554 * QCAMERA_SM_STATE_PREVIEW_READY. 555 * 556 * PARAMETERS : 557 * @evt : event to be processed 558 * @payload : event payload. Can be NULL if not needed. 559 * 560 * RETURN : int32_t type of status 561 * NO_ERROR -- success 562 * none-zero failure code 563 *==========================================================================*/ 564int32_t QCameraStateMachine::procEvtPreviewReadyState(qcamera_sm_evt_enum_t evt, 565 void *payload) 566{ 567 int32_t rc = NO_ERROR; 568 qcamera_api_result_t result; 569 memset(&result, 0, sizeof(qcamera_api_result_t)); 570 571 switch (evt) { 572 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 573 { 574 m_parent->setPreviewWindow((struct preview_stream_ops *)payload); 575 if (m_parent->mPreviewWindow != NULL) { 576 rc = m_parent->startPreview(); 577 if (rc != NO_ERROR) { 578 m_parent->unpreparePreview(); 579 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 580 } else { 581 m_state = QCAMERA_SM_STATE_PREVIEWING; 582 } 583 } 584 585 result.status = rc; 586 result.request_api = evt; 587 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 588 m_parent->signalAPIResult(&result); 589 } 590 break; 591 case QCAMERA_SM_EVT_SET_CALLBACKS: 592 { 593 qcamera_sm_evt_setcb_payload_t *setcbs = 594 (qcamera_sm_evt_setcb_payload_t *)payload; 595 rc = m_parent->setCallBacks(setcbs->notify_cb, 596 setcbs->data_cb, 597 setcbs->data_cb_timestamp, 598 setcbs->get_memory, 599 setcbs->user); 600 result.status = rc; 601 result.request_api = evt; 602 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 603 m_parent->signalAPIResult(&result); 604 } 605 break; 606 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 607 { 608 rc = m_parent->enableMsgType(int32_t(payload)); 609 result.status = rc; 610 result.request_api = evt; 611 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 612 m_parent->signalAPIResult(&result); 613 } 614 break; 615 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 616 { 617 rc = m_parent->disableMsgType(int32_t(payload)); 618 result.status = rc; 619 result.request_api = evt; 620 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 621 m_parent->signalAPIResult(&result); 622 } 623 break; 624 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 625 { 626 int enabled = m_parent->msgTypeEnabled(int32_t(payload)); 627 result.status = rc; 628 result.request_api = evt; 629 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 630 result.enabled = enabled; 631 m_parent->signalAPIResult(&result); 632 } 633 break; 634 case QCAMERA_SM_EVT_SET_PARAMS: 635 { 636 bool needRestart = false; 637 rc = m_parent->updateParameters((char*)payload, needRestart); 638 if (rc == NO_ERROR) { 639 if (needRestart) { 640 // need restart preview for parameters to take effect 641 m_parent->unpreparePreview(); 642 // commit parameter changes to server 643 m_parent->commitParameterChanges(); 644 // prepare preview again 645 rc = m_parent->preparePreview(); 646 if (rc != NO_ERROR) { 647 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 648 } 649 } else { 650 rc = m_parent->commitParameterChanges(); 651 } 652 } 653 654 result.status = rc; 655 result.request_api = evt; 656 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 657 m_parent->signalAPIResult(&result); 658 } 659 break; 660 case QCAMERA_SM_EVT_GET_PARAMS: 661 { 662 result.params = m_parent->getParameters(); 663 rc = NO_ERROR; 664 result.status = rc; 665 result.request_api = evt; 666 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 667 m_parent->signalAPIResult(&result); 668 } 669 break; 670 case QCAMERA_SM_EVT_PUT_PARAMS: 671 { 672 rc = m_parent->putParameters((char*)payload); 673 result.status = rc; 674 result.request_api = evt; 675 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 676 m_parent->signalAPIResult(&result); 677 } 678 break; 679 case QCAMERA_SM_EVT_START_PREVIEW: 680 { 681 // no ops here 682 rc = NO_ERROR; 683 result.status = rc; 684 result.request_api = evt; 685 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 686 m_parent->signalAPIResult(&result); 687 } 688 break; 689 case QCAMERA_SM_EVT_STOP_PREVIEW: 690 { 691 m_parent->unpreparePreview(); 692 rc = 0; 693 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 694 result.status = rc; 695 result.request_api = evt; 696 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 697 m_parent->signalAPIResult(&result); 698 } 699 break; 700 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 701 { 702 rc = NO_ERROR; 703 result.status = rc; 704 result.request_api = evt; 705 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 706 result.enabled = 1; 707 m_parent->signalAPIResult(&result); 708 } 709 break; 710 case QCAMERA_SM_EVT_RECORDING_ENABLED: 711 { 712 rc = 0; 713 result.status = rc; 714 result.request_api = evt; 715 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 716 result.enabled = 0; 717 m_parent->signalAPIResult(&result); 718 } 719 break; 720 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 721 { 722 rc = m_parent->storeMetaDataInBuffers(int(payload)); 723 result.status = rc; 724 result.request_api = evt; 725 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 726 m_parent->signalAPIResult(&result); 727 } 728 break; 729 case QCAMERA_SM_EVT_DUMP: 730 { 731 rc = m_parent->dump((int)payload); 732 result.status = rc; 733 result.request_api = evt; 734 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 735 m_parent->signalAPIResult(&result); 736 } 737 break; 738 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 739 { 740 rc = m_parent->autoFocus(); 741 result.status = rc; 742 result.request_api = evt; 743 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 744 m_parent->signalAPIResult(&result); 745 } 746 break; 747 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 748 { 749 rc = m_parent->cancelAutoFocus(); 750 result.status = rc; 751 result.request_api = evt; 752 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 753 m_parent->signalAPIResult(&result); 754 } 755 break; 756 case QCAMERA_SM_EVT_SEND_COMMAND: 757 { 758 qcamera_sm_evt_command_payload_t *cmd_payload = 759 (qcamera_sm_evt_command_payload_t *)payload; 760 rc = m_parent->sendCommand(cmd_payload->cmd, 761 cmd_payload->arg1, 762 cmd_payload->arg2); 763 result.status = rc; 764 result.request_api = evt; 765 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 766 m_parent->signalAPIResult(&result); 767 } 768 break; 769 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 770 { 771 int32_t faceID = 0; 772 qcamera_sm_evt_reg_face_payload_t *reg_payload = 773 (qcamera_sm_evt_reg_face_payload_t *)payload; 774 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 775 reg_payload->config, 776 faceID); 777 result.status = rc; 778 result.request_api = evt; 779 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 780 result.handle = faceID; 781 m_parent->signalAPIResult(&result); 782 } 783 break; 784 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 785 case QCAMERA_SM_EVT_START_RECORDING: 786 case QCAMERA_SM_EVT_STOP_RECORDING: 787 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 788 case QCAMERA_SM_EVT_TAKE_PICTURE: 789 case QCAMERA_SM_EVT_CANCEL_PICTURE: 790 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 791 case QCAMERA_SM_EVT_RELEASE: 792 { 793 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 794 rc = INVALID_OPERATION; 795 result.status = rc; 796 result.request_api = evt; 797 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 798 m_parent->signalAPIResult(&result); 799 } 800 break; 801 case QCAMERA_SM_EVT_EVT_INTERNAL: 802 case QCAMERA_SM_EVT_EVT_NOTIFY: 803 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 804 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 805 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 806 default: 807 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 808 break; 809 } 810 811 return rc; 812} 813 814/*=========================================================================== 815 * FUNCTION : procEvtPreviewingState 816 * 817 * DESCRIPTION: finite state machine function to handle event in state of 818 * QCAMERA_SM_STATE_PREVIEWING. 819 * 820 * PARAMETERS : 821 * @evt : event to be processed 822 * @payload : event payload. Can be NULL if not needed. 823 * 824 * RETURN : int32_t type of status 825 * NO_ERROR -- success 826 * none-zero failure code 827 *==========================================================================*/ 828int32_t QCameraStateMachine::procEvtPreviewingState(qcamera_sm_evt_enum_t evt, 829 void *payload) 830{ 831 int32_t rc = NO_ERROR; 832 qcamera_api_result_t result; 833 memset(&result, 0, sizeof(qcamera_api_result_t)); 834 835 switch (evt) { 836 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 837 { 838 // Error setting preview window during previewing 839 ALOGE("Cannot set preview window when preview is running"); 840 rc = INVALID_OPERATION; 841 result.status = rc; 842 result.request_api = evt; 843 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 844 m_parent->signalAPIResult(&result); 845 } 846 break; 847 case QCAMERA_SM_EVT_SET_CALLBACKS: 848 { 849 qcamera_sm_evt_setcb_payload_t *setcbs = 850 (qcamera_sm_evt_setcb_payload_t *)payload; 851 rc = m_parent->setCallBacks(setcbs->notify_cb, 852 setcbs->data_cb, 853 setcbs->data_cb_timestamp, 854 setcbs->get_memory, 855 setcbs->user); 856 result.status = rc; 857 result.request_api = evt; 858 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 859 m_parent->signalAPIResult(&result); 860 } 861 break; 862 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 863 { 864 rc = m_parent->enableMsgType(int32_t(payload)); 865 result.status = rc; 866 result.request_api = evt; 867 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 868 m_parent->signalAPIResult(&result); 869 } 870 break; 871 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 872 { 873 rc = m_parent->disableMsgType(int32_t(payload)); 874 result.status = rc; 875 result.request_api = evt; 876 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 877 m_parent->signalAPIResult(&result); 878 } 879 break; 880 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 881 { 882 int enabled = m_parent->msgTypeEnabled(int32_t(payload)); 883 result.status = rc; 884 result.request_api = evt; 885 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 886 result.enabled = enabled; 887 m_parent->signalAPIResult(&result); 888 } 889 break; 890 case QCAMERA_SM_EVT_SET_PARAMS: 891 { 892 bool needRestart = false; 893 rc = m_parent->updateParameters((char*)payload, needRestart); 894 if (rc == NO_ERROR) { 895 if (needRestart) { 896 // need restart preview for parameters to take effect 897 // stop preview 898 m_parent->stopPreview(); 899 // commit parameter changes to server 900 m_parent->commitParameterChanges(); 901 // start preview again 902 rc = m_parent->preparePreview(); 903 if (rc == NO_ERROR) { 904 rc = m_parent->startPreview(); 905 if (rc != NO_ERROR) { 906 m_parent->unpreparePreview(); 907 } 908 } 909 if (rc != NO_ERROR) { 910 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 911 } 912 } else { 913 rc = m_parent->commitParameterChanges(); 914 } 915 } 916 result.status = rc; 917 result.request_api = evt; 918 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 919 m_parent->signalAPIResult(&result); 920 } 921 break; 922 case QCAMERA_SM_EVT_GET_PARAMS: 923 { 924 result.params = m_parent->getParameters(); 925 rc = NO_ERROR; 926 result.status = rc; 927 result.request_api = evt; 928 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 929 m_parent->signalAPIResult(&result); 930 } 931 break; 932 case QCAMERA_SM_EVT_PUT_PARAMS: 933 { 934 rc = m_parent->putParameters((char*)payload); 935 result.status = rc; 936 result.request_api = evt; 937 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 938 m_parent->signalAPIResult(&result); 939 } 940 break; 941 case QCAMERA_SM_EVT_START_PREVIEW: 942 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 943 { 944 // no ops here 945 ALOGD("%s: Already in previewing, no ops here to start preview", __func__); 946 rc = NO_ERROR; 947 result.status = rc; 948 result.request_api = evt; 949 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 950 m_parent->signalAPIResult(&result); 951 } 952 break; 953 case QCAMERA_SM_EVT_STOP_PREVIEW: 954 { 955 rc = m_parent->stopPreview(); 956 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 957 result.status = rc; 958 result.request_api = evt; 959 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 960 m_parent->signalAPIResult(&result); 961 } 962 break; 963 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 964 { 965 rc = NO_ERROR; 966 result.status = rc; 967 result.request_api = evt; 968 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 969 result.enabled = 1; 970 m_parent->signalAPIResult(&result); 971 } 972 break; 973 case QCAMERA_SM_EVT_RECORDING_ENABLED: 974 { 975 rc = NO_ERROR; 976 result.status = rc; 977 result.request_api = evt; 978 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 979 result.enabled = 0; 980 m_parent->signalAPIResult(&result); 981 } 982 break; 983 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 984 { 985 rc = m_parent->storeMetaDataInBuffers(int(payload)); 986 result.status = rc; 987 result.request_api = evt; 988 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 989 m_parent->signalAPIResult(&result); 990 } 991 break; 992 case QCAMERA_SM_EVT_DUMP: 993 { 994 rc = m_parent->dump((int)payload); 995 result.status = rc; 996 result.request_api = evt; 997 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 998 m_parent->signalAPIResult(&result); 999 } 1000 break; 1001 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 1002 { 1003 rc = m_parent->autoFocus(); 1004 result.status = rc; 1005 result.request_api = evt; 1006 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1007 m_parent->signalAPIResult(&result); 1008 } 1009 break; 1010 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 1011 { 1012 rc = m_parent->cancelAutoFocus(); 1013 result.status = rc; 1014 result.request_api = evt; 1015 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1016 m_parent->signalAPIResult(&result); 1017 } 1018 break; 1019 case QCAMERA_SM_EVT_START_RECORDING: 1020 { 1021 rc = m_parent->startRecording(); 1022 if (rc == NO_ERROR) { 1023 // move state to recording state 1024 m_state = QCAMERA_SM_STATE_RECORDING; 1025 } 1026 result.status = rc; 1027 result.request_api = evt; 1028 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1029 m_parent->signalAPIResult(&result); 1030 } 1031 break; 1032 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 1033 { 1034 rc = m_parent->prepareHardwareForSnapshot(FALSE); 1035 if (rc == NO_ERROR) { 1036 // Do not signal API result in this case. 1037 // Need to wait for snapshot done in metadta. 1038 m_state = QCAMERA_SM_STATE_PREPARE_SNAPSHOT; 1039 } else { 1040 // Do not change state in this case. 1041 ALOGE("%s: prepareHardwareForSnapshot failed %d", 1042 __func__, rc); 1043 1044 result.status = rc; 1045 result.request_api = evt; 1046 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1047 m_parent->signalAPIResult(&result); 1048 } 1049 } 1050 break; 1051 case QCAMERA_SM_EVT_TAKE_PICTURE: 1052 { 1053 rc = m_parent->takePicture(); 1054 if (rc == NO_ERROR) { 1055 // move state to picture taking state 1056 if (m_parent->isZSLMode()) { 1057 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING; 1058 } else { 1059 m_state = QCAMERA_SM_STATE_PIC_TAKING; 1060 } 1061 } else { 1062 // move state to preview stopped state 1063 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 1064 } 1065 result.status = rc; 1066 result.request_api = evt; 1067 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1068 m_parent->signalAPIResult(&result); 1069 } 1070 break; 1071 case QCAMERA_SM_EVT_SEND_COMMAND: 1072 { 1073 qcamera_sm_evt_command_payload_t *cmd_payload = 1074 (qcamera_sm_evt_command_payload_t *)payload; 1075 rc = m_parent->sendCommand(cmd_payload->cmd, 1076 cmd_payload->arg1, 1077 cmd_payload->arg2); 1078 result.status = rc; 1079 result.request_api = evt; 1080 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1081 m_parent->signalAPIResult(&result); 1082 } 1083 break; 1084 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 1085 { 1086 int32_t faceID = 0; 1087 qcamera_sm_evt_reg_face_payload_t *reg_payload = 1088 (qcamera_sm_evt_reg_face_payload_t *)payload; 1089 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 1090 reg_payload->config, 1091 faceID); 1092 result.status = rc; 1093 result.request_api = evt; 1094 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 1095 result.handle = faceID; 1096 m_parent->signalAPIResult(&result); 1097 } 1098 break; 1099 case QCAMERA_SM_EVT_CANCEL_PICTURE: 1100 case QCAMERA_SM_EVT_STOP_RECORDING: 1101 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 1102 case QCAMERA_SM_EVT_RELEASE: 1103 { 1104 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 1105 rc = INVALID_OPERATION; 1106 result.status = rc; 1107 result.request_api = evt; 1108 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1109 m_parent->signalAPIResult(&result); 1110 } 1111 break; 1112 case QCAMERA_SM_EVT_EVT_INTERNAL: 1113 { 1114 qcamera_sm_internal_evt_payload_t *internal_evt = 1115 (qcamera_sm_internal_evt_payload_t *)payload; 1116 switch (internal_evt->evt_type) { 1117 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 1118 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 1119 break; 1120 default: 1121 ALOGE("%s: Invalid internal event %d in state(%d)", 1122 __func__, internal_evt->evt_type, m_state); 1123 break; 1124 } 1125 } 1126 break; 1127 case QCAMERA_SM_EVT_EVT_NOTIFY: 1128 { 1129 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 1130 switch (cam_evt->server_event_type) { 1131 default: 1132 ALOGD("%s: no handling for server evt (%d) at this state", 1133 __func__, cam_evt->server_event_type); 1134 break; 1135 } 1136 } 1137 break; 1138 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 1139 { 1140 rc = m_parent->updateThermalLevel( 1141 *(qcamera_thermal_level_enum_t *)&payload); 1142 } 1143 break; 1144 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 1145 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 1146 default: 1147 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 1148 break; 1149 } 1150 1151 return rc; 1152} 1153 1154/*=========================================================================== 1155 * FUNCTION : procEvtPrepareSnapshotState 1156 * 1157 * DESCRIPTION: finite state machine function to handle event in state of 1158 * QCAMERA_SM_STATE_PREPARE_SNAPSHOT. 1159 * 1160 * PARAMETERS : 1161 * @evt : event to be processed 1162 * @payload : event payload. Can be NULL if not needed. 1163 * 1164 * RETURN : int32_t type of status 1165 * NO_ERROR -- success 1166 * none-zero failure code 1167 *==========================================================================*/ 1168int32_t QCameraStateMachine::procEvtPrepareSnapshotState(qcamera_sm_evt_enum_t evt, 1169 void *payload) 1170{ 1171 int32_t rc = NO_ERROR; 1172 qcamera_api_result_t result; 1173 memset(&result, 0, sizeof(qcamera_api_result_t)); 1174 1175 switch (evt) { 1176 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 1177 case QCAMERA_SM_EVT_SET_CALLBACKS: 1178 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 1179 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 1180 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 1181 case QCAMERA_SM_EVT_SET_PARAMS: 1182 case QCAMERA_SM_EVT_GET_PARAMS: 1183 case QCAMERA_SM_EVT_PUT_PARAMS: 1184 case QCAMERA_SM_EVT_START_PREVIEW: 1185 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 1186 case QCAMERA_SM_EVT_STOP_PREVIEW: 1187 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 1188 case QCAMERA_SM_EVT_RECORDING_ENABLED: 1189 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 1190 case QCAMERA_SM_EVT_DUMP: 1191 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 1192 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 1193 case QCAMERA_SM_EVT_START_RECORDING: 1194 case QCAMERA_SM_EVT_TAKE_PICTURE: 1195 case QCAMERA_SM_EVT_SEND_COMMAND: 1196 case QCAMERA_SM_EVT_CANCEL_PICTURE: 1197 case QCAMERA_SM_EVT_STOP_RECORDING: 1198 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 1199 case QCAMERA_SM_EVT_RELEASE: 1200 { 1201 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 1202 rc = INVALID_OPERATION; 1203 result.status = rc; 1204 result.request_api = evt; 1205 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1206 m_parent->signalAPIResult(&result); 1207 } 1208 break; 1209 case QCAMERA_SM_EVT_EVT_INTERNAL: 1210 { 1211 qcamera_sm_internal_evt_payload_t *internal_evt = 1212 (qcamera_sm_internal_evt_payload_t *)payload; 1213 switch (internal_evt->evt_type) { 1214 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE: 1215 ALOGI("%s: Received QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE event", 1216 __func__); 1217 m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state); 1218 m_state = QCAMERA_SM_STATE_PREVIEWING; 1219 1220 result.status = NO_ERROR; 1221 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT; 1222 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1223 m_parent->signalAPIResult(&result); 1224 break; 1225 default: 1226 ALOGE("%s: Invalid internal event %d in state(%d)", 1227 __func__, internal_evt->evt_type, m_state); 1228 break; 1229 } 1230 } 1231 break; 1232 case QCAMERA_SM_EVT_EVT_NOTIFY: 1233 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 1234 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 1235 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 1236 default: 1237 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 1238 break; 1239 } 1240 1241 return rc; 1242} 1243 1244/*=========================================================================== 1245 * FUNCTION : procEvtPicTakingState 1246 * 1247 * DESCRIPTION: finite state machine function to handle event in state of 1248 * QCAMERA_SM_STATE_PIC_TAKING. 1249 * 1250 * PARAMETERS : 1251 * @evt : event to be processed 1252 * @payload : event payload. Can be NULL if not needed. 1253 * 1254 * RETURN : int32_t type of status 1255 * NO_ERROR -- success 1256 * none-zero failure code 1257 *==========================================================================*/ 1258int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt, 1259 void *payload) 1260{ 1261 int32_t rc = NO_ERROR; 1262 qcamera_api_result_t result; 1263 memset(&result, 0, sizeof(qcamera_api_result_t)); 1264 1265 switch (evt) { 1266 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 1267 { 1268 // Error setting preview window during previewing 1269 ALOGE("Cannot set preview window when preview is running"); 1270 rc = INVALID_OPERATION; 1271 result.status = rc; 1272 result.request_api = evt; 1273 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1274 m_parent->signalAPIResult(&result); 1275 } 1276 break; 1277 case QCAMERA_SM_EVT_SET_CALLBACKS: 1278 { 1279 qcamera_sm_evt_setcb_payload_t *setcbs = 1280 (qcamera_sm_evt_setcb_payload_t *)payload; 1281 rc = m_parent->setCallBacks(setcbs->notify_cb, 1282 setcbs->data_cb, 1283 setcbs->data_cb_timestamp, 1284 setcbs->get_memory, 1285 setcbs->user); 1286 result.status = rc; 1287 result.request_api = evt; 1288 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1289 m_parent->signalAPIResult(&result); 1290 } 1291 break; 1292 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 1293 { 1294 rc = m_parent->enableMsgType(int32_t(payload)); 1295 result.status = rc; 1296 result.request_api = evt; 1297 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1298 m_parent->signalAPIResult(&result); 1299 } 1300 break; 1301 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 1302 { 1303 rc = m_parent->disableMsgType(int32_t(payload)); 1304 result.status = rc; 1305 result.request_api = evt; 1306 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1307 m_parent->signalAPIResult(&result); 1308 } 1309 break; 1310 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 1311 { 1312 int enabled = m_parent->msgTypeEnabled(int32_t(payload)); 1313 result.status = rc; 1314 result.request_api = evt; 1315 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1316 result.enabled = enabled; 1317 m_parent->signalAPIResult(&result); 1318 } 1319 break; 1320 case QCAMERA_SM_EVT_SET_PARAMS: 1321 { 1322 bool needRestart = false; 1323 rc = m_parent->updateParameters((char*)payload, needRestart); 1324 if (rc == NO_ERROR) { 1325 rc = m_parent->commitParameterChanges(); 1326 } 1327 result.status = rc; 1328 result.request_api = evt; 1329 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1330 m_parent->signalAPIResult(&result); 1331 } 1332 break; 1333 case QCAMERA_SM_EVT_GET_PARAMS: 1334 { 1335 result.params = m_parent->getParameters(); 1336 rc = NO_ERROR; 1337 result.status = rc; 1338 result.request_api = evt; 1339 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 1340 m_parent->signalAPIResult(&result); 1341 } 1342 break; 1343 case QCAMERA_SM_EVT_PUT_PARAMS: 1344 { 1345 rc = m_parent->putParameters((char*)payload); 1346 result.status = rc; 1347 result.request_api = evt; 1348 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1349 m_parent->signalAPIResult(&result); 1350 } 1351 break; 1352 case QCAMERA_SM_EVT_STOP_PREVIEW: 1353 { 1354 // cancel picture first 1355 rc = m_parent->cancelPicture(); 1356 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 1357 1358 result.status = rc; 1359 result.request_api = evt; 1360 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1361 m_parent->signalAPIResult(&result); 1362 } 1363 break; 1364 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 1365 { 1366 rc = NO_ERROR; 1367 result.status = rc; 1368 result.request_api = evt; 1369 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1370 result.enabled = 0; 1371 m_parent->signalAPIResult(&result); 1372 } 1373 break; 1374 case QCAMERA_SM_EVT_RECORDING_ENABLED: 1375 { 1376 rc = NO_ERROR; 1377 result.status = rc; 1378 result.request_api = evt; 1379 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1380 result.enabled = 0; 1381 m_parent->signalAPIResult(&result); 1382 } 1383 break; 1384 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 1385 { 1386 rc = m_parent->storeMetaDataInBuffers(int(payload)); 1387 result.status = rc; 1388 result.request_api = evt; 1389 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1390 m_parent->signalAPIResult(&result); 1391 } 1392 break; 1393 case QCAMERA_SM_EVT_DUMP: 1394 { 1395 rc = m_parent->dump((int)payload); 1396 result.status = rc; 1397 result.request_api = evt; 1398 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1399 m_parent->signalAPIResult(&result); 1400 } 1401 break; 1402 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 1403 { 1404 rc = m_parent->autoFocus(); 1405 result.status = rc; 1406 result.request_api = evt; 1407 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1408 m_parent->signalAPIResult(&result); 1409 } 1410 break; 1411 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 1412 { 1413 rc = m_parent->cancelAutoFocus(); 1414 result.status = rc; 1415 result.request_api = evt; 1416 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1417 m_parent->signalAPIResult(&result); 1418 } 1419 break; 1420 case QCAMERA_SM_EVT_SEND_COMMAND: 1421 { 1422 qcamera_sm_evt_command_payload_t *cmd_payload = 1423 (qcamera_sm_evt_command_payload_t *)payload; 1424 rc = m_parent->sendCommand(cmd_payload->cmd, 1425 cmd_payload->arg1, 1426 cmd_payload->arg2); 1427 result.status = rc; 1428 result.request_api = evt; 1429 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1430 m_parent->signalAPIResult(&result); 1431 } 1432 break; 1433 case QCAMERA_SM_EVT_CANCEL_PICTURE: 1434 { 1435 rc = m_parent->cancelPicture(); 1436 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 1437 result.status = rc; 1438 result.request_api = evt; 1439 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1440 m_parent->signalAPIResult(&result); 1441 } 1442 break; 1443 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 1444 { 1445 int32_t faceID = 0; 1446 qcamera_sm_evt_reg_face_payload_t *reg_payload = 1447 (qcamera_sm_evt_reg_face_payload_t *)payload; 1448 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 1449 reg_payload->config, 1450 faceID); 1451 result.status = rc; 1452 result.request_api = evt; 1453 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 1454 result.handle = faceID; 1455 m_parent->signalAPIResult(&result); 1456 } 1457 break; 1458 case QCAMERA_SM_EVT_TAKE_PICTURE: 1459 case QCAMERA_SM_EVT_START_RECORDING: 1460 case QCAMERA_SM_EVT_STOP_RECORDING: 1461 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 1462 case QCAMERA_SM_EVT_START_PREVIEW: 1463 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 1464 case QCAMERA_SM_EVT_RELEASE: 1465 { 1466 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 1467 rc = INVALID_OPERATION; 1468 result.status = rc; 1469 result.request_api = evt; 1470 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1471 m_parent->signalAPIResult(&result); 1472 } 1473 break; 1474 case QCAMERA_SM_EVT_EVT_INTERNAL: 1475 { 1476 qcamera_sm_internal_evt_payload_t *internal_evt = 1477 (qcamera_sm_internal_evt_payload_t *)payload; 1478 switch (internal_evt->evt_type) { 1479 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 1480 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 1481 break; 1482 default: 1483 break; 1484 } 1485 } 1486 break; 1487 case QCAMERA_SM_EVT_EVT_NOTIFY: 1488 { 1489 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 1490 switch (cam_evt->server_event_type) { 1491 default: 1492 ALOGD("%s: no handling for server evt (%d) at this state", 1493 __func__, cam_evt->server_event_type); 1494 break; 1495 } 1496 } 1497 break; 1498 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 1499 { 1500 qcamera_jpeg_evt_payload_t *jpeg_job = 1501 (qcamera_jpeg_evt_payload_t *)payload; 1502 rc = m_parent->processJpegNotify(jpeg_job); 1503 } 1504 break; 1505 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 1506 { 1507 rc = m_parent->cancelPicture(); 1508 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 1509 } 1510 break; 1511 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 1512 default: 1513 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 1514 break; 1515 } 1516 1517 return rc; 1518} 1519 1520/*=========================================================================== 1521 * FUNCTION : procEvtRecordingState 1522 * 1523 * DESCRIPTION: finite state machine function to handle event in state of 1524 * QCAMERA_SM_STATE_RECORDING. 1525 * 1526 * PARAMETERS : 1527 * @evt : event to be processed 1528 * @payload : event payload. Can be NULL if not needed. 1529 * 1530 * RETURN : int32_t type of status 1531 * NO_ERROR -- success 1532 * none-zero failure code 1533 *==========================================================================*/ 1534int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt, 1535 void *payload) 1536{ 1537 int32_t rc = NO_ERROR; 1538 qcamera_api_result_t result; 1539 memset(&result, 0, sizeof(qcamera_api_result_t)); 1540 1541 switch (evt) { 1542 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 1543 { 1544 // Error setting preview window during previewing 1545 ALOGE("Cannot set preview window when preview is running"); 1546 rc = INVALID_OPERATION; 1547 result.status = rc; 1548 result.request_api = evt; 1549 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1550 m_parent->signalAPIResult(&result); 1551 } 1552 break; 1553 case QCAMERA_SM_EVT_SET_CALLBACKS: 1554 { 1555 qcamera_sm_evt_setcb_payload_t *setcbs = 1556 (qcamera_sm_evt_setcb_payload_t *)payload; 1557 rc = m_parent->setCallBacks(setcbs->notify_cb, 1558 setcbs->data_cb, 1559 setcbs->data_cb_timestamp, 1560 setcbs->get_memory, 1561 setcbs->user); 1562 result.status = rc; 1563 result.request_api = evt; 1564 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1565 m_parent->signalAPIResult(&result); 1566 } 1567 break; 1568 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 1569 { 1570 rc = m_parent->enableMsgType(int32_t(payload)); 1571 result.status = rc; 1572 result.request_api = evt; 1573 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1574 m_parent->signalAPIResult(&result); 1575 } 1576 break; 1577 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 1578 { 1579 rc = m_parent->disableMsgType(int32_t(payload)); 1580 result.status = rc; 1581 result.request_api = evt; 1582 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1583 m_parent->signalAPIResult(&result); 1584 } 1585 break; 1586 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 1587 { 1588 int enabled = m_parent->msgTypeEnabled(int32_t(payload)); 1589 result.status = rc; 1590 result.request_api = evt; 1591 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1592 result.enabled = enabled; 1593 m_parent->signalAPIResult(&result); 1594 } 1595 break; 1596 case QCAMERA_SM_EVT_SET_PARAMS: 1597 { 1598 bool needRestart = false; 1599 rc = m_parent->updateParameters((char*)payload, needRestart); 1600 if (rc == NO_ERROR) { 1601 if (needRestart) { 1602 // cannot set parameters that requires restart during recording 1603 ALOGE("%s: Cannot set parameters that requires restart during recording", 1604 __func__); 1605 rc = BAD_VALUE; 1606 } else { 1607 rc = m_parent->commitParameterChanges(); 1608 } 1609 } 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_GET_PARAMS: 1617 { 1618 result.params = m_parent->getParameters(); 1619 rc = NO_ERROR; 1620 result.status = rc; 1621 result.request_api = evt; 1622 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 1623 m_parent->signalAPIResult(&result); 1624 } 1625 break; 1626 case QCAMERA_SM_EVT_PUT_PARAMS: 1627 { 1628 rc = m_parent->putParameters((char*)payload); 1629 result.status = rc; 1630 result.request_api = evt; 1631 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1632 m_parent->signalAPIResult(&result); 1633 } 1634 break; 1635 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 1636 { 1637 rc = NO_ERROR; 1638 result.status = rc; 1639 result.request_api = evt; 1640 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1641 result.enabled = 0; 1642 m_parent->signalAPIResult(&result); 1643 } 1644 break; 1645 case QCAMERA_SM_EVT_RECORDING_ENABLED: 1646 { 1647 rc = NO_ERROR; 1648 result.status = rc; 1649 result.request_api = evt; 1650 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1651 result.enabled = 1; 1652 m_parent->signalAPIResult(&result); 1653 } 1654 break; 1655 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 1656 { 1657 rc = m_parent->storeMetaDataInBuffers(int(payload)); 1658 result.status = rc; 1659 result.request_api = evt; 1660 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1661 m_parent->signalAPIResult(&result); 1662 } 1663 break; 1664 case QCAMERA_SM_EVT_DUMP: 1665 { 1666 rc = m_parent->dump((int)payload); 1667 result.status = rc; 1668 result.request_api = evt; 1669 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1670 m_parent->signalAPIResult(&result); 1671 } 1672 break; 1673 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 1674 { 1675 rc = m_parent->autoFocus(); 1676 result.status = rc; 1677 result.request_api = evt; 1678 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1679 m_parent->signalAPIResult(&result); 1680 } 1681 break; 1682 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 1683 { 1684 rc = m_parent->cancelAutoFocus(); 1685 result.status = rc; 1686 result.request_api = evt; 1687 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1688 m_parent->signalAPIResult(&result); 1689 } 1690 break; 1691 case QCAMERA_SM_EVT_SEND_COMMAND: 1692 { 1693 qcamera_sm_evt_command_payload_t *cmd_payload = 1694 (qcamera_sm_evt_command_payload_t *)payload; 1695 rc = m_parent->sendCommand(cmd_payload->cmd, 1696 cmd_payload->arg1, 1697 cmd_payload->arg2); 1698 result.status = rc; 1699 result.request_api = evt; 1700 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1701 m_parent->signalAPIResult(&result); 1702 } 1703 break; 1704 case QCAMERA_SM_EVT_TAKE_PICTURE: 1705 { 1706 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING; 1707 rc = m_parent->takeLiveSnapshot(); 1708 if (rc != NO_ERROR) { 1709 m_state = QCAMERA_SM_STATE_RECORDING; 1710 } 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_START_RECORDING: 1718 { 1719 // no ops here 1720 ALOGD("%s: already in recording state, no ops for start_recording", __func__); 1721 rc = 0; 1722 result.status = rc; 1723 result.request_api = evt; 1724 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1725 m_parent->signalAPIResult(&result); 1726 } 1727 break; 1728 case QCAMERA_SM_EVT_STOP_RECORDING: 1729 { 1730 rc = m_parent->stopRecording(); 1731 m_state = QCAMERA_SM_STATE_PREVIEWING; 1732 result.status = rc; 1733 result.request_api = evt; 1734 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1735 m_parent->signalAPIResult(&result); 1736 } 1737 break; 1738 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 1739 { 1740 rc = m_parent->releaseRecordingFrame((const void *)payload); 1741 result.status = rc; 1742 result.request_api = evt; 1743 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1744 m_parent->signalAPIResult(&result); 1745 } 1746 break; 1747 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 1748 { 1749 int32_t faceID = 0; 1750 qcamera_sm_evt_reg_face_payload_t *reg_payload = 1751 (qcamera_sm_evt_reg_face_payload_t *)payload; 1752 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 1753 reg_payload->config, 1754 faceID); 1755 result.status = rc; 1756 result.request_api = evt; 1757 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 1758 result.handle = faceID; 1759 m_parent->signalAPIResult(&result); 1760 } 1761 break; 1762 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT: 1763 { 1764 //In Video snapshot, prepare hardware is a no-op. 1765 result.status = NO_ERROR; 1766 result.request_api = evt; 1767 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1768 m_parent->signalAPIResult(&result); 1769 } 1770 break; 1771 case QCAMERA_SM_EVT_CANCEL_PICTURE: 1772 case QCAMERA_SM_EVT_START_PREVIEW: 1773 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 1774 case QCAMERA_SM_EVT_STOP_PREVIEW: 1775 case QCAMERA_SM_EVT_RELEASE: 1776 { 1777 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 1778 rc = INVALID_OPERATION; 1779 result.status = rc; 1780 result.request_api = evt; 1781 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1782 m_parent->signalAPIResult(&result); 1783 } 1784 break; 1785 case QCAMERA_SM_EVT_EVT_INTERNAL: 1786 { 1787 qcamera_sm_internal_evt_payload_t *internal_evt = 1788 (qcamera_sm_internal_evt_payload_t *)payload; 1789 switch (internal_evt->evt_type) { 1790 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 1791 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 1792 break; 1793 default: 1794 break; 1795 } 1796 } 1797 break; 1798 case QCAMERA_SM_EVT_EVT_NOTIFY: 1799 { 1800 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 1801 switch (cam_evt->server_event_type) { 1802 default: 1803 ALOGD("%s: no handling for server evt (%d) at this state", 1804 __func__, cam_evt->server_event_type); 1805 break; 1806 } 1807 } 1808 break; 1809 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 1810 { 1811 rc = m_parent->updateThermalLevel( 1812 *(qcamera_thermal_level_enum_t *)&payload); 1813 } 1814 break; 1815 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 1816 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 1817 default: 1818 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 1819 break; 1820 } 1821 1822 return rc; 1823} 1824 1825/*=========================================================================== 1826 * FUNCTION : procEvtVideoPicTakingState 1827 * 1828 * DESCRIPTION: finite state machine function to handle event in state of 1829 * QCAMERA_SM_STATE_VIDEO_PIC_TAKING. 1830 * 1831 * PARAMETERS : 1832 * @evt : event to be processed 1833 * @payload : event payload. Can be NULL if not needed. 1834 * 1835 * RETURN : int32_t type of status 1836 * NO_ERROR -- success 1837 * none-zero failure code 1838 *==========================================================================*/ 1839int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt, 1840 void *payload) 1841{ 1842 int32_t rc = NO_ERROR; 1843 qcamera_api_result_t result; 1844 memset(&result, 0, sizeof(qcamera_api_result_t)); 1845 1846 switch (evt) { 1847 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 1848 { 1849 // Error setting preview window during previewing 1850 ALOGE("Cannot set preview window when preview is running"); 1851 rc = INVALID_OPERATION; 1852 result.status = rc; 1853 result.request_api = evt; 1854 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1855 m_parent->signalAPIResult(&result); 1856 } 1857 break; 1858 case QCAMERA_SM_EVT_SET_CALLBACKS: 1859 { 1860 qcamera_sm_evt_setcb_payload_t *setcbs = 1861 (qcamera_sm_evt_setcb_payload_t *)payload; 1862 rc = m_parent->setCallBacks(setcbs->notify_cb, 1863 setcbs->data_cb, 1864 setcbs->data_cb_timestamp, 1865 setcbs->get_memory, 1866 setcbs->user); 1867 result.status = rc; 1868 result.request_api = evt; 1869 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1870 m_parent->signalAPIResult(&result); 1871 } 1872 break; 1873 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 1874 { 1875 rc = m_parent->enableMsgType(int32_t(payload)); 1876 result.status = rc; 1877 result.request_api = evt; 1878 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1879 m_parent->signalAPIResult(&result); 1880 } 1881 break; 1882 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 1883 { 1884 rc = m_parent->disableMsgType(int32_t(payload)); 1885 result.status = rc; 1886 result.request_api = evt; 1887 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1888 m_parent->signalAPIResult(&result); 1889 } 1890 break; 1891 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 1892 { 1893 int enabled = m_parent->msgTypeEnabled(int32_t(payload)); 1894 result.status = rc; 1895 result.request_api = evt; 1896 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1897 result.enabled = enabled; 1898 m_parent->signalAPIResult(&result); 1899 } 1900 break; 1901 case QCAMERA_SM_EVT_SET_PARAMS: 1902 { 1903 bool needRestart = false; 1904 rc = m_parent->updateParameters((char*)payload, needRestart); 1905 if (rc == NO_ERROR) { 1906 if (needRestart) { 1907 // cannot set parameters that requires restart during recording 1908 ALOGE("%s: Cannot set parameters that requires restart during recording", 1909 __func__); 1910 rc = BAD_VALUE; 1911 } else { 1912 rc = m_parent->commitParameterChanges(); 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_GET_PARAMS: 1922 { 1923 result.params = m_parent->getParameters(); 1924 rc = NO_ERROR; 1925 result.status = rc; 1926 result.request_api = evt; 1927 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 1928 m_parent->signalAPIResult(&result); 1929 } 1930 break; 1931 case QCAMERA_SM_EVT_PUT_PARAMS: 1932 { 1933 rc = m_parent->putParameters((char*)payload); 1934 result.status = rc; 1935 result.request_api = evt; 1936 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1937 m_parent->signalAPIResult(&result); 1938 } 1939 break; 1940 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 1941 { 1942 rc = NO_ERROR; 1943 result.status = rc; 1944 result.request_api = evt; 1945 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1946 result.enabled = 1; 1947 m_parent->signalAPIResult(&result); 1948 } 1949 break; 1950 case QCAMERA_SM_EVT_RECORDING_ENABLED: 1951 { 1952 rc = NO_ERROR; 1953 result.status = rc; 1954 result.request_api = evt; 1955 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 1956 result.enabled = 1; 1957 m_parent->signalAPIResult(&result); 1958 } 1959 break; 1960 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 1961 { 1962 rc = m_parent->storeMetaDataInBuffers(int(payload)); 1963 result.status = rc; 1964 result.request_api = evt; 1965 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1966 m_parent->signalAPIResult(&result); 1967 } 1968 break; 1969 case QCAMERA_SM_EVT_DUMP: 1970 { 1971 rc = m_parent->dump((int)payload); 1972 result.status = rc; 1973 result.request_api = evt; 1974 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1975 m_parent->signalAPIResult(&result); 1976 } 1977 break; 1978 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 1979 { 1980 rc = m_parent->autoFocus(); 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_STOP_AUTO_FOCUS: 1988 { 1989 rc = m_parent->cancelAutoFocus(); 1990 result.status = rc; 1991 result.request_api = evt; 1992 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 1993 m_parent->signalAPIResult(&result); 1994 } 1995 break; 1996 case QCAMERA_SM_EVT_SEND_COMMAND: 1997 { 1998 qcamera_sm_evt_command_payload_t *cmd_payload = 1999 (qcamera_sm_evt_command_payload_t *)payload; 2000 rc = m_parent->sendCommand(cmd_payload->cmd, 2001 cmd_payload->arg1, 2002 cmd_payload->arg2); 2003 result.status = rc; 2004 result.request_api = evt; 2005 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2006 m_parent->signalAPIResult(&result); 2007 } 2008 break; 2009 case QCAMERA_SM_EVT_STOP_RECORDING: 2010 { 2011 rc = m_parent->stopRecording(); 2012 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING; 2013 result.status = rc; 2014 result.request_api = evt; 2015 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2016 m_parent->signalAPIResult(&result); 2017 } 2018 break; 2019 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 2020 { 2021 rc = m_parent->releaseRecordingFrame((const void *)payload); 2022 result.status = rc; 2023 result.request_api = evt; 2024 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2025 m_parent->signalAPIResult(&result); 2026 } 2027 break; 2028 case QCAMERA_SM_EVT_CANCEL_PICTURE: 2029 { 2030 rc = m_parent->cancelLiveSnapshot(); 2031 m_state = QCAMERA_SM_STATE_RECORDING; 2032 result.status = rc; 2033 result.request_api = evt; 2034 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2035 m_parent->signalAPIResult(&result); 2036 } 2037 break; 2038 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 2039 { 2040 int32_t faceID = 0; 2041 qcamera_sm_evt_reg_face_payload_t *reg_payload = 2042 (qcamera_sm_evt_reg_face_payload_t *)payload; 2043 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 2044 reg_payload->config, 2045 faceID); 2046 result.status = rc; 2047 result.request_api = evt; 2048 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 2049 result.handle = faceID; 2050 m_parent->signalAPIResult(&result); 2051 } 2052 break; 2053 case QCAMERA_SM_EVT_START_RECORDING: 2054 case QCAMERA_SM_EVT_START_PREVIEW: 2055 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 2056 case QCAMERA_SM_EVT_STOP_PREVIEW: 2057 case QCAMERA_SM_EVT_TAKE_PICTURE: 2058 case QCAMERA_SM_EVT_RELEASE: 2059 { 2060 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 2061 rc = INVALID_OPERATION; 2062 result.status = rc; 2063 result.request_api = evt; 2064 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2065 m_parent->signalAPIResult(&result); 2066 } 2067 break; 2068 case QCAMERA_SM_EVT_EVT_INTERNAL: 2069 { 2070 qcamera_sm_internal_evt_payload_t *internal_evt = 2071 (qcamera_sm_internal_evt_payload_t *)payload; 2072 switch (internal_evt->evt_type) { 2073 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 2074 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 2075 break; 2076 default: 2077 break; 2078 } 2079 } 2080 break; 2081 case QCAMERA_SM_EVT_EVT_NOTIFY: 2082 { 2083 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 2084 switch (cam_evt->server_event_type) { 2085 default: 2086 ALOGD("%s: no handling for server evt (%d) at this state", 2087 __func__, cam_evt->server_event_type); 2088 break; 2089 } 2090 } 2091 break; 2092 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 2093 { 2094 qcamera_jpeg_evt_payload_t *jpeg_job = 2095 (qcamera_jpeg_evt_payload_t *)payload; 2096 rc = m_parent->processJpegNotify(jpeg_job); 2097 } 2098 break; 2099 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 2100 { 2101 rc = m_parent->cancelLiveSnapshot(); 2102 m_state = QCAMERA_SM_STATE_RECORDING; 2103 } 2104 break; 2105 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 2106 { 2107 rc = m_parent->updateThermalLevel( 2108 *(qcamera_thermal_level_enum_t *)&payload); 2109 } 2110 break; 2111 default: 2112 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 2113 break; 2114 } 2115 2116 return rc; 2117} 2118 2119/*=========================================================================== 2120 * FUNCTION : procEvtPreviewPicTakingState 2121 * 2122 * DESCRIPTION: finite state machine function to handle event in state of 2123 * QCAMERA_SM_STATE_PREVIEW_PIC_TAKING. 2124 * 2125 * PARAMETERS : 2126 * @evt : event to be processed 2127 * @payload : event payload. Can be NULL if not needed. 2128 * 2129 * RETURN : int32_t type of status 2130 * NO_ERROR -- success 2131 * none-zero failure code 2132 *==========================================================================*/ 2133int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt, 2134 void *payload) 2135{ 2136 int32_t rc = NO_ERROR; 2137 qcamera_api_result_t result; 2138 memset(&result, 0, sizeof(qcamera_api_result_t)); 2139 2140 switch (evt) { 2141 case QCAMERA_SM_EVT_SET_CALLBACKS: 2142 { 2143 qcamera_sm_evt_setcb_payload_t *setcbs = 2144 (qcamera_sm_evt_setcb_payload_t *)payload; 2145 rc = m_parent->setCallBacks(setcbs->notify_cb, 2146 setcbs->data_cb, 2147 setcbs->data_cb_timestamp, 2148 setcbs->get_memory, 2149 setcbs->user); 2150 result.status = rc; 2151 result.request_api = evt; 2152 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2153 m_parent->signalAPIResult(&result); 2154 } 2155 break; 2156 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE: 2157 { 2158 rc = m_parent->enableMsgType(int32_t(payload)); 2159 result.status = rc; 2160 result.request_api = evt; 2161 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2162 m_parent->signalAPIResult(&result); 2163 } 2164 break; 2165 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE: 2166 { 2167 rc = m_parent->disableMsgType(int32_t(payload)); 2168 result.status = rc; 2169 result.request_api = evt; 2170 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2171 m_parent->signalAPIResult(&result); 2172 } 2173 break; 2174 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED: 2175 { 2176 int enabled = m_parent->msgTypeEnabled(int32_t(payload)); 2177 result.status = rc; 2178 result.request_api = evt; 2179 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2180 result.enabled = enabled; 2181 m_parent->signalAPIResult(&result); 2182 } 2183 break; 2184 case QCAMERA_SM_EVT_SET_PARAMS: 2185 { 2186 bool needRestart = false; 2187 rc = m_parent->updateParameters((char*)payload, needRestart); 2188 if (rc == NO_ERROR) { 2189 if (needRestart) { 2190 // need restart preview for parameters to take effect 2191 // stop preview 2192 m_parent->stopPreview(); 2193 // commit parameter changes to server 2194 m_parent->commitParameterChanges(); 2195 // start preview again 2196 rc = m_parent->preparePreview(); 2197 if (rc == NO_ERROR) { 2198 rc = m_parent->startPreview(); 2199 if (rc != NO_ERROR) { 2200 m_parent->unpreparePreview(); 2201 } 2202 } 2203 if (rc != NO_ERROR) { 2204 m_state = QCAMERA_SM_STATE_PIC_TAKING; 2205 } 2206 } else { 2207 rc = m_parent->commitParameterChanges(); 2208 } 2209 } 2210 result.status = rc; 2211 result.request_api = evt; 2212 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2213 m_parent->signalAPIResult(&result); 2214 } 2215 break; 2216 case QCAMERA_SM_EVT_GET_PARAMS: 2217 { 2218 result.params = m_parent->getParameters(); 2219 rc = NO_ERROR; 2220 result.status = rc; 2221 result.request_api = evt; 2222 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS; 2223 m_parent->signalAPIResult(&result); 2224 } 2225 break; 2226 case QCAMERA_SM_EVT_PUT_PARAMS: 2227 { 2228 rc = m_parent->putParameters((char*)payload); 2229 result.status = rc; 2230 result.request_api = evt; 2231 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2232 m_parent->signalAPIResult(&result); 2233 } 2234 break; 2235 case QCAMERA_SM_EVT_PREVIEW_ENABLED: 2236 { 2237 rc = NO_ERROR; 2238 result.status = rc; 2239 result.request_api = evt; 2240 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2241 result.enabled = 1; 2242 m_parent->signalAPIResult(&result); 2243 } 2244 break; 2245 case QCAMERA_SM_EVT_RECORDING_ENABLED: 2246 { 2247 rc = NO_ERROR; 2248 result.status = rc; 2249 result.request_api = evt; 2250 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG; 2251 result.enabled = 0; 2252 m_parent->signalAPIResult(&result); 2253 } 2254 break; 2255 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS: 2256 { 2257 rc = m_parent->storeMetaDataInBuffers(int(payload)); 2258 result.status = rc; 2259 result.request_api = evt; 2260 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2261 m_parent->signalAPIResult(&result); 2262 } 2263 break; 2264 case QCAMERA_SM_EVT_DUMP: 2265 { 2266 rc = m_parent->dump((int)payload); 2267 result.status = rc; 2268 result.request_api = evt; 2269 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2270 m_parent->signalAPIResult(&result); 2271 } 2272 break; 2273 case QCAMERA_SM_EVT_START_AUTO_FOCUS: 2274 { 2275 rc = m_parent->autoFocus(); 2276 result.status = rc; 2277 result.request_api = evt; 2278 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2279 m_parent->signalAPIResult(&result); 2280 } 2281 break; 2282 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS: 2283 { 2284 rc = m_parent->cancelAutoFocus(); 2285 result.status = rc; 2286 result.request_api = evt; 2287 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2288 m_parent->signalAPIResult(&result); 2289 } 2290 break; 2291 case QCAMERA_SM_EVT_SEND_COMMAND: 2292 { 2293 qcamera_sm_evt_command_payload_t *cmd_payload = 2294 (qcamera_sm_evt_command_payload_t *)payload; 2295 rc = m_parent->sendCommand(cmd_payload->cmd, 2296 cmd_payload->arg1, 2297 cmd_payload->arg2); 2298 result.status = rc; 2299 result.request_api = evt; 2300 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2301 m_parent->signalAPIResult(&result); 2302 } 2303 break; 2304 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME: 2305 { 2306 rc = m_parent->releaseRecordingFrame((const void *)payload); 2307 result.status = rc; 2308 result.request_api = evt; 2309 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2310 m_parent->signalAPIResult(&result); 2311 } 2312 break; 2313 case QCAMERA_SM_EVT_CANCEL_PICTURE: 2314 { 2315 if (m_parent->isZSLMode()) { 2316 rc = m_parent->cancelPicture(); 2317 } else { 2318 rc = m_parent->cancelLiveSnapshot(); 2319 } 2320 m_state = QCAMERA_SM_STATE_PREVIEWING; 2321 result.status = rc; 2322 result.request_api = evt; 2323 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2324 m_parent->signalAPIResult(&result); 2325 } 2326 break; 2327 case QCAMERA_SM_EVT_STOP_PREVIEW: 2328 { 2329 if (m_parent->isZSLMode()) { 2330 // cancel picture first 2331 rc = m_parent->cancelPicture(); 2332 m_parent->stopChannel(QCAMERA_CH_TYPE_ZSL); 2333 } else { 2334 rc = m_parent->cancelLiveSnapshot(); 2335 m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW); 2336 } 2337 // unprepare preview 2338 m_parent->unpreparePreview(); 2339 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED; 2340 result.status = rc; 2341 result.request_api = evt; 2342 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2343 m_parent->signalAPIResult(&result); 2344 } 2345 break; 2346 case QCAMERA_SM_EVT_START_RECORDING: 2347 { 2348 rc = m_parent->stopRecording(); 2349 if (rc == NO_ERROR) { 2350 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING; 2351 } 2352 result.status = rc; 2353 result.request_api = evt; 2354 result.result_type = QCAMERA_API_RESULT_TYPE_DEF; 2355 m_parent->signalAPIResult(&result); 2356 } 2357 break; 2358 case QCAMERA_SM_EVT_REG_FACE_IMAGE: 2359 { 2360 int32_t faceID = 0; 2361 qcamera_sm_evt_reg_face_payload_t *reg_payload = 2362 (qcamera_sm_evt_reg_face_payload_t *)payload; 2363 rc = m_parent->registerFaceImage(reg_payload->img_ptr, 2364 reg_payload->config, 2365 faceID); 2366 result.status = rc; 2367 result.request_api = evt; 2368 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE; 2369 result.handle = faceID; 2370 m_parent->signalAPIResult(&result); 2371 } 2372 break; 2373 case QCAMERA_SM_EVT_STOP_RECORDING: 2374 case QCAMERA_SM_EVT_START_PREVIEW: 2375 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW: 2376 case QCAMERA_SM_EVT_TAKE_PICTURE: 2377 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW: 2378 case QCAMERA_SM_EVT_RELEASE: 2379 { 2380 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 2381 rc = INVALID_OPERATION; 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_EVT_INTERNAL: 2389 { 2390 qcamera_sm_internal_evt_payload_t *internal_evt = 2391 (qcamera_sm_internal_evt_payload_t *)payload; 2392 switch (internal_evt->evt_type) { 2393 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE: 2394 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data); 2395 break; 2396 default: 2397 break; 2398 } 2399 } 2400 break; 2401 case QCAMERA_SM_EVT_EVT_NOTIFY: 2402 { 2403 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload; 2404 switch (cam_evt->server_event_type) { 2405 default: 2406 ALOGD("%s: no handling for server evt (%d) at this state", 2407 __func__, cam_evt->server_event_type); 2408 break; 2409 } 2410 } 2411 break; 2412 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY: 2413 { 2414 qcamera_jpeg_evt_payload_t *jpeg_job = 2415 (qcamera_jpeg_evt_payload_t *)payload; 2416 rc = m_parent->processJpegNotify(jpeg_job); 2417 } 2418 break; 2419 case QCAMERA_SM_EVT_SNAPSHOT_DONE: 2420 { 2421 if (m_parent->isZSLMode()) { 2422 rc = m_parent->cancelPicture(); 2423 } else { 2424 rc = m_parent->cancelLiveSnapshot(); 2425 } 2426 m_state = QCAMERA_SM_STATE_PREVIEWING; 2427 } 2428 break; 2429 case QCAMERA_SM_EVT_THERMAL_NOTIFY: 2430 { 2431 rc = m_parent->updateThermalLevel( 2432 *(qcamera_thermal_level_enum_t *)&payload); 2433 } 2434 break; 2435 default: 2436 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state); 2437 break; 2438 } 2439 2440 return rc; 2441} 2442 2443/*=========================================================================== 2444 * FUNCTION : isPreviewRunning 2445 * 2446 * DESCRIPTION: check if preview is in process. 2447 * 2448 * PARAMETERS : None 2449 * 2450 * RETURN : true -- preview running 2451 * false -- preview stopped 2452 *==========================================================================*/ 2453bool QCameraStateMachine::isPreviewRunning() 2454{ 2455 switch (m_state) { 2456 case QCAMERA_SM_STATE_PREVIEWING: 2457 case QCAMERA_SM_STATE_RECORDING: 2458 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING: 2459 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING: 2460 return true; 2461 default: 2462 return false; 2463 } 2464} 2465 2466}; // namespace qcamera 2467