Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / hardware / qcom / camera / 54317a7c4ae94a12b8b19fb53e7af8453ab20162 / . / QCamera2 / HAL / QCameraStateMachine.cpp
blob: 4e429b552b2e696138ea84a7874534b841a3e65e [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;
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]561 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
562 {
563 // No ops, but need to notify
564 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
565 result.status = rc;
566 result.request_api = evt;
567 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
568 m_parent->signalEvtResult(&result);
569 }
570 break;
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]571 case QCAMERA_SM_EVT_EVT_INTERNAL:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]572 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
573 default:
574 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
575 break;
576 }
577
578 return rc;
579}
580
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]581/*===========================================================================
582 * FUNCTION : procEvtPreviewReadyState
583 *
584 * DESCRIPTION: finite state machine function to handle event in state of
585 * QCAMERA_SM_STATE_PREVIEW_READY.
586 *
587 * PARAMETERS :
588 * @evt : event to be processed
589 * @payload : event payload. Can be NULL if not needed.
590 *
591 * RETURN : int32_t type of status
592 * NO_ERROR -- success
593 * none-zero failure code
594 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]595int32_t QCameraStateMachine::procEvtPreviewReadyState(qcamera_sm_evt_enum_t evt,
596 void *payload)
597{
598 int32_t rc = NO_ERROR;
599 qcamera_api_result_t result;
600 memset(&result, 0, sizeof(qcamera_api_result_t));
601
602 switch (evt) {
603 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
604 {
605 m_parent->setPreviewWindow((struct preview_stream_ops *)payload);
606 if (m_parent->mPreviewWindow != NULL) {
607 rc = m_parent->startPreview();
608 if (rc != NO_ERROR) {
609 m_parent->unpreparePreview();
610 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
611 } else {
612 m_state = QCAMERA_SM_STATE_PREVIEWING;
613 }
614 }
615
616 result.status = rc;
617 result.request_api = evt;
618 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
619 m_parent->signalAPIResult(&result);
620 }
621 break;
622 case QCAMERA_SM_EVT_SET_CALLBACKS:
623 {
624 qcamera_sm_evt_setcb_payload_t *setcbs =
625 (qcamera_sm_evt_setcb_payload_t *)payload;
626 rc = m_parent->setCallBacks(setcbs->notify_cb,
627 setcbs->data_cb,
628 setcbs->data_cb_timestamp,
629 setcbs->get_memory,
630 setcbs->user);
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_ENABLE_MSG_TYPE:
638 {
639 rc = m_parent->enableMsgType(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_DISABLE_MSG_TYPE:
647 {
648 rc = m_parent->disableMsgType(int32_t(payload));
649 result.status = rc;
650 result.request_api = evt;
651 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
652 m_parent->signalAPIResult(&result);
653 }
654 break;
655 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
656 {
657 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
658 result.status = rc;
659 result.request_api = evt;
660 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
661 result.enabled = enabled;
662 m_parent->signalAPIResult(&result);
663 }
664 break;
665 case QCAMERA_SM_EVT_SET_PARAMS:
666 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]667 bool needRestart = false;
668 rc = m_parent->updateParameters((char*)payload, needRestart);
669 if (rc == NO_ERROR) {
Muhua Li6d69e932013-01-24 16:39:27 -0800[diff] [blame]670 if (needRestart) {
671 // need restart preview for parameters to take effect
672 m_parent->unpreparePreview();
673 // commit parameter changes to server
674 m_parent->commitParameterChanges();
675 // prepare preview again
676 rc = m_parent->preparePreview();
677 if (rc != NO_ERROR) {
678 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
679 }
680 } else {
681 rc = m_parent->commitParameterChanges();
682 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]683 }
Muhua Li6d69e932013-01-24 16:39:27 -0800[diff] [blame]684
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]685 result.status = rc;
686 result.request_api = evt;
687 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
688 m_parent->signalAPIResult(&result);
689 }
690 break;
691 case QCAMERA_SM_EVT_GET_PARAMS:
692 {
693 result.params = m_parent->getParameters();
694 rc = NO_ERROR;
695 result.status = rc;
696 result.request_api = evt;
697 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
698 m_parent->signalAPIResult(&result);
699 }
700 break;
701 case QCAMERA_SM_EVT_PUT_PARAMS:
702 {
703 rc = m_parent->putParameters((char*)payload);
704 result.status = rc;
705 result.request_api = evt;
706 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
707 m_parent->signalAPIResult(&result);
708 }
709 break;
710 case QCAMERA_SM_EVT_START_PREVIEW:
711 {
712 // no ops here
713 rc = NO_ERROR;
714 result.status = rc;
715 result.request_api = evt;
716 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
717 m_parent->signalAPIResult(&result);
718 }
719 break;
720 case QCAMERA_SM_EVT_STOP_PREVIEW:
721 {
722 m_parent->unpreparePreview();
723 rc = 0;
724 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
725 result.status = rc;
726 result.request_api = evt;
727 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
728 m_parent->signalAPIResult(&result);
729 }
730 break;
731 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
732 {
733 rc = NO_ERROR;
734 result.status = rc;
735 result.request_api = evt;
736 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
737 result.enabled = 1;
738 m_parent->signalAPIResult(&result);
739 }
740 break;
741 case QCAMERA_SM_EVT_RECORDING_ENABLED:
742 {
743 rc = 0;
744 result.status = rc;
745 result.request_api = evt;
746 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
747 result.enabled = 0;
748 m_parent->signalAPIResult(&result);
749 }
750 break;
751 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
752 {
753 rc = m_parent->storeMetaDataInBuffers(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_DUMP:
761 {
762 rc = m_parent->dump((int)payload);
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_START_AUTO_FOCUS:
770 {
771 rc = m_parent->autoFocus();
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_STOP_AUTO_FOCUS:
779 {
780 rc = m_parent->cancelAutoFocus();
781 result.status = rc;
782 result.request_api = evt;
783 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
784 m_parent->signalAPIResult(&result);
785 }
786 break;
787 case QCAMERA_SM_EVT_SEND_COMMAND:
788 {
789 qcamera_sm_evt_command_payload_t *cmd_payload =
790 (qcamera_sm_evt_command_payload_t *)payload;
791 rc = m_parent->sendCommand(cmd_payload->cmd,
792 cmd_payload->arg1,
793 cmd_payload->arg2);
794 result.status = rc;
795 result.request_api = evt;
796 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
797 m_parent->signalAPIResult(&result);
798 }
799 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]800 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
801 {
802 int32_t faceID = 0;
803 qcamera_sm_evt_reg_face_payload_t *reg_payload =
804 (qcamera_sm_evt_reg_face_payload_t *)payload;
805 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
806 reg_payload->config,
807 faceID);
808 result.status = rc;
809 result.request_api = evt;
810 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
811 result.handle = faceID;
812 m_parent->signalAPIResult(&result);
813 }
814 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]815 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
816 case QCAMERA_SM_EVT_START_RECORDING:
817 case QCAMERA_SM_EVT_STOP_RECORDING:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]818 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]819 case QCAMERA_SM_EVT_TAKE_PICTURE:
820 case QCAMERA_SM_EVT_CANCEL_PICTURE:
821 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
822 case QCAMERA_SM_EVT_RELEASE:
823 {
824 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
825 rc = INVALID_OPERATION;
826 result.status = rc;
827 result.request_api = evt;
828 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
829 m_parent->signalAPIResult(&result);
830 }
831 break;
832 case QCAMERA_SM_EVT_EVT_NOTIFY:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]833 {
834 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
835 switch (cam_evt->server_event_type) {
836 case CAM_EVENT_TYPE_DAEMON_DIED:
837 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]838 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
839 CAMERA_ERROR_SERVER_DIED,
840 0);
841 }
842 break;
843 default:
844 ALOGE("%s: Invalid internal event %d in state(%d)",
845 __func__, cam_evt->server_event_type, m_state);
846 break;
847 }
848 }
849 break;
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]850 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
851 {
852 // No ops, but need to notify
853 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
854 result.status = rc;
855 result.request_api = evt;
856 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
857 m_parent->signalEvtResult(&result);
858 }
859 break;
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]860 case QCAMERA_SM_EVT_EVT_INTERNAL:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]861 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]862 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]863 default:
864 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
865 break;
866 }
867
868 return rc;
869}
870
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]871/*===========================================================================
872 * FUNCTION : procEvtPreviewingState
873 *
874 * DESCRIPTION: finite state machine function to handle event in state of
875 * QCAMERA_SM_STATE_PREVIEWING.
876 *
877 * PARAMETERS :
878 * @evt : event to be processed
879 * @payload : event payload. Can be NULL if not needed.
880 *
881 * RETURN : int32_t type of status
882 * NO_ERROR -- success
883 * none-zero failure code
884 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]885int32_t QCameraStateMachine::procEvtPreviewingState(qcamera_sm_evt_enum_t evt,
886 void *payload)
887{
888 int32_t rc = NO_ERROR;
889 qcamera_api_result_t result;
890 memset(&result, 0, sizeof(qcamera_api_result_t));
891
892 switch (evt) {
893 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
894 {
895 // Error setting preview window during previewing
896 ALOGE("Cannot set preview window when preview is running");
897 rc = INVALID_OPERATION;
898 result.status = rc;
899 result.request_api = evt;
900 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
901 m_parent->signalAPIResult(&result);
902 }
903 break;
904 case QCAMERA_SM_EVT_SET_CALLBACKS:
905 {
906 qcamera_sm_evt_setcb_payload_t *setcbs =
907 (qcamera_sm_evt_setcb_payload_t *)payload;
908 rc = m_parent->setCallBacks(setcbs->notify_cb,
909 setcbs->data_cb,
910 setcbs->data_cb_timestamp,
911 setcbs->get_memory,
912 setcbs->user);
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_ENABLE_MSG_TYPE:
920 {
921 rc = m_parent->enableMsgType(int32_t(payload));
922 result.status = rc;
923 result.request_api = evt;
924 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
925 m_parent->signalAPIResult(&result);
926 }
927 break;
928 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
929 {
930 rc = m_parent->disableMsgType(int32_t(payload));
931 result.status = rc;
932 result.request_api = evt;
933 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
934 m_parent->signalAPIResult(&result);
935 }
936 break;
937 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
938 {
939 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
940 result.status = rc;
941 result.request_api = evt;
942 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
943 result.enabled = enabled;
944 m_parent->signalAPIResult(&result);
945 }
946 break;
947 case QCAMERA_SM_EVT_SET_PARAMS:
948 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]949 bool needRestart = false;
950 rc = m_parent->updateParameters((char*)payload, needRestart);
951 if (rc == NO_ERROR) {
952 if (needRestart) {
953 // need restart preview for parameters to take effect
954 // stop preview
955 m_parent->stopPreview();
956 // commit parameter changes to server
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]957 m_parent->commitParameterChanges();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]958 // start preview again
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]959 rc = m_parent->preparePreview();
960 if (rc == NO_ERROR) {
961 rc = m_parent->startPreview();
962 if (rc != NO_ERROR) {
963 m_parent->unpreparePreview();
964 }
965 }
966 if (rc != NO_ERROR) {
967 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
968 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]969 } else {
970 rc = m_parent->commitParameterChanges();
971 }
972 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]973 result.status = rc;
974 result.request_api = evt;
975 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
976 m_parent->signalAPIResult(&result);
977 }
978 break;
979 case QCAMERA_SM_EVT_GET_PARAMS:
980 {
981 result.params = m_parent->getParameters();
982 rc = NO_ERROR;
983 result.status = rc;
984 result.request_api = evt;
985 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
986 m_parent->signalAPIResult(&result);
987 }
988 break;
989 case QCAMERA_SM_EVT_PUT_PARAMS:
990 {
991 rc = m_parent->putParameters((char*)payload);
992 result.status = rc;
993 result.request_api = evt;
994 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
995 m_parent->signalAPIResult(&result);
996 }
997 break;
998 case QCAMERA_SM_EVT_START_PREVIEW:
999 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1000 {
1001 // no ops here
1002 ALOGD("%s: Already in previewing, no ops here to start preview", __func__);
1003 rc = NO_ERROR;
1004 result.status = rc;
1005 result.request_api = evt;
1006 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1007 m_parent->signalAPIResult(&result);
1008 }
1009 break;
1010 case QCAMERA_SM_EVT_STOP_PREVIEW:
1011 {
1012 rc = m_parent->stopPreview();
1013 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1014 result.status = rc;
1015 result.request_api = evt;
1016 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1017 m_parent->signalAPIResult(&result);
1018 }
1019 break;
1020 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1021 {
1022 rc = NO_ERROR;
1023 result.status = rc;
1024 result.request_api = evt;
1025 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1026 result.enabled = 1;
1027 m_parent->signalAPIResult(&result);
1028 }
1029 break;
1030 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1031 {
1032 rc = NO_ERROR;
1033 result.status = rc;
1034 result.request_api = evt;
1035 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1036 result.enabled = 0;
1037 m_parent->signalAPIResult(&result);
1038 }
1039 break;
1040 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1041 {
1042 rc = m_parent->storeMetaDataInBuffers(int(payload));
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_DUMP:
1050 {
1051 rc = m_parent->dump((int)payload);
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_AUTO_FOCUS:
1059 {
1060 rc = m_parent->autoFocus();
1061 result.status = rc;
1062 result.request_api = evt;
1063 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1064 m_parent->signalAPIResult(&result);
1065 }
1066 break;
1067 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1068 {
1069 rc = m_parent->cancelAutoFocus();
1070 result.status = rc;
1071 result.request_api = evt;
1072 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1073 m_parent->signalAPIResult(&result);
1074 }
1075 break;
1076 case QCAMERA_SM_EVT_START_RECORDING:
1077 {
1078 rc = m_parent->startRecording();
1079 if (rc == NO_ERROR) {
1080 // move state to recording state
1081 m_state = QCAMERA_SM_STATE_RECORDING;
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 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1089 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1090 {
Muhua Li0c14e432013-03-06 15:50:17 -0800[diff] [blame]1091 rc = m_parent->prepareHardwareForSnapshot(FALSE);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1092 if (rc == NO_ERROR) {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1093 // Do not signal API result in this case.
1094 // Need to wait for snapshot done in metadta.
1095 m_state = QCAMERA_SM_STATE_PREPARE_SNAPSHOT;
1096 } else {
1097 // Do not change state in this case.
1098 ALOGE("%s: prepareHardwareForSnapshot failed %d",
1099 __func__, rc);
1100
1101 result.status = rc;
1102 result.request_api = evt;
1103 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1104 m_parent->signalAPIResult(&result);
1105 }
1106 }
1107 break;
1108 case QCAMERA_SM_EVT_TAKE_PICTURE:
1109 {
Muhua Li8e614bc2013-04-17 17:38:42 -0700[diff] [blame]1110 if ( m_parent->mParameters.getRecordingHintValue() == false) {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1111 if (m_parent->isZSLMode()) {
1112 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
Muhua Lia9dca012013-05-03 22:37:42 -0700[diff] [blame]1113 rc = m_parent->takePicture();
1114 if (rc != NO_ERROR) {
1115 // move state to previewing state
1116 m_state = QCAMERA_SM_STATE_PREVIEWING;
1117 }
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1118 } else {
1119 m_state = QCAMERA_SM_STATE_PIC_TAKING;
Muhua Lia9dca012013-05-03 22:37:42 -0700[diff] [blame]1120 rc = m_parent->takePicture();
1121 if (rc != NO_ERROR) {
1122 // move state to preview stopped state
1123 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1124 }
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1125 }
Muhua Lia9dca012013-05-03 22:37:42 -0700[diff] [blame]1126
1127 result.status = rc;
1128 result.request_api = evt;
1129 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1130 m_parent->signalAPIResult(&result);
Muhua Li8e614bc2013-04-17 17:38:42 -0700[diff] [blame]1131 } else {
Muhua Lia9dca012013-05-03 22:37:42 -0700[diff] [blame]1132 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
Muhua Li8e614bc2013-04-17 17:38:42 -0700[diff] [blame]1133 rc = m_parent->takeLiveSnapshot();
Muhua Lia9dca012013-05-03 22:37:42 -0700[diff] [blame]1134 if (rc != NO_ERROR ) {
1135 m_state = QCAMERA_SM_STATE_PREVIEWING;
Muhua Li8e614bc2013-04-17 17:38:42 -0700[diff] [blame]1136 }
Muhua Lia9dca012013-05-03 22:37:42 -0700[diff] [blame]1137 result.status = rc;
1138 result.request_api = evt;
1139 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1140 m_parent->signalAPIResult(&result);
Muhua Li8e614bc2013-04-17 17:38:42 -0700[diff] [blame]1141 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1142 }
1143 break;
1144 case QCAMERA_SM_EVT_SEND_COMMAND:
1145 {
1146 qcamera_sm_evt_command_payload_t *cmd_payload =
1147 (qcamera_sm_evt_command_payload_t *)payload;
1148 rc = m_parent->sendCommand(cmd_payload->cmd,
1149 cmd_payload->arg1,
1150 cmd_payload->arg2);
1151 result.status = rc;
1152 result.request_api = evt;
1153 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1154 m_parent->signalAPIResult(&result);
1155 }
1156 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1157 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1158 {
1159 int32_t faceID = 0;
1160 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1161 (qcamera_sm_evt_reg_face_payload_t *)payload;
1162 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1163 reg_payload->config,
1164 faceID);
1165 result.status = rc;
1166 result.request_api = evt;
1167 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1168 result.handle = faceID;
1169 m_parent->signalAPIResult(&result);
1170 }
1171 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1172 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1173 case QCAMERA_SM_EVT_STOP_RECORDING:
1174 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1175 case QCAMERA_SM_EVT_RELEASE:
1176 {
1177 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1178 rc = INVALID_OPERATION;
1179 result.status = rc;
1180 result.request_api = evt;
1181 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1182 m_parent->signalAPIResult(&result);
1183 }
1184 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1185 case QCAMERA_SM_EVT_EVT_INTERNAL:
1186 {
1187 qcamera_sm_internal_evt_payload_t *internal_evt =
1188 (qcamera_sm_internal_evt_payload_t *)payload;
1189 switch (internal_evt->evt_type) {
1190 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1191 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1192 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1193 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
1194 break;
1195 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
1196 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
1197 break;
1198 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
1199 rc = m_parent->processHistogramStats(internal_evt->stats_data);
1200 break;
1201 case QCAMERA_INTERNAL_EVT_CROP_INFO:
1202 rc = m_parent->processZoomEvent(internal_evt->crop_data);
1203 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1204 default:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1205 ALOGE("%s: Invalid internal event %d in state(%d)",
1206 __func__, internal_evt->evt_type, m_state);
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1207 break;
1208 }
1209 }
1210 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1211 case QCAMERA_SM_EVT_EVT_NOTIFY:
1212 {
1213 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1214 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1215 case CAM_EVENT_TYPE_DAEMON_DIED:
1216 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1217 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
1218 CAMERA_ERROR_SERVER_DIED,
1219 0);
1220 }
1221 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1222 default:
1223 ALOGD("%s: no handling for server evt (%d) at this state",
1224 __func__, cam_evt->server_event_type);
1225 break;
1226 }
1227 }
1228 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1229 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1230 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]1231 rc = m_parent->updateThermalLevel(
1232 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1233 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1234 break;
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1235 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]1236 {
1237 // No ops, but need to notify
1238 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1239 result.status = rc;
1240 result.request_api = evt;
1241 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1242 m_parent->signalEvtResult(&result);
1243 }
1244 break;
1245 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1246 default:
1247 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1248 break;
1249 }
1250
1251 return rc;
1252}
1253
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1254/*===========================================================================
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1255 * FUNCTION : procEvtPrepareSnapshotState
1256 *
1257 * DESCRIPTION: finite state machine function to handle event in state of
1258 * QCAMERA_SM_STATE_PREPARE_SNAPSHOT.
1259 *
1260 * PARAMETERS :
1261 * @evt : event to be processed
1262 * @payload : event payload. Can be NULL if not needed.
1263 *
1264 * RETURN : int32_t type of status
1265 * NO_ERROR -- success
1266 * none-zero failure code
1267 *==========================================================================*/
1268int32_t QCameraStateMachine::procEvtPrepareSnapshotState(qcamera_sm_evt_enum_t evt,
1269 void *payload)
1270{
1271 int32_t rc = NO_ERROR;
1272 qcamera_api_result_t result;
1273 memset(&result, 0, sizeof(qcamera_api_result_t));
1274
1275 switch (evt) {
1276 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1277 case QCAMERA_SM_EVT_SET_CALLBACKS:
1278 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1279 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1280 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1281 case QCAMERA_SM_EVT_SET_PARAMS:
1282 case QCAMERA_SM_EVT_GET_PARAMS:
1283 case QCAMERA_SM_EVT_PUT_PARAMS:
1284 case QCAMERA_SM_EVT_START_PREVIEW:
1285 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1286 case QCAMERA_SM_EVT_STOP_PREVIEW:
1287 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1288 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1289 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1290 case QCAMERA_SM_EVT_DUMP:
1291 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1292 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1293 case QCAMERA_SM_EVT_START_RECORDING:
1294 case QCAMERA_SM_EVT_TAKE_PICTURE:
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1295 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1296 case QCAMERA_SM_EVT_SEND_COMMAND:
1297 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1298 case QCAMERA_SM_EVT_STOP_RECORDING:
1299 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1300 case QCAMERA_SM_EVT_RELEASE:
1301 {
1302 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1303 rc = INVALID_OPERATION;
1304 result.status = rc;
1305 result.request_api = evt;
1306 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1307 m_parent->signalAPIResult(&result);
1308 }
1309 break;
1310 case QCAMERA_SM_EVT_EVT_INTERNAL:
1311 {
1312 qcamera_sm_internal_evt_payload_t *internal_evt =
1313 (qcamera_sm_internal_evt_payload_t *)payload;
1314 switch (internal_evt->evt_type) {
Muhua Li6f3c5322013-05-08 17:20:17 -0700[diff] [blame]1315 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1316 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1317 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1318 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
1319 ALOGI("%s: Received QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE event",
1320 __func__);
1321 m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state);
1322 m_state = QCAMERA_SM_STATE_PREVIEWING;
1323
1324 result.status = NO_ERROR;
1325 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT;
1326 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1327 m_parent->signalAPIResult(&result);
1328 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1329 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
1330 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
1331 break;
1332 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
1333 rc = m_parent->processHistogramStats(internal_evt->stats_data);
1334 break;
1335 case QCAMERA_INTERNAL_EVT_CROP_INFO:
1336 rc = m_parent->processZoomEvent(internal_evt->crop_data);
1337 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1338 default:
1339 ALOGE("%s: Invalid internal event %d in state(%d)",
1340 __func__, internal_evt->evt_type, m_state);
1341 break;
1342 }
1343 }
1344 break;
1345 case QCAMERA_SM_EVT_EVT_NOTIFY:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1346 {
1347 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1348 switch (cam_evt->server_event_type) {
1349 case CAM_EVENT_TYPE_DAEMON_DIED:
1350 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1351 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
1352 CAMERA_ERROR_SERVER_DIED,
1353 0);
1354 }
1355 break;
1356 default:
1357 ALOGE("%s: Invalid internal event %d in state(%d)",
1358 __func__, cam_evt->server_event_type, m_state);
1359 break;
1360 }
1361 }
1362 break;
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]1363 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1364 {
1365 // No ops, but need to notify
1366 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1367 result.status = rc;
1368 result.request_api = evt;
1369 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1370 m_parent->signalEvtResult(&result);
1371 }
1372 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1373 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
1374 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1375 default:
1376 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1377 break;
1378 }
1379
1380 return rc;
1381}
1382
1383/*===========================================================================
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1384 * FUNCTION : procEvtPicTakingState
1385 *
1386 * DESCRIPTION: finite state machine function to handle event in state of
1387 * QCAMERA_SM_STATE_PIC_TAKING.
1388 *
1389 * PARAMETERS :
1390 * @evt : event to be processed
1391 * @payload : event payload. Can be NULL if not needed.
1392 *
1393 * RETURN : int32_t type of status
1394 * NO_ERROR -- success
1395 * none-zero failure code
1396 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1397int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt,
1398 void *payload)
1399{
1400 int32_t rc = NO_ERROR;
1401 qcamera_api_result_t result;
1402 memset(&result, 0, sizeof(qcamera_api_result_t));
1403
1404 switch (evt) {
1405 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1406 {
1407 // Error setting preview window during previewing
1408 ALOGE("Cannot set preview window when preview is running");
1409 rc = INVALID_OPERATION;
1410 result.status = rc;
1411 result.request_api = evt;
1412 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1413 m_parent->signalAPIResult(&result);
1414 }
1415 break;
1416 case QCAMERA_SM_EVT_SET_CALLBACKS:
1417 {
1418 qcamera_sm_evt_setcb_payload_t *setcbs =
1419 (qcamera_sm_evt_setcb_payload_t *)payload;
1420 rc = m_parent->setCallBacks(setcbs->notify_cb,
1421 setcbs->data_cb,
1422 setcbs->data_cb_timestamp,
1423 setcbs->get_memory,
1424 setcbs->user);
1425 result.status = rc;
1426 result.request_api = evt;
1427 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1428 m_parent->signalAPIResult(&result);
1429 }
1430 break;
1431 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1432 {
1433 rc = m_parent->enableMsgType(int32_t(payload));
1434 result.status = rc;
1435 result.request_api = evt;
1436 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1437 m_parent->signalAPIResult(&result);
1438 }
1439 break;
1440 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1441 {
1442 rc = m_parent->disableMsgType(int32_t(payload));
1443 result.status = rc;
1444 result.request_api = evt;
1445 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1446 m_parent->signalAPIResult(&result);
1447 }
1448 break;
1449 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1450 {
1451 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1452 result.status = rc;
1453 result.request_api = evt;
1454 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1455 result.enabled = enabled;
1456 m_parent->signalAPIResult(&result);
1457 }
1458 break;
1459 case QCAMERA_SM_EVT_SET_PARAMS:
1460 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1461 bool needRestart = false;
1462 rc = m_parent->updateParameters((char*)payload, needRestart);
1463 if (rc == NO_ERROR) {
1464 rc = m_parent->commitParameterChanges();
1465 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1466 result.status = rc;
1467 result.request_api = evt;
1468 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1469 m_parent->signalAPIResult(&result);
1470 }
1471 break;
1472 case QCAMERA_SM_EVT_GET_PARAMS:
1473 {
1474 result.params = m_parent->getParameters();
1475 rc = NO_ERROR;
1476 result.status = rc;
1477 result.request_api = evt;
1478 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1479 m_parent->signalAPIResult(&result);
1480 }
1481 break;
1482 case QCAMERA_SM_EVT_PUT_PARAMS:
1483 {
1484 rc = m_parent->putParameters((char*)payload);
1485 result.status = rc;
1486 result.request_api = evt;
1487 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1488 m_parent->signalAPIResult(&result);
1489 }
1490 break;
1491 case QCAMERA_SM_EVT_STOP_PREVIEW:
1492 {
Muhua Libd1b6122013-03-05 15:25:27 -0800[diff] [blame]1493 // cancel picture first
1494 rc = m_parent->cancelPicture();
1495 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1496
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1497 result.status = rc;
1498 result.request_api = evt;
1499 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1500 m_parent->signalAPIResult(&result);
1501 }
1502 break;
1503 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1504 {
1505 rc = NO_ERROR;
1506 result.status = rc;
1507 result.request_api = evt;
1508 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1509 result.enabled = 0;
1510 m_parent->signalAPIResult(&result);
1511 }
1512 break;
1513 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1514 {
1515 rc = NO_ERROR;
1516 result.status = rc;
1517 result.request_api = evt;
1518 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1519 result.enabled = 0;
1520 m_parent->signalAPIResult(&result);
1521 }
1522 break;
1523 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1524 {
1525 rc = m_parent->storeMetaDataInBuffers(int(payload));
1526 result.status = rc;
1527 result.request_api = evt;
1528 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1529 m_parent->signalAPIResult(&result);
1530 }
1531 break;
1532 case QCAMERA_SM_EVT_DUMP:
1533 {
1534 rc = m_parent->dump((int)payload);
1535 result.status = rc;
1536 result.request_api = evt;
1537 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1538 m_parent->signalAPIResult(&result);
1539 }
1540 break;
1541 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1542 {
1543 rc = m_parent->autoFocus();
1544 result.status = rc;
1545 result.request_api = evt;
1546 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1547 m_parent->signalAPIResult(&result);
1548 }
1549 break;
1550 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1551 {
1552 rc = m_parent->cancelAutoFocus();
1553 result.status = rc;
1554 result.request_api = evt;
1555 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1556 m_parent->signalAPIResult(&result);
1557 }
1558 break;
1559 case QCAMERA_SM_EVT_SEND_COMMAND:
1560 {
1561 qcamera_sm_evt_command_payload_t *cmd_payload =
1562 (qcamera_sm_evt_command_payload_t *)payload;
1563 rc = m_parent->sendCommand(cmd_payload->cmd,
1564 cmd_payload->arg1,
1565 cmd_payload->arg2);
1566 result.status = rc;
1567 result.request_api = evt;
1568 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1569 m_parent->signalAPIResult(&result);
1570 }
1571 break;
1572 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1573 {
1574 rc = m_parent->cancelPicture();
1575 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1576 result.status = rc;
1577 result.request_api = evt;
1578 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1579 m_parent->signalAPIResult(&result);
1580 }
1581 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1582 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1583 {
1584 int32_t faceID = 0;
1585 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1586 (qcamera_sm_evt_reg_face_payload_t *)payload;
1587 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1588 reg_payload->config,
1589 faceID);
1590 result.status = rc;
1591 result.request_api = evt;
1592 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1593 result.handle = faceID;
1594 m_parent->signalAPIResult(&result);
1595 }
1596 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1597 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1598 case QCAMERA_SM_EVT_TAKE_PICTURE:
1599 case QCAMERA_SM_EVT_START_RECORDING:
1600 case QCAMERA_SM_EVT_STOP_RECORDING:
1601 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1602 case QCAMERA_SM_EVT_START_PREVIEW:
1603 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1604 case QCAMERA_SM_EVT_RELEASE:
1605 {
1606 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1607 rc = INVALID_OPERATION;
1608 result.status = rc;
1609 result.request_api = evt;
1610 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1611 m_parent->signalAPIResult(&result);
1612 }
1613 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1614 case QCAMERA_SM_EVT_EVT_INTERNAL:
1615 {
1616 qcamera_sm_internal_evt_payload_t *internal_evt =
1617 (qcamera_sm_internal_evt_payload_t *)payload;
1618 switch (internal_evt->evt_type) {
1619 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1620 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1621 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1622 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
1623 break;
1624 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
1625 break;
1626 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
1627 break;
1628 case QCAMERA_INTERNAL_EVT_CROP_INFO:
1629 rc = m_parent->processZoomEvent(internal_evt->crop_data);
1630 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1631 default:
1632 break;
1633 }
1634 }
1635 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1636 case QCAMERA_SM_EVT_EVT_NOTIFY:
1637 {
1638 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1639 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1640 case CAM_EVENT_TYPE_DAEMON_DIED:
1641 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1642 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
1643 CAMERA_ERROR_SERVER_DIED,
1644 0);
1645 }
1646 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1647 default:
1648 ALOGD("%s: no handling for server evt (%d) at this state",
1649 __func__, cam_evt->server_event_type);
1650 break;
1651 }
1652 }
1653 break;
1654 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1655 {
1656 qcamera_jpeg_evt_payload_t *jpeg_job =
1657 (qcamera_jpeg_evt_payload_t *)payload;
1658 rc = m_parent->processJpegNotify(jpeg_job);
1659 }
1660 break;
1661 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1662 {
1663 rc = m_parent->cancelPicture();
1664 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
Emilian Peev6d90c1f2013-04-12 09:33:06 +0300[diff] [blame]1665 result.status = rc;
1666 result.request_api = evt;
1667 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1668 m_parent->signalEvtResult(&result);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1669 }
1670 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1671 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peev2ae455e2013-04-18 10:41:56 +0300[diff] [blame]1672 {
1673 rc = m_parent->updateThermalLevel(
1674 *(qcamera_thermal_level_enum_t *)&payload);
1675 }
1676 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1677 default:
1678 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1679 break;
1680 }
1681
1682 return rc;
1683}
1684
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1685/*===========================================================================
1686 * FUNCTION : procEvtRecordingState
1687 *
1688 * DESCRIPTION: finite state machine function to handle event in state of
1689 * QCAMERA_SM_STATE_RECORDING.
1690 *
1691 * PARAMETERS :
1692 * @evt : event to be processed
1693 * @payload : event payload. Can be NULL if not needed.
1694 *
1695 * RETURN : int32_t type of status
1696 * NO_ERROR -- success
1697 * none-zero failure code
1698 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1699int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt,
1700 void *payload)
1701{
1702 int32_t rc = NO_ERROR;
1703 qcamera_api_result_t result;
1704 memset(&result, 0, sizeof(qcamera_api_result_t));
1705
1706 switch (evt) {
1707 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1708 {
1709 // Error setting preview window during previewing
1710 ALOGE("Cannot set preview window when preview is running");
1711 rc = INVALID_OPERATION;
1712 result.status = rc;
1713 result.request_api = evt;
1714 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1715 m_parent->signalAPIResult(&result);
1716 }
1717 break;
1718 case QCAMERA_SM_EVT_SET_CALLBACKS:
1719 {
1720 qcamera_sm_evt_setcb_payload_t *setcbs =
1721 (qcamera_sm_evt_setcb_payload_t *)payload;
1722 rc = m_parent->setCallBacks(setcbs->notify_cb,
1723 setcbs->data_cb,
1724 setcbs->data_cb_timestamp,
1725 setcbs->get_memory,
1726 setcbs->user);
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_ENABLE_MSG_TYPE:
1734 {
1735 rc = m_parent->enableMsgType(int32_t(payload));
1736 result.status = rc;
1737 result.request_api = evt;
1738 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1739 m_parent->signalAPIResult(&result);
1740 }
1741 break;
1742 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1743 {
1744 rc = m_parent->disableMsgType(int32_t(payload));
1745 result.status = rc;
1746 result.request_api = evt;
1747 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1748 m_parent->signalAPIResult(&result);
1749 }
1750 break;
1751 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1752 {
1753 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1754 result.status = rc;
1755 result.request_api = evt;
1756 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1757 result.enabled = enabled;
1758 m_parent->signalAPIResult(&result);
1759 }
1760 break;
1761 case QCAMERA_SM_EVT_SET_PARAMS:
1762 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1763 bool needRestart = false;
1764 rc = m_parent->updateParameters((char*)payload, needRestart);
1765 if (rc == NO_ERROR) {
1766 if (needRestart) {
1767 // cannot set parameters that requires restart during recording
1768 ALOGE("%s: Cannot set parameters that requires restart during recording",
1769 __func__);
1770 rc = BAD_VALUE;
1771 } else {
1772 rc = m_parent->commitParameterChanges();
1773 }
1774 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1775 result.status = rc;
1776 result.request_api = evt;
1777 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1778 m_parent->signalAPIResult(&result);
1779 }
1780 break;
1781 case QCAMERA_SM_EVT_GET_PARAMS:
1782 {
1783 result.params = m_parent->getParameters();
1784 rc = NO_ERROR;
1785 result.status = rc;
1786 result.request_api = evt;
1787 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1788 m_parent->signalAPIResult(&result);
1789 }
1790 break;
1791 case QCAMERA_SM_EVT_PUT_PARAMS:
1792 {
1793 rc = m_parent->putParameters((char*)payload);
1794 result.status = rc;
1795 result.request_api = evt;
1796 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1797 m_parent->signalAPIResult(&result);
1798 }
1799 break;
1800 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1801 {
1802 rc = NO_ERROR;
1803 result.status = rc;
1804 result.request_api = evt;
1805 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1806 result.enabled = 0;
1807 m_parent->signalAPIResult(&result);
1808 }
1809 break;
1810 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1811 {
1812 rc = NO_ERROR;
1813 result.status = rc;
1814 result.request_api = evt;
1815 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1816 result.enabled = 1;
1817 m_parent->signalAPIResult(&result);
1818 }
1819 break;
1820 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1821 {
1822 rc = m_parent->storeMetaDataInBuffers(int(payload));
1823 result.status = rc;
1824 result.request_api = evt;
1825 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1826 m_parent->signalAPIResult(&result);
1827 }
1828 break;
1829 case QCAMERA_SM_EVT_DUMP:
1830 {
1831 rc = m_parent->dump((int)payload);
1832 result.status = rc;
1833 result.request_api = evt;
1834 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1835 m_parent->signalAPIResult(&result);
1836 }
1837 break;
1838 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1839 {
1840 rc = m_parent->autoFocus();
1841 result.status = rc;
1842 result.request_api = evt;
1843 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1844 m_parent->signalAPIResult(&result);
1845 }
1846 break;
1847 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1848 {
1849 rc = m_parent->cancelAutoFocus();
1850 result.status = rc;
1851 result.request_api = evt;
1852 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1853 m_parent->signalAPIResult(&result);
1854 }
1855 break;
1856 case QCAMERA_SM_EVT_SEND_COMMAND:
1857 {
1858 qcamera_sm_evt_command_payload_t *cmd_payload =
1859 (qcamera_sm_evt_command_payload_t *)payload;
1860 rc = m_parent->sendCommand(cmd_payload->cmd,
1861 cmd_payload->arg1,
1862 cmd_payload->arg2);
1863 result.status = rc;
1864 result.request_api = evt;
1865 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1866 m_parent->signalAPIResult(&result);
1867 }
1868 break;
1869 case QCAMERA_SM_EVT_TAKE_PICTURE:
1870 {
Muhua Li1d0c4772013-02-22 15:39:45 -0800[diff] [blame]1871 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1872 rc = m_parent->takeLiveSnapshot();
Muhua Li1d0c4772013-02-22 15:39:45 -0800[diff] [blame]1873 if (rc != NO_ERROR) {
1874 m_state = QCAMERA_SM_STATE_RECORDING;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1875 }
1876 result.status = rc;
1877 result.request_api = evt;
1878 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1879 m_parent->signalAPIResult(&result);
1880 }
1881 break;
1882 case QCAMERA_SM_EVT_START_RECORDING:
1883 {
1884 // no ops here
1885 ALOGD("%s: already in recording state, no ops for start_recording", __func__);
1886 rc = 0;
1887 result.status = rc;
1888 result.request_api = evt;
1889 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1890 m_parent->signalAPIResult(&result);
1891 }
1892 break;
1893 case QCAMERA_SM_EVT_STOP_RECORDING:
1894 {
1895 rc = m_parent->stopRecording();
1896 m_state = QCAMERA_SM_STATE_PREVIEWING;
1897 result.status = rc;
1898 result.request_api = evt;
1899 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1900 m_parent->signalAPIResult(&result);
1901 }
1902 break;
Emilian Peevf392f172013-05-13 16:29:53 -0700[diff] [blame]1903 case QCAMERA_SM_EVT_STOP_PREVIEW:
1904 {
1905 rc = m_parent->stopRecording();
1906 m_state = QCAMERA_SM_STATE_PREVIEWING;
1907
1908 rc = m_parent->stopPreview();
1909 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1910
1911 result.status = rc;
1912 result.request_api = evt;
1913 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1914 m_parent->signalAPIResult(&result);
1915 }
1916 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1917 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1918 {
1919 rc = m_parent->releaseRecordingFrame((const void *)payload);
1920 result.status = rc;
1921 result.request_api = evt;
1922 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1923 m_parent->signalAPIResult(&result);
1924 }
1925 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1926 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1927 {
1928 int32_t faceID = 0;
1929 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1930 (qcamera_sm_evt_reg_face_payload_t *)payload;
1931 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1932 reg_payload->config,
1933 faceID);
1934 result.status = rc;
1935 result.request_api = evt;
1936 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1937 result.handle = faceID;
1938 m_parent->signalAPIResult(&result);
1939 }
1940 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1941 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
1942 {
1943 //In Video snapshot, prepare hardware is a no-op.
1944 result.status = NO_ERROR;
1945 result.request_api = evt;
1946 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1947 m_parent->signalAPIResult(&result);
1948 }
1949 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1950 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1951 case QCAMERA_SM_EVT_START_PREVIEW:
1952 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1953 case QCAMERA_SM_EVT_RELEASE:
1954 {
1955 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1956 rc = INVALID_OPERATION;
1957 result.status = rc;
1958 result.request_api = evt;
1959 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1960 m_parent->signalAPIResult(&result);
1961 }
1962 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1963 case QCAMERA_SM_EVT_EVT_INTERNAL:
1964 {
1965 qcamera_sm_internal_evt_payload_t *internal_evt =
1966 (qcamera_sm_internal_evt_payload_t *)payload;
1967 switch (internal_evt->evt_type) {
1968 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1969 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1970 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1971 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
1972 break;
1973 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
1974 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
1975 break;
1976 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
1977 rc = m_parent->processHistogramStats(internal_evt->stats_data);
1978 break;
1979 case QCAMERA_INTERNAL_EVT_CROP_INFO:
1980 rc = m_parent->processZoomEvent(internal_evt->crop_data);
1981 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1982 default:
1983 break;
1984 }
1985 }
1986 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1987 case QCAMERA_SM_EVT_EVT_NOTIFY:
1988 {
1989 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1990 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1991 case CAM_EVENT_TYPE_DAEMON_DIED:
1992 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1993 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
1994 CAMERA_ERROR_SERVER_DIED,
1995 0);
1996 }
1997 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1998 default:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1999 ALOGE("%s: Invalid internal event %d in state(%d)",
2000 __func__, cam_evt->server_event_type, m_state);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2001 break;
2002 }
2003 }
2004 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2005 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2006 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2007 rc = m_parent->updateThermalLevel(
2008 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2009 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2010 break;
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2011 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]2012 {
2013 // No ops, but need to notify
2014 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2015 result.status = rc;
2016 result.request_api = evt;
2017 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2018 m_parent->signalEvtResult(&result);
2019 }
2020 break;
2021 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2022 default:
2023 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2024 break;
2025 }
2026
2027 return rc;
2028}
2029
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2030/*===========================================================================
2031 * FUNCTION : procEvtVideoPicTakingState
2032 *
2033 * DESCRIPTION: finite state machine function to handle event in state of
2034 * QCAMERA_SM_STATE_VIDEO_PIC_TAKING.
2035 *
2036 * PARAMETERS :
2037 * @evt : event to be processed
2038 * @payload : event payload. Can be NULL if not needed.
2039 *
2040 * RETURN : int32_t type of status
2041 * NO_ERROR -- success
2042 * none-zero failure code
2043 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2044int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt,
2045 void *payload)
2046{
2047 int32_t rc = NO_ERROR;
2048 qcamera_api_result_t result;
2049 memset(&result, 0, sizeof(qcamera_api_result_t));
2050
2051 switch (evt) {
2052 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
2053 {
2054 // Error setting preview window during previewing
2055 ALOGE("Cannot set preview window when preview is running");
2056 rc = INVALID_OPERATION;
2057 result.status = rc;
2058 result.request_api = evt;
2059 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2060 m_parent->signalAPIResult(&result);
2061 }
2062 break;
2063 case QCAMERA_SM_EVT_SET_CALLBACKS:
2064 {
2065 qcamera_sm_evt_setcb_payload_t *setcbs =
2066 (qcamera_sm_evt_setcb_payload_t *)payload;
2067 rc = m_parent->setCallBacks(setcbs->notify_cb,
2068 setcbs->data_cb,
2069 setcbs->data_cb_timestamp,
2070 setcbs->get_memory,
2071 setcbs->user);
2072 result.status = rc;
2073 result.request_api = evt;
2074 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2075 m_parent->signalAPIResult(&result);
2076 }
2077 break;
2078 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
2079 {
2080 rc = m_parent->enableMsgType(int32_t(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_DISABLE_MSG_TYPE:
2088 {
2089 rc = m_parent->disableMsgType(int32_t(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_MSG_TYPE_ENABLED:
2097 {
2098 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
2099 result.status = rc;
2100 result.request_api = evt;
2101 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2102 result.enabled = enabled;
2103 m_parent->signalAPIResult(&result);
2104 }
2105 break;
2106 case QCAMERA_SM_EVT_SET_PARAMS:
2107 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2108 bool needRestart = false;
2109 rc = m_parent->updateParameters((char*)payload, needRestart);
2110 if (rc == NO_ERROR) {
2111 if (needRestart) {
2112 // cannot set parameters that requires restart during recording
2113 ALOGE("%s: Cannot set parameters that requires restart during recording",
2114 __func__);
2115 rc = BAD_VALUE;
2116 } else {
2117 rc = m_parent->commitParameterChanges();
2118 }
2119 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2120 result.status = rc;
2121 result.request_api = evt;
2122 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2123 m_parent->signalAPIResult(&result);
2124 }
2125 break;
2126 case QCAMERA_SM_EVT_GET_PARAMS:
2127 {
2128 result.params = m_parent->getParameters();
2129 rc = NO_ERROR;
2130 result.status = rc;
2131 result.request_api = evt;
2132 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
2133 m_parent->signalAPIResult(&result);
2134 }
2135 break;
2136 case QCAMERA_SM_EVT_PUT_PARAMS:
2137 {
2138 rc = m_parent->putParameters((char*)payload);
2139 result.status = rc;
2140 result.request_api = evt;
2141 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2142 m_parent->signalAPIResult(&result);
2143 }
2144 break;
2145 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
2146 {
2147 rc = NO_ERROR;
2148 result.status = rc;
2149 result.request_api = evt;
2150 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2151 result.enabled = 1;
2152 m_parent->signalAPIResult(&result);
2153 }
2154 break;
2155 case QCAMERA_SM_EVT_RECORDING_ENABLED:
2156 {
2157 rc = NO_ERROR;
2158 result.status = rc;
2159 result.request_api = evt;
2160 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2161 result.enabled = 1;
2162 m_parent->signalAPIResult(&result);
2163 }
2164 break;
2165 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
2166 {
2167 rc = m_parent->storeMetaDataInBuffers(int(payload));
2168 result.status = rc;
2169 result.request_api = evt;
2170 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2171 m_parent->signalAPIResult(&result);
2172 }
2173 break;
2174 case QCAMERA_SM_EVT_DUMP:
2175 {
2176 rc = m_parent->dump((int)payload);
2177 result.status = rc;
2178 result.request_api = evt;
2179 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2180 m_parent->signalAPIResult(&result);
2181 }
2182 break;
2183 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
2184 {
2185 rc = m_parent->autoFocus();
2186 result.status = rc;
2187 result.request_api = evt;
2188 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2189 m_parent->signalAPIResult(&result);
2190 }
2191 break;
2192 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
2193 {
2194 rc = m_parent->cancelAutoFocus();
2195 result.status = rc;
2196 result.request_api = evt;
2197 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2198 m_parent->signalAPIResult(&result);
2199 }
2200 break;
2201 case QCAMERA_SM_EVT_SEND_COMMAND:
2202 {
2203 qcamera_sm_evt_command_payload_t *cmd_payload =
2204 (qcamera_sm_evt_command_payload_t *)payload;
2205 rc = m_parent->sendCommand(cmd_payload->cmd,
2206 cmd_payload->arg1,
2207 cmd_payload->arg2);
2208 result.status = rc;
2209 result.request_api = evt;
2210 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2211 m_parent->signalAPIResult(&result);
2212 }
2213 break;
2214 case QCAMERA_SM_EVT_STOP_RECORDING:
2215 {
2216 rc = m_parent->stopRecording();
2217 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
2218 result.status = rc;
2219 result.request_api = evt;
2220 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2221 m_parent->signalAPIResult(&result);
2222 }
2223 break;
2224 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2225 {
2226 rc = m_parent->releaseRecordingFrame((const void *)payload);
2227 result.status = rc;
2228 result.request_api = evt;
2229 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2230 m_parent->signalAPIResult(&result);
2231 }
2232 break;
2233 case QCAMERA_SM_EVT_CANCEL_PICTURE:
2234 {
2235 rc = m_parent->cancelLiveSnapshot();
2236 m_state = QCAMERA_SM_STATE_RECORDING;
2237 result.status = rc;
2238 result.request_api = evt;
2239 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2240 m_parent->signalAPIResult(&result);
2241 }
2242 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]2243 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
2244 {
2245 int32_t faceID = 0;
2246 qcamera_sm_evt_reg_face_payload_t *reg_payload =
2247 (qcamera_sm_evt_reg_face_payload_t *)payload;
2248 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
2249 reg_payload->config,
2250 faceID);
2251 result.status = rc;
2252 result.request_api = evt;
2253 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2254 result.handle = faceID;
2255 m_parent->signalAPIResult(&result);
2256 }
2257 break;
Emilian Peevf392f172013-05-13 16:29:53 -0700[diff] [blame]2258 case QCAMERA_SM_EVT_STOP_PREVIEW:
2259 {
2260 rc = m_parent->cancelLiveSnapshot();
2261 m_state = QCAMERA_SM_STATE_RECORDING;
2262
2263 rc = m_parent->stopRecording();
2264 m_state = QCAMERA_SM_STATE_PREVIEWING;
2265
2266 rc = m_parent->stopPreview();
2267 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
2268
2269 result.status = rc;
2270 result.request_api = evt;
2271 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2272 m_parent->signalAPIResult(&result);
2273 }
2274 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2275 case QCAMERA_SM_EVT_START_RECORDING:
2276 case QCAMERA_SM_EVT_START_PREVIEW:
2277 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2278 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2279 case QCAMERA_SM_EVT_TAKE_PICTURE:
2280 case QCAMERA_SM_EVT_RELEASE:
2281 {
2282 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2283 rc = INVALID_OPERATION;
2284 result.status = rc;
2285 result.request_api = evt;
2286 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2287 m_parent->signalAPIResult(&result);
2288 }
2289 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2290 case QCAMERA_SM_EVT_EVT_INTERNAL:
2291 {
2292 qcamera_sm_internal_evt_payload_t *internal_evt =
2293 (qcamera_sm_internal_evt_payload_t *)payload;
2294 switch (internal_evt->evt_type) {
2295 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2296 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2297 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2298 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
2299 break;
2300 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
2301 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
2302 break;
2303 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
2304 rc = m_parent->processHistogramStats(internal_evt->stats_data);
2305 break;
2306 case QCAMERA_INTERNAL_EVT_CROP_INFO:
2307 rc = m_parent->processZoomEvent(internal_evt->crop_data);
2308 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2309 default:
2310 break;
2311 }
2312 }
2313 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2314 case QCAMERA_SM_EVT_EVT_NOTIFY:
2315 {
2316 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2317 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2318 case CAM_EVENT_TYPE_DAEMON_DIED:
2319 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2320 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
2321 CAMERA_ERROR_SERVER_DIED,
2322 0);
2323 }
2324 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2325 default:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2326 ALOGE("%s: Invalid internal event %d in state(%d)",
2327 __func__, cam_evt->server_event_type, m_state);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2328 break;
2329 }
2330 }
2331 break;
2332 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
2333 {
2334 qcamera_jpeg_evt_payload_t *jpeg_job =
2335 (qcamera_jpeg_evt_payload_t *)payload;
2336 rc = m_parent->processJpegNotify(jpeg_job);
2337 }
2338 break;
2339 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
2340 {
2341 rc = m_parent->cancelLiveSnapshot();
2342 m_state = QCAMERA_SM_STATE_RECORDING;
Emilian Peev6d90c1f2013-04-12 09:33:06 +0300[diff] [blame]2343 result.status = rc;
2344 result.request_api = evt;
2345 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2346 m_parent->signalEvtResult(&result);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2347 }
2348 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2349 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2350 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2351 rc = m_parent->updateThermalLevel(
2352 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2353 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2354 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2355 default:
2356 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2357 break;
2358 }
2359
2360 return rc;
2361}
2362
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2363/*===========================================================================
2364 * FUNCTION : procEvtPreviewPicTakingState
2365 *
2366 * DESCRIPTION: finite state machine function to handle event in state of
2367 * QCAMERA_SM_STATE_PREVIEW_PIC_TAKING.
2368 *
2369 * PARAMETERS :
2370 * @evt : event to be processed
2371 * @payload : event payload. Can be NULL if not needed.
2372 *
2373 * RETURN : int32_t type of status
2374 * NO_ERROR -- success
2375 * none-zero failure code
2376 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2377int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt,
2378 void *payload)
2379{
2380 int32_t rc = NO_ERROR;
2381 qcamera_api_result_t result;
2382 memset(&result, 0, sizeof(qcamera_api_result_t));
2383
2384 switch (evt) {
2385 case QCAMERA_SM_EVT_SET_CALLBACKS:
2386 {
2387 qcamera_sm_evt_setcb_payload_t *setcbs =
2388 (qcamera_sm_evt_setcb_payload_t *)payload;
2389 rc = m_parent->setCallBacks(setcbs->notify_cb,
2390 setcbs->data_cb,
2391 setcbs->data_cb_timestamp,
2392 setcbs->get_memory,
2393 setcbs->user);
2394 result.status = rc;
2395 result.request_api = evt;
2396 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2397 m_parent->signalAPIResult(&result);
2398 }
2399 break;
2400 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
2401 {
2402 rc = m_parent->enableMsgType(int32_t(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_DISABLE_MSG_TYPE:
2410 {
2411 rc = m_parent->disableMsgType(int32_t(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_MSG_TYPE_ENABLED:
2419 {
2420 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
2421 result.status = rc;
2422 result.request_api = evt;
2423 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2424 result.enabled = enabled;
2425 m_parent->signalAPIResult(&result);
2426 }
2427 break;
2428 case QCAMERA_SM_EVT_SET_PARAMS:
2429 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2430 bool needRestart = false;
2431 rc = m_parent->updateParameters((char*)payload, needRestart);
2432 if (rc == NO_ERROR) {
2433 if (needRestart) {
2434 // need restart preview for parameters to take effect
2435 // stop preview
2436 m_parent->stopPreview();
2437 // commit parameter changes to server
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]2438 m_parent->commitParameterChanges();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2439 // start preview again
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]2440 rc = m_parent->preparePreview();
2441 if (rc == NO_ERROR) {
2442 rc = m_parent->startPreview();
2443 if (rc != NO_ERROR) {
2444 m_parent->unpreparePreview();
2445 }
2446 }
2447 if (rc != NO_ERROR) {
2448 m_state = QCAMERA_SM_STATE_PIC_TAKING;
2449 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2450 } else {
2451 rc = m_parent->commitParameterChanges();
2452 }
2453 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2454 result.status = rc;
2455 result.request_api = evt;
2456 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2457 m_parent->signalAPIResult(&result);
2458 }
2459 break;
2460 case QCAMERA_SM_EVT_GET_PARAMS:
2461 {
2462 result.params = m_parent->getParameters();
2463 rc = NO_ERROR;
2464 result.status = rc;
2465 result.request_api = evt;
2466 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
2467 m_parent->signalAPIResult(&result);
2468 }
2469 break;
2470 case QCAMERA_SM_EVT_PUT_PARAMS:
2471 {
2472 rc = m_parent->putParameters((char*)payload);
2473 result.status = rc;
2474 result.request_api = evt;
2475 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2476 m_parent->signalAPIResult(&result);
2477 }
2478 break;
2479 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
2480 {
2481 rc = NO_ERROR;
2482 result.status = rc;
2483 result.request_api = evt;
2484 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2485 result.enabled = 1;
2486 m_parent->signalAPIResult(&result);
2487 }
2488 break;
2489 case QCAMERA_SM_EVT_RECORDING_ENABLED:
2490 {
2491 rc = NO_ERROR;
2492 result.status = rc;
2493 result.request_api = evt;
2494 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2495 result.enabled = 0;
2496 m_parent->signalAPIResult(&result);
2497 }
2498 break;
2499 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
2500 {
2501 rc = m_parent->storeMetaDataInBuffers(int(payload));
2502 result.status = rc;
2503 result.request_api = evt;
2504 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2505 m_parent->signalAPIResult(&result);
2506 }
2507 break;
2508 case QCAMERA_SM_EVT_DUMP:
2509 {
2510 rc = m_parent->dump((int)payload);
2511 result.status = rc;
2512 result.request_api = evt;
2513 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2514 m_parent->signalAPIResult(&result);
2515 }
2516 break;
2517 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
2518 {
2519 rc = m_parent->autoFocus();
2520 result.status = rc;
2521 result.request_api = evt;
2522 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2523 m_parent->signalAPIResult(&result);
2524 }
2525 break;
2526 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
2527 {
2528 rc = m_parent->cancelAutoFocus();
2529 result.status = rc;
2530 result.request_api = evt;
2531 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2532 m_parent->signalAPIResult(&result);
2533 }
2534 break;
2535 case QCAMERA_SM_EVT_SEND_COMMAND:
2536 {
2537 qcamera_sm_evt_command_payload_t *cmd_payload =
2538 (qcamera_sm_evt_command_payload_t *)payload;
2539 rc = m_parent->sendCommand(cmd_payload->cmd,
2540 cmd_payload->arg1,
2541 cmd_payload->arg2);
2542 result.status = rc;
2543 result.request_api = evt;
2544 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2545 m_parent->signalAPIResult(&result);
2546 }
2547 break;
2548 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2549 {
2550 rc = m_parent->releaseRecordingFrame((const void *)payload);
2551 result.status = rc;
2552 result.request_api = evt;
2553 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2554 m_parent->signalAPIResult(&result);
2555 }
2556 break;
2557 case QCAMERA_SM_EVT_CANCEL_PICTURE:
2558 {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]2559 if (m_parent->isZSLMode()) {
2560 rc = m_parent->cancelPicture();
2561 } else {
2562 rc = m_parent->cancelLiveSnapshot();
2563 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2564 m_state = QCAMERA_SM_STATE_PREVIEWING;
2565 result.status = rc;
2566 result.request_api = evt;
2567 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2568 m_parent->signalAPIResult(&result);
2569 }
2570 break;
2571 case QCAMERA_SM_EVT_STOP_PREVIEW:
2572 {
Muhua Libd1b6122013-03-05 15:25:27 -0800[diff] [blame]2573 if (m_parent->isZSLMode()) {
2574 // cancel picture first
2575 rc = m_parent->cancelPicture();
2576 m_parent->stopChannel(QCAMERA_CH_TYPE_ZSL);
2577 } else {
2578 rc = m_parent->cancelLiveSnapshot();
2579 m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW);
2580 }
2581 // unprepare preview
2582 m_parent->unpreparePreview();
2583 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2584 result.status = rc;
2585 result.request_api = evt;
2586 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2587 m_parent->signalAPIResult(&result);
2588 }
2589 break;
2590 case QCAMERA_SM_EVT_START_RECORDING:
2591 {
Muhua Licf1cf672013-05-10 09:42:50 -0700[diff] [blame]2592 if (m_parent->isZSLMode()) {
2593 ALOGE("%s: cannot handle evt(%d) in state(%d) in ZSL mode",
2594 __func__, evt, m_state);
2595 rc = INVALID_OPERATION;
2596 } else {
2597 rc = m_parent->startRecording();
2598 if (rc == NO_ERROR) {
2599 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
2600 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2601 }
2602 result.status = rc;
2603 result.request_api = evt;
2604 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2605 m_parent->signalAPIResult(&result);
2606 }
2607 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]2608 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
2609 {
2610 int32_t faceID = 0;
2611 qcamera_sm_evt_reg_face_payload_t *reg_payload =
2612 (qcamera_sm_evt_reg_face_payload_t *)payload;
2613 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
2614 reg_payload->config,
2615 faceID);
2616 result.status = rc;
2617 result.request_api = evt;
2618 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2619 result.handle = faceID;
2620 m_parent->signalAPIResult(&result);
2621 }
2622 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2623 case QCAMERA_SM_EVT_STOP_RECORDING:
2624 case QCAMERA_SM_EVT_START_PREVIEW:
2625 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2626 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2627 case QCAMERA_SM_EVT_TAKE_PICTURE:
2628 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
2629 case QCAMERA_SM_EVT_RELEASE:
2630 {
2631 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2632 rc = INVALID_OPERATION;
2633 result.status = rc;
2634 result.request_api = evt;
2635 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2636 m_parent->signalAPIResult(&result);
2637 }
2638 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2639 case QCAMERA_SM_EVT_EVT_INTERNAL:
2640 {
2641 qcamera_sm_internal_evt_payload_t *internal_evt =
2642 (qcamera_sm_internal_evt_payload_t *)payload;
2643 switch (internal_evt->evt_type) {
2644 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2645 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2646 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2647 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
2648 break;
2649 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
2650 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
2651 break;
2652 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
2653 rc = m_parent->processHistogramStats(internal_evt->stats_data);
2654 break;
2655 case QCAMERA_INTERNAL_EVT_CROP_INFO:
2656 rc = m_parent->processZoomEvent(internal_evt->crop_data);
2657 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2658 default:
2659 break;
2660 }
2661 }
2662 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2663 case QCAMERA_SM_EVT_EVT_NOTIFY:
2664 {
2665 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2666 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2667 case CAM_EVENT_TYPE_DAEMON_DIED:
2668 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2669 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
2670 CAMERA_ERROR_SERVER_DIED,
2671 0);
2672 }
2673 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2674 default:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2675 ALOGE("%s: Invalid internal event %d in state(%d)",
2676 __func__, cam_evt->server_event_type, m_state);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2677 break;
2678 }
2679 }
2680 break;
2681 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
2682 {
2683 qcamera_jpeg_evt_payload_t *jpeg_job =
2684 (qcamera_jpeg_evt_payload_t *)payload;
2685 rc = m_parent->processJpegNotify(jpeg_job);
2686 }
2687 break;
2688 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
2689 {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]2690 if (m_parent->isZSLMode()) {
2691 rc = m_parent->cancelPicture();
2692 } else {
2693 rc = m_parent->cancelLiveSnapshot();
2694 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2695 m_state = QCAMERA_SM_STATE_PREVIEWING;
Emilian Peev6d90c1f2013-04-12 09:33:06 +0300[diff] [blame]2696 result.status = rc;
2697 result.request_api = evt;
2698 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2699 m_parent->signalEvtResult(&result);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2700 }
2701 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2702 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2703 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2704 rc = m_parent->updateThermalLevel(
2705 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2706 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2707 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2708 default:
2709 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2710 break;
2711 }
2712
2713 return rc;
2714}
2715
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2716/*===========================================================================
2717 * FUNCTION : isPreviewRunning
2718 *
2719 * DESCRIPTION: check if preview is in process.
2720 *
2721 * PARAMETERS : None
2722 *
2723 * RETURN : true -- preview running
2724 * false -- preview stopped
2725 *==========================================================================*/
2726bool QCameraStateMachine::isPreviewRunning()
2727{
2728 switch (m_state) {
2729 case QCAMERA_SM_STATE_PREVIEWING:
2730 case QCAMERA_SM_STATE_RECORDING:
2731 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
2732 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
Muhua Libf818e52013-04-23 18:05:26 -0700[diff] [blame]2733 case QCAMERA_SM_STATE_PREPARE_SNAPSHOT:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2734 return true;
2735 default:
2736 return false;
2737 }
2738}
2739
Shuzhen Wang89635cf2012-12-20 13:47:22 -0800[diff] [blame]2740}; // namespace qcamera