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