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