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