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