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