Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / hardware / qcom / camera / 4d4f0a3237dad74301329b15ed224a56e357f472 / . / QCamera2 / HAL / QCameraStateMachine.cpp
blob: 882f443913a689593693d022cce94fe7e967c8d6 [file] [log] [blame]
Muhua Li1612f422013-01-03 11:07:39 -0800[diff] [blame]1/* Copyright (c) 2012-2013, The Linux Foundataion. All rights reserved.
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2*
3* Redistribution and use in source and binary forms, with or without
4* modification, are permitted provided that the following conditions are
5* met:
6* * Redistributions of source code must retain the above copyright
7* notice, this list of conditions and the following disclaimer.
8* * Redistributions in binary form must reproduce the above
9* copyright notice, this list of conditions and the following
10* disclaimer in the documentation and/or other materials provided
11* with the distribution.
12* * Neither the name of The Linux Foundation nor the names of its
13* contributors may be used to endorse or promote products derived
14* from this software without specific prior written permission.
15*
16* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27*
28*/
29
30#define LOG_TAG "QCameraStateMachine"
31
32#include <utils/Log.h>
33#include <utils/Errors.h>
34#include "QCamera2HWI.h"
35#include "QCameraStateMachine.h"
36
Shuzhen Wang89635cf2012-12-20 13:47:22 -0800[diff] [blame]37namespace qcamera {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]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 {
Shuzhen Wang2da44612012-12-20 10:51:57 -0800[diff] [blame]58 ret = cam_sem_wait(&pme->cmd_sem);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]59 if (ret != 0 && errno != EINVAL) {
Shuzhen Wang2da44612012-12-20 10:51:57 -0800[diff] [blame]60 ALOGE("%s: cam_sem_wait error (%s)",
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]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;
Shuzhen Wang2da44612012-12-20 10:51:57 -0800[diff] [blame]118 cam_sem_init(&cmd_sem, 0);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]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);
Shuzhen Wang2da44612012-12-20 10:51:57 -0800[diff] [blame]144 cam_sem_post(&cmd_sem);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]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 }
Shuzhen Wang2da44612012-12-20 10:51:57 -0800[diff] [blame]153 cam_sem_destroy(&cmd_sem);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]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)) {
Shuzhen Wang2da44612012-12-20 10:51:57 -0800[diff] [blame]184 cam_sem_post(&cmd_sem);
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]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)) {
Shuzhen Wang2da44612012-12-20 10:51:57 -0800[diff] [blame]221 cam_sem_post(&cmd_sem);
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]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) {
Mansoor Aftab06c809c2013-01-23 19:44:47 -0800[diff] [blame]384 rc = m_parent->preparePreview();
385 if(rc == NO_ERROR) {
386 // preview window is not set yet, move to previewReady state
387 m_state = QCAMERA_SM_STATE_PREVIEW_READY;
388 } else {
389 ALOGE("%s: preparePreview failed",__func__);
390 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]391 } else {
392 rc = m_parent->preparePreview();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]393 if (rc == NO_ERROR) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]394 rc = m_parent->startPreview();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]395 if (rc != NO_ERROR) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]396 m_parent->unpreparePreview();
397 } else {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]398 // start preview success, move to previewing state
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]399 m_state = QCAMERA_SM_STATE_PREVIEWING;
400 }
401 }
402 }
403 result.status = rc;
404 result.request_api = evt;
405 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
406 m_parent->signalAPIResult(&result);
407 }
408 break;
409 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
410 {
411 rc = m_parent->preparePreview();
412 if (rc == NO_ERROR) {
413 rc = m_parent->startPreview();
414 if (rc != NO_ERROR) {
415 m_parent->unpreparePreview();
416 } else {
417 m_state = QCAMERA_SM_STATE_PREVIEWING;
418 }
419 }
420 result.status = rc;
421 result.request_api = evt;
422 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
423 m_parent->signalAPIResult(&result);
424 }
425 break;
426 case QCAMERA_SM_EVT_STOP_PREVIEW:
427 {
428 // no op needed here
429 ALOGD("%s: already in preview stopped state, do nothing", __func__);
430 result.status = NO_ERROR;
431 result.request_api = evt;
432 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
433 m_parent->signalAPIResult(&result);
434 }
435 break;
436 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
437 case QCAMERA_SM_EVT_RECORDING_ENABLED:
438 {
439 result.status = NO_ERROR;
440 result.request_api = evt;
441 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
442 result.enabled = 0;
443 m_parent->signalAPIResult(&result);
444 }
445 break;
446 case QCAMERA_SM_EVT_RELEASE:
447 {
448 rc = m_parent->release();
449 result.status = rc;
450 result.request_api = evt;
451 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
452 m_parent->signalAPIResult(&result);
453 }
454 break;
455 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
456 {
457 rc = m_parent->storeMetaDataInBuffers(int(payload));
458 result.status = rc;
459 result.request_api = evt;
460 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
461 m_parent->signalAPIResult(&result);
462 }
463 break;
464 case QCAMERA_SM_EVT_DUMP:
465 {
466 rc = m_parent->dump((int)payload);
467 result.status = rc;
468 result.request_api = evt;
469 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
470 m_parent->signalAPIResult(&result);
471 }
472 break;
Ankit Premrajka3b00dc62012-12-14 18:37:52 -0800[diff] [blame]473 case QCAMERA_SM_EVT_SEND_COMMAND:
474 {
475 qcamera_sm_evt_command_payload_t *cmd_payload =
476 (qcamera_sm_evt_command_payload_t *)payload;
477 rc = m_parent->sendCommand(cmd_payload->cmd,
478 cmd_payload->arg1,
479 cmd_payload->arg2);
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 Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]486 case QCAMERA_SM_EVT_START_RECORDING:
487 case QCAMERA_SM_EVT_STOP_RECORDING:
488 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
489 case QCAMERA_SM_EVT_TAKE_PICTURE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]490 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]491 {
492 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
493 rc = INVALID_OPERATION;
494 result.status = rc;
495 result.request_api = evt;
496 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
497 m_parent->signalAPIResult(&result);
498 }
499 break;
Muhua Li1612f422013-01-03 11:07:39 -0800[diff] [blame]500 case QCAMERA_SM_EVT_CANCEL_PICTURE:
501 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
502 {
503 // no op needed here
504 ALOGD("%s: No ops for evt(%d) in state(%d)", __func__, evt, m_state);
505 result.status = NO_ERROR;
506 result.request_api = evt;
507 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
508 m_parent->signalAPIResult(&result);
509 }
510 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]511 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
512 {
513 int32_t faceID = 0;
514 qcamera_sm_evt_reg_face_payload_t *reg_payload =
515 (qcamera_sm_evt_reg_face_payload_t *)payload;
516 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
517 reg_payload->config,
518 faceID);
519 result.status = rc;
520 result.request_api = evt;
521 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
522 result.handle = faceID;
523 m_parent->signalAPIResult(&result);
524 }
525 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]526 case QCAMERA_SM_EVT_EVT_INTERNAL:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]527 case QCAMERA_SM_EVT_EVT_NOTIFY:
528 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]529 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]530 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]531 default:
532 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
533 break;
534 }
535
536 return rc;
537}
538
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]539/*===========================================================================
540 * FUNCTION : procEvtPreviewReadyState
541 *
542 * DESCRIPTION: finite state machine function to handle event in state of
543 * QCAMERA_SM_STATE_PREVIEW_READY.
544 *
545 * PARAMETERS :
546 * @evt : event to be processed
547 * @payload : event payload. Can be NULL if not needed.
548 *
549 * RETURN : int32_t type of status
550 * NO_ERROR -- success
551 * none-zero failure code
552 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]553int32_t QCameraStateMachine::procEvtPreviewReadyState(qcamera_sm_evt_enum_t evt,
554 void *payload)
555{
556 int32_t rc = NO_ERROR;
557 qcamera_api_result_t result;
558 memset(&result, 0, sizeof(qcamera_api_result_t));
559
560 switch (evt) {
561 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
562 {
563 m_parent->setPreviewWindow((struct preview_stream_ops *)payload);
564 if (m_parent->mPreviewWindow != NULL) {
565 rc = m_parent->startPreview();
566 if (rc != NO_ERROR) {
567 m_parent->unpreparePreview();
568 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
569 } else {
570 m_state = QCAMERA_SM_STATE_PREVIEWING;
571 }
572 }
573
574 result.status = rc;
575 result.request_api = evt;
576 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
577 m_parent->signalAPIResult(&result);
578 }
579 break;
580 case QCAMERA_SM_EVT_SET_CALLBACKS:
581 {
582 qcamera_sm_evt_setcb_payload_t *setcbs =
583 (qcamera_sm_evt_setcb_payload_t *)payload;
584 rc = m_parent->setCallBacks(setcbs->notify_cb,
585 setcbs->data_cb,
586 setcbs->data_cb_timestamp,
587 setcbs->get_memory,
588 setcbs->user);
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_ENABLE_MSG_TYPE:
596 {
597 rc = m_parent->enableMsgType(int32_t(payload));
598 result.status = rc;
599 result.request_api = evt;
600 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
601 m_parent->signalAPIResult(&result);
602 }
603 break;
604 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
605 {
606 rc = m_parent->disableMsgType(int32_t(payload));
607 result.status = rc;
608 result.request_api = evt;
609 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
610 m_parent->signalAPIResult(&result);
611 }
612 break;
613 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
614 {
615 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
616 result.status = rc;
617 result.request_api = evt;
618 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
619 result.enabled = enabled;
620 m_parent->signalAPIResult(&result);
621 }
622 break;
623 case QCAMERA_SM_EVT_SET_PARAMS:
624 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]625 bool needRestart = false;
626 rc = m_parent->updateParameters((char*)payload, needRestart);
627 if (rc == NO_ERROR) {
Muhua Li6d69e932013-01-24 16:39:27 -0800[diff] [blame]628 if (needRestart) {
629 // need restart preview for parameters to take effect
630 m_parent->unpreparePreview();
631 // commit parameter changes to server
632 m_parent->commitParameterChanges();
633 // prepare preview again
634 rc = m_parent->preparePreview();
635 if (rc != NO_ERROR) {
636 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
637 }
638 } else {
639 rc = m_parent->commitParameterChanges();
640 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]641 }
Muhua Li6d69e932013-01-24 16:39:27 -0800[diff] [blame]642
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]643 result.status = rc;
644 result.request_api = evt;
645 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
646 m_parent->signalAPIResult(&result);
647 }
648 break;
649 case QCAMERA_SM_EVT_GET_PARAMS:
650 {
651 result.params = m_parent->getParameters();
652 rc = NO_ERROR;
653 result.status = rc;
654 result.request_api = evt;
655 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
656 m_parent->signalAPIResult(&result);
657 }
658 break;
659 case QCAMERA_SM_EVT_PUT_PARAMS:
660 {
661 rc = m_parent->putParameters((char*)payload);
662 result.status = rc;
663 result.request_api = evt;
664 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
665 m_parent->signalAPIResult(&result);
666 }
667 break;
668 case QCAMERA_SM_EVT_START_PREVIEW:
669 {
670 // no ops here
671 rc = NO_ERROR;
672 result.status = rc;
673 result.request_api = evt;
674 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
675 m_parent->signalAPIResult(&result);
676 }
677 break;
678 case QCAMERA_SM_EVT_STOP_PREVIEW:
679 {
680 m_parent->unpreparePreview();
681 rc = 0;
682 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
683 result.status = rc;
684 result.request_api = evt;
685 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
686 m_parent->signalAPIResult(&result);
687 }
688 break;
689 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
690 {
691 rc = NO_ERROR;
692 result.status = rc;
693 result.request_api = evt;
694 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
695 result.enabled = 1;
696 m_parent->signalAPIResult(&result);
697 }
698 break;
699 case QCAMERA_SM_EVT_RECORDING_ENABLED:
700 {
701 rc = 0;
702 result.status = rc;
703 result.request_api = evt;
704 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
705 result.enabled = 0;
706 m_parent->signalAPIResult(&result);
707 }
708 break;
709 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
710 {
711 rc = m_parent->storeMetaDataInBuffers(int(payload));
712 result.status = rc;
713 result.request_api = evt;
714 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
715 m_parent->signalAPIResult(&result);
716 }
717 break;
718 case QCAMERA_SM_EVT_DUMP:
719 {
720 rc = m_parent->dump((int)payload);
721 result.status = rc;
722 result.request_api = evt;
723 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
724 m_parent->signalAPIResult(&result);
725 }
726 break;
727 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
728 {
729 rc = m_parent->autoFocus();
730 result.status = rc;
731 result.request_api = evt;
732 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
733 m_parent->signalAPIResult(&result);
734 }
735 break;
736 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
737 {
738 rc = m_parent->cancelAutoFocus();
739 result.status = rc;
740 result.request_api = evt;
741 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
742 m_parent->signalAPIResult(&result);
743 }
744 break;
745 case QCAMERA_SM_EVT_SEND_COMMAND:
746 {
747 qcamera_sm_evt_command_payload_t *cmd_payload =
748 (qcamera_sm_evt_command_payload_t *)payload;
749 rc = m_parent->sendCommand(cmd_payload->cmd,
750 cmd_payload->arg1,
751 cmd_payload->arg2);
752 result.status = rc;
753 result.request_api = evt;
754 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
755 m_parent->signalAPIResult(&result);
756 }
757 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]758 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
759 {
760 int32_t faceID = 0;
761 qcamera_sm_evt_reg_face_payload_t *reg_payload =
762 (qcamera_sm_evt_reg_face_payload_t *)payload;
763 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
764 reg_payload->config,
765 faceID);
766 result.status = rc;
767 result.request_api = evt;
768 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
769 result.handle = faceID;
770 m_parent->signalAPIResult(&result);
771 }
772 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]773 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
774 case QCAMERA_SM_EVT_START_RECORDING:
775 case QCAMERA_SM_EVT_STOP_RECORDING:
776 case QCAMERA_SM_EVT_TAKE_PICTURE:
777 case QCAMERA_SM_EVT_CANCEL_PICTURE:
778 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
779 case QCAMERA_SM_EVT_RELEASE:
780 {
781 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
782 rc = INVALID_OPERATION;
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;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]789 case QCAMERA_SM_EVT_EVT_INTERNAL:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]790 case QCAMERA_SM_EVT_EVT_NOTIFY:
791 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]792 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]793 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]794 default:
795 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
796 break;
797 }
798
799 return rc;
800}
801
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]802/*===========================================================================
803 * FUNCTION : procEvtPreviewingState
804 *
805 * DESCRIPTION: finite state machine function to handle event in state of
806 * QCAMERA_SM_STATE_PREVIEWING.
807 *
808 * PARAMETERS :
809 * @evt : event to be processed
810 * @payload : event payload. Can be NULL if not needed.
811 *
812 * RETURN : int32_t type of status
813 * NO_ERROR -- success
814 * none-zero failure code
815 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]816int32_t QCameraStateMachine::procEvtPreviewingState(qcamera_sm_evt_enum_t evt,
817 void *payload)
818{
819 int32_t rc = NO_ERROR;
820 qcamera_api_result_t result;
821 memset(&result, 0, sizeof(qcamera_api_result_t));
822
823 switch (evt) {
824 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
825 {
826 // Error setting preview window during previewing
827 ALOGE("Cannot set preview window when preview is running");
828 rc = INVALID_OPERATION;
829 result.status = rc;
830 result.request_api = evt;
831 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
832 m_parent->signalAPIResult(&result);
833 }
834 break;
835 case QCAMERA_SM_EVT_SET_CALLBACKS:
836 {
837 qcamera_sm_evt_setcb_payload_t *setcbs =
838 (qcamera_sm_evt_setcb_payload_t *)payload;
839 rc = m_parent->setCallBacks(setcbs->notify_cb,
840 setcbs->data_cb,
841 setcbs->data_cb_timestamp,
842 setcbs->get_memory,
843 setcbs->user);
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_ENABLE_MSG_TYPE:
851 {
852 rc = m_parent->enableMsgType(int32_t(payload));
853 result.status = rc;
854 result.request_api = evt;
855 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
856 m_parent->signalAPIResult(&result);
857 }
858 break;
859 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
860 {
861 rc = m_parent->disableMsgType(int32_t(payload));
862 result.status = rc;
863 result.request_api = evt;
864 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
865 m_parent->signalAPIResult(&result);
866 }
867 break;
868 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
869 {
870 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
871 result.status = rc;
872 result.request_api = evt;
873 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
874 result.enabled = enabled;
875 m_parent->signalAPIResult(&result);
876 }
877 break;
878 case QCAMERA_SM_EVT_SET_PARAMS:
879 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]880 bool needRestart = false;
881 rc = m_parent->updateParameters((char*)payload, needRestart);
882 if (rc == NO_ERROR) {
883 if (needRestart) {
884 // need restart preview for parameters to take effect
885 // stop preview
886 m_parent->stopPreview();
887 // commit parameter changes to server
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]888 m_parent->commitParameterChanges();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]889 // start preview again
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]890 rc = m_parent->preparePreview();
891 if (rc == NO_ERROR) {
892 rc = m_parent->startPreview();
893 if (rc != NO_ERROR) {
894 m_parent->unpreparePreview();
895 }
896 }
897 if (rc != NO_ERROR) {
898 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
899 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]900 } else {
901 rc = m_parent->commitParameterChanges();
902 }
903 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]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_GET_PARAMS:
911 {
912 result.params = m_parent->getParameters();
913 rc = NO_ERROR;
914 result.status = rc;
915 result.request_api = evt;
916 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
917 m_parent->signalAPIResult(&result);
918 }
919 break;
920 case QCAMERA_SM_EVT_PUT_PARAMS:
921 {
922 rc = m_parent->putParameters((char*)payload);
923 result.status = rc;
924 result.request_api = evt;
925 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
926 m_parent->signalAPIResult(&result);
927 }
928 break;
929 case QCAMERA_SM_EVT_START_PREVIEW:
930 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
931 {
932 // no ops here
933 ALOGD("%s: Already in previewing, no ops here to start preview", __func__);
934 rc = NO_ERROR;
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_STOP_PREVIEW:
942 {
943 rc = m_parent->stopPreview();
944 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
945 result.status = rc;
946 result.request_api = evt;
947 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
948 m_parent->signalAPIResult(&result);
949 }
950 break;
951 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
952 {
953 rc = NO_ERROR;
954 result.status = rc;
955 result.request_api = evt;
956 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
957 result.enabled = 1;
958 m_parent->signalAPIResult(&result);
959 }
960 break;
961 case QCAMERA_SM_EVT_RECORDING_ENABLED:
962 {
963 rc = NO_ERROR;
964 result.status = rc;
965 result.request_api = evt;
966 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
967 result.enabled = 0;
968 m_parent->signalAPIResult(&result);
969 }
970 break;
971 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
972 {
973 rc = m_parent->storeMetaDataInBuffers(int(payload));
974 result.status = rc;
975 result.request_api = evt;
976 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
977 m_parent->signalAPIResult(&result);
978 }
979 break;
980 case QCAMERA_SM_EVT_DUMP:
981 {
982 rc = m_parent->dump((int)payload);
983 result.status = rc;
984 result.request_api = evt;
985 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
986 m_parent->signalAPIResult(&result);
987 }
988 break;
989 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
990 {
991 rc = m_parent->autoFocus();
992 result.status = rc;
993 result.request_api = evt;
994 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
995 m_parent->signalAPIResult(&result);
996 }
997 break;
998 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
999 {
1000 rc = m_parent->cancelAutoFocus();
1001 result.status = rc;
1002 result.request_api = evt;
1003 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1004 m_parent->signalAPIResult(&result);
1005 }
1006 break;
1007 case QCAMERA_SM_EVT_START_RECORDING:
1008 {
1009 rc = m_parent->startRecording();
1010 if (rc == NO_ERROR) {
1011 // move state to recording state
1012 m_state = QCAMERA_SM_STATE_RECORDING;
1013 }
1014 result.status = rc;
1015 result.request_api = evt;
1016 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1017 m_parent->signalAPIResult(&result);
1018 }
1019 break;
1020 case QCAMERA_SM_EVT_TAKE_PICTURE:
1021 {
1022 rc = m_parent->takePicture();
1023 if (rc == NO_ERROR) {
1024 // move state to picture taking state
Muhua Li6d69e932013-01-24 16:39:27 -0800[diff] [blame]1025 if (m_parent->isZSLMode()) {
1026 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
1027 } else {
1028 m_state = QCAMERA_SM_STATE_PIC_TAKING;
1029 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1030 } else {
1031 // move state to preview stopped state
1032 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1033 }
1034 result.status = rc;
1035 result.request_api = evt;
1036 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1037 m_parent->signalAPIResult(&result);
1038 }
1039 break;
1040 case QCAMERA_SM_EVT_SEND_COMMAND:
1041 {
1042 qcamera_sm_evt_command_payload_t *cmd_payload =
1043 (qcamera_sm_evt_command_payload_t *)payload;
1044 rc = m_parent->sendCommand(cmd_payload->cmd,
1045 cmd_payload->arg1,
1046 cmd_payload->arg2);
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;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1053 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1054 {
1055 int32_t faceID = 0;
1056 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1057 (qcamera_sm_evt_reg_face_payload_t *)payload;
1058 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1059 reg_payload->config,
1060 faceID);
1061 result.status = rc;
1062 result.request_api = evt;
1063 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1064 result.handle = faceID;
1065 m_parent->signalAPIResult(&result);
1066 }
1067 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1068 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1069 case QCAMERA_SM_EVT_STOP_RECORDING:
1070 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1071 case QCAMERA_SM_EVT_RELEASE:
1072 {
1073 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1074 rc = INVALID_OPERATION;
1075 result.status = rc;
1076 result.request_api = evt;
1077 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1078 m_parent->signalAPIResult(&result);
1079 }
1080 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1081 case QCAMERA_SM_EVT_EVT_INTERNAL:
1082 {
1083 qcamera_sm_internal_evt_payload_t *internal_evt =
1084 (qcamera_sm_internal_evt_payload_t *)payload;
1085 switch (internal_evt->evt_type) {
1086 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1087 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1088 break;
1089 default:
1090 break;
1091 }
1092 }
1093 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1094 case QCAMERA_SM_EVT_EVT_NOTIFY:
1095 {
1096 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1097 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1098 default:
1099 ALOGD("%s: no handling for server evt (%d) at this state",
1100 __func__, cam_evt->server_event_type);
1101 break;
1102 }
1103 }
1104 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1105 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1106 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]1107 rc = m_parent->updateThermalLevel(
1108 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1109 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1110 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1111 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1112 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1113 default:
1114 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1115 break;
1116 }
1117
1118 return rc;
1119}
1120
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1121/*===========================================================================
1122 * FUNCTION : procEvtPicTakingState
1123 *
1124 * DESCRIPTION: finite state machine function to handle event in state of
1125 * QCAMERA_SM_STATE_PIC_TAKING.
1126 *
1127 * PARAMETERS :
1128 * @evt : event to be processed
1129 * @payload : event payload. Can be NULL if not needed.
1130 *
1131 * RETURN : int32_t type of status
1132 * NO_ERROR -- success
1133 * none-zero failure code
1134 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1135int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt,
1136 void *payload)
1137{
1138 int32_t rc = NO_ERROR;
1139 qcamera_api_result_t result;
1140 memset(&result, 0, sizeof(qcamera_api_result_t));
1141
1142 switch (evt) {
1143 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1144 {
1145 // Error setting preview window during previewing
1146 ALOGE("Cannot set preview window when preview is running");
1147 rc = INVALID_OPERATION;
1148 result.status = rc;
1149 result.request_api = evt;
1150 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1151 m_parent->signalAPIResult(&result);
1152 }
1153 break;
1154 case QCAMERA_SM_EVT_SET_CALLBACKS:
1155 {
1156 qcamera_sm_evt_setcb_payload_t *setcbs =
1157 (qcamera_sm_evt_setcb_payload_t *)payload;
1158 rc = m_parent->setCallBacks(setcbs->notify_cb,
1159 setcbs->data_cb,
1160 setcbs->data_cb_timestamp,
1161 setcbs->get_memory,
1162 setcbs->user);
1163 result.status = rc;
1164 result.request_api = evt;
1165 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1166 m_parent->signalAPIResult(&result);
1167 }
1168 break;
1169 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1170 {
1171 rc = m_parent->enableMsgType(int32_t(payload));
1172 result.status = rc;
1173 result.request_api = evt;
1174 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1175 m_parent->signalAPIResult(&result);
1176 }
1177 break;
1178 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1179 {
1180 rc = m_parent->disableMsgType(int32_t(payload));
1181 result.status = rc;
1182 result.request_api = evt;
1183 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1184 m_parent->signalAPIResult(&result);
1185 }
1186 break;
1187 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1188 {
1189 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1190 result.status = rc;
1191 result.request_api = evt;
1192 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1193 result.enabled = enabled;
1194 m_parent->signalAPIResult(&result);
1195 }
1196 break;
1197 case QCAMERA_SM_EVT_SET_PARAMS:
1198 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1199 bool needRestart = false;
1200 rc = m_parent->updateParameters((char*)payload, needRestart);
1201 if (rc == NO_ERROR) {
1202 rc = m_parent->commitParameterChanges();
1203 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1204 result.status = rc;
1205 result.request_api = evt;
1206 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1207 m_parent->signalAPIResult(&result);
1208 }
1209 break;
1210 case QCAMERA_SM_EVT_GET_PARAMS:
1211 {
1212 result.params = m_parent->getParameters();
1213 rc = NO_ERROR;
1214 result.status = rc;
1215 result.request_api = evt;
1216 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1217 m_parent->signalAPIResult(&result);
1218 }
1219 break;
1220 case QCAMERA_SM_EVT_PUT_PARAMS:
1221 {
1222 rc = m_parent->putParameters((char*)payload);
1223 result.status = rc;
1224 result.request_api = evt;
1225 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1226 m_parent->signalAPIResult(&result);
1227 }
1228 break;
1229 case QCAMERA_SM_EVT_STOP_PREVIEW:
1230 {
1231 // no ops, since preview is stopped (normal),
1232 // or preview msg type is disabled (ZSL)
1233 rc = NO_ERROR;
1234 result.status = rc;
1235 result.request_api = evt;
1236 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1237 m_parent->signalAPIResult(&result);
1238 }
1239 break;
1240 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1241 {
1242 rc = NO_ERROR;
1243 result.status = rc;
1244 result.request_api = evt;
1245 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1246 result.enabled = 0;
1247 m_parent->signalAPIResult(&result);
1248 }
1249 break;
1250 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1251 {
1252 rc = NO_ERROR;
1253 result.status = rc;
1254 result.request_api = evt;
1255 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1256 result.enabled = 0;
1257 m_parent->signalAPIResult(&result);
1258 }
1259 break;
1260 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1261 {
1262 rc = m_parent->storeMetaDataInBuffers(int(payload));
1263 result.status = rc;
1264 result.request_api = evt;
1265 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1266 m_parent->signalAPIResult(&result);
1267 }
1268 break;
1269 case QCAMERA_SM_EVT_DUMP:
1270 {
1271 rc = m_parent->dump((int)payload);
1272 result.status = rc;
1273 result.request_api = evt;
1274 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1275 m_parent->signalAPIResult(&result);
1276 }
1277 break;
1278 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1279 {
1280 rc = m_parent->autoFocus();
1281 result.status = rc;
1282 result.request_api = evt;
1283 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1284 m_parent->signalAPIResult(&result);
1285 }
1286 break;
1287 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1288 {
1289 rc = m_parent->cancelAutoFocus();
1290 result.status = rc;
1291 result.request_api = evt;
1292 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1293 m_parent->signalAPIResult(&result);
1294 }
1295 break;
1296 case QCAMERA_SM_EVT_SEND_COMMAND:
1297 {
1298 qcamera_sm_evt_command_payload_t *cmd_payload =
1299 (qcamera_sm_evt_command_payload_t *)payload;
1300 rc = m_parent->sendCommand(cmd_payload->cmd,
1301 cmd_payload->arg1,
1302 cmd_payload->arg2);
1303 result.status = rc;
1304 result.request_api = evt;
1305 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1306 m_parent->signalAPIResult(&result);
1307 }
1308 break;
1309 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1310 {
1311 rc = m_parent->cancelPicture();
1312 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1313 result.status = rc;
1314 result.request_api = evt;
1315 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1316 m_parent->signalAPIResult(&result);
1317 }
1318 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1319 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1320 {
1321 int32_t faceID = 0;
1322 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1323 (qcamera_sm_evt_reg_face_payload_t *)payload;
1324 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1325 reg_payload->config,
1326 faceID);
1327 result.status = rc;
1328 result.request_api = evt;
1329 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1330 result.handle = faceID;
1331 m_parent->signalAPIResult(&result);
1332 }
1333 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1334 case QCAMERA_SM_EVT_TAKE_PICTURE:
1335 case QCAMERA_SM_EVT_START_RECORDING:
1336 case QCAMERA_SM_EVT_STOP_RECORDING:
1337 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1338 case QCAMERA_SM_EVT_START_PREVIEW:
1339 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1340 case QCAMERA_SM_EVT_RELEASE:
1341 {
1342 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1343 rc = INVALID_OPERATION;
1344 result.status = rc;
1345 result.request_api = evt;
1346 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1347 m_parent->signalAPIResult(&result);
1348 }
1349 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1350 case QCAMERA_SM_EVT_EVT_INTERNAL:
1351 {
1352 qcamera_sm_internal_evt_payload_t *internal_evt =
1353 (qcamera_sm_internal_evt_payload_t *)payload;
1354 switch (internal_evt->evt_type) {
1355 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1356 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1357 break;
1358 default:
1359 break;
1360 }
1361 }
1362 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1363 case QCAMERA_SM_EVT_EVT_NOTIFY:
1364 {
1365 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1366 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1367 default:
1368 ALOGD("%s: no handling for server evt (%d) at this state",
1369 __func__, cam_evt->server_event_type);
1370 break;
1371 }
1372 }
1373 break;
1374 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1375 {
1376 qcamera_jpeg_evt_payload_t *jpeg_job =
1377 (qcamera_jpeg_evt_payload_t *)payload;
1378 rc = m_parent->processJpegNotify(jpeg_job);
1379 }
1380 break;
1381 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1382 {
1383 rc = m_parent->cancelPicture();
1384 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1385 }
1386 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1387 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1388 default:
1389 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1390 break;
1391 }
1392
1393 return rc;
1394}
1395
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1396/*===========================================================================
1397 * FUNCTION : procEvtRecordingState
1398 *
1399 * DESCRIPTION: finite state machine function to handle event in state of
1400 * QCAMERA_SM_STATE_RECORDING.
1401 *
1402 * PARAMETERS :
1403 * @evt : event to be processed
1404 * @payload : event payload. Can be NULL if not needed.
1405 *
1406 * RETURN : int32_t type of status
1407 * NO_ERROR -- success
1408 * none-zero failure code
1409 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1410int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt,
1411 void *payload)
1412{
1413 int32_t rc = NO_ERROR;
1414 qcamera_api_result_t result;
1415 memset(&result, 0, sizeof(qcamera_api_result_t));
1416
1417 switch (evt) {
1418 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1419 {
1420 // Error setting preview window during previewing
1421 ALOGE("Cannot set preview window when preview is running");
1422 rc = INVALID_OPERATION;
1423 result.status = rc;
1424 result.request_api = evt;
1425 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1426 m_parent->signalAPIResult(&result);
1427 }
1428 break;
1429 case QCAMERA_SM_EVT_SET_CALLBACKS:
1430 {
1431 qcamera_sm_evt_setcb_payload_t *setcbs =
1432 (qcamera_sm_evt_setcb_payload_t *)payload;
1433 rc = m_parent->setCallBacks(setcbs->notify_cb,
1434 setcbs->data_cb,
1435 setcbs->data_cb_timestamp,
1436 setcbs->get_memory,
1437 setcbs->user);
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_ENABLE_MSG_TYPE:
1445 {
1446 rc = m_parent->enableMsgType(int32_t(payload));
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_DISABLE_MSG_TYPE:
1454 {
1455 rc = m_parent->disableMsgType(int32_t(payload));
1456 result.status = rc;
1457 result.request_api = evt;
1458 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1459 m_parent->signalAPIResult(&result);
1460 }
1461 break;
1462 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1463 {
1464 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1465 result.status = rc;
1466 result.request_api = evt;
1467 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1468 result.enabled = enabled;
1469 m_parent->signalAPIResult(&result);
1470 }
1471 break;
1472 case QCAMERA_SM_EVT_SET_PARAMS:
1473 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1474 bool needRestart = false;
1475 rc = m_parent->updateParameters((char*)payload, needRestart);
1476 if (rc == NO_ERROR) {
1477 if (needRestart) {
1478 // cannot set parameters that requires restart during recording
1479 ALOGE("%s: Cannot set parameters that requires restart during recording",
1480 __func__);
1481 rc = BAD_VALUE;
1482 } else {
1483 rc = m_parent->commitParameterChanges();
1484 }
1485 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1486 result.status = rc;
1487 result.request_api = evt;
1488 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1489 m_parent->signalAPIResult(&result);
1490 }
1491 break;
1492 case QCAMERA_SM_EVT_GET_PARAMS:
1493 {
1494 result.params = m_parent->getParameters();
1495 rc = NO_ERROR;
1496 result.status = rc;
1497 result.request_api = evt;
1498 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1499 m_parent->signalAPIResult(&result);
1500 }
1501 break;
1502 case QCAMERA_SM_EVT_PUT_PARAMS:
1503 {
1504 rc = m_parent->putParameters((char*)payload);
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_PREVIEW_ENABLED:
1512 {
1513 rc = NO_ERROR;
1514 result.status = rc;
1515 result.request_api = evt;
1516 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1517 result.enabled = 0;
1518 m_parent->signalAPIResult(&result);
1519 }
1520 break;
1521 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1522 {
1523 rc = NO_ERROR;
1524 result.status = rc;
1525 result.request_api = evt;
1526 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1527 result.enabled = 1;
1528 m_parent->signalAPIResult(&result);
1529 }
1530 break;
1531 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1532 {
1533 rc = m_parent->storeMetaDataInBuffers(int(payload));
1534 result.status = rc;
1535 result.request_api = evt;
1536 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1537 m_parent->signalAPIResult(&result);
1538 }
1539 break;
1540 case QCAMERA_SM_EVT_DUMP:
1541 {
1542 rc = m_parent->dump((int)payload);
1543 result.status = rc;
1544 result.request_api = evt;
1545 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1546 m_parent->signalAPIResult(&result);
1547 }
1548 break;
1549 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1550 {
1551 rc = m_parent->autoFocus();
1552 result.status = rc;
1553 result.request_api = evt;
1554 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1555 m_parent->signalAPIResult(&result);
1556 }
1557 break;
1558 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1559 {
1560 rc = m_parent->cancelAutoFocus();
1561 result.status = rc;
1562 result.request_api = evt;
1563 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1564 m_parent->signalAPIResult(&result);
1565 }
1566 break;
1567 case QCAMERA_SM_EVT_SEND_COMMAND:
1568 {
1569 qcamera_sm_evt_command_payload_t *cmd_payload =
1570 (qcamera_sm_evt_command_payload_t *)payload;
1571 rc = m_parent->sendCommand(cmd_payload->cmd,
1572 cmd_payload->arg1,
1573 cmd_payload->arg2);
1574 result.status = rc;
1575 result.request_api = evt;
1576 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1577 m_parent->signalAPIResult(&result);
1578 }
1579 break;
1580 case QCAMERA_SM_EVT_TAKE_PICTURE:
1581 {
1582 rc = m_parent->takeLiveSnapshot();
1583 if (rc == 0) {
1584 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
1585 }
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_START_RECORDING:
1593 {
1594 // no ops here
1595 ALOGD("%s: already in recording state, no ops for start_recording", __func__);
1596 rc = 0;
1597 result.status = rc;
1598 result.request_api = evt;
1599 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1600 m_parent->signalAPIResult(&result);
1601 }
1602 break;
1603 case QCAMERA_SM_EVT_STOP_RECORDING:
1604 {
1605 rc = m_parent->stopRecording();
1606 m_state = QCAMERA_SM_STATE_PREVIEWING;
1607 result.status = rc;
1608 result.request_api = evt;
1609 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1610 m_parent->signalAPIResult(&result);
1611 }
1612 break;
1613 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1614 {
1615 rc = m_parent->releaseRecordingFrame((const void *)payload);
1616 result.status = rc;
1617 result.request_api = evt;
1618 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1619 m_parent->signalAPIResult(&result);
1620 }
1621 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1622 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1623 {
1624 int32_t faceID = 0;
1625 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1626 (qcamera_sm_evt_reg_face_payload_t *)payload;
1627 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1628 reg_payload->config,
1629 faceID);
1630 result.status = rc;
1631 result.request_api = evt;
1632 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1633 result.handle = faceID;
1634 m_parent->signalAPIResult(&result);
1635 }
1636 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1637 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1638 case QCAMERA_SM_EVT_START_PREVIEW:
1639 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1640 case QCAMERA_SM_EVT_STOP_PREVIEW:
1641 case QCAMERA_SM_EVT_RELEASE:
1642 {
1643 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1644 rc = INVALID_OPERATION;
1645 result.status = rc;
1646 result.request_api = evt;
1647 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1648 m_parent->signalAPIResult(&result);
1649 }
1650 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1651 case QCAMERA_SM_EVT_EVT_INTERNAL:
1652 {
1653 qcamera_sm_internal_evt_payload_t *internal_evt =
1654 (qcamera_sm_internal_evt_payload_t *)payload;
1655 switch (internal_evt->evt_type) {
1656 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1657 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1658 break;
1659 default:
1660 break;
1661 }
1662 }
1663 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1664 case QCAMERA_SM_EVT_EVT_NOTIFY:
1665 {
1666 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1667 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1668 default:
1669 ALOGD("%s: no handling for server evt (%d) at this state",
1670 __func__, cam_evt->server_event_type);
1671 break;
1672 }
1673 }
1674 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1675 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1676 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]1677 rc = m_parent->updateThermalLevel(
1678 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1679 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1680 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1681 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1682 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1683 default:
1684 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1685 break;
1686 }
1687
1688 return rc;
1689}
1690
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1691/*===========================================================================
1692 * FUNCTION : procEvtVideoPicTakingState
1693 *
1694 * DESCRIPTION: finite state machine function to handle event in state of
1695 * QCAMERA_SM_STATE_VIDEO_PIC_TAKING.
1696 *
1697 * PARAMETERS :
1698 * @evt : event to be processed
1699 * @payload : event payload. Can be NULL if not needed.
1700 *
1701 * RETURN : int32_t type of status
1702 * NO_ERROR -- success
1703 * none-zero failure code
1704 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1705int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt,
1706 void *payload)
1707{
1708 int32_t rc = NO_ERROR;
1709 qcamera_api_result_t result;
1710 memset(&result, 0, sizeof(qcamera_api_result_t));
1711
1712 switch (evt) {
1713 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1714 {
1715 // Error setting preview window during previewing
1716 ALOGE("Cannot set preview window when preview is running");
1717 rc = INVALID_OPERATION;
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_SET_CALLBACKS:
1725 {
1726 qcamera_sm_evt_setcb_payload_t *setcbs =
1727 (qcamera_sm_evt_setcb_payload_t *)payload;
1728 rc = m_parent->setCallBacks(setcbs->notify_cb,
1729 setcbs->data_cb,
1730 setcbs->data_cb_timestamp,
1731 setcbs->get_memory,
1732 setcbs->user);
1733 result.status = rc;
1734 result.request_api = evt;
1735 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1736 m_parent->signalAPIResult(&result);
1737 }
1738 break;
1739 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1740 {
1741 rc = m_parent->enableMsgType(int32_t(payload));
1742 result.status = rc;
1743 result.request_api = evt;
1744 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1745 m_parent->signalAPIResult(&result);
1746 }
1747 break;
1748 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1749 {
1750 rc = m_parent->disableMsgType(int32_t(payload));
1751 result.status = rc;
1752 result.request_api = evt;
1753 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1754 m_parent->signalAPIResult(&result);
1755 }
1756 break;
1757 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1758 {
1759 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1760 result.status = rc;
1761 result.request_api = evt;
1762 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1763 result.enabled = enabled;
1764 m_parent->signalAPIResult(&result);
1765 }
1766 break;
1767 case QCAMERA_SM_EVT_SET_PARAMS:
1768 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1769 bool needRestart = false;
1770 rc = m_parent->updateParameters((char*)payload, needRestart);
1771 if (rc == NO_ERROR) {
1772 if (needRestart) {
1773 // cannot set parameters that requires restart during recording
1774 ALOGE("%s: Cannot set parameters that requires restart during recording",
1775 __func__);
1776 rc = BAD_VALUE;
1777 } else {
1778 rc = m_parent->commitParameterChanges();
1779 }
1780 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]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;
1787 case QCAMERA_SM_EVT_GET_PARAMS:
1788 {
1789 result.params = m_parent->getParameters();
1790 rc = NO_ERROR;
1791 result.status = rc;
1792 result.request_api = evt;
1793 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1794 m_parent->signalAPIResult(&result);
1795 }
1796 break;
1797 case QCAMERA_SM_EVT_PUT_PARAMS:
1798 {
1799 rc = m_parent->putParameters((char*)payload);
1800 result.status = rc;
1801 result.request_api = evt;
1802 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1803 m_parent->signalAPIResult(&result);
1804 }
1805 break;
1806 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1807 {
1808 rc = NO_ERROR;
1809 result.status = rc;
1810 result.request_api = evt;
1811 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1812 result.enabled = 1;
1813 m_parent->signalAPIResult(&result);
1814 }
1815 break;
1816 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1817 {
1818 rc = NO_ERROR;
1819 result.status = rc;
1820 result.request_api = evt;
1821 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1822 result.enabled = 1;
1823 m_parent->signalAPIResult(&result);
1824 }
1825 break;
1826 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1827 {
1828 rc = m_parent->storeMetaDataInBuffers(int(payload));
1829 result.status = rc;
1830 result.request_api = evt;
1831 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1832 m_parent->signalAPIResult(&result);
1833 }
1834 break;
1835 case QCAMERA_SM_EVT_DUMP:
1836 {
1837 rc = m_parent->dump((int)payload);
1838 result.status = rc;
1839 result.request_api = evt;
1840 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1841 m_parent->signalAPIResult(&result);
1842 }
1843 break;
1844 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1845 {
1846 rc = m_parent->autoFocus();
1847 result.status = rc;
1848 result.request_api = evt;
1849 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1850 m_parent->signalAPIResult(&result);
1851 }
1852 break;
1853 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1854 {
1855 rc = m_parent->cancelAutoFocus();
1856 result.status = rc;
1857 result.request_api = evt;
1858 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1859 m_parent->signalAPIResult(&result);
1860 }
1861 break;
1862 case QCAMERA_SM_EVT_SEND_COMMAND:
1863 {
1864 qcamera_sm_evt_command_payload_t *cmd_payload =
1865 (qcamera_sm_evt_command_payload_t *)payload;
1866 rc = m_parent->sendCommand(cmd_payload->cmd,
1867 cmd_payload->arg1,
1868 cmd_payload->arg2);
1869 result.status = rc;
1870 result.request_api = evt;
1871 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1872 m_parent->signalAPIResult(&result);
1873 }
1874 break;
1875 case QCAMERA_SM_EVT_STOP_RECORDING:
1876 {
1877 rc = m_parent->stopRecording();
1878 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
1879 result.status = rc;
1880 result.request_api = evt;
1881 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1882 m_parent->signalAPIResult(&result);
1883 }
1884 break;
1885 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1886 {
1887 rc = m_parent->releaseRecordingFrame((const void *)payload);
1888 result.status = rc;
1889 result.request_api = evt;
1890 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1891 m_parent->signalAPIResult(&result);
1892 }
1893 break;
1894 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1895 {
1896 rc = m_parent->cancelLiveSnapshot();
1897 m_state = QCAMERA_SM_STATE_RECORDING;
1898 result.status = rc;
1899 result.request_api = evt;
1900 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1901 m_parent->signalAPIResult(&result);
1902 }
1903 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1904 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1905 {
1906 int32_t faceID = 0;
1907 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1908 (qcamera_sm_evt_reg_face_payload_t *)payload;
1909 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1910 reg_payload->config,
1911 faceID);
1912 result.status = rc;
1913 result.request_api = evt;
1914 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1915 result.handle = faceID;
1916 m_parent->signalAPIResult(&result);
1917 }
1918 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1919 case QCAMERA_SM_EVT_START_RECORDING:
1920 case QCAMERA_SM_EVT_START_PREVIEW:
1921 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1922 case QCAMERA_SM_EVT_STOP_PREVIEW:
1923 case QCAMERA_SM_EVT_TAKE_PICTURE:
1924 case QCAMERA_SM_EVT_RELEASE:
1925 {
1926 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1927 rc = INVALID_OPERATION;
1928 result.status = rc;
1929 result.request_api = evt;
1930 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1931 m_parent->signalAPIResult(&result);
1932 }
1933 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1934 case QCAMERA_SM_EVT_EVT_INTERNAL:
1935 {
1936 qcamera_sm_internal_evt_payload_t *internal_evt =
1937 (qcamera_sm_internal_evt_payload_t *)payload;
1938 switch (internal_evt->evt_type) {
1939 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1940 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1941 break;
1942 default:
1943 break;
1944 }
1945 }
1946 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1947 case QCAMERA_SM_EVT_EVT_NOTIFY:
1948 {
1949 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1950 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1951 default:
1952 ALOGD("%s: no handling for server evt (%d) at this state",
1953 __func__, cam_evt->server_event_type);
1954 break;
1955 }
1956 }
1957 break;
1958 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1959 {
1960 qcamera_jpeg_evt_payload_t *jpeg_job =
1961 (qcamera_jpeg_evt_payload_t *)payload;
1962 rc = m_parent->processJpegNotify(jpeg_job);
1963 }
1964 break;
1965 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1966 {
1967 rc = m_parent->cancelLiveSnapshot();
1968 m_state = QCAMERA_SM_STATE_RECORDING;
1969 }
1970 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1971 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1972 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]1973 rc = m_parent->updateThermalLevel(
1974 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1975 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1976 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1977 default:
1978 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1979 break;
1980 }
1981
1982 return rc;
1983}
1984
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1985/*===========================================================================
1986 * FUNCTION : procEvtPreviewPicTakingState
1987 *
1988 * DESCRIPTION: finite state machine function to handle event in state of
1989 * QCAMERA_SM_STATE_PREVIEW_PIC_TAKING.
1990 *
1991 * PARAMETERS :
1992 * @evt : event to be processed
1993 * @payload : event payload. Can be NULL if not needed.
1994 *
1995 * RETURN : int32_t type of status
1996 * NO_ERROR -- success
1997 * none-zero failure code
1998 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1999int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt,
2000 void *payload)
2001{
2002 int32_t rc = NO_ERROR;
2003 qcamera_api_result_t result;
2004 memset(&result, 0, sizeof(qcamera_api_result_t));
2005
2006 switch (evt) {
2007 case QCAMERA_SM_EVT_SET_CALLBACKS:
2008 {
2009 qcamera_sm_evt_setcb_payload_t *setcbs =
2010 (qcamera_sm_evt_setcb_payload_t *)payload;
2011 rc = m_parent->setCallBacks(setcbs->notify_cb,
2012 setcbs->data_cb,
2013 setcbs->data_cb_timestamp,
2014 setcbs->get_memory,
2015 setcbs->user);
2016 result.status = rc;
2017 result.request_api = evt;
2018 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2019 m_parent->signalAPIResult(&result);
2020 }
2021 break;
2022 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
2023 {
2024 rc = m_parent->enableMsgType(int32_t(payload));
2025 result.status = rc;
2026 result.request_api = evt;
2027 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2028 m_parent->signalAPIResult(&result);
2029 }
2030 break;
2031 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
2032 {
2033 rc = m_parent->disableMsgType(int32_t(payload));
2034 result.status = rc;
2035 result.request_api = evt;
2036 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2037 m_parent->signalAPIResult(&result);
2038 }
2039 break;
2040 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
2041 {
2042 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
2043 result.status = rc;
2044 result.request_api = evt;
2045 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2046 result.enabled = enabled;
2047 m_parent->signalAPIResult(&result);
2048 }
2049 break;
2050 case QCAMERA_SM_EVT_SET_PARAMS:
2051 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2052 bool needRestart = false;
2053 rc = m_parent->updateParameters((char*)payload, needRestart);
2054 if (rc == NO_ERROR) {
2055 if (needRestart) {
2056 // need restart preview for parameters to take effect
2057 // stop preview
2058 m_parent->stopPreview();
2059 // commit parameter changes to server
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]2060 m_parent->commitParameterChanges();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2061 // start preview again
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]2062 rc = m_parent->preparePreview();
2063 if (rc == NO_ERROR) {
2064 rc = m_parent->startPreview();
2065 if (rc != NO_ERROR) {
2066 m_parent->unpreparePreview();
2067 }
2068 }
2069 if (rc != NO_ERROR) {
2070 m_state = QCAMERA_SM_STATE_PIC_TAKING;
2071 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2072 } else {
2073 rc = m_parent->commitParameterChanges();
2074 }
2075 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]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;
2082 case QCAMERA_SM_EVT_GET_PARAMS:
2083 {
2084 result.params = m_parent->getParameters();
2085 rc = NO_ERROR;
2086 result.status = rc;
2087 result.request_api = evt;
2088 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
2089 m_parent->signalAPIResult(&result);
2090 }
2091 break;
2092 case QCAMERA_SM_EVT_PUT_PARAMS:
2093 {
2094 rc = m_parent->putParameters((char*)payload);
2095 result.status = rc;
2096 result.request_api = evt;
2097 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2098 m_parent->signalAPIResult(&result);
2099 }
2100 break;
2101 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
2102 {
2103 rc = NO_ERROR;
2104 result.status = rc;
2105 result.request_api = evt;
2106 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2107 result.enabled = 1;
2108 m_parent->signalAPIResult(&result);
2109 }
2110 break;
2111 case QCAMERA_SM_EVT_RECORDING_ENABLED:
2112 {
2113 rc = NO_ERROR;
2114 result.status = rc;
2115 result.request_api = evt;
2116 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2117 result.enabled = 0;
2118 m_parent->signalAPIResult(&result);
2119 }
2120 break;
2121 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
2122 {
2123 rc = m_parent->storeMetaDataInBuffers(int(payload));
2124 result.status = rc;
2125 result.request_api = evt;
2126 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2127 m_parent->signalAPIResult(&result);
2128 }
2129 break;
2130 case QCAMERA_SM_EVT_DUMP:
2131 {
2132 rc = m_parent->dump((int)payload);
2133 result.status = rc;
2134 result.request_api = evt;
2135 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2136 m_parent->signalAPIResult(&result);
2137 }
2138 break;
2139 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
2140 {
2141 rc = m_parent->autoFocus();
2142 result.status = rc;
2143 result.request_api = evt;
2144 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2145 m_parent->signalAPIResult(&result);
2146 }
2147 break;
2148 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
2149 {
2150 rc = m_parent->cancelAutoFocus();
2151 result.status = rc;
2152 result.request_api = evt;
2153 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2154 m_parent->signalAPIResult(&result);
2155 }
2156 break;
2157 case QCAMERA_SM_EVT_SEND_COMMAND:
2158 {
2159 qcamera_sm_evt_command_payload_t *cmd_payload =
2160 (qcamera_sm_evt_command_payload_t *)payload;
2161 rc = m_parent->sendCommand(cmd_payload->cmd,
2162 cmd_payload->arg1,
2163 cmd_payload->arg2);
2164 result.status = rc;
2165 result.request_api = evt;
2166 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2167 m_parent->signalAPIResult(&result);
2168 }
2169 break;
2170 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2171 {
2172 rc = m_parent->releaseRecordingFrame((const void *)payload);
2173 result.status = rc;
2174 result.request_api = evt;
2175 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2176 m_parent->signalAPIResult(&result);
2177 }
2178 break;
2179 case QCAMERA_SM_EVT_CANCEL_PICTURE:
2180 {
2181 rc = m_parent->cancelLiveSnapshot();
2182 m_state = QCAMERA_SM_STATE_PREVIEWING;
2183 result.status = rc;
2184 result.request_api = evt;
2185 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2186 m_parent->signalAPIResult(&result);
2187 }
2188 break;
2189 case QCAMERA_SM_EVT_STOP_PREVIEW:
2190 {
2191 m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW);
2192 m_parent->delChannel(QCAMERA_CH_TYPE_PREVIEW);
2193 m_parent->delChannel(QCAMERA_CH_TYPE_VIDEO);
2194 m_state = QCAMERA_SM_STATE_PIC_TAKING;
2195 rc = NO_ERROR;
2196 result.status = rc;
2197 result.request_api = evt;
2198 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2199 m_parent->signalAPIResult(&result);
2200 }
2201 break;
2202 case QCAMERA_SM_EVT_START_RECORDING:
2203 {
2204 rc = m_parent->stopRecording();
2205 if (rc == NO_ERROR) {
2206 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
2207 }
2208 result.status = rc;
2209 result.request_api = evt;
2210 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2211 m_parent->signalAPIResult(&result);
2212 }
2213 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]2214 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
2215 {
2216 int32_t faceID = 0;
2217 qcamera_sm_evt_reg_face_payload_t *reg_payload =
2218 (qcamera_sm_evt_reg_face_payload_t *)payload;
2219 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
2220 reg_payload->config,
2221 faceID);
2222 result.status = rc;
2223 result.request_api = evt;
2224 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2225 result.handle = faceID;
2226 m_parent->signalAPIResult(&result);
2227 }
2228 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2229 case QCAMERA_SM_EVT_STOP_RECORDING:
2230 case QCAMERA_SM_EVT_START_PREVIEW:
2231 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
2232 case QCAMERA_SM_EVT_TAKE_PICTURE:
2233 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
2234 case QCAMERA_SM_EVT_RELEASE:
2235 {
2236 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2237 rc = INVALID_OPERATION;
2238 result.status = rc;
2239 result.request_api = evt;
2240 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2241 m_parent->signalAPIResult(&result);
2242 }
2243 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2244 case QCAMERA_SM_EVT_EVT_INTERNAL:
2245 {
2246 qcamera_sm_internal_evt_payload_t *internal_evt =
2247 (qcamera_sm_internal_evt_payload_t *)payload;
2248 switch (internal_evt->evt_type) {
2249 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2250 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2251 break;
2252 default:
2253 break;
2254 }
2255 }
2256 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2257 case QCAMERA_SM_EVT_EVT_NOTIFY:
2258 {
2259 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2260 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2261 default:
2262 ALOGD("%s: no handling for server evt (%d) at this state",
2263 __func__, cam_evt->server_event_type);
2264 break;
2265 }
2266 }
2267 break;
2268 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
2269 {
2270 qcamera_jpeg_evt_payload_t *jpeg_job =
2271 (qcamera_jpeg_evt_payload_t *)payload;
2272 rc = m_parent->processJpegNotify(jpeg_job);
2273 }
2274 break;
2275 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
2276 {
2277 rc = m_parent->cancelLiveSnapshot();
2278 m_state = QCAMERA_SM_STATE_PREVIEWING;
2279 }
2280 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2281 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2282 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2283 rc = m_parent->updateThermalLevel(
2284 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2285 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2286 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2287 default:
2288 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2289 break;
2290 }
2291
2292 return rc;
2293}
2294
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2295/*===========================================================================
2296 * FUNCTION : isPreviewRunning
2297 *
2298 * DESCRIPTION: check if preview is in process.
2299 *
2300 * PARAMETERS : None
2301 *
2302 * RETURN : true -- preview running
2303 * false -- preview stopped
2304 *==========================================================================*/
2305bool QCameraStateMachine::isPreviewRunning()
2306{
2307 switch (m_state) {
2308 case QCAMERA_SM_STATE_PREVIEWING:
2309 case QCAMERA_SM_STATE_RECORDING:
2310 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
2311 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
2312 return true;
2313 default:
2314 return false;
2315 }
2316}
2317
Shuzhen Wang89635cf2012-12-20 13:47:22 -0800[diff] [blame]2318}; // namespace qcamera