Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / hardware / qcom / camera / 9c53a9e6bfe3a86dfb81cd8b3185e260ecda4537 / . / QCamera2 / HAL / QCameraStateMachine.cpp
blob: e724d1cd79d66555a9be71e2b97c7a0c44952e89 [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 {
494 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
495 rc = INVALID_OPERATION;
496 result.status = rc;
497 result.request_api = evt;
498 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
499 m_parent->signalAPIResult(&result);
500 }
501 break;
Georgi Hristv72d768f2013-10-02 17:47:59 +0300[diff] [blame]502 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
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) {
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]1111 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]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;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]1204 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
1205 rc = m_parent->processASDUpdate(internal_evt->asd_data);
1206 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1207 default:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1208 ALOGE("%s: Invalid internal event %d in state(%d)",
1209 __func__, internal_evt->evt_type, m_state);
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1210 break;
1211 }
1212 }
1213 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1214 case QCAMERA_SM_EVT_EVT_NOTIFY:
1215 {
1216 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1217 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1218 case CAM_EVENT_TYPE_DAEMON_DIED:
1219 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1220 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
1221 CAMERA_ERROR_SERVER_DIED,
1222 0);
1223 }
1224 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1225 default:
1226 ALOGD("%s: no handling for server evt (%d) at this state",
1227 __func__, cam_evt->server_event_type);
1228 break;
1229 }
1230 }
1231 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1232 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1233 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]1234 rc = m_parent->updateThermalLevel(
1235 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1236 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1237 break;
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1238 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]1239 {
1240 // No ops, but need to notify
1241 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1242 result.status = rc;
1243 result.request_api = evt;
1244 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1245 m_parent->signalEvtResult(&result);
1246 }
1247 break;
1248 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1249 default:
1250 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1251 break;
1252 }
1253
1254 return rc;
1255}
1256
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1257/*===========================================================================
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1258 * FUNCTION : procEvtPrepareSnapshotState
1259 *
1260 * DESCRIPTION: finite state machine function to handle event in state of
1261 * QCAMERA_SM_STATE_PREPARE_SNAPSHOT.
1262 *
1263 * PARAMETERS :
1264 * @evt : event to be processed
1265 * @payload : event payload. Can be NULL if not needed.
1266 *
1267 * RETURN : int32_t type of status
1268 * NO_ERROR -- success
1269 * none-zero failure code
1270 *==========================================================================*/
1271int32_t QCameraStateMachine::procEvtPrepareSnapshotState(qcamera_sm_evt_enum_t evt,
1272 void *payload)
1273{
1274 int32_t rc = NO_ERROR;
1275 qcamera_api_result_t result;
1276 memset(&result, 0, sizeof(qcamera_api_result_t));
1277
1278 switch (evt) {
1279 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1280 case QCAMERA_SM_EVT_SET_CALLBACKS:
1281 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1282 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1283 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1284 case QCAMERA_SM_EVT_SET_PARAMS:
1285 case QCAMERA_SM_EVT_GET_PARAMS:
1286 case QCAMERA_SM_EVT_PUT_PARAMS:
1287 case QCAMERA_SM_EVT_START_PREVIEW:
1288 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1289 case QCAMERA_SM_EVT_STOP_PREVIEW:
1290 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1291 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1292 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1293 case QCAMERA_SM_EVT_DUMP:
1294 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1295 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1296 case QCAMERA_SM_EVT_START_RECORDING:
1297 case QCAMERA_SM_EVT_TAKE_PICTURE:
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1298 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1299 case QCAMERA_SM_EVT_SEND_COMMAND:
1300 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1301 case QCAMERA_SM_EVT_STOP_RECORDING:
1302 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1303 case QCAMERA_SM_EVT_RELEASE:
1304 {
1305 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1306 rc = INVALID_OPERATION;
1307 result.status = rc;
1308 result.request_api = evt;
1309 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1310 m_parent->signalAPIResult(&result);
1311 }
1312 break;
1313 case QCAMERA_SM_EVT_EVT_INTERNAL:
1314 {
1315 qcamera_sm_internal_evt_payload_t *internal_evt =
1316 (qcamera_sm_internal_evt_payload_t *)payload;
1317 switch (internal_evt->evt_type) {
Muhua Li6f3c5322013-05-08 17:20:17 -0700[diff] [blame]1318 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1319 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1320 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1321 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
1322 ALOGI("%s: Received QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE event",
1323 __func__);
1324 m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state);
1325 m_state = QCAMERA_SM_STATE_PREVIEWING;
1326
1327 result.status = NO_ERROR;
1328 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT;
1329 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1330 m_parent->signalAPIResult(&result);
1331 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1332 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
1333 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
1334 break;
1335 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
1336 rc = m_parent->processHistogramStats(internal_evt->stats_data);
1337 break;
1338 case QCAMERA_INTERNAL_EVT_CROP_INFO:
1339 rc = m_parent->processZoomEvent(internal_evt->crop_data);
1340 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]1341 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
1342 rc = m_parent->processASDUpdate(internal_evt->asd_data);
1343 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1344 default:
1345 ALOGE("%s: Invalid internal event %d in state(%d)",
1346 __func__, internal_evt->evt_type, m_state);
1347 break;
1348 }
1349 }
1350 break;
1351 case QCAMERA_SM_EVT_EVT_NOTIFY:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1352 {
1353 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1354 switch (cam_evt->server_event_type) {
1355 case CAM_EVENT_TYPE_DAEMON_DIED:
1356 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1357 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
1358 CAMERA_ERROR_SERVER_DIED,
1359 0);
1360 }
1361 break;
1362 default:
1363 ALOGE("%s: Invalid internal event %d in state(%d)",
1364 __func__, cam_evt->server_event_type, m_state);
1365 break;
1366 }
1367 }
1368 break;
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]1369 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1370 {
1371 // No ops, but need to notify
1372 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1373 result.status = rc;
1374 result.request_api = evt;
1375 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1376 m_parent->signalEvtResult(&result);
1377 }
1378 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1379 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
1380 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1381 default:
1382 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1383 break;
1384 }
1385
1386 return rc;
1387}
1388
1389/*===========================================================================
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1390 * FUNCTION : procEvtPicTakingState
1391 *
1392 * DESCRIPTION: finite state machine function to handle event in state of
1393 * QCAMERA_SM_STATE_PIC_TAKING.
1394 *
1395 * PARAMETERS :
1396 * @evt : event to be processed
1397 * @payload : event payload. Can be NULL if not needed.
1398 *
1399 * RETURN : int32_t type of status
1400 * NO_ERROR -- success
1401 * none-zero failure code
1402 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1403int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt,
1404 void *payload)
1405{
1406 int32_t rc = NO_ERROR;
1407 qcamera_api_result_t result;
1408 memset(&result, 0, sizeof(qcamera_api_result_t));
1409
1410 switch (evt) {
1411 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1412 {
1413 // Error setting preview window during previewing
1414 ALOGE("Cannot set preview window when preview is running");
1415 rc = INVALID_OPERATION;
1416 result.status = rc;
1417 result.request_api = evt;
1418 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1419 m_parent->signalAPIResult(&result);
1420 }
1421 break;
1422 case QCAMERA_SM_EVT_SET_CALLBACKS:
1423 {
1424 qcamera_sm_evt_setcb_payload_t *setcbs =
1425 (qcamera_sm_evt_setcb_payload_t *)payload;
1426 rc = m_parent->setCallBacks(setcbs->notify_cb,
1427 setcbs->data_cb,
1428 setcbs->data_cb_timestamp,
1429 setcbs->get_memory,
1430 setcbs->user);
1431 result.status = rc;
1432 result.request_api = evt;
1433 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1434 m_parent->signalAPIResult(&result);
1435 }
1436 break;
1437 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1438 {
1439 rc = m_parent->enableMsgType(int32_t(payload));
1440 result.status = rc;
1441 result.request_api = evt;
1442 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1443 m_parent->signalAPIResult(&result);
1444 }
1445 break;
1446 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1447 {
1448 rc = m_parent->disableMsgType(int32_t(payload));
1449 result.status = rc;
1450 result.request_api = evt;
1451 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1452 m_parent->signalAPIResult(&result);
1453 }
1454 break;
1455 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1456 {
1457 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1458 result.status = rc;
1459 result.request_api = evt;
1460 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1461 result.enabled = enabled;
1462 m_parent->signalAPIResult(&result);
1463 }
1464 break;
1465 case QCAMERA_SM_EVT_SET_PARAMS:
1466 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1467 bool needRestart = false;
1468 rc = m_parent->updateParameters((char*)payload, needRestart);
1469 if (rc == NO_ERROR) {
1470 rc = m_parent->commitParameterChanges();
1471 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1472 result.status = rc;
1473 result.request_api = evt;
1474 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1475 m_parent->signalAPIResult(&result);
1476 }
1477 break;
1478 case QCAMERA_SM_EVT_GET_PARAMS:
1479 {
1480 result.params = m_parent->getParameters();
1481 rc = NO_ERROR;
1482 result.status = rc;
1483 result.request_api = evt;
1484 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1485 m_parent->signalAPIResult(&result);
1486 }
1487 break;
1488 case QCAMERA_SM_EVT_PUT_PARAMS:
1489 {
1490 rc = m_parent->putParameters((char*)payload);
1491 result.status = rc;
1492 result.request_api = evt;
1493 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1494 m_parent->signalAPIResult(&result);
1495 }
1496 break;
1497 case QCAMERA_SM_EVT_STOP_PREVIEW:
1498 {
Muhua Libd1b6122013-03-05 15:25:27 -0800[diff] [blame]1499 // cancel picture first
1500 rc = m_parent->cancelPicture();
1501 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1502
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1503 result.status = rc;
1504 result.request_api = evt;
1505 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1506 m_parent->signalAPIResult(&result);
1507 }
1508 break;
1509 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1510 {
1511 rc = NO_ERROR;
1512 result.status = rc;
1513 result.request_api = evt;
1514 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1515 result.enabled = 0;
1516 m_parent->signalAPIResult(&result);
1517 }
1518 break;
1519 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1520 {
1521 rc = NO_ERROR;
1522 result.status = rc;
1523 result.request_api = evt;
1524 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1525 result.enabled = 0;
1526 m_parent->signalAPIResult(&result);
1527 }
1528 break;
1529 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1530 {
1531 rc = m_parent->storeMetaDataInBuffers(int(payload));
1532 result.status = rc;
1533 result.request_api = evt;
1534 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1535 m_parent->signalAPIResult(&result);
1536 }
1537 break;
1538 case QCAMERA_SM_EVT_DUMP:
1539 {
1540 rc = m_parent->dump((int)payload);
1541 result.status = rc;
1542 result.request_api = evt;
1543 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1544 m_parent->signalAPIResult(&result);
1545 }
1546 break;
1547 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1548 {
1549 rc = m_parent->autoFocus();
1550 result.status = rc;
1551 result.request_api = evt;
1552 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1553 m_parent->signalAPIResult(&result);
1554 }
1555 break;
1556 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1557 {
1558 rc = m_parent->cancelAutoFocus();
1559 result.status = rc;
1560 result.request_api = evt;
1561 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1562 m_parent->signalAPIResult(&result);
1563 }
1564 break;
1565 case QCAMERA_SM_EVT_SEND_COMMAND:
1566 {
1567 qcamera_sm_evt_command_payload_t *cmd_payload =
1568 (qcamera_sm_evt_command_payload_t *)payload;
1569 rc = m_parent->sendCommand(cmd_payload->cmd,
1570 cmd_payload->arg1,
1571 cmd_payload->arg2);
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]1572 if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) {
1573 // move state to previewing state
1574 m_state = QCAMERA_SM_STATE_PREVIEWING;
1575 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]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;
1582 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1583 {
1584 rc = m_parent->cancelPicture();
1585 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1586 result.status = rc;
1587 result.request_api = evt;
1588 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1589 m_parent->signalAPIResult(&result);
1590 }
1591 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1592 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1593 {
1594 int32_t faceID = 0;
1595 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1596 (qcamera_sm_evt_reg_face_payload_t *)payload;
1597 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1598 reg_payload->config,
1599 faceID);
1600 result.status = rc;
1601 result.request_api = evt;
1602 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1603 result.handle = faceID;
1604 m_parent->signalAPIResult(&result);
1605 }
1606 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1607 case QCAMERA_SM_EVT_TAKE_PICTURE:
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]1608 {
1609 if ( m_parent->isLongshotEnabled() ) {
1610 rc = m_parent->longShot();
1611 } else {
1612 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1613 rc = INVALID_OPERATION;
1614 }
1615
1616 result.status = rc;
1617 result.request_api = evt;
1618 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1619 m_parent->signalAPIResult(&result);
1620 }
1621 break;
1622 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1623 case QCAMERA_SM_EVT_START_RECORDING:
1624 case QCAMERA_SM_EVT_STOP_RECORDING:
1625 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1626 case QCAMERA_SM_EVT_START_PREVIEW:
1627 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1628 case QCAMERA_SM_EVT_RELEASE:
1629 {
1630 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1631 rc = INVALID_OPERATION;
1632 result.status = rc;
1633 result.request_api = evt;
1634 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1635 m_parent->signalAPIResult(&result);
1636 }
1637 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1638 case QCAMERA_SM_EVT_EVT_INTERNAL:
1639 {
1640 qcamera_sm_internal_evt_payload_t *internal_evt =
1641 (qcamera_sm_internal_evt_payload_t *)payload;
1642 switch (internal_evt->evt_type) {
1643 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1644 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1645 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1646 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
1647 break;
1648 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
1649 break;
1650 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
1651 break;
1652 case QCAMERA_INTERNAL_EVT_CROP_INFO:
1653 rc = m_parent->processZoomEvent(internal_evt->crop_data);
1654 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]1655 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
1656 rc = m_parent->processASDUpdate(internal_evt->asd_data);
1657 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1658 default:
1659 break;
1660 }
1661 }
1662 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1663 case QCAMERA_SM_EVT_EVT_NOTIFY:
1664 {
1665 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1666 switch (cam_evt->server_event_type) {
Emilian Peev9c53a9e2013-12-12 15:58:13 +0200[diff] [blame^]1667 case CAM_EVENT_TYPE_REPROCESS_STAGE_DONE:
1668 {
1669 if ( m_parent->isLongshotEnabled() ) {
1670 if(!m_parent->m_postprocessor.getMultipleStages()) {
1671 m_parent->m_postprocessor.setMultipleStages(true);
1672 }
1673 m_parent->playShutter();
1674 }
1675 }
1676 break;
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1677 case CAM_EVENT_TYPE_DAEMON_DIED:
1678 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1679 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
1680 CAMERA_ERROR_SERVER_DIED,
1681 0);
1682 }
1683 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1684 default:
1685 ALOGD("%s: no handling for server evt (%d) at this state",
1686 __func__, cam_evt->server_event_type);
1687 break;
1688 }
1689 }
1690 break;
1691 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1692 {
1693 qcamera_jpeg_evt_payload_t *jpeg_job =
1694 (qcamera_jpeg_evt_payload_t *)payload;
1695 rc = m_parent->processJpegNotify(jpeg_job);
1696 }
1697 break;
Emilian Peev7d36a812013-11-20 00:15:54 -0800[diff] [blame]1698 case QCAMERA_SM_EVT_STOP_CAPTURE_CHANNEL:
1699 {
Emilian Peev8a977232013-11-04 07:56:32 -0800[diff] [blame]1700 bool restartPreview = m_parent->isPreviewRestartEnabled();
1701 rc = m_parent->stopCaptureChannel(restartPreview);
1702
1703 if (restartPreview && (NO_ERROR == rc)) {
1704 rc = m_parent->preparePreview();
1705 if (NO_ERROR == rc) {
1706 m_parent->m_bPreviewStarted = true;
1707 rc = m_parent->startPreview();
1708 }
1709 }
1710
Emilian Peev7d36a812013-11-20 00:15:54 -0800[diff] [blame]1711 result.status = rc;
1712 result.request_api = evt;
1713 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1714 m_parent->signalAPIResult(&result);
1715 }
1716 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1717 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1718 {
1719 rc = m_parent->cancelPicture();
Emilian Peev8a977232013-11-04 07:56:32 -0800[diff] [blame]1720
1721 bool restartPreview = m_parent->isPreviewRestartEnabled();
1722 if (restartPreview) {
1723 m_state = QCAMERA_SM_STATE_PREVIEWING;
1724 } else {
1725 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1726 }
1727
Emilian Peev6d90c1f2013-04-12 09:33:06 +0300[diff] [blame]1728 result.status = rc;
1729 result.request_api = evt;
1730 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1731 m_parent->signalEvtResult(&result);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1732 }
1733 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1734 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peev2ae455e2013-04-18 10:41:56 +0300[diff] [blame]1735 {
1736 rc = m_parent->updateThermalLevel(
1737 *(qcamera_thermal_level_enum_t *)&payload);
1738 }
1739 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1740 default:
1741 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1742 break;
1743 }
1744
1745 return rc;
1746}
1747
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1748/*===========================================================================
1749 * FUNCTION : procEvtRecordingState
1750 *
1751 * DESCRIPTION: finite state machine function to handle event in state of
1752 * QCAMERA_SM_STATE_RECORDING.
1753 *
1754 * PARAMETERS :
1755 * @evt : event to be processed
1756 * @payload : event payload. Can be NULL if not needed.
1757 *
1758 * RETURN : int32_t type of status
1759 * NO_ERROR -- success
1760 * none-zero failure code
1761 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1762int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt,
1763 void *payload)
1764{
1765 int32_t rc = NO_ERROR;
1766 qcamera_api_result_t result;
1767 memset(&result, 0, sizeof(qcamera_api_result_t));
1768
1769 switch (evt) {
Emilian Peev88293e92013-06-07 12:37:18 +0300[diff] [blame]1770 case QCAMERA_SM_EVT_START_PREVIEW:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1771 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1772 {
Emilian Peev88293e92013-06-07 12:37:18 +0300[diff] [blame]1773 // WA: CTS test VideoSnapshot will try to
1774 // start preview during video recording.
1775 ALOGE("CTS video restart op");
1776 rc = NO_ERROR;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1777 result.status = rc;
1778 result.request_api = evt;
1779 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1780 m_parent->signalAPIResult(&result);
1781 }
1782 break;
1783 case QCAMERA_SM_EVT_SET_CALLBACKS:
1784 {
1785 qcamera_sm_evt_setcb_payload_t *setcbs =
1786 (qcamera_sm_evt_setcb_payload_t *)payload;
1787 rc = m_parent->setCallBacks(setcbs->notify_cb,
1788 setcbs->data_cb,
1789 setcbs->data_cb_timestamp,
1790 setcbs->get_memory,
1791 setcbs->user);
1792 result.status = rc;
1793 result.request_api = evt;
1794 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1795 m_parent->signalAPIResult(&result);
1796 }
1797 break;
1798 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1799 {
1800 rc = m_parent->enableMsgType(int32_t(payload));
1801 result.status = rc;
1802 result.request_api = evt;
1803 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1804 m_parent->signalAPIResult(&result);
1805 }
1806 break;
1807 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1808 {
1809 rc = m_parent->disableMsgType(int32_t(payload));
1810 result.status = rc;
1811 result.request_api = evt;
1812 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1813 m_parent->signalAPIResult(&result);
1814 }
1815 break;
1816 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1817 {
1818 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1819 result.status = rc;
1820 result.request_api = evt;
1821 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1822 result.enabled = enabled;
1823 m_parent->signalAPIResult(&result);
1824 }
1825 break;
1826 case QCAMERA_SM_EVT_SET_PARAMS:
1827 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1828 bool needRestart = false;
1829 rc = m_parent->updateParameters((char*)payload, needRestart);
1830 if (rc == NO_ERROR) {
1831 if (needRestart) {
1832 // cannot set parameters that requires restart during recording
1833 ALOGE("%s: Cannot set parameters that requires restart during recording",
1834 __func__);
1835 rc = BAD_VALUE;
1836 } else {
1837 rc = m_parent->commitParameterChanges();
1838 }
1839 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1840 result.status = rc;
1841 result.request_api = evt;
1842 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1843 m_parent->signalAPIResult(&result);
1844 }
1845 break;
1846 case QCAMERA_SM_EVT_GET_PARAMS:
1847 {
1848 result.params = m_parent->getParameters();
1849 rc = NO_ERROR;
1850 result.status = rc;
1851 result.request_api = evt;
1852 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1853 m_parent->signalAPIResult(&result);
1854 }
1855 break;
1856 case QCAMERA_SM_EVT_PUT_PARAMS:
1857 {
1858 rc = m_parent->putParameters((char*)payload);
1859 result.status = rc;
1860 result.request_api = evt;
1861 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1862 m_parent->signalAPIResult(&result);
1863 }
1864 break;
1865 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1866 {
1867 rc = NO_ERROR;
1868 result.status = rc;
1869 result.request_api = evt;
1870 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1871 result.enabled = 0;
1872 m_parent->signalAPIResult(&result);
1873 }
1874 break;
1875 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1876 {
1877 rc = NO_ERROR;
1878 result.status = rc;
1879 result.request_api = evt;
1880 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1881 result.enabled = 1;
1882 m_parent->signalAPIResult(&result);
1883 }
1884 break;
1885 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1886 {
1887 rc = m_parent->storeMetaDataInBuffers(int(payload));
1888 result.status = rc;
1889 result.request_api = evt;
1890 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1891 m_parent->signalAPIResult(&result);
1892 }
1893 break;
1894 case QCAMERA_SM_EVT_DUMP:
1895 {
1896 rc = m_parent->dump((int)payload);
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;
1903 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1904 {
1905 rc = m_parent->autoFocus();
1906 result.status = rc;
1907 result.request_api = evt;
1908 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1909 m_parent->signalAPIResult(&result);
1910 }
1911 break;
1912 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1913 {
1914 rc = m_parent->cancelAutoFocus();
1915 result.status = rc;
1916 result.request_api = evt;
1917 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1918 m_parent->signalAPIResult(&result);
1919 }
1920 break;
1921 case QCAMERA_SM_EVT_SEND_COMMAND:
1922 {
1923 qcamera_sm_evt_command_payload_t *cmd_payload =
1924 (qcamera_sm_evt_command_payload_t *)payload;
1925 rc = m_parent->sendCommand(cmd_payload->cmd,
1926 cmd_payload->arg1,
1927 cmd_payload->arg2);
1928 result.status = rc;
1929 result.request_api = evt;
1930 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1931 m_parent->signalAPIResult(&result);
1932 }
1933 break;
1934 case QCAMERA_SM_EVT_TAKE_PICTURE:
1935 {
Muhua Li1d0c4772013-02-22 15:39:45 -0800[diff] [blame]1936 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1937 rc = m_parent->takeLiveSnapshot();
Muhua Li1d0c4772013-02-22 15:39:45 -0800[diff] [blame]1938 if (rc != NO_ERROR) {
1939 m_state = QCAMERA_SM_STATE_RECORDING;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1940 }
1941 result.status = rc;
1942 result.request_api = evt;
1943 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1944 m_parent->signalAPIResult(&result);
1945 }
1946 break;
1947 case QCAMERA_SM_EVT_START_RECORDING:
1948 {
1949 // no ops here
1950 ALOGD("%s: already in recording state, no ops for start_recording", __func__);
1951 rc = 0;
1952 result.status = rc;
1953 result.request_api = evt;
1954 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1955 m_parent->signalAPIResult(&result);
1956 }
1957 break;
1958 case QCAMERA_SM_EVT_STOP_RECORDING:
1959 {
1960 rc = m_parent->stopRecording();
1961 m_state = QCAMERA_SM_STATE_PREVIEWING;
1962 result.status = rc;
1963 result.request_api = evt;
1964 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1965 m_parent->signalAPIResult(&result);
1966 }
1967 break;
Emilian Peevf392f172013-05-13 16:29:53 -0700[diff] [blame]1968 case QCAMERA_SM_EVT_STOP_PREVIEW:
1969 {
1970 rc = m_parent->stopRecording();
1971 m_state = QCAMERA_SM_STATE_PREVIEWING;
1972
1973 rc = m_parent->stopPreview();
1974 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1975
1976 result.status = rc;
1977 result.request_api = evt;
1978 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1979 m_parent->signalAPIResult(&result);
1980 }
1981 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1982 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1983 {
1984 rc = m_parent->releaseRecordingFrame((const void *)payload);
1985 result.status = rc;
1986 result.request_api = evt;
1987 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1988 m_parent->signalAPIResult(&result);
1989 }
1990 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1991 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1992 {
1993 int32_t faceID = 0;
1994 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1995 (qcamera_sm_evt_reg_face_payload_t *)payload;
1996 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1997 reg_payload->config,
1998 faceID);
1999 result.status = rc;
2000 result.request_api = evt;
2001 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2002 result.handle = faceID;
2003 m_parent->signalAPIResult(&result);
2004 }
2005 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]2006 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
2007 {
2008 //In Video snapshot, prepare hardware is a no-op.
2009 result.status = NO_ERROR;
2010 result.request_api = evt;
2011 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2012 m_parent->signalAPIResult(&result);
2013 }
2014 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2015 case QCAMERA_SM_EVT_CANCEL_PICTURE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2016 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2017 case QCAMERA_SM_EVT_RELEASE:
2018 {
2019 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2020 rc = INVALID_OPERATION;
2021 result.status = rc;
2022 result.request_api = evt;
2023 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2024 m_parent->signalAPIResult(&result);
2025 }
2026 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2027 case QCAMERA_SM_EVT_EVT_INTERNAL:
2028 {
2029 qcamera_sm_internal_evt_payload_t *internal_evt =
2030 (qcamera_sm_internal_evt_payload_t *)payload;
2031 switch (internal_evt->evt_type) {
2032 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2033 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2034 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2035 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
2036 break;
2037 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
2038 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
2039 break;
2040 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
2041 rc = m_parent->processHistogramStats(internal_evt->stats_data);
2042 break;
2043 case QCAMERA_INTERNAL_EVT_CROP_INFO:
2044 rc = m_parent->processZoomEvent(internal_evt->crop_data);
2045 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]2046 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
2047 rc = m_parent->processASDUpdate(internal_evt->asd_data);
2048 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2049 default:
2050 break;
2051 }
2052 }
2053 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2054 case QCAMERA_SM_EVT_EVT_NOTIFY:
2055 {
2056 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2057 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2058 case CAM_EVENT_TYPE_DAEMON_DIED:
2059 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2060 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
2061 CAMERA_ERROR_SERVER_DIED,
2062 0);
2063 }
2064 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2065 default:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2066 ALOGE("%s: Invalid internal event %d in state(%d)",
2067 __func__, cam_evt->server_event_type, m_state);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2068 break;
2069 }
2070 }
2071 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2072 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2073 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2074 rc = m_parent->updateThermalLevel(
2075 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2076 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2077 break;
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2078 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]2079 {
2080 // No ops, but need to notify
2081 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2082 result.status = rc;
2083 result.request_api = evt;
2084 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2085 m_parent->signalEvtResult(&result);
2086 }
2087 break;
2088 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2089 default:
2090 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2091 break;
2092 }
2093
2094 return rc;
2095}
2096
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2097/*===========================================================================
2098 * FUNCTION : procEvtVideoPicTakingState
2099 *
2100 * DESCRIPTION: finite state machine function to handle event in state of
2101 * QCAMERA_SM_STATE_VIDEO_PIC_TAKING.
2102 *
2103 * PARAMETERS :
2104 * @evt : event to be processed
2105 * @payload : event payload. Can be NULL if not needed.
2106 *
2107 * RETURN : int32_t type of status
2108 * NO_ERROR -- success
2109 * none-zero failure code
2110 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2111int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt,
2112 void *payload)
2113{
2114 int32_t rc = NO_ERROR;
2115 qcamera_api_result_t result;
2116 memset(&result, 0, sizeof(qcamera_api_result_t));
2117
2118 switch (evt) {
2119 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
2120 {
2121 // Error setting preview window during previewing
2122 ALOGE("Cannot set preview window when preview is running");
2123 rc = INVALID_OPERATION;
2124 result.status = rc;
2125 result.request_api = evt;
2126 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2127 m_parent->signalAPIResult(&result);
2128 }
2129 break;
2130 case QCAMERA_SM_EVT_SET_CALLBACKS:
2131 {
2132 qcamera_sm_evt_setcb_payload_t *setcbs =
2133 (qcamera_sm_evt_setcb_payload_t *)payload;
2134 rc = m_parent->setCallBacks(setcbs->notify_cb,
2135 setcbs->data_cb,
2136 setcbs->data_cb_timestamp,
2137 setcbs->get_memory,
2138 setcbs->user);
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_ENABLE_MSG_TYPE:
2146 {
2147 rc = m_parent->enableMsgType(int32_t(payload));
2148 result.status = rc;
2149 result.request_api = evt;
2150 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2151 m_parent->signalAPIResult(&result);
2152 }
2153 break;
2154 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
2155 {
2156 rc = m_parent->disableMsgType(int32_t(payload));
2157 result.status = rc;
2158 result.request_api = evt;
2159 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2160 m_parent->signalAPIResult(&result);
2161 }
2162 break;
2163 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
2164 {
2165 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
2166 result.status = rc;
2167 result.request_api = evt;
2168 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2169 result.enabled = enabled;
2170 m_parent->signalAPIResult(&result);
2171 }
2172 break;
2173 case QCAMERA_SM_EVT_SET_PARAMS:
2174 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2175 bool needRestart = false;
2176 rc = m_parent->updateParameters((char*)payload, needRestart);
2177 if (rc == NO_ERROR) {
2178 if (needRestart) {
2179 // cannot set parameters that requires restart during recording
2180 ALOGE("%s: Cannot set parameters that requires restart during recording",
2181 __func__);
2182 rc = BAD_VALUE;
2183 } else {
2184 rc = m_parent->commitParameterChanges();
2185 }
2186 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2187 result.status = rc;
2188 result.request_api = evt;
2189 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2190 m_parent->signalAPIResult(&result);
2191 }
2192 break;
2193 case QCAMERA_SM_EVT_GET_PARAMS:
2194 {
2195 result.params = m_parent->getParameters();
2196 rc = NO_ERROR;
2197 result.status = rc;
2198 result.request_api = evt;
2199 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
2200 m_parent->signalAPIResult(&result);
2201 }
2202 break;
2203 case QCAMERA_SM_EVT_PUT_PARAMS:
2204 {
2205 rc = m_parent->putParameters((char*)payload);
2206 result.status = rc;
2207 result.request_api = evt;
2208 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2209 m_parent->signalAPIResult(&result);
2210 }
2211 break;
2212 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
2213 {
2214 rc = NO_ERROR;
2215 result.status = rc;
2216 result.request_api = evt;
2217 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2218 result.enabled = 1;
2219 m_parent->signalAPIResult(&result);
2220 }
2221 break;
2222 case QCAMERA_SM_EVT_RECORDING_ENABLED:
2223 {
2224 rc = NO_ERROR;
2225 result.status = rc;
2226 result.request_api = evt;
2227 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2228 result.enabled = 1;
2229 m_parent->signalAPIResult(&result);
2230 }
2231 break;
2232 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
2233 {
2234 rc = m_parent->storeMetaDataInBuffers(int(payload));
2235 result.status = rc;
2236 result.request_api = evt;
2237 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2238 m_parent->signalAPIResult(&result);
2239 }
2240 break;
2241 case QCAMERA_SM_EVT_DUMP:
2242 {
2243 rc = m_parent->dump((int)payload);
2244 result.status = rc;
2245 result.request_api = evt;
2246 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2247 m_parent->signalAPIResult(&result);
2248 }
2249 break;
2250 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
2251 {
2252 rc = m_parent->autoFocus();
2253 result.status = rc;
2254 result.request_api = evt;
2255 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2256 m_parent->signalAPIResult(&result);
2257 }
2258 break;
2259 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
2260 {
2261 rc = m_parent->cancelAutoFocus();
2262 result.status = rc;
2263 result.request_api = evt;
2264 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2265 m_parent->signalAPIResult(&result);
2266 }
2267 break;
2268 case QCAMERA_SM_EVT_SEND_COMMAND:
2269 {
2270 qcamera_sm_evt_command_payload_t *cmd_payload =
2271 (qcamera_sm_evt_command_payload_t *)payload;
2272 rc = m_parent->sendCommand(cmd_payload->cmd,
2273 cmd_payload->arg1,
2274 cmd_payload->arg2);
2275 result.status = rc;
2276 result.request_api = evt;
2277 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2278 m_parent->signalAPIResult(&result);
2279 }
2280 break;
2281 case QCAMERA_SM_EVT_STOP_RECORDING:
2282 {
2283 rc = m_parent->stopRecording();
2284 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
2285 result.status = rc;
2286 result.request_api = evt;
2287 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2288 m_parent->signalAPIResult(&result);
2289 }
2290 break;
2291 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2292 {
2293 rc = m_parent->releaseRecordingFrame((const void *)payload);
2294 result.status = rc;
2295 result.request_api = evt;
2296 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2297 m_parent->signalAPIResult(&result);
2298 }
2299 break;
2300 case QCAMERA_SM_EVT_CANCEL_PICTURE:
2301 {
2302 rc = m_parent->cancelLiveSnapshot();
2303 m_state = QCAMERA_SM_STATE_RECORDING;
2304 result.status = rc;
2305 result.request_api = evt;
2306 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2307 m_parent->signalAPIResult(&result);
2308 }
2309 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]2310 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
2311 {
2312 int32_t faceID = 0;
2313 qcamera_sm_evt_reg_face_payload_t *reg_payload =
2314 (qcamera_sm_evt_reg_face_payload_t *)payload;
2315 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
2316 reg_payload->config,
2317 faceID);
2318 result.status = rc;
2319 result.request_api = evt;
2320 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2321 result.handle = faceID;
2322 m_parent->signalAPIResult(&result);
2323 }
2324 break;
Emilian Peevf392f172013-05-13 16:29:53 -0700[diff] [blame]2325 case QCAMERA_SM_EVT_STOP_PREVIEW:
2326 {
2327 rc = m_parent->cancelLiveSnapshot();
2328 m_state = QCAMERA_SM_STATE_RECORDING;
2329
2330 rc = m_parent->stopRecording();
2331 m_state = QCAMERA_SM_STATE_PREVIEWING;
2332
2333 rc = m_parent->stopPreview();
2334 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
2335
2336 result.status = rc;
2337 result.request_api = evt;
2338 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2339 m_parent->signalAPIResult(&result);
2340 }
2341 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2342 case QCAMERA_SM_EVT_START_RECORDING:
2343 case QCAMERA_SM_EVT_START_PREVIEW:
2344 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2345 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2346 case QCAMERA_SM_EVT_TAKE_PICTURE:
2347 case QCAMERA_SM_EVT_RELEASE:
2348 {
2349 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2350 rc = INVALID_OPERATION;
2351 result.status = rc;
2352 result.request_api = evt;
2353 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2354 m_parent->signalAPIResult(&result);
2355 }
2356 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2357 case QCAMERA_SM_EVT_EVT_INTERNAL:
2358 {
2359 qcamera_sm_internal_evt_payload_t *internal_evt =
2360 (qcamera_sm_internal_evt_payload_t *)payload;
2361 switch (internal_evt->evt_type) {
2362 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2363 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2364 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2365 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
2366 break;
2367 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
2368 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
2369 break;
2370 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
2371 rc = m_parent->processHistogramStats(internal_evt->stats_data);
2372 break;
2373 case QCAMERA_INTERNAL_EVT_CROP_INFO:
2374 rc = m_parent->processZoomEvent(internal_evt->crop_data);
2375 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]2376 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
2377 rc = m_parent->processASDUpdate(internal_evt->asd_data);
2378 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2379 default:
2380 break;
2381 }
2382 }
2383 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2384 case QCAMERA_SM_EVT_EVT_NOTIFY:
2385 {
2386 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2387 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2388 case CAM_EVENT_TYPE_DAEMON_DIED:
2389 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2390 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
2391 CAMERA_ERROR_SERVER_DIED,
2392 0);
2393 }
2394 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2395 default:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2396 ALOGE("%s: Invalid internal event %d in state(%d)",
2397 __func__, cam_evt->server_event_type, m_state);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2398 break;
2399 }
2400 }
2401 break;
2402 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
2403 {
2404 qcamera_jpeg_evt_payload_t *jpeg_job =
2405 (qcamera_jpeg_evt_payload_t *)payload;
2406 rc = m_parent->processJpegNotify(jpeg_job);
2407 }
2408 break;
2409 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
2410 {
2411 rc = m_parent->cancelLiveSnapshot();
2412 m_state = QCAMERA_SM_STATE_RECORDING;
Emilian Peev6d90c1f2013-04-12 09:33:06 +0300[diff] [blame]2413 result.status = rc;
2414 result.request_api = evt;
2415 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2416 m_parent->signalEvtResult(&result);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2417 }
2418 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2419 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2420 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2421 rc = m_parent->updateThermalLevel(
2422 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2423 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2424 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2425 default:
2426 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2427 break;
2428 }
2429
2430 return rc;
2431}
2432
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2433/*===========================================================================
2434 * FUNCTION : procEvtPreviewPicTakingState
2435 *
2436 * DESCRIPTION: finite state machine function to handle event in state of
2437 * QCAMERA_SM_STATE_PREVIEW_PIC_TAKING.
2438 *
2439 * PARAMETERS :
2440 * @evt : event to be processed
2441 * @payload : event payload. Can be NULL if not needed.
2442 *
2443 * RETURN : int32_t type of status
2444 * NO_ERROR -- success
2445 * none-zero failure code
2446 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2447int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt,
2448 void *payload)
2449{
2450 int32_t rc = NO_ERROR;
2451 qcamera_api_result_t result;
2452 memset(&result, 0, sizeof(qcamera_api_result_t));
2453
2454 switch (evt) {
2455 case QCAMERA_SM_EVT_SET_CALLBACKS:
2456 {
2457 qcamera_sm_evt_setcb_payload_t *setcbs =
2458 (qcamera_sm_evt_setcb_payload_t *)payload;
2459 rc = m_parent->setCallBacks(setcbs->notify_cb,
2460 setcbs->data_cb,
2461 setcbs->data_cb_timestamp,
2462 setcbs->get_memory,
2463 setcbs->user);
2464 result.status = rc;
2465 result.request_api = evt;
2466 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2467 m_parent->signalAPIResult(&result);
2468 }
2469 break;
2470 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
2471 {
2472 rc = m_parent->enableMsgType(int32_t(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_DISABLE_MSG_TYPE:
2480 {
2481 rc = m_parent->disableMsgType(int32_t(payload));
2482 result.status = rc;
2483 result.request_api = evt;
2484 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2485 m_parent->signalAPIResult(&result);
2486 }
2487 break;
2488 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
2489 {
2490 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
2491 result.status = rc;
2492 result.request_api = evt;
2493 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2494 result.enabled = enabled;
2495 m_parent->signalAPIResult(&result);
2496 }
2497 break;
2498 case QCAMERA_SM_EVT_SET_PARAMS:
2499 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2500 bool needRestart = false;
2501 rc = m_parent->updateParameters((char*)payload, needRestart);
2502 if (rc == NO_ERROR) {
2503 if (needRestart) {
2504 // need restart preview for parameters to take effect
2505 // stop preview
2506 m_parent->stopPreview();
2507 // commit parameter changes to server
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]2508 m_parent->commitParameterChanges();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2509 // start preview again
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]2510 rc = m_parent->preparePreview();
2511 if (rc == NO_ERROR) {
2512 rc = m_parent->startPreview();
2513 if (rc != NO_ERROR) {
2514 m_parent->unpreparePreview();
2515 }
2516 }
2517 if (rc != NO_ERROR) {
2518 m_state = QCAMERA_SM_STATE_PIC_TAKING;
2519 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2520 } else {
2521 rc = m_parent->commitParameterChanges();
2522 }
2523 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2524 result.status = rc;
2525 result.request_api = evt;
2526 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2527 m_parent->signalAPIResult(&result);
2528 }
2529 break;
2530 case QCAMERA_SM_EVT_GET_PARAMS:
2531 {
2532 result.params = m_parent->getParameters();
2533 rc = NO_ERROR;
2534 result.status = rc;
2535 result.request_api = evt;
2536 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
2537 m_parent->signalAPIResult(&result);
2538 }
2539 break;
2540 case QCAMERA_SM_EVT_PUT_PARAMS:
2541 {
2542 rc = m_parent->putParameters((char*)payload);
2543 result.status = rc;
2544 result.request_api = evt;
2545 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2546 m_parent->signalAPIResult(&result);
2547 }
2548 break;
2549 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
2550 {
2551 rc = NO_ERROR;
2552 result.status = rc;
2553 result.request_api = evt;
2554 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2555 result.enabled = 1;
2556 m_parent->signalAPIResult(&result);
2557 }
2558 break;
2559 case QCAMERA_SM_EVT_RECORDING_ENABLED:
2560 {
2561 rc = NO_ERROR;
2562 result.status = rc;
2563 result.request_api = evt;
2564 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2565 result.enabled = 0;
2566 m_parent->signalAPIResult(&result);
2567 }
2568 break;
2569 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
2570 {
2571 rc = m_parent->storeMetaDataInBuffers(int(payload));
2572 result.status = rc;
2573 result.request_api = evt;
2574 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2575 m_parent->signalAPIResult(&result);
2576 }
2577 break;
2578 case QCAMERA_SM_EVT_DUMP:
2579 {
2580 rc = m_parent->dump((int)payload);
2581 result.status = rc;
2582 result.request_api = evt;
2583 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2584 m_parent->signalAPIResult(&result);
2585 }
2586 break;
2587 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
2588 {
2589 rc = m_parent->autoFocus();
2590 result.status = rc;
2591 result.request_api = evt;
2592 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2593 m_parent->signalAPIResult(&result);
2594 }
2595 break;
2596 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
2597 {
2598 rc = m_parent->cancelAutoFocus();
2599 result.status = rc;
2600 result.request_api = evt;
2601 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2602 m_parent->signalAPIResult(&result);
2603 }
2604 break;
2605 case QCAMERA_SM_EVT_SEND_COMMAND:
2606 {
2607 qcamera_sm_evt_command_payload_t *cmd_payload =
2608 (qcamera_sm_evt_command_payload_t *)payload;
2609 rc = m_parent->sendCommand(cmd_payload->cmd,
2610 cmd_payload->arg1,
2611 cmd_payload->arg2);
Emilian Peeve32d03b2013-08-13 16:15:41 +0300[diff] [blame]2612 if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) {
2613 // move state to previewing state
2614 m_state = QCAMERA_SM_STATE_PREVIEWING;
2615 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2616 result.status = rc;
2617 result.request_api = evt;
2618 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2619 m_parent->signalAPIResult(&result);
2620 }
2621 break;
2622 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2623 {
2624 rc = m_parent->releaseRecordingFrame((const void *)payload);
2625 result.status = rc;
2626 result.request_api = evt;
2627 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2628 m_parent->signalAPIResult(&result);
2629 }
2630 break;
2631 case QCAMERA_SM_EVT_CANCEL_PICTURE:
2632 {
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]2633 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]2634 rc = m_parent->cancelPicture();
2635 } else {
2636 rc = m_parent->cancelLiveSnapshot();
2637 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2638 m_state = QCAMERA_SM_STATE_PREVIEWING;
2639 result.status = rc;
2640 result.request_api = evt;
2641 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2642 m_parent->signalAPIResult(&result);
2643 }
2644 break;
2645 case QCAMERA_SM_EVT_STOP_PREVIEW:
2646 {
Muhua Libd1b6122013-03-05 15:25:27 -0800[diff] [blame]2647 if (m_parent->isZSLMode()) {
2648 // cancel picture first
2649 rc = m_parent->cancelPicture();
2650 m_parent->stopChannel(QCAMERA_CH_TYPE_ZSL);
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]2651 } else if (m_parent->isLongshotEnabled()) {
2652 // just cancel picture
2653 rc = m_parent->cancelPicture();
Muhua Libd1b6122013-03-05 15:25:27 -0800[diff] [blame]2654 } else {
2655 rc = m_parent->cancelLiveSnapshot();
2656 m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW);
2657 }
2658 // unprepare preview
2659 m_parent->unpreparePreview();
2660 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2661 result.status = rc;
2662 result.request_api = evt;
2663 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2664 m_parent->signalAPIResult(&result);
2665 }
2666 break;
2667 case QCAMERA_SM_EVT_START_RECORDING:
2668 {
Muhua Licf1cf672013-05-10 09:42:50 -0700[diff] [blame]2669 if (m_parent->isZSLMode()) {
2670 ALOGE("%s: cannot handle evt(%d) in state(%d) in ZSL mode",
2671 __func__, evt, m_state);
2672 rc = INVALID_OPERATION;
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]2673 } else if (m_parent->isLongshotEnabled()) {
2674 ALOGE("%s: cannot handle evt(%d) in state(%d) in Longshot mode",
2675 __func__, evt, m_state);
2676 rc = INVALID_OPERATION;
Muhua Licf1cf672013-05-10 09:42:50 -0700[diff] [blame]2677 } else {
2678 rc = m_parent->startRecording();
2679 if (rc == NO_ERROR) {
2680 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
2681 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2682 }
2683 result.status = rc;
2684 result.request_api = evt;
2685 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2686 m_parent->signalAPIResult(&result);
2687 }
2688 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]2689 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
2690 {
2691 int32_t faceID = 0;
2692 qcamera_sm_evt_reg_face_payload_t *reg_payload =
2693 (qcamera_sm_evt_reg_face_payload_t *)payload;
2694 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
2695 reg_payload->config,
2696 faceID);
2697 result.status = rc;
2698 result.request_api = evt;
2699 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2700 result.handle = faceID;
2701 m_parent->signalAPIResult(&result);
2702 }
2703 break;
Emilian Peeve32d03b2013-08-13 16:15:41 +0300[diff] [blame]2704 case QCAMERA_SM_EVT_TAKE_PICTURE:
2705 {
2706 if ( m_parent->isLongshotEnabled() ) {
2707 rc = m_parent->longShot();
2708 } else {
2709 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2710 rc = INVALID_OPERATION;
2711 }
2712
2713 result.status = rc;
2714 result.request_api = evt;
2715 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2716 m_parent->signalAPIResult(&result);
2717 }
2718 break;
2719 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2720 case QCAMERA_SM_EVT_STOP_RECORDING:
2721 case QCAMERA_SM_EVT_START_PREVIEW:
2722 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2723 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
2724 case QCAMERA_SM_EVT_RELEASE:
2725 {
2726 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2727 rc = INVALID_OPERATION;
2728 result.status = rc;
2729 result.request_api = evt;
2730 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2731 m_parent->signalAPIResult(&result);
2732 }
2733 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2734 case QCAMERA_SM_EVT_EVT_INTERNAL:
2735 {
2736 qcamera_sm_internal_evt_payload_t *internal_evt =
2737 (qcamera_sm_internal_evt_payload_t *)payload;
2738 switch (internal_evt->evt_type) {
2739 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2740 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2741 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2742 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
2743 break;
2744 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
2745 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
2746 break;
2747 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
2748 rc = m_parent->processHistogramStats(internal_evt->stats_data);
2749 break;
2750 case QCAMERA_INTERNAL_EVT_CROP_INFO:
2751 rc = m_parent->processZoomEvent(internal_evt->crop_data);
2752 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]2753 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
2754 rc = m_parent->processASDUpdate(internal_evt->asd_data);
2755 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2756 default:
2757 break;
2758 }
2759 }
2760 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2761 case QCAMERA_SM_EVT_EVT_NOTIFY:
2762 {
2763 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2764 switch (cam_evt->server_event_type) {
Emilian Peev9c53a9e2013-12-12 15:58:13 +0200[diff] [blame^]2765 case CAM_EVENT_TYPE_REPROCESS_STAGE_DONE:
2766 {
2767 if ( m_parent->isLongshotEnabled() ) {
2768 if(!m_parent->m_postprocessor.getMultipleStages()) {
2769 m_parent->m_postprocessor.setMultipleStages(true);
2770 }
2771 m_parent->playShutter();
2772 }
2773 }
2774 break;
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2775 case CAM_EVENT_TYPE_DAEMON_DIED:
2776 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2777 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
2778 CAMERA_ERROR_SERVER_DIED,
2779 0);
2780 }
2781 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2782 default:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2783 ALOGE("%s: Invalid internal event %d in state(%d)",
2784 __func__, cam_evt->server_event_type, m_state);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2785 break;
2786 }
2787 }
2788 break;
2789 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
2790 {
2791 qcamera_jpeg_evt_payload_t *jpeg_job =
2792 (qcamera_jpeg_evt_payload_t *)payload;
2793 rc = m_parent->processJpegNotify(jpeg_job);
2794 }
2795 break;
2796 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
2797 {
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]2798 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]2799 rc = m_parent->cancelPicture();
2800 } else {
2801 rc = m_parent->cancelLiveSnapshot();
2802 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2803 m_state = QCAMERA_SM_STATE_PREVIEWING;
Emilian Peev6d90c1f2013-04-12 09:33:06 +0300[diff] [blame]2804 result.status = rc;
2805 result.request_api = evt;
2806 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2807 m_parent->signalEvtResult(&result);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2808 }
2809 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2810 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2811 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2812 rc = m_parent->updateThermalLevel(
2813 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2814 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2815 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2816 default:
2817 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2818 break;
2819 }
2820
2821 return rc;
2822}
2823
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2824/*===========================================================================
2825 * FUNCTION : isPreviewRunning
2826 *
2827 * DESCRIPTION: check if preview is in process.
2828 *
2829 * PARAMETERS : None
2830 *
2831 * RETURN : true -- preview running
2832 * false -- preview stopped
2833 *==========================================================================*/
2834bool QCameraStateMachine::isPreviewRunning()
2835{
2836 switch (m_state) {
2837 case QCAMERA_SM_STATE_PREVIEWING:
2838 case QCAMERA_SM_STATE_RECORDING:
2839 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
2840 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
Muhua Libf818e52013-04-23 18:05:26 -0700[diff] [blame]2841 case QCAMERA_SM_STATE_PREPARE_SNAPSHOT:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2842 return true;
2843 default:
2844 return false;
2845 }
2846}
2847
Emilian Peeve32d03b2013-08-13 16:15:41 +0300[diff] [blame]2848/*===========================================================================
2849 * FUNCTION : isCaptureRunning
2850 *
2851 * DESCRIPTION: check if image capture is in process.
2852 *
2853 * PARAMETERS : None
2854 *
2855 * RETURN : true -- capture running
2856 * false -- capture stopped
2857 *==========================================================================*/
2858bool QCameraStateMachine::isCaptureRunning()
2859{
2860 switch (m_state) {
2861 case QCAMERA_SM_STATE_PIC_TAKING:
2862 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
2863 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
2864 return true;
2865 default:
2866 return false;
2867 }
2868}
Vijay kumar Tumatifa8d9b32013-09-23 16:09:07 +0530[diff] [blame]2869/*===========================================================================
2870 * FUNCTION : isNonZSLCaptureRunning
2871 *
2872 * DESCRIPTION: check if image capture is in process in non ZSL mode.
2873 *
2874 * PARAMETERS : None
2875 *
2876 * RETURN : true -- capture running in non ZSL mode
2877 * false -- Either in not capture mode or captur is not in non ZSL mode
2878 *==========================================================================*/
2879bool QCameraStateMachine::isNonZSLCaptureRunning()
2880{
2881 switch (m_state) {
2882 case QCAMERA_SM_STATE_PIC_TAKING:
2883 return true;
2884 default:
2885 return false;
2886 }
2887}
2888
Emilian Peeve32d03b2013-08-13 16:15:41 +0300[diff] [blame]2889
Shuzhen Wang89635cf2012-12-20 13:47:22 -0800[diff] [blame]2890}; // namespace qcamera