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