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