Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / hardware / qcom / camera / 3b00dc6f87ba28d465b488e8abcc556ce8b3378a / . / QCamera2 / HAL / QCameraStateMachine.cpp
blob: f5b829895a4170521f2ce3b8e657f26b963bb891 [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;
Ankit Premrajka3b00dc62012-12-14 18:37:52 -0800[diff] [blame^]469 case QCAMERA_SM_EVT_SEND_COMMAND:
470 {
471 qcamera_sm_evt_command_payload_t *cmd_payload =
472 (qcamera_sm_evt_command_payload_t *)payload;
473 rc = m_parent->sendCommand(cmd_payload->cmd,
474 cmd_payload->arg1,
475 cmd_payload->arg2);
476 result.status = rc;
477 result.request_api = evt;
478 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
479 m_parent->signalAPIResult(&result);
480 }
481 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]482 case QCAMERA_SM_EVT_START_RECORDING:
483 case QCAMERA_SM_EVT_STOP_RECORDING:
484 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
485 case QCAMERA_SM_EVT_TAKE_PICTURE:
486 case QCAMERA_SM_EVT_CANCEL_PICTURE:
487 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
488 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]489 {
490 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
491 rc = INVALID_OPERATION;
492 result.status = rc;
493 result.request_api = evt;
494 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
495 m_parent->signalAPIResult(&result);
496 }
497 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]498 case QCAMERA_SM_EVT_EVT_INTERNAL:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]499 case QCAMERA_SM_EVT_EVT_NOTIFY:
500 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]501 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]502 default:
503 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
504 break;
505 }
506
507 return rc;
508}
509
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]510/*===========================================================================
511 * FUNCTION : procEvtPreviewReadyState
512 *
513 * DESCRIPTION: finite state machine function to handle event in state of
514 * QCAMERA_SM_STATE_PREVIEW_READY.
515 *
516 * PARAMETERS :
517 * @evt : event to be processed
518 * @payload : event payload. Can be NULL if not needed.
519 *
520 * RETURN : int32_t type of status
521 * NO_ERROR -- success
522 * none-zero failure code
523 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]524int32_t QCameraStateMachine::procEvtPreviewReadyState(qcamera_sm_evt_enum_t evt,
525 void *payload)
526{
527 int32_t rc = NO_ERROR;
528 qcamera_api_result_t result;
529 memset(&result, 0, sizeof(qcamera_api_result_t));
530
531 switch (evt) {
532 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
533 {
534 m_parent->setPreviewWindow((struct preview_stream_ops *)payload);
535 if (m_parent->mPreviewWindow != NULL) {
536 rc = m_parent->startPreview();
537 if (rc != NO_ERROR) {
538 m_parent->unpreparePreview();
539 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
540 } else {
541 m_state = QCAMERA_SM_STATE_PREVIEWING;
542 }
543 }
544
545 result.status = rc;
546 result.request_api = evt;
547 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
548 m_parent->signalAPIResult(&result);
549 }
550 break;
551 case QCAMERA_SM_EVT_SET_CALLBACKS:
552 {
553 qcamera_sm_evt_setcb_payload_t *setcbs =
554 (qcamera_sm_evt_setcb_payload_t *)payload;
555 rc = m_parent->setCallBacks(setcbs->notify_cb,
556 setcbs->data_cb,
557 setcbs->data_cb_timestamp,
558 setcbs->get_memory,
559 setcbs->user);
560 result.status = rc;
561 result.request_api = evt;
562 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
563 m_parent->signalAPIResult(&result);
564 }
565 break;
566 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
567 {
568 rc = m_parent->enableMsgType(int32_t(payload));
569 result.status = rc;
570 result.request_api = evt;
571 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
572 m_parent->signalAPIResult(&result);
573 }
574 break;
575 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
576 {
577 rc = m_parent->disableMsgType(int32_t(payload));
578 result.status = rc;
579 result.request_api = evt;
580 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
581 m_parent->signalAPIResult(&result);
582 }
583 break;
584 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
585 {
586 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
587 result.status = rc;
588 result.request_api = evt;
589 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
590 result.enabled = enabled;
591 m_parent->signalAPIResult(&result);
592 }
593 break;
594 case QCAMERA_SM_EVT_SET_PARAMS:
595 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]596 bool needRestart = false;
597 rc = m_parent->updateParameters((char*)payload, needRestart);
598 if (rc == NO_ERROR) {
599 rc = m_parent->commitParameterChanges();
600 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]601 result.status = rc;
602 result.request_api = evt;
603 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
604 m_parent->signalAPIResult(&result);
605 }
606 break;
607 case QCAMERA_SM_EVT_GET_PARAMS:
608 {
609 result.params = m_parent->getParameters();
610 rc = NO_ERROR;
611 result.status = rc;
612 result.request_api = evt;
613 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
614 m_parent->signalAPIResult(&result);
615 }
616 break;
617 case QCAMERA_SM_EVT_PUT_PARAMS:
618 {
619 rc = m_parent->putParameters((char*)payload);
620 result.status = rc;
621 result.request_api = evt;
622 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
623 m_parent->signalAPIResult(&result);
624 }
625 break;
626 case QCAMERA_SM_EVT_START_PREVIEW:
627 {
628 // no ops here
629 rc = NO_ERROR;
630 result.status = rc;
631 result.request_api = evt;
632 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
633 m_parent->signalAPIResult(&result);
634 }
635 break;
636 case QCAMERA_SM_EVT_STOP_PREVIEW:
637 {
638 m_parent->unpreparePreview();
639 rc = 0;
640 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
641 result.status = rc;
642 result.request_api = evt;
643 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
644 m_parent->signalAPIResult(&result);
645 }
646 break;
647 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
648 {
649 rc = NO_ERROR;
650 result.status = rc;
651 result.request_api = evt;
652 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
653 result.enabled = 1;
654 m_parent->signalAPIResult(&result);
655 }
656 break;
657 case QCAMERA_SM_EVT_RECORDING_ENABLED:
658 {
659 rc = 0;
660 result.status = rc;
661 result.request_api = evt;
662 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
663 result.enabled = 0;
664 m_parent->signalAPIResult(&result);
665 }
666 break;
667 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
668 {
669 rc = m_parent->storeMetaDataInBuffers(int(payload));
670 result.status = rc;
671 result.request_api = evt;
672 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
673 m_parent->signalAPIResult(&result);
674 }
675 break;
676 case QCAMERA_SM_EVT_DUMP:
677 {
678 rc = m_parent->dump((int)payload);
679 result.status = rc;
680 result.request_api = evt;
681 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
682 m_parent->signalAPIResult(&result);
683 }
684 break;
685 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
686 {
687 rc = m_parent->autoFocus();
688 result.status = rc;
689 result.request_api = evt;
690 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
691 m_parent->signalAPIResult(&result);
692 }
693 break;
694 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
695 {
696 rc = m_parent->cancelAutoFocus();
697 result.status = rc;
698 result.request_api = evt;
699 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
700 m_parent->signalAPIResult(&result);
701 }
702 break;
703 case QCAMERA_SM_EVT_SEND_COMMAND:
704 {
705 qcamera_sm_evt_command_payload_t *cmd_payload =
706 (qcamera_sm_evt_command_payload_t *)payload;
707 rc = m_parent->sendCommand(cmd_payload->cmd,
708 cmd_payload->arg1,
709 cmd_payload->arg2);
710 result.status = rc;
711 result.request_api = evt;
712 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
713 m_parent->signalAPIResult(&result);
714 }
715 break;
716 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
717 case QCAMERA_SM_EVT_START_RECORDING:
718 case QCAMERA_SM_EVT_STOP_RECORDING:
719 case QCAMERA_SM_EVT_TAKE_PICTURE:
720 case QCAMERA_SM_EVT_CANCEL_PICTURE:
721 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
722 case QCAMERA_SM_EVT_RELEASE:
723 {
724 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
725 rc = INVALID_OPERATION;
726 result.status = rc;
727 result.request_api = evt;
728 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
729 m_parent->signalAPIResult(&result);
730 }
731 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]732 case QCAMERA_SM_EVT_EVT_INTERNAL:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]733 case QCAMERA_SM_EVT_EVT_NOTIFY:
734 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]735 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]736 default:
737 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
738 break;
739 }
740
741 return rc;
742}
743
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]744/*===========================================================================
745 * FUNCTION : procEvtPreviewingState
746 *
747 * DESCRIPTION: finite state machine function to handle event in state of
748 * QCAMERA_SM_STATE_PREVIEWING.
749 *
750 * PARAMETERS :
751 * @evt : event to be processed
752 * @payload : event payload. Can be NULL if not needed.
753 *
754 * RETURN : int32_t type of status
755 * NO_ERROR -- success
756 * none-zero failure code
757 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]758int32_t QCameraStateMachine::procEvtPreviewingState(qcamera_sm_evt_enum_t evt,
759 void *payload)
760{
761 int32_t rc = NO_ERROR;
762 qcamera_api_result_t result;
763 memset(&result, 0, sizeof(qcamera_api_result_t));
764
765 switch (evt) {
766 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
767 {
768 // Error setting preview window during previewing
769 ALOGE("Cannot set preview window when preview is running");
770 rc = INVALID_OPERATION;
771 result.status = rc;
772 result.request_api = evt;
773 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
774 m_parent->signalAPIResult(&result);
775 }
776 break;
777 case QCAMERA_SM_EVT_SET_CALLBACKS:
778 {
779 qcamera_sm_evt_setcb_payload_t *setcbs =
780 (qcamera_sm_evt_setcb_payload_t *)payload;
781 rc = m_parent->setCallBacks(setcbs->notify_cb,
782 setcbs->data_cb,
783 setcbs->data_cb_timestamp,
784 setcbs->get_memory,
785 setcbs->user);
786 result.status = rc;
787 result.request_api = evt;
788 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
789 m_parent->signalAPIResult(&result);
790 }
791 break;
792 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
793 {
794 rc = m_parent->enableMsgType(int32_t(payload));
795 result.status = rc;
796 result.request_api = evt;
797 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
798 m_parent->signalAPIResult(&result);
799 }
800 break;
801 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
802 {
803 rc = m_parent->disableMsgType(int32_t(payload));
804 result.status = rc;
805 result.request_api = evt;
806 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
807 m_parent->signalAPIResult(&result);
808 }
809 break;
810 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
811 {
812 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
813 result.status = rc;
814 result.request_api = evt;
815 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
816 result.enabled = enabled;
817 m_parent->signalAPIResult(&result);
818 }
819 break;
820 case QCAMERA_SM_EVT_SET_PARAMS:
821 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]822 bool needRestart = false;
823 rc = m_parent->updateParameters((char*)payload, needRestart);
824 if (rc == NO_ERROR) {
825 if (needRestart) {
826 // need restart preview for parameters to take effect
827 // stop preview
828 m_parent->stopPreview();
829 // commit parameter changes to server
830 rc = m_parent->commitParameterChanges();
831 // start preview again
832 m_parent->startPreview();
833 } else {
834 rc = m_parent->commitParameterChanges();
835 }
836 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]837 result.status = rc;
838 result.request_api = evt;
839 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
840 m_parent->signalAPIResult(&result);
841 }
842 break;
843 case QCAMERA_SM_EVT_GET_PARAMS:
844 {
845 result.params = m_parent->getParameters();
846 rc = NO_ERROR;
847 result.status = rc;
848 result.request_api = evt;
849 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
850 m_parent->signalAPIResult(&result);
851 }
852 break;
853 case QCAMERA_SM_EVT_PUT_PARAMS:
854 {
855 rc = m_parent->putParameters((char*)payload);
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_START_PREVIEW:
863 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
864 {
865 // no ops here
866 ALOGD("%s: Already in previewing, no ops here to start preview", __func__);
867 rc = NO_ERROR;
868 result.status = rc;
869 result.request_api = evt;
870 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
871 m_parent->signalAPIResult(&result);
872 }
873 break;
874 case QCAMERA_SM_EVT_STOP_PREVIEW:
875 {
876 rc = m_parent->stopPreview();
877 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
878 result.status = rc;
879 result.request_api = evt;
880 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
881 m_parent->signalAPIResult(&result);
882 }
883 break;
884 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
885 {
886 rc = NO_ERROR;
887 result.status = rc;
888 result.request_api = evt;
889 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
890 result.enabled = 1;
891 m_parent->signalAPIResult(&result);
892 }
893 break;
894 case QCAMERA_SM_EVT_RECORDING_ENABLED:
895 {
896 rc = NO_ERROR;
897 result.status = rc;
898 result.request_api = evt;
899 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
900 result.enabled = 0;
901 m_parent->signalAPIResult(&result);
902 }
903 break;
904 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
905 {
906 rc = m_parent->storeMetaDataInBuffers(int(payload));
907 result.status = rc;
908 result.request_api = evt;
909 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
910 m_parent->signalAPIResult(&result);
911 }
912 break;
913 case QCAMERA_SM_EVT_DUMP:
914 {
915 rc = m_parent->dump((int)payload);
916 result.status = rc;
917 result.request_api = evt;
918 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
919 m_parent->signalAPIResult(&result);
920 }
921 break;
922 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
923 {
924 rc = m_parent->autoFocus();
925 result.status = rc;
926 result.request_api = evt;
927 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
928 m_parent->signalAPIResult(&result);
929 }
930 break;
931 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
932 {
933 rc = m_parent->cancelAutoFocus();
934 result.status = rc;
935 result.request_api = evt;
936 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
937 m_parent->signalAPIResult(&result);
938 }
939 break;
940 case QCAMERA_SM_EVT_START_RECORDING:
941 {
942 rc = m_parent->startRecording();
943 if (rc == NO_ERROR) {
944 // move state to recording state
945 m_state = QCAMERA_SM_STATE_RECORDING;
946 }
947 result.status = rc;
948 result.request_api = evt;
949 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
950 m_parent->signalAPIResult(&result);
951 }
952 break;
953 case QCAMERA_SM_EVT_TAKE_PICTURE:
954 {
955 rc = m_parent->takePicture();
956 if (rc == NO_ERROR) {
957 // move state to picture taking state
958 m_state = QCAMERA_SM_STATE_PIC_TAKING;
959 } else {
960 // move state to preview stopped state
961 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
962 }
963 result.status = rc;
964 result.request_api = evt;
965 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
966 m_parent->signalAPIResult(&result);
967 }
968 break;
969 case QCAMERA_SM_EVT_SEND_COMMAND:
970 {
971 qcamera_sm_evt_command_payload_t *cmd_payload =
972 (qcamera_sm_evt_command_payload_t *)payload;
973 rc = m_parent->sendCommand(cmd_payload->cmd,
974 cmd_payload->arg1,
975 cmd_payload->arg2);
976 result.status = rc;
977 result.request_api = evt;
978 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
979 m_parent->signalAPIResult(&result);
980 }
981 break;
982 case QCAMERA_SM_EVT_CANCEL_PICTURE:
983 case QCAMERA_SM_EVT_STOP_RECORDING:
984 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
985 case QCAMERA_SM_EVT_RELEASE:
986 {
987 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
988 rc = INVALID_OPERATION;
989 result.status = rc;
990 result.request_api = evt;
991 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
992 m_parent->signalAPIResult(&result);
993 }
994 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]995 case QCAMERA_SM_EVT_EVT_INTERNAL:
996 {
997 qcamera_sm_internal_evt_payload_t *internal_evt =
998 (qcamera_sm_internal_evt_payload_t *)payload;
999 switch (internal_evt->evt_type) {
1000 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1001 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1002 break;
1003 default:
1004 break;
1005 }
1006 }
1007 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1008 case QCAMERA_SM_EVT_EVT_NOTIFY:
1009 {
1010 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1011 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1012 case CAM_EVENT_TYPE_ZOOM_DONE:
1013 rc = m_parent->processZoomEvent(cam_evt->status);
1014 break;
1015 default:
1016 ALOGD("%s: no handling for server evt (%d) at this state",
1017 __func__, cam_evt->server_event_type);
1018 break;
1019 }
1020 }
1021 break;
1022 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1023 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1024 default:
1025 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1026 break;
1027 }
1028
1029 return rc;
1030}
1031
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1032/*===========================================================================
1033 * FUNCTION : procEvtPicTakingState
1034 *
1035 * DESCRIPTION: finite state machine function to handle event in state of
1036 * QCAMERA_SM_STATE_PIC_TAKING.
1037 *
1038 * PARAMETERS :
1039 * @evt : event to be processed
1040 * @payload : event payload. Can be NULL if not needed.
1041 *
1042 * RETURN : int32_t type of status
1043 * NO_ERROR -- success
1044 * none-zero failure code
1045 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1046int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt,
1047 void *payload)
1048{
1049 int32_t rc = NO_ERROR;
1050 qcamera_api_result_t result;
1051 memset(&result, 0, sizeof(qcamera_api_result_t));
1052
1053 switch (evt) {
1054 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1055 {
1056 // Error setting preview window during previewing
1057 ALOGE("Cannot set preview window when preview is running");
1058 rc = INVALID_OPERATION;
1059 result.status = rc;
1060 result.request_api = evt;
1061 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1062 m_parent->signalAPIResult(&result);
1063 }
1064 break;
1065 case QCAMERA_SM_EVT_SET_CALLBACKS:
1066 {
1067 qcamera_sm_evt_setcb_payload_t *setcbs =
1068 (qcamera_sm_evt_setcb_payload_t *)payload;
1069 rc = m_parent->setCallBacks(setcbs->notify_cb,
1070 setcbs->data_cb,
1071 setcbs->data_cb_timestamp,
1072 setcbs->get_memory,
1073 setcbs->user);
1074 result.status = rc;
1075 result.request_api = evt;
1076 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1077 m_parent->signalAPIResult(&result);
1078 }
1079 break;
1080 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1081 {
1082 rc = m_parent->enableMsgType(int32_t(payload));
1083 result.status = rc;
1084 result.request_api = evt;
1085 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1086 m_parent->signalAPIResult(&result);
1087 }
1088 break;
1089 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1090 {
1091 rc = m_parent->disableMsgType(int32_t(payload));
1092 result.status = rc;
1093 result.request_api = evt;
1094 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1095 m_parent->signalAPIResult(&result);
1096 }
1097 break;
1098 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1099 {
1100 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1101 result.status = rc;
1102 result.request_api = evt;
1103 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1104 result.enabled = enabled;
1105 m_parent->signalAPIResult(&result);
1106 }
1107 break;
1108 case QCAMERA_SM_EVT_SET_PARAMS:
1109 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1110 bool needRestart = false;
1111 rc = m_parent->updateParameters((char*)payload, needRestart);
1112 if (rc == NO_ERROR) {
1113 rc = m_parent->commitParameterChanges();
1114 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1115 result.status = rc;
1116 result.request_api = evt;
1117 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1118 m_parent->signalAPIResult(&result);
1119 }
1120 break;
1121 case QCAMERA_SM_EVT_GET_PARAMS:
1122 {
1123 result.params = m_parent->getParameters();
1124 rc = NO_ERROR;
1125 result.status = rc;
1126 result.request_api = evt;
1127 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1128 m_parent->signalAPIResult(&result);
1129 }
1130 break;
1131 case QCAMERA_SM_EVT_PUT_PARAMS:
1132 {
1133 rc = m_parent->putParameters((char*)payload);
1134 result.status = rc;
1135 result.request_api = evt;
1136 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1137 m_parent->signalAPIResult(&result);
1138 }
1139 break;
1140 case QCAMERA_SM_EVT_STOP_PREVIEW:
1141 {
1142 // no ops, since preview is stopped (normal),
1143 // or preview msg type is disabled (ZSL)
1144 rc = NO_ERROR;
1145 result.status = rc;
1146 result.request_api = evt;
1147 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1148 m_parent->signalAPIResult(&result);
1149 }
1150 break;
1151 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1152 {
1153 rc = NO_ERROR;
1154 result.status = rc;
1155 result.request_api = evt;
1156 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1157 result.enabled = 0;
1158 m_parent->signalAPIResult(&result);
1159 }
1160 break;
1161 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1162 {
1163 rc = NO_ERROR;
1164 result.status = rc;
1165 result.request_api = evt;
1166 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1167 result.enabled = 0;
1168 m_parent->signalAPIResult(&result);
1169 }
1170 break;
1171 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1172 {
1173 rc = m_parent->storeMetaDataInBuffers(int(payload));
1174 result.status = rc;
1175 result.request_api = evt;
1176 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1177 m_parent->signalAPIResult(&result);
1178 }
1179 break;
1180 case QCAMERA_SM_EVT_DUMP:
1181 {
1182 rc = m_parent->dump((int)payload);
1183 result.status = rc;
1184 result.request_api = evt;
1185 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1186 m_parent->signalAPIResult(&result);
1187 }
1188 break;
1189 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1190 {
1191 rc = m_parent->autoFocus();
1192 result.status = rc;
1193 result.request_api = evt;
1194 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1195 m_parent->signalAPIResult(&result);
1196 }
1197 break;
1198 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1199 {
1200 rc = m_parent->cancelAutoFocus();
1201 result.status = rc;
1202 result.request_api = evt;
1203 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1204 m_parent->signalAPIResult(&result);
1205 }
1206 break;
1207 case QCAMERA_SM_EVT_SEND_COMMAND:
1208 {
1209 qcamera_sm_evt_command_payload_t *cmd_payload =
1210 (qcamera_sm_evt_command_payload_t *)payload;
1211 rc = m_parent->sendCommand(cmd_payload->cmd,
1212 cmd_payload->arg1,
1213 cmd_payload->arg2);
1214 result.status = rc;
1215 result.request_api = evt;
1216 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1217 m_parent->signalAPIResult(&result);
1218 }
1219 break;
1220 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1221 {
1222 rc = m_parent->cancelPicture();
1223 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1224 result.status = rc;
1225 result.request_api = evt;
1226 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1227 m_parent->signalAPIResult(&result);
1228 }
1229 break;
1230 case QCAMERA_SM_EVT_TAKE_PICTURE:
1231 case QCAMERA_SM_EVT_START_RECORDING:
1232 case QCAMERA_SM_EVT_STOP_RECORDING:
1233 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1234 case QCAMERA_SM_EVT_START_PREVIEW:
1235 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1236 case QCAMERA_SM_EVT_RELEASE:
1237 {
1238 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1239 rc = INVALID_OPERATION;
1240 result.status = rc;
1241 result.request_api = evt;
1242 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1243 m_parent->signalAPIResult(&result);
1244 }
1245 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1246 case QCAMERA_SM_EVT_EVT_INTERNAL:
1247 {
1248 qcamera_sm_internal_evt_payload_t *internal_evt =
1249 (qcamera_sm_internal_evt_payload_t *)payload;
1250 switch (internal_evt->evt_type) {
1251 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1252 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1253 break;
1254 default:
1255 break;
1256 }
1257 }
1258 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1259 case QCAMERA_SM_EVT_EVT_NOTIFY:
1260 {
1261 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1262 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1263 case CAM_EVENT_TYPE_ZOOM_DONE:
1264 rc = m_parent->processZoomEvent(cam_evt->status);
1265 break;
1266 default:
1267 ALOGD("%s: no handling for server evt (%d) at this state",
1268 __func__, cam_evt->server_event_type);
1269 break;
1270 }
1271 }
1272 break;
1273 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1274 {
1275 qcamera_jpeg_evt_payload_t *jpeg_job =
1276 (qcamera_jpeg_evt_payload_t *)payload;
1277 rc = m_parent->processJpegNotify(jpeg_job);
1278 }
1279 break;
1280 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1281 {
1282 rc = m_parent->cancelPicture();
1283 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1284 }
1285 break;
1286 default:
1287 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1288 break;
1289 }
1290
1291 return rc;
1292}
1293
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1294/*===========================================================================
1295 * FUNCTION : procEvtRecordingState
1296 *
1297 * DESCRIPTION: finite state machine function to handle event in state of
1298 * QCAMERA_SM_STATE_RECORDING.
1299 *
1300 * PARAMETERS :
1301 * @evt : event to be processed
1302 * @payload : event payload. Can be NULL if not needed.
1303 *
1304 * RETURN : int32_t type of status
1305 * NO_ERROR -- success
1306 * none-zero failure code
1307 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1308int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt,
1309 void *payload)
1310{
1311 int32_t rc = NO_ERROR;
1312 qcamera_api_result_t result;
1313 memset(&result, 0, sizeof(qcamera_api_result_t));
1314
1315 switch (evt) {
1316 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1317 {
1318 // Error setting preview window during previewing
1319 ALOGE("Cannot set preview window when preview is running");
1320 rc = INVALID_OPERATION;
1321 result.status = rc;
1322 result.request_api = evt;
1323 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1324 m_parent->signalAPIResult(&result);
1325 }
1326 break;
1327 case QCAMERA_SM_EVT_SET_CALLBACKS:
1328 {
1329 qcamera_sm_evt_setcb_payload_t *setcbs =
1330 (qcamera_sm_evt_setcb_payload_t *)payload;
1331 rc = m_parent->setCallBacks(setcbs->notify_cb,
1332 setcbs->data_cb,
1333 setcbs->data_cb_timestamp,
1334 setcbs->get_memory,
1335 setcbs->user);
1336 result.status = rc;
1337 result.request_api = evt;
1338 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1339 m_parent->signalAPIResult(&result);
1340 }
1341 break;
1342 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1343 {
1344 rc = m_parent->enableMsgType(int32_t(payload));
1345 result.status = rc;
1346 result.request_api = evt;
1347 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1348 m_parent->signalAPIResult(&result);
1349 }
1350 break;
1351 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1352 {
1353 rc = m_parent->disableMsgType(int32_t(payload));
1354 result.status = rc;
1355 result.request_api = evt;
1356 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1357 m_parent->signalAPIResult(&result);
1358 }
1359 break;
1360 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1361 {
1362 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1363 result.status = rc;
1364 result.request_api = evt;
1365 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1366 result.enabled = enabled;
1367 m_parent->signalAPIResult(&result);
1368 }
1369 break;
1370 case QCAMERA_SM_EVT_SET_PARAMS:
1371 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1372 bool needRestart = false;
1373 rc = m_parent->updateParameters((char*)payload, needRestart);
1374 if (rc == NO_ERROR) {
1375 if (needRestart) {
1376 // cannot set parameters that requires restart during recording
1377 ALOGE("%s: Cannot set parameters that requires restart during recording",
1378 __func__);
1379 rc = BAD_VALUE;
1380 } else {
1381 rc = m_parent->commitParameterChanges();
1382 }
1383 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1384 result.status = rc;
1385 result.request_api = evt;
1386 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1387 m_parent->signalAPIResult(&result);
1388 }
1389 break;
1390 case QCAMERA_SM_EVT_GET_PARAMS:
1391 {
1392 result.params = m_parent->getParameters();
1393 rc = NO_ERROR;
1394 result.status = rc;
1395 result.request_api = evt;
1396 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1397 m_parent->signalAPIResult(&result);
1398 }
1399 break;
1400 case QCAMERA_SM_EVT_PUT_PARAMS:
1401 {
1402 rc = m_parent->putParameters((char*)payload);
1403 result.status = rc;
1404 result.request_api = evt;
1405 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1406 m_parent->signalAPIResult(&result);
1407 }
1408 break;
1409 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1410 {
1411 rc = NO_ERROR;
1412 result.status = rc;
1413 result.request_api = evt;
1414 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1415 result.enabled = 0;
1416 m_parent->signalAPIResult(&result);
1417 }
1418 break;
1419 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1420 {
1421 rc = NO_ERROR;
1422 result.status = rc;
1423 result.request_api = evt;
1424 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1425 result.enabled = 1;
1426 m_parent->signalAPIResult(&result);
1427 }
1428 break;
1429 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1430 {
1431 rc = m_parent->storeMetaDataInBuffers(int(payload));
1432 result.status = rc;
1433 result.request_api = evt;
1434 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1435 m_parent->signalAPIResult(&result);
1436 }
1437 break;
1438 case QCAMERA_SM_EVT_DUMP:
1439 {
1440 rc = m_parent->dump((int)payload);
1441 result.status = rc;
1442 result.request_api = evt;
1443 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1444 m_parent->signalAPIResult(&result);
1445 }
1446 break;
1447 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1448 {
1449 rc = m_parent->autoFocus();
1450 result.status = rc;
1451 result.request_api = evt;
1452 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1453 m_parent->signalAPIResult(&result);
1454 }
1455 break;
1456 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1457 {
1458 rc = m_parent->cancelAutoFocus();
1459 result.status = rc;
1460 result.request_api = evt;
1461 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1462 m_parent->signalAPIResult(&result);
1463 }
1464 break;
1465 case QCAMERA_SM_EVT_SEND_COMMAND:
1466 {
1467 qcamera_sm_evt_command_payload_t *cmd_payload =
1468 (qcamera_sm_evt_command_payload_t *)payload;
1469 rc = m_parent->sendCommand(cmd_payload->cmd,
1470 cmd_payload->arg1,
1471 cmd_payload->arg2);
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_TAKE_PICTURE:
1479 {
1480 rc = m_parent->takeLiveSnapshot();
1481 if (rc == 0) {
1482 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
1483 }
1484 result.status = rc;
1485 result.request_api = evt;
1486 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1487 m_parent->signalAPIResult(&result);
1488 }
1489 break;
1490 case QCAMERA_SM_EVT_START_RECORDING:
1491 {
1492 // no ops here
1493 ALOGD("%s: already in recording state, no ops for start_recording", __func__);
1494 rc = 0;
1495 result.status = rc;
1496 result.request_api = evt;
1497 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1498 m_parent->signalAPIResult(&result);
1499 }
1500 break;
1501 case QCAMERA_SM_EVT_STOP_RECORDING:
1502 {
1503 rc = m_parent->stopRecording();
1504 m_state = QCAMERA_SM_STATE_PREVIEWING;
1505 result.status = rc;
1506 result.request_api = evt;
1507 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1508 m_parent->signalAPIResult(&result);
1509 }
1510 break;
1511 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1512 {
1513 rc = m_parent->releaseRecordingFrame((const void *)payload);
1514 result.status = rc;
1515 result.request_api = evt;
1516 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1517 m_parent->signalAPIResult(&result);
1518 }
1519 break;
1520 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1521 case QCAMERA_SM_EVT_START_PREVIEW:
1522 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1523 case QCAMERA_SM_EVT_STOP_PREVIEW:
1524 case QCAMERA_SM_EVT_RELEASE:
1525 {
1526 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1527 rc = INVALID_OPERATION;
1528 result.status = rc;
1529 result.request_api = evt;
1530 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1531 m_parent->signalAPIResult(&result);
1532 }
1533 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1534 case QCAMERA_SM_EVT_EVT_INTERNAL:
1535 {
1536 qcamera_sm_internal_evt_payload_t *internal_evt =
1537 (qcamera_sm_internal_evt_payload_t *)payload;
1538 switch (internal_evt->evt_type) {
1539 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1540 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1541 break;
1542 default:
1543 break;
1544 }
1545 }
1546 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1547 case QCAMERA_SM_EVT_EVT_NOTIFY:
1548 {
1549 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1550 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1551 case CAM_EVENT_TYPE_ZOOM_DONE:
1552 rc = m_parent->processZoomEvent(cam_evt->status);
1553 break;
1554 default:
1555 ALOGD("%s: no handling for server evt (%d) at this state",
1556 __func__, cam_evt->server_event_type);
1557 break;
1558 }
1559 }
1560 break;
1561 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1562 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1563 default:
1564 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1565 break;
1566 }
1567
1568 return rc;
1569}
1570
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1571/*===========================================================================
1572 * FUNCTION : procEvtVideoPicTakingState
1573 *
1574 * DESCRIPTION: finite state machine function to handle event in state of
1575 * QCAMERA_SM_STATE_VIDEO_PIC_TAKING.
1576 *
1577 * PARAMETERS :
1578 * @evt : event to be processed
1579 * @payload : event payload. Can be NULL if not needed.
1580 *
1581 * RETURN : int32_t type of status
1582 * NO_ERROR -- success
1583 * none-zero failure code
1584 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1585int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt,
1586 void *payload)
1587{
1588 int32_t rc = NO_ERROR;
1589 qcamera_api_result_t result;
1590 memset(&result, 0, sizeof(qcamera_api_result_t));
1591
1592 switch (evt) {
1593 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1594 {
1595 // Error setting preview window during previewing
1596 ALOGE("Cannot set preview window when preview is running");
1597 rc = INVALID_OPERATION;
1598 result.status = rc;
1599 result.request_api = evt;
1600 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1601 m_parent->signalAPIResult(&result);
1602 }
1603 break;
1604 case QCAMERA_SM_EVT_SET_CALLBACKS:
1605 {
1606 qcamera_sm_evt_setcb_payload_t *setcbs =
1607 (qcamera_sm_evt_setcb_payload_t *)payload;
1608 rc = m_parent->setCallBacks(setcbs->notify_cb,
1609 setcbs->data_cb,
1610 setcbs->data_cb_timestamp,
1611 setcbs->get_memory,
1612 setcbs->user);
1613 result.status = rc;
1614 result.request_api = evt;
1615 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1616 m_parent->signalAPIResult(&result);
1617 }
1618 break;
1619 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1620 {
1621 rc = m_parent->enableMsgType(int32_t(payload));
1622 result.status = rc;
1623 result.request_api = evt;
1624 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1625 m_parent->signalAPIResult(&result);
1626 }
1627 break;
1628 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1629 {
1630 rc = m_parent->disableMsgType(int32_t(payload));
1631 result.status = rc;
1632 result.request_api = evt;
1633 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1634 m_parent->signalAPIResult(&result);
1635 }
1636 break;
1637 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1638 {
1639 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1640 result.status = rc;
1641 result.request_api = evt;
1642 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1643 result.enabled = enabled;
1644 m_parent->signalAPIResult(&result);
1645 }
1646 break;
1647 case QCAMERA_SM_EVT_SET_PARAMS:
1648 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1649 bool needRestart = false;
1650 rc = m_parent->updateParameters((char*)payload, needRestart);
1651 if (rc == NO_ERROR) {
1652 if (needRestart) {
1653 // cannot set parameters that requires restart during recording
1654 ALOGE("%s: Cannot set parameters that requires restart during recording",
1655 __func__);
1656 rc = BAD_VALUE;
1657 } else {
1658 rc = m_parent->commitParameterChanges();
1659 }
1660 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]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_GET_PARAMS:
1668 {
1669 result.params = m_parent->getParameters();
1670 rc = NO_ERROR;
1671 result.status = rc;
1672 result.request_api = evt;
1673 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1674 m_parent->signalAPIResult(&result);
1675 }
1676 break;
1677 case QCAMERA_SM_EVT_PUT_PARAMS:
1678 {
1679 rc = m_parent->putParameters((char*)payload);
1680 result.status = rc;
1681 result.request_api = evt;
1682 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1683 m_parent->signalAPIResult(&result);
1684 }
1685 break;
1686 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1687 {
1688 rc = NO_ERROR;
1689 result.status = rc;
1690 result.request_api = evt;
1691 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1692 result.enabled = 1;
1693 m_parent->signalAPIResult(&result);
1694 }
1695 break;
1696 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1697 {
1698 rc = NO_ERROR;
1699 result.status = rc;
1700 result.request_api = evt;
1701 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1702 result.enabled = 1;
1703 m_parent->signalAPIResult(&result);
1704 }
1705 break;
1706 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1707 {
1708 rc = m_parent->storeMetaDataInBuffers(int(payload));
1709 result.status = rc;
1710 result.request_api = evt;
1711 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1712 m_parent->signalAPIResult(&result);
1713 }
1714 break;
1715 case QCAMERA_SM_EVT_DUMP:
1716 {
1717 rc = m_parent->dump((int)payload);
1718 result.status = rc;
1719 result.request_api = evt;
1720 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1721 m_parent->signalAPIResult(&result);
1722 }
1723 break;
1724 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1725 {
1726 rc = m_parent->autoFocus();
1727 result.status = rc;
1728 result.request_api = evt;
1729 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1730 m_parent->signalAPIResult(&result);
1731 }
1732 break;
1733 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1734 {
1735 rc = m_parent->cancelAutoFocus();
1736 result.status = rc;
1737 result.request_api = evt;
1738 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1739 m_parent->signalAPIResult(&result);
1740 }
1741 break;
1742 case QCAMERA_SM_EVT_SEND_COMMAND:
1743 {
1744 qcamera_sm_evt_command_payload_t *cmd_payload =
1745 (qcamera_sm_evt_command_payload_t *)payload;
1746 rc = m_parent->sendCommand(cmd_payload->cmd,
1747 cmd_payload->arg1,
1748 cmd_payload->arg2);
1749 result.status = rc;
1750 result.request_api = evt;
1751 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1752 m_parent->signalAPIResult(&result);
1753 }
1754 break;
1755 case QCAMERA_SM_EVT_STOP_RECORDING:
1756 {
1757 rc = m_parent->stopRecording();
1758 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
1759 result.status = rc;
1760 result.request_api = evt;
1761 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1762 m_parent->signalAPIResult(&result);
1763 }
1764 break;
1765 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1766 {
1767 rc = m_parent->releaseRecordingFrame((const void *)payload);
1768 result.status = rc;
1769 result.request_api = evt;
1770 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1771 m_parent->signalAPIResult(&result);
1772 }
1773 break;
1774 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1775 {
1776 rc = m_parent->cancelLiveSnapshot();
1777 m_state = QCAMERA_SM_STATE_RECORDING;
1778 result.status = rc;
1779 result.request_api = evt;
1780 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1781 m_parent->signalAPIResult(&result);
1782 }
1783 break;
1784 case QCAMERA_SM_EVT_START_RECORDING:
1785 case QCAMERA_SM_EVT_START_PREVIEW:
1786 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1787 case QCAMERA_SM_EVT_STOP_PREVIEW:
1788 case QCAMERA_SM_EVT_TAKE_PICTURE:
1789 case QCAMERA_SM_EVT_RELEASE:
1790 {
1791 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1792 rc = INVALID_OPERATION;
1793 result.status = rc;
1794 result.request_api = evt;
1795 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1796 m_parent->signalAPIResult(&result);
1797 }
1798 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1799 case QCAMERA_SM_EVT_EVT_INTERNAL:
1800 {
1801 qcamera_sm_internal_evt_payload_t *internal_evt =
1802 (qcamera_sm_internal_evt_payload_t *)payload;
1803 switch (internal_evt->evt_type) {
1804 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1805 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1806 break;
1807 default:
1808 break;
1809 }
1810 }
1811 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1812 case QCAMERA_SM_EVT_EVT_NOTIFY:
1813 {
1814 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1815 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1816 case CAM_EVENT_TYPE_ZOOM_DONE:
1817 rc = m_parent->processZoomEvent(cam_evt->status);
1818 break;
1819 default:
1820 ALOGD("%s: no handling for server evt (%d) at this state",
1821 __func__, cam_evt->server_event_type);
1822 break;
1823 }
1824 }
1825 break;
1826 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1827 {
1828 qcamera_jpeg_evt_payload_t *jpeg_job =
1829 (qcamera_jpeg_evt_payload_t *)payload;
1830 rc = m_parent->processJpegNotify(jpeg_job);
1831 }
1832 break;
1833 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1834 {
1835 rc = m_parent->cancelLiveSnapshot();
1836 m_state = QCAMERA_SM_STATE_RECORDING;
1837 }
1838 break;
1839 default:
1840 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1841 break;
1842 }
1843
1844 return rc;
1845}
1846
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1847/*===========================================================================
1848 * FUNCTION : procEvtPreviewPicTakingState
1849 *
1850 * DESCRIPTION: finite state machine function to handle event in state of
1851 * QCAMERA_SM_STATE_PREVIEW_PIC_TAKING.
1852 *
1853 * PARAMETERS :
1854 * @evt : event to be processed
1855 * @payload : event payload. Can be NULL if not needed.
1856 *
1857 * RETURN : int32_t type of status
1858 * NO_ERROR -- success
1859 * none-zero failure code
1860 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1861int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt,
1862 void *payload)
1863{
1864 int32_t rc = NO_ERROR;
1865 qcamera_api_result_t result;
1866 memset(&result, 0, sizeof(qcamera_api_result_t));
1867
1868 switch (evt) {
1869 case QCAMERA_SM_EVT_SET_CALLBACKS:
1870 {
1871 qcamera_sm_evt_setcb_payload_t *setcbs =
1872 (qcamera_sm_evt_setcb_payload_t *)payload;
1873 rc = m_parent->setCallBacks(setcbs->notify_cb,
1874 setcbs->data_cb,
1875 setcbs->data_cb_timestamp,
1876 setcbs->get_memory,
1877 setcbs->user);
1878 result.status = rc;
1879 result.request_api = evt;
1880 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1881 m_parent->signalAPIResult(&result);
1882 }
1883 break;
1884 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1885 {
1886 rc = m_parent->enableMsgType(int32_t(payload));
1887 result.status = rc;
1888 result.request_api = evt;
1889 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1890 m_parent->signalAPIResult(&result);
1891 }
1892 break;
1893 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1894 {
1895 rc = m_parent->disableMsgType(int32_t(payload));
1896 result.status = rc;
1897 result.request_api = evt;
1898 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1899 m_parent->signalAPIResult(&result);
1900 }
1901 break;
1902 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1903 {
1904 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1905 result.status = rc;
1906 result.request_api = evt;
1907 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1908 result.enabled = enabled;
1909 m_parent->signalAPIResult(&result);
1910 }
1911 break;
1912 case QCAMERA_SM_EVT_SET_PARAMS:
1913 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1914 bool needRestart = false;
1915 rc = m_parent->updateParameters((char*)payload, needRestart);
1916 if (rc == NO_ERROR) {
1917 if (needRestart) {
1918 // need restart preview for parameters to take effect
1919 // stop preview
1920 m_parent->stopPreview();
1921 // commit parameter changes to server
1922 rc = m_parent->commitParameterChanges();
1923 // start preview again
1924 m_parent->startPreview();
1925 } else {
1926 rc = m_parent->commitParameterChanges();
1927 }
1928 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1929 result.status = rc;
1930 result.request_api = evt;
1931 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1932 m_parent->signalAPIResult(&result);
1933 }
1934 break;
1935 case QCAMERA_SM_EVT_GET_PARAMS:
1936 {
1937 result.params = m_parent->getParameters();
1938 rc = NO_ERROR;
1939 result.status = rc;
1940 result.request_api = evt;
1941 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1942 m_parent->signalAPIResult(&result);
1943 }
1944 break;
1945 case QCAMERA_SM_EVT_PUT_PARAMS:
1946 {
1947 rc = m_parent->putParameters((char*)payload);
1948 result.status = rc;
1949 result.request_api = evt;
1950 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1951 m_parent->signalAPIResult(&result);
1952 }
1953 break;
1954 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1955 {
1956 rc = NO_ERROR;
1957 result.status = rc;
1958 result.request_api = evt;
1959 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1960 result.enabled = 1;
1961 m_parent->signalAPIResult(&result);
1962 }
1963 break;
1964 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1965 {
1966 rc = NO_ERROR;
1967 result.status = rc;
1968 result.request_api = evt;
1969 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1970 result.enabled = 0;
1971 m_parent->signalAPIResult(&result);
1972 }
1973 break;
1974 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1975 {
1976 rc = m_parent->storeMetaDataInBuffers(int(payload));
1977 result.status = rc;
1978 result.request_api = evt;
1979 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1980 m_parent->signalAPIResult(&result);
1981 }
1982 break;
1983 case QCAMERA_SM_EVT_DUMP:
1984 {
1985 rc = m_parent->dump((int)payload);
1986 result.status = rc;
1987 result.request_api = evt;
1988 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1989 m_parent->signalAPIResult(&result);
1990 }
1991 break;
1992 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1993 {
1994 rc = m_parent->autoFocus();
1995 result.status = rc;
1996 result.request_api = evt;
1997 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1998 m_parent->signalAPIResult(&result);
1999 }
2000 break;
2001 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
2002 {
2003 rc = m_parent->cancelAutoFocus();
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_SEND_COMMAND:
2011 {
2012 qcamera_sm_evt_command_payload_t *cmd_payload =
2013 (qcamera_sm_evt_command_payload_t *)payload;
2014 rc = m_parent->sendCommand(cmd_payload->cmd,
2015 cmd_payload->arg1,
2016 cmd_payload->arg2);
2017 result.status = rc;
2018 result.request_api = evt;
2019 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2020 m_parent->signalAPIResult(&result);
2021 }
2022 break;
2023 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2024 {
2025 rc = m_parent->releaseRecordingFrame((const void *)payload);
2026 result.status = rc;
2027 result.request_api = evt;
2028 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2029 m_parent->signalAPIResult(&result);
2030 }
2031 break;
2032 case QCAMERA_SM_EVT_CANCEL_PICTURE:
2033 {
2034 rc = m_parent->cancelLiveSnapshot();
2035 m_state = QCAMERA_SM_STATE_PREVIEWING;
2036 result.status = rc;
2037 result.request_api = evt;
2038 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2039 m_parent->signalAPIResult(&result);
2040 }
2041 break;
2042 case QCAMERA_SM_EVT_STOP_PREVIEW:
2043 {
2044 m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW);
2045 m_parent->delChannel(QCAMERA_CH_TYPE_PREVIEW);
2046 m_parent->delChannel(QCAMERA_CH_TYPE_VIDEO);
2047 m_state = QCAMERA_SM_STATE_PIC_TAKING;
2048 rc = NO_ERROR;
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_START_RECORDING:
2056 {
2057 rc = m_parent->stopRecording();
2058 if (rc == NO_ERROR) {
2059 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
2060 }
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_STOP_RECORDING:
2068 case QCAMERA_SM_EVT_START_PREVIEW:
2069 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
2070 case QCAMERA_SM_EVT_TAKE_PICTURE:
2071 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
2072 case QCAMERA_SM_EVT_RELEASE:
2073 {
2074 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2075 rc = INVALID_OPERATION;
2076 result.status = rc;
2077 result.request_api = evt;
2078 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2079 m_parent->signalAPIResult(&result);
2080 }
2081 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2082 case QCAMERA_SM_EVT_EVT_INTERNAL:
2083 {
2084 qcamera_sm_internal_evt_payload_t *internal_evt =
2085 (qcamera_sm_internal_evt_payload_t *)payload;
2086 switch (internal_evt->evt_type) {
2087 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2088 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2089 break;
2090 default:
2091 break;
2092 }
2093 }
2094 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2095 case QCAMERA_SM_EVT_EVT_NOTIFY:
2096 {
2097 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2098 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2099 case CAM_EVENT_TYPE_ZOOM_DONE:
2100 rc = m_parent->processZoomEvent(cam_evt->status);
2101 break;
2102 default:
2103 ALOGD("%s: no handling for server evt (%d) at this state",
2104 __func__, cam_evt->server_event_type);
2105 break;
2106 }
2107 }
2108 break;
2109 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
2110 {
2111 qcamera_jpeg_evt_payload_t *jpeg_job =
2112 (qcamera_jpeg_evt_payload_t *)payload;
2113 rc = m_parent->processJpegNotify(jpeg_job);
2114 }
2115 break;
2116 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
2117 {
2118 rc = m_parent->cancelLiveSnapshot();
2119 m_state = QCAMERA_SM_STATE_PREVIEWING;
2120 }
2121 break;
2122 default:
2123 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2124 break;
2125 }
2126
2127 return rc;
2128}
2129
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2130/*===========================================================================
2131 * FUNCTION : isPreviewRunning
2132 *
2133 * DESCRIPTION: check if preview is in process.
2134 *
2135 * PARAMETERS : None
2136 *
2137 * RETURN : true -- preview running
2138 * false -- preview stopped
2139 *==========================================================================*/
2140bool QCameraStateMachine::isPreviewRunning()
2141{
2142 switch (m_state) {
2143 case QCAMERA_SM_STATE_PREVIEWING:
2144 case QCAMERA_SM_STATE_RECORDING:
2145 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
2146 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
2147 return true;
2148 default:
2149 return false;
2150 }
2151}
2152
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2153}; // namespace android