Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / hardware / qcom / camera / 31eaee08d56170ec636fa0f255937966acad8563 / . / QCamera2 / HAL / QCameraStateMachine.cpp
blob: 45e75f607a4717b3c0896c50e9bdfde96ca46ee6 [file] [log] [blame]
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1/* Copyright (c) 2012, The Linux Foundataion. All rights reserved.
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
32#include <utils/Log.h>
33#include <utils/Errors.h>
34#include "QCamera2HWI.h"
35#include "QCameraStateMachine.h"
36
37namespace android {
38
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]39/*===========================================================================
40 * FUNCTION : smEvtProcRoutine
41 *
42 * DESCRIPTION: Statemachine process thread routine to handle events
43 * in different state.
44 *
45 * PARAMETERS :
46 * @data : ptr to QCameraStateMachine object
47 *
48 * RETURN : none
49 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]50void *QCameraStateMachine::smEvtProcRoutine(void *data)
51{
52 int running = 1, ret;
53 QCameraStateMachine *pme = (QCameraStateMachine *)data;
54
55 ALOGD("%s: E", __func__);
56 do {
57 do {
58 ret = sem_wait(&pme->cmd_sem);
59 if (ret != 0 && errno != EINVAL) {
60 ALOGE("%s: sem_wait error (%s)",
61 __func__, strerror(errno));
62 return NULL;
63 }
64 } while (ret != 0);
65
66 // we got notified about new cmd avail in cmd queue
67 // first check API cmd queue
68 qcamera_sm_cmd_t *node = (qcamera_sm_cmd_t *)pme->api_queue.dequeue();
69 if (node == NULL) {
70 // no API cmd, then check evt cmd queue
71 node = (qcamera_sm_cmd_t *)pme->evt_queue.dequeue();
72 }
73 if (node != NULL) {
74 switch (node->cmd) {
75 case QCAMERA_SM_CMD_TYPE_API:
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame^]76 pme->stateMachine(node->evt, node->evt_payload);
77 // API is in a way sync call, so evt_payload is managed by HWI
78 // no need to free payload for API
79 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]80 case QCAMERA_SM_CMD_TYPE_EVT:
81 pme->stateMachine(node->evt, node->evt_payload);
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame^]82
83 // EVT is async call, so payload need to be free after use
84 free(node->evt_payload);
85 node->evt_payload = NULL;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]86 break;
87 case QCAMERA_SM_CMD_TYPE_EXIT:
88 running = 0;
89 break;
90 default:
91 break;
92 }
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame^]93 free(node);
94 node = NULL;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]95 }
96 } while (running);
97 ALOGD("%s: X", __func__);
98 return NULL;
99}
100
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]101/*===========================================================================
102 * FUNCTION : QCameraStateMachine
103 *
104 * DESCRIPTION: constructor of QCameraStateMachine. Will start process thread
105 *
106 * PARAMETERS :
107 * @ctrl : ptr to HWI object
108 *
109 * RETURN : none
110 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]111QCameraStateMachine::QCameraStateMachine(QCamera2HardwareInterface *ctrl) :
112 api_queue(),
113 evt_queue()
114{
115 m_parent = ctrl;
116 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
117 cmd_pid = 0;
118 sem_init(&cmd_sem, 0, 0);
119 pthread_create(&cmd_pid,
120 NULL,
121 smEvtProcRoutine,
122 this);
123}
124
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]125/*===========================================================================
126 * FUNCTION : ~QCameraStateMachine
127 *
128 * DESCRIPTION: desctructor of QCameraStateMachine. Will stop process thread.
129 *
130 * PARAMETERS : none
131 *
132 * RETURN : none
133 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]134QCameraStateMachine::~QCameraStateMachine()
135{
136 if (cmd_pid != 0) {
137 qcamera_sm_cmd_t *node =
138 (qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t));
139 if (NULL != node) {
140 memset(node, 0, sizeof(qcamera_sm_cmd_t));
141 node->cmd = QCAMERA_SM_CMD_TYPE_EXIT;
142
143 api_queue.enqueue((void *)node);
144 sem_post(&cmd_sem);
145
146 /* wait until cmd thread exits */
147 if (pthread_join(cmd_pid, NULL) != 0) {
148 ALOGD("%s: pthread dead already\n", __func__);
149 }
150 }
151 cmd_pid = 0;
152 }
153 sem_destroy(&cmd_sem);
154}
155
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]156/*===========================================================================
157 * FUNCTION : procAPI
158 *
159 * DESCRIPTION: process incoming API request from framework layer.
160 *
161 * PARAMETERS :
162 * @evt : event to be processed
163 * @api_payload : API payload. Can be NULL if not needed.
164 *
165 * RETURN : int32_t type of status
166 * NO_ERROR -- success
167 * none-zero failure code
168 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]169int32_t QCameraStateMachine::procAPI(qcamera_sm_evt_enum_t evt,
170 void *api_payload)
171{
172 qcamera_sm_cmd_t *node =
173 (qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t));
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]174 if (NULL == node) {
175 ALOGE("%s: No memory for qcamera_sm_cmd_t", __func__);
176 return NO_MEMORY;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]177 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]178
179 memset(node, 0, sizeof(qcamera_sm_cmd_t));
180 node->cmd = QCAMERA_SM_CMD_TYPE_API;
181 node->evt = evt;
182 node->evt_payload = api_payload;
183 if (api_queue.enqueue((void *)node)) {
184 sem_post(&cmd_sem);
185 return NO_ERROR;
186 } else {
187 free(node);
188 return UNKNOWN_ERROR;
189 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]190}
191
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]192/*===========================================================================
193 * FUNCTION : procEvt
194 *
195 * DESCRIPTION: process incoming envent from mm-camera-interface and
196 * mm-jpeg-interface.
197 *
198 * PARAMETERS :
199 * @evt : event to be processed
200 * @evt_payload : event payload. Can be NULL if not needed.
201 *
202 * RETURN : int32_t type of status
203 * NO_ERROR -- success
204 * none-zero failure code
205 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]206int32_t QCameraStateMachine::procEvt(qcamera_sm_evt_enum_t evt,
207 void *evt_payload)
208{
209 qcamera_sm_cmd_t *node =
210 (qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t));
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]211 if (NULL == node) {
212 ALOGE("%s: No memory for qcamera_sm_cmd_t", __func__);
213 return NO_MEMORY;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]214 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]215
216 memset(node, 0, sizeof(qcamera_sm_cmd_t));
217 node->cmd = QCAMERA_SM_CMD_TYPE_EVT;
218 node->evt = evt;
219 node->evt_payload = evt_payload;
220 if (evt_queue.enqueue((void *)node)) {
221 sem_post(&cmd_sem);
222 return NO_ERROR;
223 } else {
224 free(node);
225 return UNKNOWN_ERROR;
226 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]227}
228
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]229/*===========================================================================
230 * FUNCTION : stateMachine
231 *
232 * DESCRIPTION: finite state machine entry function. Depends on state,
233 * incoming event will be handled differently.
234 *
235 * PARAMETERS :
236 * @evt : event to be processed
237 * @payload : event payload. Can be NULL if not needed.
238 *
239 * RETURN : int32_t type of status
240 * NO_ERROR -- success
241 * none-zero failure code
242 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]243int32_t QCameraStateMachine::stateMachine(qcamera_sm_evt_enum_t evt, void *payload)
244{
245 int32_t rc = NO_ERROR;
246 switch (m_state) {
247 case QCAMERA_SM_STATE_PREVIEW_STOPPED:
248 rc = procEvtPreviewStoppedState(evt, payload);
249 break;
250 case QCAMERA_SM_STATE_PREVIEW_READY:
251 rc = procEvtPreviewReadyState(evt, payload);
252 break;
253 case QCAMERA_SM_STATE_PREVIEWING:
254 rc = procEvtPreviewingState(evt, payload);
255 break;
256 case QCAMERA_SM_STATE_PIC_TAKING:
257 rc = procEvtPicTakingState(evt, payload);
258 break;
259 case QCAMERA_SM_STATE_RECORDING:
260 rc = procEvtRecordingState(evt, payload);
261 break;
262 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
263 rc = procEvtVideoPicTakingState(evt, payload);
264 break;
265 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
266 rc = procEvtPreviewPicTakingState(evt, payload);
267 break;
268 default:
269 break;
270 }
271
272 return rc;
273}
274
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]275/*===========================================================================
276 * FUNCTION : procEvtPreviewStoppedState
277 *
278 * DESCRIPTION: finite state machine function to handle event in state of
279 * QCAMERA_SM_STATE_PREVIEW_STOPPED.
280 *
281 * PARAMETERS :
282 * @evt : event to be processed
283 * @payload : event payload. Can be NULL if not needed.
284 *
285 * RETURN : int32_t type of status
286 * NO_ERROR -- success
287 * none-zero failure code
288 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]289int32_t QCameraStateMachine::procEvtPreviewStoppedState(qcamera_sm_evt_enum_t evt,
290 void *payload)
291{
292 int32_t rc = NO_ERROR;
293 qcamera_api_result_t result;
294 memset(&result, 0, sizeof(qcamera_api_result_t));
295
296 switch (evt) {
297 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
298 {
299 rc = m_parent->setPreviewWindow((struct preview_stream_ops *)payload);
300 result.status = rc;
301 result.request_api = evt;
302 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
303 m_parent->signalAPIResult(&result);
304 }
305 break;
306 case QCAMERA_SM_EVT_SET_CALLBACKS:
307 {
308 qcamera_sm_evt_setcb_payload_t *setcbs =
309 (qcamera_sm_evt_setcb_payload_t *)payload;
310 rc = m_parent->setCallBacks(setcbs->notify_cb,
311 setcbs->data_cb,
312 setcbs->data_cb_timestamp,
313 setcbs->get_memory,
314 setcbs->user);
315 result.status = rc;
316 result.request_api = evt;
317 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
318 m_parent->signalAPIResult(&result);
319 }
320 break;
321 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
322 {
323 rc = m_parent->enableMsgType(int32_t(payload));
324 result.status = rc;
325 result.request_api = evt;
326 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
327 m_parent->signalAPIResult(&result);
328 }
329 break;
330 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
331 {
332 rc = m_parent->disableMsgType(int32_t(payload));
333 result.status = rc;
334 result.request_api = evt;
335 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
336 m_parent->signalAPIResult(&result);
337 }
338 break;
339 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
340 {
341 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
342 result.status = rc;
343 result.request_api = evt;
344 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
345 result.enabled = enabled;
346 m_parent->signalAPIResult(&result);
347 }
348 break;
349 case QCAMERA_SM_EVT_SET_PARAMS:
350 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]351 bool needRestart = false;
352 rc = m_parent->updateParameters((char*)payload, needRestart);
353 if (rc == NO_ERROR) {
354 rc = m_parent->commitParameterChanges();
355 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]356 result.status = rc;
357 result.request_api = evt;
358 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
359 m_parent->signalAPIResult(&result);
360 }
361 break;
362 case QCAMERA_SM_EVT_GET_PARAMS:
363 {
364 result.params = m_parent->getParameters();
365 rc = NO_ERROR;
366 result.status = rc;
367 result.request_api = evt;
368 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
369 m_parent->signalAPIResult(&result);
370 }
371 break;
372 case QCAMERA_SM_EVT_PUT_PARAMS:
373 {
374 rc = m_parent->putParameters((char*)payload);
375 result.status = rc;
376 result.request_api = evt;
377 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
378 m_parent->signalAPIResult(&result);
379 }
380 break;
381 case QCAMERA_SM_EVT_START_PREVIEW:
382 {
383 if (m_parent->mPreviewWindow == NULL) {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]384 // preview window is not set yet, move to previewReady state
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]385 m_state = QCAMERA_SM_STATE_PREVIEW_READY;
386 rc = NO_ERROR;
387 } else {
388 rc = m_parent->preparePreview();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]389 if (rc == NO_ERROR) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]390 rc = m_parent->startPreview();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]391 if (rc != NO_ERROR) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]392 m_parent->unpreparePreview();
393 } else {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]394 // start preview success, move to previewing state
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]395 m_state = QCAMERA_SM_STATE_PREVIEWING;
396 }
397 }
398 }
399 result.status = rc;
400 result.request_api = evt;
401 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
402 m_parent->signalAPIResult(&result);
403 }
404 break;
405 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
406 {
407 rc = m_parent->preparePreview();
408 if (rc == NO_ERROR) {
409 rc = m_parent->startPreview();
410 if (rc != NO_ERROR) {
411 m_parent->unpreparePreview();
412 } else {
413 m_state = QCAMERA_SM_STATE_PREVIEWING;
414 }
415 }
416 result.status = rc;
417 result.request_api = evt;
418 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
419 m_parent->signalAPIResult(&result);
420 }
421 break;
422 case QCAMERA_SM_EVT_STOP_PREVIEW:
423 {
424 // no op needed here
425 ALOGD("%s: already in preview stopped state, do nothing", __func__);
426 result.status = NO_ERROR;
427 result.request_api = evt;
428 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
429 m_parent->signalAPIResult(&result);
430 }
431 break;
432 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
433 case QCAMERA_SM_EVT_RECORDING_ENABLED:
434 {
435 result.status = NO_ERROR;
436 result.request_api = evt;
437 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
438 result.enabled = 0;
439 m_parent->signalAPIResult(&result);
440 }
441 break;
442 case QCAMERA_SM_EVT_RELEASE:
443 {
444 rc = m_parent->release();
445 result.status = rc;
446 result.request_api = evt;
447 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
448 m_parent->signalAPIResult(&result);
449 }
450 break;
451 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
452 {
453 rc = m_parent->storeMetaDataInBuffers(int(payload));
454 result.status = rc;
455 result.request_api = evt;
456 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
457 m_parent->signalAPIResult(&result);
458 }
459 break;
460 case QCAMERA_SM_EVT_DUMP:
461 {
462 rc = m_parent->dump((int)payload);
463 result.status = rc;
464 result.request_api = evt;
465 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
466 m_parent->signalAPIResult(&result);
467 }
468 break;
469 case QCAMERA_SM_EVT_START_RECORDING:
470 case QCAMERA_SM_EVT_STOP_RECORDING:
471 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
472 case QCAMERA_SM_EVT_TAKE_PICTURE:
473 case QCAMERA_SM_EVT_CANCEL_PICTURE:
474 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
475 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
476 case QCAMERA_SM_EVT_SEND_COMMAND:
477 {
478 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
479 rc = INVALID_OPERATION;
480 result.status = rc;
481 result.request_api = evt;
482 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
483 m_parent->signalAPIResult(&result);
484 }
485 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame^]486 case QCAMERA_SM_EVT_EVT_INTERNAL:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]487 case QCAMERA_SM_EVT_EVT_NOTIFY:
488 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]489 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]490 default:
491 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
492 break;
493 }
494
495 return rc;
496}
497
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]498/*===========================================================================
499 * FUNCTION : procEvtPreviewReadyState
500 *
501 * DESCRIPTION: finite state machine function to handle event in state of
502 * QCAMERA_SM_STATE_PREVIEW_READY.
503 *
504 * PARAMETERS :
505 * @evt : event to be processed
506 * @payload : event payload. Can be NULL if not needed.
507 *
508 * RETURN : int32_t type of status
509 * NO_ERROR -- success
510 * none-zero failure code
511 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]512int32_t QCameraStateMachine::procEvtPreviewReadyState(qcamera_sm_evt_enum_t evt,
513 void *payload)
514{
515 int32_t rc = NO_ERROR;
516 qcamera_api_result_t result;
517 memset(&result, 0, sizeof(qcamera_api_result_t));
518
519 switch (evt) {
520 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
521 {
522 m_parent->setPreviewWindow((struct preview_stream_ops *)payload);
523 if (m_parent->mPreviewWindow != NULL) {
524 rc = m_parent->startPreview();
525 if (rc != NO_ERROR) {
526 m_parent->unpreparePreview();
527 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
528 } else {
529 m_state = QCAMERA_SM_STATE_PREVIEWING;
530 }
531 }
532
533 result.status = rc;
534 result.request_api = evt;
535 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
536 m_parent->signalAPIResult(&result);
537 }
538 break;
539 case QCAMERA_SM_EVT_SET_CALLBACKS:
540 {
541 qcamera_sm_evt_setcb_payload_t *setcbs =
542 (qcamera_sm_evt_setcb_payload_t *)payload;
543 rc = m_parent->setCallBacks(setcbs->notify_cb,
544 setcbs->data_cb,
545 setcbs->data_cb_timestamp,
546 setcbs->get_memory,
547 setcbs->user);
548 result.status = rc;
549 result.request_api = evt;
550 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
551 m_parent->signalAPIResult(&result);
552 }
553 break;
554 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
555 {
556 rc = m_parent->enableMsgType(int32_t(payload));
557 result.status = rc;
558 result.request_api = evt;
559 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
560 m_parent->signalAPIResult(&result);
561 }
562 break;
563 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
564 {
565 rc = m_parent->disableMsgType(int32_t(payload));
566 result.status = rc;
567 result.request_api = evt;
568 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
569 m_parent->signalAPIResult(&result);
570 }
571 break;
572 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
573 {
574 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
575 result.status = rc;
576 result.request_api = evt;
577 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
578 result.enabled = enabled;
579 m_parent->signalAPIResult(&result);
580 }
581 break;
582 case QCAMERA_SM_EVT_SET_PARAMS:
583 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]584 bool needRestart = false;
585 rc = m_parent->updateParameters((char*)payload, needRestart);
586 if (rc == NO_ERROR) {
587 rc = m_parent->commitParameterChanges();
588 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]589 result.status = rc;
590 result.request_api = evt;
591 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
592 m_parent->signalAPIResult(&result);
593 }
594 break;
595 case QCAMERA_SM_EVT_GET_PARAMS:
596 {
597 result.params = m_parent->getParameters();
598 rc = NO_ERROR;
599 result.status = rc;
600 result.request_api = evt;
601 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
602 m_parent->signalAPIResult(&result);
603 }
604 break;
605 case QCAMERA_SM_EVT_PUT_PARAMS:
606 {
607 rc = m_parent->putParameters((char*)payload);
608 result.status = rc;
609 result.request_api = evt;
610 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
611 m_parent->signalAPIResult(&result);
612 }
613 break;
614 case QCAMERA_SM_EVT_START_PREVIEW:
615 {
616 // no ops here
617 rc = NO_ERROR;
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_STOP_PREVIEW:
625 {
626 m_parent->unpreparePreview();
627 rc = 0;
628 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
629 result.status = rc;
630 result.request_api = evt;
631 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
632 m_parent->signalAPIResult(&result);
633 }
634 break;
635 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
636 {
637 rc = NO_ERROR;
638 result.status = rc;
639 result.request_api = evt;
640 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
641 result.enabled = 1;
642 m_parent->signalAPIResult(&result);
643 }
644 break;
645 case QCAMERA_SM_EVT_RECORDING_ENABLED:
646 {
647 rc = 0;
648 result.status = rc;
649 result.request_api = evt;
650 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
651 result.enabled = 0;
652 m_parent->signalAPIResult(&result);
653 }
654 break;
655 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
656 {
657 rc = m_parent->storeMetaDataInBuffers(int(payload));
658 result.status = rc;
659 result.request_api = evt;
660 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
661 m_parent->signalAPIResult(&result);
662 }
663 break;
664 case QCAMERA_SM_EVT_DUMP:
665 {
666 rc = m_parent->dump((int)payload);
667 result.status = rc;
668 result.request_api = evt;
669 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
670 m_parent->signalAPIResult(&result);
671 }
672 break;
673 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
674 {
675 rc = m_parent->autoFocus();
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_STOP_AUTO_FOCUS:
683 {
684 rc = m_parent->cancelAutoFocus();
685 result.status = rc;
686 result.request_api = evt;
687 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
688 m_parent->signalAPIResult(&result);
689 }
690 break;
691 case QCAMERA_SM_EVT_SEND_COMMAND:
692 {
693 qcamera_sm_evt_command_payload_t *cmd_payload =
694 (qcamera_sm_evt_command_payload_t *)payload;
695 rc = m_parent->sendCommand(cmd_payload->cmd,
696 cmd_payload->arg1,
697 cmd_payload->arg2);
698 result.status = rc;
699 result.request_api = evt;
700 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
701 m_parent->signalAPIResult(&result);
702 }
703 break;
704 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
705 case QCAMERA_SM_EVT_START_RECORDING:
706 case QCAMERA_SM_EVT_STOP_RECORDING:
707 case QCAMERA_SM_EVT_TAKE_PICTURE:
708 case QCAMERA_SM_EVT_CANCEL_PICTURE:
709 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
710 case QCAMERA_SM_EVT_RELEASE:
711 {
712 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
713 rc = INVALID_OPERATION;
714 result.status = rc;
715 result.request_api = evt;
716 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
717 m_parent->signalAPIResult(&result);
718 }
719 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame^]720 case QCAMERA_SM_EVT_EVT_INTERNAL:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]721 case QCAMERA_SM_EVT_EVT_NOTIFY:
722 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]723 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]724 default:
725 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
726 break;
727 }
728
729 return rc;
730}
731
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]732/*===========================================================================
733 * FUNCTION : procEvtPreviewingState
734 *
735 * DESCRIPTION: finite state machine function to handle event in state of
736 * QCAMERA_SM_STATE_PREVIEWING.
737 *
738 * PARAMETERS :
739 * @evt : event to be processed
740 * @payload : event payload. Can be NULL if not needed.
741 *
742 * RETURN : int32_t type of status
743 * NO_ERROR -- success
744 * none-zero failure code
745 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]746int32_t QCameraStateMachine::procEvtPreviewingState(qcamera_sm_evt_enum_t evt,
747 void *payload)
748{
749 int32_t rc = NO_ERROR;
750 qcamera_api_result_t result;
751 memset(&result, 0, sizeof(qcamera_api_result_t));
752
753 switch (evt) {
754 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
755 {
756 // Error setting preview window during previewing
757 ALOGE("Cannot set preview window when preview is running");
758 rc = INVALID_OPERATION;
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_SET_CALLBACKS:
766 {
767 qcamera_sm_evt_setcb_payload_t *setcbs =
768 (qcamera_sm_evt_setcb_payload_t *)payload;
769 rc = m_parent->setCallBacks(setcbs->notify_cb,
770 setcbs->data_cb,
771 setcbs->data_cb_timestamp,
772 setcbs->get_memory,
773 setcbs->user);
774 result.status = rc;
775 result.request_api = evt;
776 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
777 m_parent->signalAPIResult(&result);
778 }
779 break;
780 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
781 {
782 rc = m_parent->enableMsgType(int32_t(payload));
783 result.status = rc;
784 result.request_api = evt;
785 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
786 m_parent->signalAPIResult(&result);
787 }
788 break;
789 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
790 {
791 rc = m_parent->disableMsgType(int32_t(payload));
792 result.status = rc;
793 result.request_api = evt;
794 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
795 m_parent->signalAPIResult(&result);
796 }
797 break;
798 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
799 {
800 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
801 result.status = rc;
802 result.request_api = evt;
803 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
804 result.enabled = enabled;
805 m_parent->signalAPIResult(&result);
806 }
807 break;
808 case QCAMERA_SM_EVT_SET_PARAMS:
809 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]810 bool needRestart = false;
811 rc = m_parent->updateParameters((char*)payload, needRestart);
812 if (rc == NO_ERROR) {
813 if (needRestart) {
814 // need restart preview for parameters to take effect
815 // stop preview
816 m_parent->stopPreview();
817 // commit parameter changes to server
818 rc = m_parent->commitParameterChanges();
819 // start preview again
820 m_parent->startPreview();
821 } else {
822 rc = m_parent->commitParameterChanges();
823 }
824 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]825 result.status = rc;
826 result.request_api = evt;
827 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
828 m_parent->signalAPIResult(&result);
829 }
830 break;
831 case QCAMERA_SM_EVT_GET_PARAMS:
832 {
833 result.params = m_parent->getParameters();
834 rc = NO_ERROR;
835 result.status = rc;
836 result.request_api = evt;
837 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
838 m_parent->signalAPIResult(&result);
839 }
840 break;
841 case QCAMERA_SM_EVT_PUT_PARAMS:
842 {
843 rc = m_parent->putParameters((char*)payload);
844 result.status = rc;
845 result.request_api = evt;
846 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
847 m_parent->signalAPIResult(&result);
848 }
849 break;
850 case QCAMERA_SM_EVT_START_PREVIEW:
851 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
852 {
853 // no ops here
854 ALOGD("%s: Already in previewing, no ops here to start preview", __func__);
855 rc = NO_ERROR;
856 result.status = rc;
857 result.request_api = evt;
858 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
859 m_parent->signalAPIResult(&result);
860 }
861 break;
862 case QCAMERA_SM_EVT_STOP_PREVIEW:
863 {
864 rc = m_parent->stopPreview();
865 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
866 result.status = rc;
867 result.request_api = evt;
868 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
869 m_parent->signalAPIResult(&result);
870 }
871 break;
872 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
873 {
874 rc = NO_ERROR;
875 result.status = rc;
876 result.request_api = evt;
877 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
878 result.enabled = 1;
879 m_parent->signalAPIResult(&result);
880 }
881 break;
882 case QCAMERA_SM_EVT_RECORDING_ENABLED:
883 {
884 rc = NO_ERROR;
885 result.status = rc;
886 result.request_api = evt;
887 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
888 result.enabled = 0;
889 m_parent->signalAPIResult(&result);
890 }
891 break;
892 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
893 {
894 rc = m_parent->storeMetaDataInBuffers(int(payload));
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_DUMP:
902 {
903 rc = m_parent->dump((int)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_START_AUTO_FOCUS:
911 {
912 rc = m_parent->autoFocus();
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_STOP_AUTO_FOCUS:
920 {
921 rc = m_parent->cancelAutoFocus();
922 result.status = rc;
923 result.request_api = evt;
924 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
925 m_parent->signalAPIResult(&result);
926 }
927 break;
928 case QCAMERA_SM_EVT_START_RECORDING:
929 {
930 rc = m_parent->startRecording();
931 if (rc == NO_ERROR) {
932 // move state to recording state
933 m_state = QCAMERA_SM_STATE_RECORDING;
934 }
935 result.status = rc;
936 result.request_api = evt;
937 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
938 m_parent->signalAPIResult(&result);
939 }
940 break;
941 case QCAMERA_SM_EVT_TAKE_PICTURE:
942 {
943 rc = m_parent->takePicture();
944 if (rc == NO_ERROR) {
945 // move state to picture taking state
946 m_state = QCAMERA_SM_STATE_PIC_TAKING;
947 } else {
948 // move state to preview stopped state
949 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
950 }
951 result.status = rc;
952 result.request_api = evt;
953 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
954 m_parent->signalAPIResult(&result);
955 }
956 break;
957 case QCAMERA_SM_EVT_SEND_COMMAND:
958 {
959 qcamera_sm_evt_command_payload_t *cmd_payload =
960 (qcamera_sm_evt_command_payload_t *)payload;
961 rc = m_parent->sendCommand(cmd_payload->cmd,
962 cmd_payload->arg1,
963 cmd_payload->arg2);
964 result.status = rc;
965 result.request_api = evt;
966 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
967 m_parent->signalAPIResult(&result);
968 }
969 break;
970 case QCAMERA_SM_EVT_CANCEL_PICTURE:
971 case QCAMERA_SM_EVT_STOP_RECORDING:
972 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
973 case QCAMERA_SM_EVT_RELEASE:
974 {
975 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
976 rc = INVALID_OPERATION;
977 result.status = rc;
978 result.request_api = evt;
979 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
980 m_parent->signalAPIResult(&result);
981 }
982 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame^]983 case QCAMERA_SM_EVT_EVT_INTERNAL:
984 {
985 qcamera_sm_internal_evt_payload_t *internal_evt =
986 (qcamera_sm_internal_evt_payload_t *)payload;
987 switch (internal_evt->evt_type) {
988 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
989 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
990 break;
991 default:
992 break;
993 }
994 }
995 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]996 case QCAMERA_SM_EVT_EVT_NOTIFY:
997 {
998 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
999 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1000 case CAM_EVENT_TYPE_ZOOM_DONE:
1001 rc = m_parent->processZoomEvent(cam_evt->status);
1002 break;
1003 default:
1004 ALOGD("%s: no handling for server evt (%d) at this state",
1005 __func__, cam_evt->server_event_type);
1006 break;
1007 }
1008 }
1009 break;
1010 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1011 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1012 default:
1013 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1014 break;
1015 }
1016
1017 return rc;
1018}
1019
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1020/*===========================================================================
1021 * FUNCTION : procEvtPicTakingState
1022 *
1023 * DESCRIPTION: finite state machine function to handle event in state of
1024 * QCAMERA_SM_STATE_PIC_TAKING.
1025 *
1026 * PARAMETERS :
1027 * @evt : event to be processed
1028 * @payload : event payload. Can be NULL if not needed.
1029 *
1030 * RETURN : int32_t type of status
1031 * NO_ERROR -- success
1032 * none-zero failure code
1033 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1034int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt,
1035 void *payload)
1036{
1037 int32_t rc = NO_ERROR;
1038 qcamera_api_result_t result;
1039 memset(&result, 0, sizeof(qcamera_api_result_t));
1040
1041 switch (evt) {
1042 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1043 {
1044 // Error setting preview window during previewing
1045 ALOGE("Cannot set preview window when preview is running");
1046 rc = INVALID_OPERATION;
1047 result.status = rc;
1048 result.request_api = evt;
1049 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1050 m_parent->signalAPIResult(&result);
1051 }
1052 break;
1053 case QCAMERA_SM_EVT_SET_CALLBACKS:
1054 {
1055 qcamera_sm_evt_setcb_payload_t *setcbs =
1056 (qcamera_sm_evt_setcb_payload_t *)payload;
1057 rc = m_parent->setCallBacks(setcbs->notify_cb,
1058 setcbs->data_cb,
1059 setcbs->data_cb_timestamp,
1060 setcbs->get_memory,
1061 setcbs->user);
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;
1068 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1069 {
1070 rc = m_parent->enableMsgType(int32_t(payload));
1071 result.status = rc;
1072 result.request_api = evt;
1073 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1074 m_parent->signalAPIResult(&result);
1075 }
1076 break;
1077 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1078 {
1079 rc = m_parent->disableMsgType(int32_t(payload));
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 break;
1086 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1087 {
1088 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1089 result.status = rc;
1090 result.request_api = evt;
1091 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1092 result.enabled = enabled;
1093 m_parent->signalAPIResult(&result);
1094 }
1095 break;
1096 case QCAMERA_SM_EVT_SET_PARAMS:
1097 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1098 bool needRestart = false;
1099 rc = m_parent->updateParameters((char*)payload, needRestart);
1100 if (rc == NO_ERROR) {
1101 rc = m_parent->commitParameterChanges();
1102 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1103 result.status = rc;
1104 result.request_api = evt;
1105 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1106 m_parent->signalAPIResult(&result);
1107 }
1108 break;
1109 case QCAMERA_SM_EVT_GET_PARAMS:
1110 {
1111 result.params = m_parent->getParameters();
1112 rc = NO_ERROR;
1113 result.status = rc;
1114 result.request_api = evt;
1115 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1116 m_parent->signalAPIResult(&result);
1117 }
1118 break;
1119 case QCAMERA_SM_EVT_PUT_PARAMS:
1120 {
1121 rc = m_parent->putParameters((char*)payload);
1122 result.status = rc;
1123 result.request_api = evt;
1124 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1125 m_parent->signalAPIResult(&result);
1126 }
1127 break;
1128 case QCAMERA_SM_EVT_STOP_PREVIEW:
1129 {
1130 // no ops, since preview is stopped (normal),
1131 // or preview msg type is disabled (ZSL)
1132 rc = NO_ERROR;
1133 result.status = rc;
1134 result.request_api = evt;
1135 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1136 m_parent->signalAPIResult(&result);
1137 }
1138 break;
1139 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1140 {
1141 rc = NO_ERROR;
1142 result.status = rc;
1143 result.request_api = evt;
1144 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1145 result.enabled = 0;
1146 m_parent->signalAPIResult(&result);
1147 }
1148 break;
1149 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1150 {
1151 rc = NO_ERROR;
1152 result.status = rc;
1153 result.request_api = evt;
1154 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1155 result.enabled = 0;
1156 m_parent->signalAPIResult(&result);
1157 }
1158 break;
1159 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1160 {
1161 rc = m_parent->storeMetaDataInBuffers(int(payload));
1162 result.status = rc;
1163 result.request_api = evt;
1164 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1165 m_parent->signalAPIResult(&result);
1166 }
1167 break;
1168 case QCAMERA_SM_EVT_DUMP:
1169 {
1170 rc = m_parent->dump((int)payload);
1171 result.status = rc;
1172 result.request_api = evt;
1173 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1174 m_parent->signalAPIResult(&result);
1175 }
1176 break;
1177 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1178 {
1179 rc = m_parent->autoFocus();
1180 result.status = rc;
1181 result.request_api = evt;
1182 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1183 m_parent->signalAPIResult(&result);
1184 }
1185 break;
1186 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1187 {
1188 rc = m_parent->cancelAutoFocus();
1189 result.status = rc;
1190 result.request_api = evt;
1191 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1192 m_parent->signalAPIResult(&result);
1193 }
1194 break;
1195 case QCAMERA_SM_EVT_SEND_COMMAND:
1196 {
1197 qcamera_sm_evt_command_payload_t *cmd_payload =
1198 (qcamera_sm_evt_command_payload_t *)payload;
1199 rc = m_parent->sendCommand(cmd_payload->cmd,
1200 cmd_payload->arg1,
1201 cmd_payload->arg2);
1202 result.status = rc;
1203 result.request_api = evt;
1204 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1205 m_parent->signalAPIResult(&result);
1206 }
1207 break;
1208 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1209 {
1210 rc = m_parent->cancelPicture();
1211 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1212 result.status = rc;
1213 result.request_api = evt;
1214 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1215 m_parent->signalAPIResult(&result);
1216 }
1217 break;
1218 case QCAMERA_SM_EVT_TAKE_PICTURE:
1219 case QCAMERA_SM_EVT_START_RECORDING:
1220 case QCAMERA_SM_EVT_STOP_RECORDING:
1221 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1222 case QCAMERA_SM_EVT_START_PREVIEW:
1223 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1224 case QCAMERA_SM_EVT_RELEASE:
1225 {
1226 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1227 rc = INVALID_OPERATION;
1228 result.status = rc;
1229 result.request_api = evt;
1230 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1231 m_parent->signalAPIResult(&result);
1232 }
1233 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame^]1234 case QCAMERA_SM_EVT_EVT_INTERNAL:
1235 {
1236 qcamera_sm_internal_evt_payload_t *internal_evt =
1237 (qcamera_sm_internal_evt_payload_t *)payload;
1238 switch (internal_evt->evt_type) {
1239 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1240 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1241 break;
1242 default:
1243 break;
1244 }
1245 }
1246 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1247 case QCAMERA_SM_EVT_EVT_NOTIFY:
1248 {
1249 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1250 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1251 case CAM_EVENT_TYPE_ZOOM_DONE:
1252 rc = m_parent->processZoomEvent(cam_evt->status);
1253 break;
1254 default:
1255 ALOGD("%s: no handling for server evt (%d) at this state",
1256 __func__, cam_evt->server_event_type);
1257 break;
1258 }
1259 }
1260 break;
1261 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1262 {
1263 qcamera_jpeg_evt_payload_t *jpeg_job =
1264 (qcamera_jpeg_evt_payload_t *)payload;
1265 rc = m_parent->processJpegNotify(jpeg_job);
1266 }
1267 break;
1268 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1269 {
1270 rc = m_parent->cancelPicture();
1271 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1272 }
1273 break;
1274 default:
1275 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1276 break;
1277 }
1278
1279 return rc;
1280}
1281
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1282/*===========================================================================
1283 * FUNCTION : procEvtRecordingState
1284 *
1285 * DESCRIPTION: finite state machine function to handle event in state of
1286 * QCAMERA_SM_STATE_RECORDING.
1287 *
1288 * PARAMETERS :
1289 * @evt : event to be processed
1290 * @payload : event payload. Can be NULL if not needed.
1291 *
1292 * RETURN : int32_t type of status
1293 * NO_ERROR -- success
1294 * none-zero failure code
1295 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1296int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt,
1297 void *payload)
1298{
1299 int32_t rc = NO_ERROR;
1300 qcamera_api_result_t result;
1301 memset(&result, 0, sizeof(qcamera_api_result_t));
1302
1303 switch (evt) {
1304 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1305 {
1306 // Error setting preview window during previewing
1307 ALOGE("Cannot set preview window when preview is running");
1308 rc = INVALID_OPERATION;
1309 result.status = rc;
1310 result.request_api = evt;
1311 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1312 m_parent->signalAPIResult(&result);
1313 }
1314 break;
1315 case QCAMERA_SM_EVT_SET_CALLBACKS:
1316 {
1317 qcamera_sm_evt_setcb_payload_t *setcbs =
1318 (qcamera_sm_evt_setcb_payload_t *)payload;
1319 rc = m_parent->setCallBacks(setcbs->notify_cb,
1320 setcbs->data_cb,
1321 setcbs->data_cb_timestamp,
1322 setcbs->get_memory,
1323 setcbs->user);
1324 result.status = rc;
1325 result.request_api = evt;
1326 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1327 m_parent->signalAPIResult(&result);
1328 }
1329 break;
1330 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1331 {
1332 rc = m_parent->enableMsgType(int32_t(payload));
1333 result.status = rc;
1334 result.request_api = evt;
1335 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1336 m_parent->signalAPIResult(&result);
1337 }
1338 break;
1339 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1340 {
1341 rc = m_parent->disableMsgType(int32_t(payload));
1342 result.status = rc;
1343 result.request_api = evt;
1344 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1345 m_parent->signalAPIResult(&result);
1346 }
1347 break;
1348 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1349 {
1350 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1351 result.status = rc;
1352 result.request_api = evt;
1353 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1354 result.enabled = enabled;
1355 m_parent->signalAPIResult(&result);
1356 }
1357 break;
1358 case QCAMERA_SM_EVT_SET_PARAMS:
1359 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1360 bool needRestart = false;
1361 rc = m_parent->updateParameters((char*)payload, needRestart);
1362 if (rc == NO_ERROR) {
1363 if (needRestart) {
1364 // cannot set parameters that requires restart during recording
1365 ALOGE("%s: Cannot set parameters that requires restart during recording",
1366 __func__);
1367 rc = BAD_VALUE;
1368 } else {
1369 rc = m_parent->commitParameterChanges();
1370 }
1371 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1372 result.status = rc;
1373 result.request_api = evt;
1374 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1375 m_parent->signalAPIResult(&result);
1376 }
1377 break;
1378 case QCAMERA_SM_EVT_GET_PARAMS:
1379 {
1380 result.params = m_parent->getParameters();
1381 rc = NO_ERROR;
1382 result.status = rc;
1383 result.request_api = evt;
1384 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1385 m_parent->signalAPIResult(&result);
1386 }
1387 break;
1388 case QCAMERA_SM_EVT_PUT_PARAMS:
1389 {
1390 rc = m_parent->putParameters((char*)payload);
1391 result.status = rc;
1392 result.request_api = evt;
1393 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1394 m_parent->signalAPIResult(&result);
1395 }
1396 break;
1397 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1398 {
1399 rc = NO_ERROR;
1400 result.status = rc;
1401 result.request_api = evt;
1402 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1403 result.enabled = 0;
1404 m_parent->signalAPIResult(&result);
1405 }
1406 break;
1407 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1408 {
1409 rc = NO_ERROR;
1410 result.status = rc;
1411 result.request_api = evt;
1412 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1413 result.enabled = 1;
1414 m_parent->signalAPIResult(&result);
1415 }
1416 break;
1417 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1418 {
1419 rc = m_parent->storeMetaDataInBuffers(int(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_DUMP:
1427 {
1428 rc = m_parent->dump((int)payload);
1429 result.status = rc;
1430 result.request_api = evt;
1431 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1432 m_parent->signalAPIResult(&result);
1433 }
1434 break;
1435 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1436 {
1437 rc = m_parent->autoFocus();
1438 result.status = rc;
1439 result.request_api = evt;
1440 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1441 m_parent->signalAPIResult(&result);
1442 }
1443 break;
1444 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1445 {
1446 rc = m_parent->cancelAutoFocus();
1447 result.status = rc;
1448 result.request_api = evt;
1449 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1450 m_parent->signalAPIResult(&result);
1451 }
1452 break;
1453 case QCAMERA_SM_EVT_SEND_COMMAND:
1454 {
1455 qcamera_sm_evt_command_payload_t *cmd_payload =
1456 (qcamera_sm_evt_command_payload_t *)payload;
1457 rc = m_parent->sendCommand(cmd_payload->cmd,
1458 cmd_payload->arg1,
1459 cmd_payload->arg2);
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_TAKE_PICTURE:
1467 {
1468 rc = m_parent->takeLiveSnapshot();
1469 if (rc == 0) {
1470 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
1471 }
1472 result.status = rc;
1473 result.request_api = evt;
1474 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1475 m_parent->signalAPIResult(&result);
1476 }
1477 break;
1478 case QCAMERA_SM_EVT_START_RECORDING:
1479 {
1480 // no ops here
1481 ALOGD("%s: already in recording state, no ops for start_recording", __func__);
1482 rc = 0;
1483 result.status = rc;
1484 result.request_api = evt;
1485 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1486 m_parent->signalAPIResult(&result);
1487 }
1488 break;
1489 case QCAMERA_SM_EVT_STOP_RECORDING:
1490 {
1491 rc = m_parent->stopRecording();
1492 m_state = QCAMERA_SM_STATE_PREVIEWING;
1493 result.status = rc;
1494 result.request_api = evt;
1495 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1496 m_parent->signalAPIResult(&result);
1497 }
1498 break;
1499 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1500 {
1501 rc = m_parent->releaseRecordingFrame((const void *)payload);
1502 result.status = rc;
1503 result.request_api = evt;
1504 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1505 m_parent->signalAPIResult(&result);
1506 }
1507 break;
1508 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1509 case QCAMERA_SM_EVT_START_PREVIEW:
1510 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1511 case QCAMERA_SM_EVT_STOP_PREVIEW:
1512 case QCAMERA_SM_EVT_RELEASE:
1513 {
1514 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1515 rc = INVALID_OPERATION;
1516 result.status = rc;
1517 result.request_api = evt;
1518 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1519 m_parent->signalAPIResult(&result);
1520 }
1521 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame^]1522 case QCAMERA_SM_EVT_EVT_INTERNAL:
1523 {
1524 qcamera_sm_internal_evt_payload_t *internal_evt =
1525 (qcamera_sm_internal_evt_payload_t *)payload;
1526 switch (internal_evt->evt_type) {
1527 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1528 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1529 break;
1530 default:
1531 break;
1532 }
1533 }
1534 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1535 case QCAMERA_SM_EVT_EVT_NOTIFY:
1536 {
1537 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1538 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1539 case CAM_EVENT_TYPE_ZOOM_DONE:
1540 rc = m_parent->processZoomEvent(cam_evt->status);
1541 break;
1542 default:
1543 ALOGD("%s: no handling for server evt (%d) at this state",
1544 __func__, cam_evt->server_event_type);
1545 break;
1546 }
1547 }
1548 break;
1549 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1550 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1551 default:
1552 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1553 break;
1554 }
1555
1556 return rc;
1557}
1558
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1559/*===========================================================================
1560 * FUNCTION : procEvtVideoPicTakingState
1561 *
1562 * DESCRIPTION: finite state machine function to handle event in state of
1563 * QCAMERA_SM_STATE_VIDEO_PIC_TAKING.
1564 *
1565 * PARAMETERS :
1566 * @evt : event to be processed
1567 * @payload : event payload. Can be NULL if not needed.
1568 *
1569 * RETURN : int32_t type of status
1570 * NO_ERROR -- success
1571 * none-zero failure code
1572 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1573int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt,
1574 void *payload)
1575{
1576 int32_t rc = NO_ERROR;
1577 qcamera_api_result_t result;
1578 memset(&result, 0, sizeof(qcamera_api_result_t));
1579
1580 switch (evt) {
1581 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1582 {
1583 // Error setting preview window during previewing
1584 ALOGE("Cannot set preview window when preview is running");
1585 rc = INVALID_OPERATION;
1586 result.status = rc;
1587 result.request_api = evt;
1588 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1589 m_parent->signalAPIResult(&result);
1590 }
1591 break;
1592 case QCAMERA_SM_EVT_SET_CALLBACKS:
1593 {
1594 qcamera_sm_evt_setcb_payload_t *setcbs =
1595 (qcamera_sm_evt_setcb_payload_t *)payload;
1596 rc = m_parent->setCallBacks(setcbs->notify_cb,
1597 setcbs->data_cb,
1598 setcbs->data_cb_timestamp,
1599 setcbs->get_memory,
1600 setcbs->user);
1601 result.status = rc;
1602 result.request_api = evt;
1603 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1604 m_parent->signalAPIResult(&result);
1605 }
1606 break;
1607 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1608 {
1609 rc = m_parent->enableMsgType(int32_t(payload));
1610 result.status = rc;
1611 result.request_api = evt;
1612 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1613 m_parent->signalAPIResult(&result);
1614 }
1615 break;
1616 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1617 {
1618 rc = m_parent->disableMsgType(int32_t(payload));
1619 result.status = rc;
1620 result.request_api = evt;
1621 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1622 m_parent->signalAPIResult(&result);
1623 }
1624 break;
1625 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1626 {
1627 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1628 result.status = rc;
1629 result.request_api = evt;
1630 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1631 result.enabled = enabled;
1632 m_parent->signalAPIResult(&result);
1633 }
1634 break;
1635 case QCAMERA_SM_EVT_SET_PARAMS:
1636 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1637 bool needRestart = false;
1638 rc = m_parent->updateParameters((char*)payload, needRestart);
1639 if (rc == NO_ERROR) {
1640 if (needRestart) {
1641 // cannot set parameters that requires restart during recording
1642 ALOGE("%s: Cannot set parameters that requires restart during recording",
1643 __func__);
1644 rc = BAD_VALUE;
1645 } else {
1646 rc = m_parent->commitParameterChanges();
1647 }
1648 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1649 result.status = rc;
1650 result.request_api = evt;
1651 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1652 m_parent->signalAPIResult(&result);
1653 }
1654 break;
1655 case QCAMERA_SM_EVT_GET_PARAMS:
1656 {
1657 result.params = m_parent->getParameters();
1658 rc = NO_ERROR;
1659 result.status = rc;
1660 result.request_api = evt;
1661 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1662 m_parent->signalAPIResult(&result);
1663 }
1664 break;
1665 case QCAMERA_SM_EVT_PUT_PARAMS:
1666 {
1667 rc = m_parent->putParameters((char*)payload);
1668 result.status = rc;
1669 result.request_api = evt;
1670 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1671 m_parent->signalAPIResult(&result);
1672 }
1673 break;
1674 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1675 {
1676 rc = NO_ERROR;
1677 result.status = rc;
1678 result.request_api = evt;
1679 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1680 result.enabled = 1;
1681 m_parent->signalAPIResult(&result);
1682 }
1683 break;
1684 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1685 {
1686 rc = NO_ERROR;
1687 result.status = rc;
1688 result.request_api = evt;
1689 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1690 result.enabled = 1;
1691 m_parent->signalAPIResult(&result);
1692 }
1693 break;
1694 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1695 {
1696 rc = m_parent->storeMetaDataInBuffers(int(payload));
1697 result.status = rc;
1698 result.request_api = evt;
1699 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1700 m_parent->signalAPIResult(&result);
1701 }
1702 break;
1703 case QCAMERA_SM_EVT_DUMP:
1704 {
1705 rc = m_parent->dump((int)payload);
1706 result.status = rc;
1707 result.request_api = evt;
1708 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1709 m_parent->signalAPIResult(&result);
1710 }
1711 break;
1712 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1713 {
1714 rc = m_parent->autoFocus();
1715 result.status = rc;
1716 result.request_api = evt;
1717 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1718 m_parent->signalAPIResult(&result);
1719 }
1720 break;
1721 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1722 {
1723 rc = m_parent->cancelAutoFocus();
1724 result.status = rc;
1725 result.request_api = evt;
1726 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1727 m_parent->signalAPIResult(&result);
1728 }
1729 break;
1730 case QCAMERA_SM_EVT_SEND_COMMAND:
1731 {
1732 qcamera_sm_evt_command_payload_t *cmd_payload =
1733 (qcamera_sm_evt_command_payload_t *)payload;
1734 rc = m_parent->sendCommand(cmd_payload->cmd,
1735 cmd_payload->arg1,
1736 cmd_payload->arg2);
1737 result.status = rc;
1738 result.request_api = evt;
1739 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1740 m_parent->signalAPIResult(&result);
1741 }
1742 break;
1743 case QCAMERA_SM_EVT_STOP_RECORDING:
1744 {
1745 rc = m_parent->stopRecording();
1746 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
1747 result.status = rc;
1748 result.request_api = evt;
1749 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1750 m_parent->signalAPIResult(&result);
1751 }
1752 break;
1753 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1754 {
1755 rc = m_parent->releaseRecordingFrame((const void *)payload);
1756 result.status = rc;
1757 result.request_api = evt;
1758 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1759 m_parent->signalAPIResult(&result);
1760 }
1761 break;
1762 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1763 {
1764 rc = m_parent->cancelLiveSnapshot();
1765 m_state = QCAMERA_SM_STATE_RECORDING;
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_START_RECORDING:
1773 case QCAMERA_SM_EVT_START_PREVIEW:
1774 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1775 case QCAMERA_SM_EVT_STOP_PREVIEW:
1776 case QCAMERA_SM_EVT_TAKE_PICTURE:
1777 case QCAMERA_SM_EVT_RELEASE:
1778 {
1779 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1780 rc = INVALID_OPERATION;
1781 result.status = rc;
1782 result.request_api = evt;
1783 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1784 m_parent->signalAPIResult(&result);
1785 }
1786 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame^]1787 case QCAMERA_SM_EVT_EVT_INTERNAL:
1788 {
1789 qcamera_sm_internal_evt_payload_t *internal_evt =
1790 (qcamera_sm_internal_evt_payload_t *)payload;
1791 switch (internal_evt->evt_type) {
1792 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1793 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1794 break;
1795 default:
1796 break;
1797 }
1798 }
1799 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1800 case QCAMERA_SM_EVT_EVT_NOTIFY:
1801 {
1802 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1803 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1804 case CAM_EVENT_TYPE_ZOOM_DONE:
1805 rc = m_parent->processZoomEvent(cam_evt->status);
1806 break;
1807 default:
1808 ALOGD("%s: no handling for server evt (%d) at this state",
1809 __func__, cam_evt->server_event_type);
1810 break;
1811 }
1812 }
1813 break;
1814 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1815 {
1816 qcamera_jpeg_evt_payload_t *jpeg_job =
1817 (qcamera_jpeg_evt_payload_t *)payload;
1818 rc = m_parent->processJpegNotify(jpeg_job);
1819 }
1820 break;
1821 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1822 {
1823 rc = m_parent->cancelLiveSnapshot();
1824 m_state = QCAMERA_SM_STATE_RECORDING;
1825 }
1826 break;
1827 default:
1828 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1829 break;
1830 }
1831
1832 return rc;
1833}
1834
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1835/*===========================================================================
1836 * FUNCTION : procEvtPreviewPicTakingState
1837 *
1838 * DESCRIPTION: finite state machine function to handle event in state of
1839 * QCAMERA_SM_STATE_PREVIEW_PIC_TAKING.
1840 *
1841 * PARAMETERS :
1842 * @evt : event to be processed
1843 * @payload : event payload. Can be NULL if not needed.
1844 *
1845 * RETURN : int32_t type of status
1846 * NO_ERROR -- success
1847 * none-zero failure code
1848 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1849int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt,
1850 void *payload)
1851{
1852 int32_t rc = NO_ERROR;
1853 qcamera_api_result_t result;
1854 memset(&result, 0, sizeof(qcamera_api_result_t));
1855
1856 switch (evt) {
1857 case QCAMERA_SM_EVT_SET_CALLBACKS:
1858 {
1859 qcamera_sm_evt_setcb_payload_t *setcbs =
1860 (qcamera_sm_evt_setcb_payload_t *)payload;
1861 rc = m_parent->setCallBacks(setcbs->notify_cb,
1862 setcbs->data_cb,
1863 setcbs->data_cb_timestamp,
1864 setcbs->get_memory,
1865 setcbs->user);
1866 result.status = rc;
1867 result.request_api = evt;
1868 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1869 m_parent->signalAPIResult(&result);
1870 }
1871 break;
1872 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1873 {
1874 rc = m_parent->enableMsgType(int32_t(payload));
1875 result.status = rc;
1876 result.request_api = evt;
1877 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1878 m_parent->signalAPIResult(&result);
1879 }
1880 break;
1881 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1882 {
1883 rc = m_parent->disableMsgType(int32_t(payload));
1884 result.status = rc;
1885 result.request_api = evt;
1886 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1887 m_parent->signalAPIResult(&result);
1888 }
1889 break;
1890 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1891 {
1892 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1893 result.status = rc;
1894 result.request_api = evt;
1895 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1896 result.enabled = enabled;
1897 m_parent->signalAPIResult(&result);
1898 }
1899 break;
1900 case QCAMERA_SM_EVT_SET_PARAMS:
1901 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1902 bool needRestart = false;
1903 rc = m_parent->updateParameters((char*)payload, needRestart);
1904 if (rc == NO_ERROR) {
1905 if (needRestart) {
1906 // need restart preview for parameters to take effect
1907 // stop preview
1908 m_parent->stopPreview();
1909 // commit parameter changes to server
1910 rc = m_parent->commitParameterChanges();
1911 // start preview again
1912 m_parent->startPreview();
1913 } else {
1914 rc = m_parent->commitParameterChanges();
1915 }
1916 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1917 result.status = rc;
1918 result.request_api = evt;
1919 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1920 m_parent->signalAPIResult(&result);
1921 }
1922 break;
1923 case QCAMERA_SM_EVT_GET_PARAMS:
1924 {
1925 result.params = m_parent->getParameters();
1926 rc = NO_ERROR;
1927 result.status = rc;
1928 result.request_api = evt;
1929 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1930 m_parent->signalAPIResult(&result);
1931 }
1932 break;
1933 case QCAMERA_SM_EVT_PUT_PARAMS:
1934 {
1935 rc = m_parent->putParameters((char*)payload);
1936 result.status = rc;
1937 result.request_api = evt;
1938 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1939 m_parent->signalAPIResult(&result);
1940 }
1941 break;
1942 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1943 {
1944 rc = NO_ERROR;
1945 result.status = rc;
1946 result.request_api = evt;
1947 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1948 result.enabled = 1;
1949 m_parent->signalAPIResult(&result);
1950 }
1951 break;
1952 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1953 {
1954 rc = NO_ERROR;
1955 result.status = rc;
1956 result.request_api = evt;
1957 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1958 result.enabled = 0;
1959 m_parent->signalAPIResult(&result);
1960 }
1961 break;
1962 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1963 {
1964 rc = m_parent->storeMetaDataInBuffers(int(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_DUMP:
1972 {
1973 rc = m_parent->dump((int)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_START_AUTO_FOCUS:
1981 {
1982 rc = m_parent->autoFocus();
1983 result.status = rc;
1984 result.request_api = evt;
1985 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1986 m_parent->signalAPIResult(&result);
1987 }
1988 break;
1989 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1990 {
1991 rc = m_parent->cancelAutoFocus();
1992 result.status = rc;
1993 result.request_api = evt;
1994 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1995 m_parent->signalAPIResult(&result);
1996 }
1997 break;
1998 case QCAMERA_SM_EVT_SEND_COMMAND:
1999 {
2000 qcamera_sm_evt_command_payload_t *cmd_payload =
2001 (qcamera_sm_evt_command_payload_t *)payload;
2002 rc = m_parent->sendCommand(cmd_payload->cmd,
2003 cmd_payload->arg1,
2004 cmd_payload->arg2);
2005 result.status = rc;
2006 result.request_api = evt;
2007 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2008 m_parent->signalAPIResult(&result);
2009 }
2010 break;
2011 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2012 {
2013 rc = m_parent->releaseRecordingFrame((const void *)payload);
2014 result.status = rc;
2015 result.request_api = evt;
2016 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2017 m_parent->signalAPIResult(&result);
2018 }
2019 break;
2020 case QCAMERA_SM_EVT_CANCEL_PICTURE:
2021 {
2022 rc = m_parent->cancelLiveSnapshot();
2023 m_state = QCAMERA_SM_STATE_PREVIEWING;
2024 result.status = rc;
2025 result.request_api = evt;
2026 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2027 m_parent->signalAPIResult(&result);
2028 }
2029 break;
2030 case QCAMERA_SM_EVT_STOP_PREVIEW:
2031 {
2032 m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW);
2033 m_parent->delChannel(QCAMERA_CH_TYPE_PREVIEW);
2034 m_parent->delChannel(QCAMERA_CH_TYPE_VIDEO);
2035 m_state = QCAMERA_SM_STATE_PIC_TAKING;
2036 rc = NO_ERROR;
2037 result.status = rc;
2038 result.request_api = evt;
2039 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2040 m_parent->signalAPIResult(&result);
2041 }
2042 break;
2043 case QCAMERA_SM_EVT_START_RECORDING:
2044 {
2045 rc = m_parent->stopRecording();
2046 if (rc == NO_ERROR) {
2047 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
2048 }
2049 result.status = rc;
2050 result.request_api = evt;
2051 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2052 m_parent->signalAPIResult(&result);
2053 }
2054 break;
2055 case QCAMERA_SM_EVT_STOP_RECORDING:
2056 case QCAMERA_SM_EVT_START_PREVIEW:
2057 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
2058 case QCAMERA_SM_EVT_TAKE_PICTURE:
2059 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
2060 case QCAMERA_SM_EVT_RELEASE:
2061 {
2062 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2063 rc = INVALID_OPERATION;
2064 result.status = rc;
2065 result.request_api = evt;
2066 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2067 m_parent->signalAPIResult(&result);
2068 }
2069 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame^]2070 case QCAMERA_SM_EVT_EVT_INTERNAL:
2071 {
2072 qcamera_sm_internal_evt_payload_t *internal_evt =
2073 (qcamera_sm_internal_evt_payload_t *)payload;
2074 switch (internal_evt->evt_type) {
2075 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2076 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2077 break;
2078 default:
2079 break;
2080 }
2081 }
2082 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2083 case QCAMERA_SM_EVT_EVT_NOTIFY:
2084 {
2085 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2086 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2087 case CAM_EVENT_TYPE_ZOOM_DONE:
2088 rc = m_parent->processZoomEvent(cam_evt->status);
2089 break;
2090 default:
2091 ALOGD("%s: no handling for server evt (%d) at this state",
2092 __func__, cam_evt->server_event_type);
2093 break;
2094 }
2095 }
2096 break;
2097 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
2098 {
2099 qcamera_jpeg_evt_payload_t *jpeg_job =
2100 (qcamera_jpeg_evt_payload_t *)payload;
2101 rc = m_parent->processJpegNotify(jpeg_job);
2102 }
2103 break;
2104 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
2105 {
2106 rc = m_parent->cancelLiveSnapshot();
2107 m_state = QCAMERA_SM_STATE_PREVIEWING;
2108 }
2109 break;
2110 default:
2111 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2112 break;
2113 }
2114
2115 return rc;
2116}
2117
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2118/*===========================================================================
2119 * FUNCTION : isPreviewRunning
2120 *
2121 * DESCRIPTION: check if preview is in process.
2122 *
2123 * PARAMETERS : None
2124 *
2125 * RETURN : true -- preview running
2126 * false -- preview stopped
2127 *==========================================================================*/
2128bool QCameraStateMachine::isPreviewRunning()
2129{
2130 switch (m_state) {
2131 case QCAMERA_SM_STATE_PREVIEWING:
2132 case QCAMERA_SM_STATE_RECORDING:
2133 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
2134 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
2135 return true;
2136 default:
2137 return false;
2138 }
2139}
2140
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2141}; // namespace android