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