Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / hardware / qcom / camera / 8e614bc43072f871a08333bbcd41b00cc592162f / . / QCamera2 / HAL / QCameraStateMachine.cpp
blob: 523dfea62cc85a3d33fc1197910a1aaf3c857254 [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 {
Muhua Li8e614bc2013-04-17 17:38:42 -0700[diff] [blame^]1053 if ( m_parent->mParameters.getRecordingHintValue() == false) {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1054 rc = m_parent->takePicture();
1055 if (rc == NO_ERROR) {
1056 // move state to picture taking state
1057 if (m_parent->isZSLMode()) {
1058 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
1059 } else {
1060 m_state = QCAMERA_SM_STATE_PIC_TAKING;
1061 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1062 } else {
1063 // move state to preview stopped state
1064 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1065 }
1066 result.status = rc;
1067 result.request_api = evt;
1068 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1069 m_parent->signalAPIResult(&result);
Muhua Li8e614bc2013-04-17 17:38:42 -0700[diff] [blame^]1070 } else {
1071 rc = m_parent->takeLiveSnapshot();
1072 if (rc == NO_ERROR ) {
1073 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
1074 result.status = rc;
1075 result.request_api = evt;
1076 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1077 m_parent->signalAPIResult(&result);
1078 }
1079 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1080 }
1081 break;
1082 case QCAMERA_SM_EVT_SEND_COMMAND:
1083 {
1084 qcamera_sm_evt_command_payload_t *cmd_payload =
1085 (qcamera_sm_evt_command_payload_t *)payload;
1086 rc = m_parent->sendCommand(cmd_payload->cmd,
1087 cmd_payload->arg1,
1088 cmd_payload->arg2);
1089 result.status = rc;
1090 result.request_api = evt;
1091 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1092 m_parent->signalAPIResult(&result);
1093 }
1094 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1095 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1096 {
1097 int32_t faceID = 0;
1098 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1099 (qcamera_sm_evt_reg_face_payload_t *)payload;
1100 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1101 reg_payload->config,
1102 faceID);
1103 result.status = rc;
1104 result.request_api = evt;
1105 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1106 result.handle = faceID;
1107 m_parent->signalAPIResult(&result);
1108 }
1109 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1110 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1111 case QCAMERA_SM_EVT_STOP_RECORDING:
1112 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1113 case QCAMERA_SM_EVT_RELEASE:
1114 {
1115 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1116 rc = INVALID_OPERATION;
1117 result.status = rc;
1118 result.request_api = evt;
1119 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1120 m_parent->signalAPIResult(&result);
1121 }
1122 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1123 case QCAMERA_SM_EVT_EVT_INTERNAL:
1124 {
1125 qcamera_sm_internal_evt_payload_t *internal_evt =
1126 (qcamera_sm_internal_evt_payload_t *)payload;
1127 switch (internal_evt->evt_type) {
1128 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1129 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1130 break;
1131 default:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1132 ALOGE("%s: Invalid internal event %d in state(%d)",
1133 __func__, internal_evt->evt_type, m_state);
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1134 break;
1135 }
1136 }
1137 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1138 case QCAMERA_SM_EVT_EVT_NOTIFY:
1139 {
1140 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1141 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1142 default:
1143 ALOGD("%s: no handling for server evt (%d) at this state",
1144 __func__, cam_evt->server_event_type);
1145 break;
1146 }
1147 }
1148 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1149 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1150 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]1151 rc = m_parent->updateThermalLevel(
1152 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1153 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1154 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1155 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1156 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1157 default:
1158 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1159 break;
1160 }
1161
1162 return rc;
1163}
1164
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1165/*===========================================================================
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1166 * FUNCTION : procEvtPrepareSnapshotState
1167 *
1168 * DESCRIPTION: finite state machine function to handle event in state of
1169 * QCAMERA_SM_STATE_PREPARE_SNAPSHOT.
1170 *
1171 * PARAMETERS :
1172 * @evt : event to be processed
1173 * @payload : event payload. Can be NULL if not needed.
1174 *
1175 * RETURN : int32_t type of status
1176 * NO_ERROR -- success
1177 * none-zero failure code
1178 *==========================================================================*/
1179int32_t QCameraStateMachine::procEvtPrepareSnapshotState(qcamera_sm_evt_enum_t evt,
1180 void *payload)
1181{
1182 int32_t rc = NO_ERROR;
1183 qcamera_api_result_t result;
1184 memset(&result, 0, sizeof(qcamera_api_result_t));
1185
1186 switch (evt) {
1187 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1188 case QCAMERA_SM_EVT_SET_CALLBACKS:
1189 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1190 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1191 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1192 case QCAMERA_SM_EVT_SET_PARAMS:
1193 case QCAMERA_SM_EVT_GET_PARAMS:
1194 case QCAMERA_SM_EVT_PUT_PARAMS:
1195 case QCAMERA_SM_EVT_START_PREVIEW:
1196 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1197 case QCAMERA_SM_EVT_STOP_PREVIEW:
1198 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1199 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1200 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1201 case QCAMERA_SM_EVT_DUMP:
1202 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1203 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1204 case QCAMERA_SM_EVT_START_RECORDING:
1205 case QCAMERA_SM_EVT_TAKE_PICTURE:
1206 case QCAMERA_SM_EVT_SEND_COMMAND:
1207 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1208 case QCAMERA_SM_EVT_STOP_RECORDING:
1209 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1210 case QCAMERA_SM_EVT_RELEASE:
1211 {
1212 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1213 rc = INVALID_OPERATION;
1214 result.status = rc;
1215 result.request_api = evt;
1216 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1217 m_parent->signalAPIResult(&result);
1218 }
1219 break;
1220 case QCAMERA_SM_EVT_EVT_INTERNAL:
1221 {
1222 qcamera_sm_internal_evt_payload_t *internal_evt =
1223 (qcamera_sm_internal_evt_payload_t *)payload;
1224 switch (internal_evt->evt_type) {
1225 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
1226 ALOGI("%s: Received QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE event",
1227 __func__);
1228 m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state);
1229 m_state = QCAMERA_SM_STATE_PREVIEWING;
1230
1231 result.status = NO_ERROR;
1232 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT;
1233 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1234 m_parent->signalAPIResult(&result);
1235 break;
1236 default:
1237 ALOGE("%s: Invalid internal event %d in state(%d)",
1238 __func__, internal_evt->evt_type, m_state);
1239 break;
1240 }
1241 }
1242 break;
1243 case QCAMERA_SM_EVT_EVT_NOTIFY:
1244 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
1245 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1246 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1247 default:
1248 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1249 break;
1250 }
1251
1252 return rc;
1253}
1254
1255/*===========================================================================
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1256 * FUNCTION : procEvtPicTakingState
1257 *
1258 * DESCRIPTION: finite state machine function to handle event in state of
1259 * QCAMERA_SM_STATE_PIC_TAKING.
1260 *
1261 * PARAMETERS :
1262 * @evt : event to be processed
1263 * @payload : event payload. Can be NULL if not needed.
1264 *
1265 * RETURN : int32_t type of status
1266 * NO_ERROR -- success
1267 * none-zero failure code
1268 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1269int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt,
1270 void *payload)
1271{
1272 int32_t rc = NO_ERROR;
1273 qcamera_api_result_t result;
1274 memset(&result, 0, sizeof(qcamera_api_result_t));
1275
1276 switch (evt) {
1277 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1278 {
1279 // Error setting preview window during previewing
1280 ALOGE("Cannot set preview window when preview is running");
1281 rc = INVALID_OPERATION;
1282 result.status = rc;
1283 result.request_api = evt;
1284 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1285 m_parent->signalAPIResult(&result);
1286 }
1287 break;
1288 case QCAMERA_SM_EVT_SET_CALLBACKS:
1289 {
1290 qcamera_sm_evt_setcb_payload_t *setcbs =
1291 (qcamera_sm_evt_setcb_payload_t *)payload;
1292 rc = m_parent->setCallBacks(setcbs->notify_cb,
1293 setcbs->data_cb,
1294 setcbs->data_cb_timestamp,
1295 setcbs->get_memory,
1296 setcbs->user);
1297 result.status = rc;
1298 result.request_api = evt;
1299 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1300 m_parent->signalAPIResult(&result);
1301 }
1302 break;
1303 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1304 {
1305 rc = m_parent->enableMsgType(int32_t(payload));
1306 result.status = rc;
1307 result.request_api = evt;
1308 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1309 m_parent->signalAPIResult(&result);
1310 }
1311 break;
1312 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1313 {
1314 rc = m_parent->disableMsgType(int32_t(payload));
1315 result.status = rc;
1316 result.request_api = evt;
1317 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1318 m_parent->signalAPIResult(&result);
1319 }
1320 break;
1321 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1322 {
1323 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1324 result.status = rc;
1325 result.request_api = evt;
1326 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1327 result.enabled = enabled;
1328 m_parent->signalAPIResult(&result);
1329 }
1330 break;
1331 case QCAMERA_SM_EVT_SET_PARAMS:
1332 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1333 bool needRestart = false;
1334 rc = m_parent->updateParameters((char*)payload, needRestart);
1335 if (rc == NO_ERROR) {
1336 rc = m_parent->commitParameterChanges();
1337 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1338 result.status = rc;
1339 result.request_api = evt;
1340 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1341 m_parent->signalAPIResult(&result);
1342 }
1343 break;
1344 case QCAMERA_SM_EVT_GET_PARAMS:
1345 {
1346 result.params = m_parent->getParameters();
1347 rc = NO_ERROR;
1348 result.status = rc;
1349 result.request_api = evt;
1350 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1351 m_parent->signalAPIResult(&result);
1352 }
1353 break;
1354 case QCAMERA_SM_EVT_PUT_PARAMS:
1355 {
1356 rc = m_parent->putParameters((char*)payload);
1357 result.status = rc;
1358 result.request_api = evt;
1359 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1360 m_parent->signalAPIResult(&result);
1361 }
1362 break;
1363 case QCAMERA_SM_EVT_STOP_PREVIEW:
1364 {
Muhua Libd1b6122013-03-05 15:25:27 -0800[diff] [blame]1365 // cancel picture first
1366 rc = m_parent->cancelPicture();
1367 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1368
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1369 result.status = rc;
1370 result.request_api = evt;
1371 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1372 m_parent->signalAPIResult(&result);
1373 }
1374 break;
1375 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1376 {
1377 rc = NO_ERROR;
1378 result.status = rc;
1379 result.request_api = evt;
1380 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1381 result.enabled = 0;
1382 m_parent->signalAPIResult(&result);
1383 }
1384 break;
1385 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1386 {
1387 rc = NO_ERROR;
1388 result.status = rc;
1389 result.request_api = evt;
1390 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1391 result.enabled = 0;
1392 m_parent->signalAPIResult(&result);
1393 }
1394 break;
1395 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1396 {
1397 rc = m_parent->storeMetaDataInBuffers(int(payload));
1398 result.status = rc;
1399 result.request_api = evt;
1400 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1401 m_parent->signalAPIResult(&result);
1402 }
1403 break;
1404 case QCAMERA_SM_EVT_DUMP:
1405 {
1406 rc = m_parent->dump((int)payload);
1407 result.status = rc;
1408 result.request_api = evt;
1409 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1410 m_parent->signalAPIResult(&result);
1411 }
1412 break;
1413 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1414 {
1415 rc = m_parent->autoFocus();
1416 result.status = rc;
1417 result.request_api = evt;
1418 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1419 m_parent->signalAPIResult(&result);
1420 }
1421 break;
1422 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1423 {
1424 rc = m_parent->cancelAutoFocus();
1425 result.status = rc;
1426 result.request_api = evt;
1427 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1428 m_parent->signalAPIResult(&result);
1429 }
1430 break;
1431 case QCAMERA_SM_EVT_SEND_COMMAND:
1432 {
1433 qcamera_sm_evt_command_payload_t *cmd_payload =
1434 (qcamera_sm_evt_command_payload_t *)payload;
1435 rc = m_parent->sendCommand(cmd_payload->cmd,
1436 cmd_payload->arg1,
1437 cmd_payload->arg2);
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_CANCEL_PICTURE:
1445 {
1446 rc = m_parent->cancelPicture();
1447 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1448 result.status = rc;
1449 result.request_api = evt;
1450 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1451 m_parent->signalAPIResult(&result);
1452 }
1453 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1454 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1455 {
1456 int32_t faceID = 0;
1457 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1458 (qcamera_sm_evt_reg_face_payload_t *)payload;
1459 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1460 reg_payload->config,
1461 faceID);
1462 result.status = rc;
1463 result.request_api = evt;
1464 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1465 result.handle = faceID;
1466 m_parent->signalAPIResult(&result);
1467 }
1468 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1469 case QCAMERA_SM_EVT_TAKE_PICTURE:
1470 case QCAMERA_SM_EVT_START_RECORDING:
1471 case QCAMERA_SM_EVT_STOP_RECORDING:
1472 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1473 case QCAMERA_SM_EVT_START_PREVIEW:
1474 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1475 case QCAMERA_SM_EVT_RELEASE:
1476 {
1477 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1478 rc = INVALID_OPERATION;
1479 result.status = rc;
1480 result.request_api = evt;
1481 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1482 m_parent->signalAPIResult(&result);
1483 }
1484 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1485 case QCAMERA_SM_EVT_EVT_INTERNAL:
1486 {
1487 qcamera_sm_internal_evt_payload_t *internal_evt =
1488 (qcamera_sm_internal_evt_payload_t *)payload;
1489 switch (internal_evt->evt_type) {
1490 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1491 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1492 break;
1493 default:
1494 break;
1495 }
1496 }
1497 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1498 case QCAMERA_SM_EVT_EVT_NOTIFY:
1499 {
1500 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1501 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1502 default:
1503 ALOGD("%s: no handling for server evt (%d) at this state",
1504 __func__, cam_evt->server_event_type);
1505 break;
1506 }
1507 }
1508 break;
1509 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1510 {
1511 qcamera_jpeg_evt_payload_t *jpeg_job =
1512 (qcamera_jpeg_evt_payload_t *)payload;
1513 rc = m_parent->processJpegNotify(jpeg_job);
1514 }
1515 break;
1516 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1517 {
1518 rc = m_parent->cancelPicture();
1519 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1520 }
1521 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1522 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1523 default:
1524 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1525 break;
1526 }
1527
1528 return rc;
1529}
1530
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1531/*===========================================================================
1532 * FUNCTION : procEvtRecordingState
1533 *
1534 * DESCRIPTION: finite state machine function to handle event in state of
1535 * QCAMERA_SM_STATE_RECORDING.
1536 *
1537 * PARAMETERS :
1538 * @evt : event to be processed
1539 * @payload : event payload. Can be NULL if not needed.
1540 *
1541 * RETURN : int32_t type of status
1542 * NO_ERROR -- success
1543 * none-zero failure code
1544 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1545int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt,
1546 void *payload)
1547{
1548 int32_t rc = NO_ERROR;
1549 qcamera_api_result_t result;
1550 memset(&result, 0, sizeof(qcamera_api_result_t));
1551
1552 switch (evt) {
1553 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1554 {
1555 // Error setting preview window during previewing
1556 ALOGE("Cannot set preview window when preview is running");
1557 rc = INVALID_OPERATION;
1558 result.status = rc;
1559 result.request_api = evt;
1560 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1561 m_parent->signalAPIResult(&result);
1562 }
1563 break;
1564 case QCAMERA_SM_EVT_SET_CALLBACKS:
1565 {
1566 qcamera_sm_evt_setcb_payload_t *setcbs =
1567 (qcamera_sm_evt_setcb_payload_t *)payload;
1568 rc = m_parent->setCallBacks(setcbs->notify_cb,
1569 setcbs->data_cb,
1570 setcbs->data_cb_timestamp,
1571 setcbs->get_memory,
1572 setcbs->user);
1573 result.status = rc;
1574 result.request_api = evt;
1575 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1576 m_parent->signalAPIResult(&result);
1577 }
1578 break;
1579 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1580 {
1581 rc = m_parent->enableMsgType(int32_t(payload));
1582 result.status = rc;
1583 result.request_api = evt;
1584 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1585 m_parent->signalAPIResult(&result);
1586 }
1587 break;
1588 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1589 {
1590 rc = m_parent->disableMsgType(int32_t(payload));
1591 result.status = rc;
1592 result.request_api = evt;
1593 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1594 m_parent->signalAPIResult(&result);
1595 }
1596 break;
1597 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1598 {
1599 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1600 result.status = rc;
1601 result.request_api = evt;
1602 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1603 result.enabled = enabled;
1604 m_parent->signalAPIResult(&result);
1605 }
1606 break;
1607 case QCAMERA_SM_EVT_SET_PARAMS:
1608 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1609 bool needRestart = false;
1610 rc = m_parent->updateParameters((char*)payload, needRestart);
1611 if (rc == NO_ERROR) {
1612 if (needRestart) {
1613 // cannot set parameters that requires restart during recording
1614 ALOGE("%s: Cannot set parameters that requires restart during recording",
1615 __func__);
1616 rc = BAD_VALUE;
1617 } else {
1618 rc = m_parent->commitParameterChanges();
1619 }
1620 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1621 result.status = rc;
1622 result.request_api = evt;
1623 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1624 m_parent->signalAPIResult(&result);
1625 }
1626 break;
1627 case QCAMERA_SM_EVT_GET_PARAMS:
1628 {
1629 result.params = m_parent->getParameters();
1630 rc = NO_ERROR;
1631 result.status = rc;
1632 result.request_api = evt;
1633 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1634 m_parent->signalAPIResult(&result);
1635 }
1636 break;
1637 case QCAMERA_SM_EVT_PUT_PARAMS:
1638 {
1639 rc = m_parent->putParameters((char*)payload);
1640 result.status = rc;
1641 result.request_api = evt;
1642 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1643 m_parent->signalAPIResult(&result);
1644 }
1645 break;
1646 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1647 {
1648 rc = NO_ERROR;
1649 result.status = rc;
1650 result.request_api = evt;
1651 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1652 result.enabled = 0;
1653 m_parent->signalAPIResult(&result);
1654 }
1655 break;
1656 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1657 {
1658 rc = NO_ERROR;
1659 result.status = rc;
1660 result.request_api = evt;
1661 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1662 result.enabled = 1;
1663 m_parent->signalAPIResult(&result);
1664 }
1665 break;
1666 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1667 {
1668 rc = m_parent->storeMetaDataInBuffers(int(payload));
1669 result.status = rc;
1670 result.request_api = evt;
1671 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1672 m_parent->signalAPIResult(&result);
1673 }
1674 break;
1675 case QCAMERA_SM_EVT_DUMP:
1676 {
1677 rc = m_parent->dump((int)payload);
1678 result.status = rc;
1679 result.request_api = evt;
1680 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1681 m_parent->signalAPIResult(&result);
1682 }
1683 break;
1684 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1685 {
1686 rc = m_parent->autoFocus();
1687 result.status = rc;
1688 result.request_api = evt;
1689 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1690 m_parent->signalAPIResult(&result);
1691 }
1692 break;
1693 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1694 {
1695 rc = m_parent->cancelAutoFocus();
1696 result.status = rc;
1697 result.request_api = evt;
1698 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1699 m_parent->signalAPIResult(&result);
1700 }
1701 break;
1702 case QCAMERA_SM_EVT_SEND_COMMAND:
1703 {
1704 qcamera_sm_evt_command_payload_t *cmd_payload =
1705 (qcamera_sm_evt_command_payload_t *)payload;
1706 rc = m_parent->sendCommand(cmd_payload->cmd,
1707 cmd_payload->arg1,
1708 cmd_payload->arg2);
1709 result.status = rc;
1710 result.request_api = evt;
1711 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1712 m_parent->signalAPIResult(&result);
1713 }
1714 break;
1715 case QCAMERA_SM_EVT_TAKE_PICTURE:
1716 {
Muhua Li1d0c4772013-02-22 15:39:45 -0800[diff] [blame]1717 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1718 rc = m_parent->takeLiveSnapshot();
Muhua Li1d0c4772013-02-22 15:39:45 -0800[diff] [blame]1719 if (rc != NO_ERROR) {
1720 m_state = QCAMERA_SM_STATE_RECORDING;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1721 }
1722 result.status = rc;
1723 result.request_api = evt;
1724 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1725 m_parent->signalAPIResult(&result);
1726 }
1727 break;
1728 case QCAMERA_SM_EVT_START_RECORDING:
1729 {
1730 // no ops here
1731 ALOGD("%s: already in recording state, no ops for start_recording", __func__);
1732 rc = 0;
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_STOP_RECORDING:
1740 {
1741 rc = m_parent->stopRecording();
1742 m_state = QCAMERA_SM_STATE_PREVIEWING;
1743 result.status = rc;
1744 result.request_api = evt;
1745 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1746 m_parent->signalAPIResult(&result);
1747 }
1748 break;
1749 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1750 {
1751 rc = m_parent->releaseRecordingFrame((const void *)payload);
1752 result.status = rc;
1753 result.request_api = evt;
1754 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1755 m_parent->signalAPIResult(&result);
1756 }
1757 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1758 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1759 {
1760 int32_t faceID = 0;
1761 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1762 (qcamera_sm_evt_reg_face_payload_t *)payload;
1763 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1764 reg_payload->config,
1765 faceID);
1766 result.status = rc;
1767 result.request_api = evt;
1768 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1769 result.handle = faceID;
1770 m_parent->signalAPIResult(&result);
1771 }
1772 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1773 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
1774 {
1775 //In Video snapshot, prepare hardware is a no-op.
1776 result.status = NO_ERROR;
1777 result.request_api = evt;
1778 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1779 m_parent->signalAPIResult(&result);
1780 }
1781 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1782 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1783 case QCAMERA_SM_EVT_START_PREVIEW:
1784 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1785 case QCAMERA_SM_EVT_STOP_PREVIEW:
1786 case QCAMERA_SM_EVT_RELEASE:
1787 {
1788 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1789 rc = INVALID_OPERATION;
1790 result.status = rc;
1791 result.request_api = evt;
1792 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1793 m_parent->signalAPIResult(&result);
1794 }
1795 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1796 case QCAMERA_SM_EVT_EVT_INTERNAL:
1797 {
1798 qcamera_sm_internal_evt_payload_t *internal_evt =
1799 (qcamera_sm_internal_evt_payload_t *)payload;
1800 switch (internal_evt->evt_type) {
1801 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1802 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1803 break;
1804 default:
1805 break;
1806 }
1807 }
1808 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1809 case QCAMERA_SM_EVT_EVT_NOTIFY:
1810 {
1811 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1812 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1813 default:
1814 ALOGD("%s: no handling for server evt (%d) at this state",
1815 __func__, cam_evt->server_event_type);
1816 break;
1817 }
1818 }
1819 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1820 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1821 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]1822 rc = m_parent->updateThermalLevel(
1823 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1824 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1825 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1826 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1827 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1828 default:
1829 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1830 break;
1831 }
1832
1833 return rc;
1834}
1835
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1836/*===========================================================================
1837 * FUNCTION : procEvtVideoPicTakingState
1838 *
1839 * DESCRIPTION: finite state machine function to handle event in state of
1840 * QCAMERA_SM_STATE_VIDEO_PIC_TAKING.
1841 *
1842 * PARAMETERS :
1843 * @evt : event to be processed
1844 * @payload : event payload. Can be NULL if not needed.
1845 *
1846 * RETURN : int32_t type of status
1847 * NO_ERROR -- success
1848 * none-zero failure code
1849 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1850int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt,
1851 void *payload)
1852{
1853 int32_t rc = NO_ERROR;
1854 qcamera_api_result_t result;
1855 memset(&result, 0, sizeof(qcamera_api_result_t));
1856
1857 switch (evt) {
1858 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1859 {
1860 // Error setting preview window during previewing
1861 ALOGE("Cannot set preview window when preview is running");
1862 rc = INVALID_OPERATION;
1863 result.status = rc;
1864 result.request_api = evt;
1865 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1866 m_parent->signalAPIResult(&result);
1867 }
1868 break;
1869 case QCAMERA_SM_EVT_SET_CALLBACKS:
1870 {
1871 qcamera_sm_evt_setcb_payload_t *setcbs =
1872 (qcamera_sm_evt_setcb_payload_t *)payload;
1873 rc = m_parent->setCallBacks(setcbs->notify_cb,
1874 setcbs->data_cb,
1875 setcbs->data_cb_timestamp,
1876 setcbs->get_memory,
1877 setcbs->user);
1878 result.status = rc;
1879 result.request_api = evt;
1880 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1881 m_parent->signalAPIResult(&result);
1882 }
1883 break;
1884 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1885 {
1886 rc = m_parent->enableMsgType(int32_t(payload));
1887 result.status = rc;
1888 result.request_api = evt;
1889 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1890 m_parent->signalAPIResult(&result);
1891 }
1892 break;
1893 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1894 {
1895 rc = m_parent->disableMsgType(int32_t(payload));
1896 result.status = rc;
1897 result.request_api = evt;
1898 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1899 m_parent->signalAPIResult(&result);
1900 }
1901 break;
1902 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1903 {
1904 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1905 result.status = rc;
1906 result.request_api = evt;
1907 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1908 result.enabled = enabled;
1909 m_parent->signalAPIResult(&result);
1910 }
1911 break;
1912 case QCAMERA_SM_EVT_SET_PARAMS:
1913 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1914 bool needRestart = false;
1915 rc = m_parent->updateParameters((char*)payload, needRestart);
1916 if (rc == NO_ERROR) {
1917 if (needRestart) {
1918 // cannot set parameters that requires restart during recording
1919 ALOGE("%s: Cannot set parameters that requires restart during recording",
1920 __func__);
1921 rc = BAD_VALUE;
1922 } else {
1923 rc = m_parent->commitParameterChanges();
1924 }
1925 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1926 result.status = rc;
1927 result.request_api = evt;
1928 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1929 m_parent->signalAPIResult(&result);
1930 }
1931 break;
1932 case QCAMERA_SM_EVT_GET_PARAMS:
1933 {
1934 result.params = m_parent->getParameters();
1935 rc = NO_ERROR;
1936 result.status = rc;
1937 result.request_api = evt;
1938 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1939 m_parent->signalAPIResult(&result);
1940 }
1941 break;
1942 case QCAMERA_SM_EVT_PUT_PARAMS:
1943 {
1944 rc = m_parent->putParameters((char*)payload);
1945 result.status = rc;
1946 result.request_api = evt;
1947 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1948 m_parent->signalAPIResult(&result);
1949 }
1950 break;
1951 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1952 {
1953 rc = NO_ERROR;
1954 result.status = rc;
1955 result.request_api = evt;
1956 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1957 result.enabled = 1;
1958 m_parent->signalAPIResult(&result);
1959 }
1960 break;
1961 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1962 {
1963 rc = NO_ERROR;
1964 result.status = rc;
1965 result.request_api = evt;
1966 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1967 result.enabled = 1;
1968 m_parent->signalAPIResult(&result);
1969 }
1970 break;
1971 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1972 {
1973 rc = m_parent->storeMetaDataInBuffers(int(payload));
1974 result.status = rc;
1975 result.request_api = evt;
1976 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1977 m_parent->signalAPIResult(&result);
1978 }
1979 break;
1980 case QCAMERA_SM_EVT_DUMP:
1981 {
1982 rc = m_parent->dump((int)payload);
1983 result.status = rc;
1984 result.request_api = evt;
1985 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1986 m_parent->signalAPIResult(&result);
1987 }
1988 break;
1989 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1990 {
1991 rc = m_parent->autoFocus();
1992 result.status = rc;
1993 result.request_api = evt;
1994 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1995 m_parent->signalAPIResult(&result);
1996 }
1997 break;
1998 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1999 {
2000 rc = m_parent->cancelAutoFocus();
2001 result.status = rc;
2002 result.request_api = evt;
2003 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2004 m_parent->signalAPIResult(&result);
2005 }
2006 break;
2007 case QCAMERA_SM_EVT_SEND_COMMAND:
2008 {
2009 qcamera_sm_evt_command_payload_t *cmd_payload =
2010 (qcamera_sm_evt_command_payload_t *)payload;
2011 rc = m_parent->sendCommand(cmd_payload->cmd,
2012 cmd_payload->arg1,
2013 cmd_payload->arg2);
2014 result.status = rc;
2015 result.request_api = evt;
2016 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2017 m_parent->signalAPIResult(&result);
2018 }
2019 break;
2020 case QCAMERA_SM_EVT_STOP_RECORDING:
2021 {
2022 rc = m_parent->stopRecording();
2023 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
2024 result.status = rc;
2025 result.request_api = evt;
2026 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2027 m_parent->signalAPIResult(&result);
2028 }
2029 break;
2030 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2031 {
2032 rc = m_parent->releaseRecordingFrame((const void *)payload);
2033 result.status = rc;
2034 result.request_api = evt;
2035 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2036 m_parent->signalAPIResult(&result);
2037 }
2038 break;
2039 case QCAMERA_SM_EVT_CANCEL_PICTURE:
2040 {
2041 rc = m_parent->cancelLiveSnapshot();
2042 m_state = QCAMERA_SM_STATE_RECORDING;
2043 result.status = rc;
2044 result.request_api = evt;
2045 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2046 m_parent->signalAPIResult(&result);
2047 }
2048 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]2049 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
2050 {
2051 int32_t faceID = 0;
2052 qcamera_sm_evt_reg_face_payload_t *reg_payload =
2053 (qcamera_sm_evt_reg_face_payload_t *)payload;
2054 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
2055 reg_payload->config,
2056 faceID);
2057 result.status = rc;
2058 result.request_api = evt;
2059 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2060 result.handle = faceID;
2061 m_parent->signalAPIResult(&result);
2062 }
2063 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2064 case QCAMERA_SM_EVT_START_RECORDING:
2065 case QCAMERA_SM_EVT_START_PREVIEW:
2066 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
2067 case QCAMERA_SM_EVT_STOP_PREVIEW:
2068 case QCAMERA_SM_EVT_TAKE_PICTURE:
2069 case QCAMERA_SM_EVT_RELEASE:
2070 {
2071 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2072 rc = INVALID_OPERATION;
2073 result.status = rc;
2074 result.request_api = evt;
2075 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2076 m_parent->signalAPIResult(&result);
2077 }
2078 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2079 case QCAMERA_SM_EVT_EVT_INTERNAL:
2080 {
2081 qcamera_sm_internal_evt_payload_t *internal_evt =
2082 (qcamera_sm_internal_evt_payload_t *)payload;
2083 switch (internal_evt->evt_type) {
2084 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2085 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2086 break;
2087 default:
2088 break;
2089 }
2090 }
2091 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2092 case QCAMERA_SM_EVT_EVT_NOTIFY:
2093 {
2094 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2095 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2096 default:
2097 ALOGD("%s: no handling for server evt (%d) at this state",
2098 __func__, cam_evt->server_event_type);
2099 break;
2100 }
2101 }
2102 break;
2103 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
2104 {
2105 qcamera_jpeg_evt_payload_t *jpeg_job =
2106 (qcamera_jpeg_evt_payload_t *)payload;
2107 rc = m_parent->processJpegNotify(jpeg_job);
2108 }
2109 break;
2110 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
2111 {
2112 rc = m_parent->cancelLiveSnapshot();
2113 m_state = QCAMERA_SM_STATE_RECORDING;
2114 }
2115 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2116 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2117 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2118 rc = m_parent->updateThermalLevel(
2119 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2120 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2121 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2122 default:
2123 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2124 break;
2125 }
2126
2127 return rc;
2128}
2129
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2130/*===========================================================================
2131 * FUNCTION : procEvtPreviewPicTakingState
2132 *
2133 * DESCRIPTION: finite state machine function to handle event in state of
2134 * QCAMERA_SM_STATE_PREVIEW_PIC_TAKING.
2135 *
2136 * PARAMETERS :
2137 * @evt : event to be processed
2138 * @payload : event payload. Can be NULL if not needed.
2139 *
2140 * RETURN : int32_t type of status
2141 * NO_ERROR -- success
2142 * none-zero failure code
2143 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2144int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt,
2145 void *payload)
2146{
2147 int32_t rc = NO_ERROR;
2148 qcamera_api_result_t result;
2149 memset(&result, 0, sizeof(qcamera_api_result_t));
2150
2151 switch (evt) {
2152 case QCAMERA_SM_EVT_SET_CALLBACKS:
2153 {
2154 qcamera_sm_evt_setcb_payload_t *setcbs =
2155 (qcamera_sm_evt_setcb_payload_t *)payload;
2156 rc = m_parent->setCallBacks(setcbs->notify_cb,
2157 setcbs->data_cb,
2158 setcbs->data_cb_timestamp,
2159 setcbs->get_memory,
2160 setcbs->user);
2161 result.status = rc;
2162 result.request_api = evt;
2163 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2164 m_parent->signalAPIResult(&result);
2165 }
2166 break;
2167 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
2168 {
2169 rc = m_parent->enableMsgType(int32_t(payload));
2170 result.status = rc;
2171 result.request_api = evt;
2172 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2173 m_parent->signalAPIResult(&result);
2174 }
2175 break;
2176 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
2177 {
2178 rc = m_parent->disableMsgType(int32_t(payload));
2179 result.status = rc;
2180 result.request_api = evt;
2181 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2182 m_parent->signalAPIResult(&result);
2183 }
2184 break;
2185 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
2186 {
2187 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
2188 result.status = rc;
2189 result.request_api = evt;
2190 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2191 result.enabled = enabled;
2192 m_parent->signalAPIResult(&result);
2193 }
2194 break;
2195 case QCAMERA_SM_EVT_SET_PARAMS:
2196 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2197 bool needRestart = false;
2198 rc = m_parent->updateParameters((char*)payload, needRestart);
2199 if (rc == NO_ERROR) {
2200 if (needRestart) {
2201 // need restart preview for parameters to take effect
2202 // stop preview
2203 m_parent->stopPreview();
2204 // commit parameter changes to server
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]2205 m_parent->commitParameterChanges();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2206 // start preview again
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]2207 rc = m_parent->preparePreview();
2208 if (rc == NO_ERROR) {
2209 rc = m_parent->startPreview();
2210 if (rc != NO_ERROR) {
2211 m_parent->unpreparePreview();
2212 }
2213 }
2214 if (rc != NO_ERROR) {
2215 m_state = QCAMERA_SM_STATE_PIC_TAKING;
2216 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2217 } else {
2218 rc = m_parent->commitParameterChanges();
2219 }
2220 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2221 result.status = rc;
2222 result.request_api = evt;
2223 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2224 m_parent->signalAPIResult(&result);
2225 }
2226 break;
2227 case QCAMERA_SM_EVT_GET_PARAMS:
2228 {
2229 result.params = m_parent->getParameters();
2230 rc = NO_ERROR;
2231 result.status = rc;
2232 result.request_api = evt;
2233 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
2234 m_parent->signalAPIResult(&result);
2235 }
2236 break;
2237 case QCAMERA_SM_EVT_PUT_PARAMS:
2238 {
2239 rc = m_parent->putParameters((char*)payload);
2240 result.status = rc;
2241 result.request_api = evt;
2242 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2243 m_parent->signalAPIResult(&result);
2244 }
2245 break;
2246 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
2247 {
2248 rc = NO_ERROR;
2249 result.status = rc;
2250 result.request_api = evt;
2251 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2252 result.enabled = 1;
2253 m_parent->signalAPIResult(&result);
2254 }
2255 break;
2256 case QCAMERA_SM_EVT_RECORDING_ENABLED:
2257 {
2258 rc = NO_ERROR;
2259 result.status = rc;
2260 result.request_api = evt;
2261 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2262 result.enabled = 0;
2263 m_parent->signalAPIResult(&result);
2264 }
2265 break;
2266 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
2267 {
2268 rc = m_parent->storeMetaDataInBuffers(int(payload));
2269 result.status = rc;
2270 result.request_api = evt;
2271 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2272 m_parent->signalAPIResult(&result);
2273 }
2274 break;
2275 case QCAMERA_SM_EVT_DUMP:
2276 {
2277 rc = m_parent->dump((int)payload);
2278 result.status = rc;
2279 result.request_api = evt;
2280 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2281 m_parent->signalAPIResult(&result);
2282 }
2283 break;
2284 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
2285 {
2286 rc = m_parent->autoFocus();
2287 result.status = rc;
2288 result.request_api = evt;
2289 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2290 m_parent->signalAPIResult(&result);
2291 }
2292 break;
2293 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
2294 {
2295 rc = m_parent->cancelAutoFocus();
2296 result.status = rc;
2297 result.request_api = evt;
2298 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2299 m_parent->signalAPIResult(&result);
2300 }
2301 break;
2302 case QCAMERA_SM_EVT_SEND_COMMAND:
2303 {
2304 qcamera_sm_evt_command_payload_t *cmd_payload =
2305 (qcamera_sm_evt_command_payload_t *)payload;
2306 rc = m_parent->sendCommand(cmd_payload->cmd,
2307 cmd_payload->arg1,
2308 cmd_payload->arg2);
2309 result.status = rc;
2310 result.request_api = evt;
2311 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2312 m_parent->signalAPIResult(&result);
2313 }
2314 break;
2315 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2316 {
2317 rc = m_parent->releaseRecordingFrame((const void *)payload);
2318 result.status = rc;
2319 result.request_api = evt;
2320 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2321 m_parent->signalAPIResult(&result);
2322 }
2323 break;
2324 case QCAMERA_SM_EVT_CANCEL_PICTURE:
2325 {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]2326 if (m_parent->isZSLMode()) {
2327 rc = m_parent->cancelPicture();
2328 } else {
2329 rc = m_parent->cancelLiveSnapshot();
2330 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2331 m_state = QCAMERA_SM_STATE_PREVIEWING;
2332 result.status = rc;
2333 result.request_api = evt;
2334 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2335 m_parent->signalAPIResult(&result);
2336 }
2337 break;
2338 case QCAMERA_SM_EVT_STOP_PREVIEW:
2339 {
Muhua Libd1b6122013-03-05 15:25:27 -0800[diff] [blame]2340 if (m_parent->isZSLMode()) {
2341 // cancel picture first
2342 rc = m_parent->cancelPicture();
2343 m_parent->stopChannel(QCAMERA_CH_TYPE_ZSL);
2344 } else {
2345 rc = m_parent->cancelLiveSnapshot();
2346 m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW);
2347 }
2348 // unprepare preview
2349 m_parent->unpreparePreview();
2350 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2351 result.status = rc;
2352 result.request_api = evt;
2353 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2354 m_parent->signalAPIResult(&result);
2355 }
2356 break;
2357 case QCAMERA_SM_EVT_START_RECORDING:
2358 {
2359 rc = m_parent->stopRecording();
2360 if (rc == NO_ERROR) {
2361 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
2362 }
2363 result.status = rc;
2364 result.request_api = evt;
2365 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2366 m_parent->signalAPIResult(&result);
2367 }
2368 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]2369 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
2370 {
2371 int32_t faceID = 0;
2372 qcamera_sm_evt_reg_face_payload_t *reg_payload =
2373 (qcamera_sm_evt_reg_face_payload_t *)payload;
2374 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
2375 reg_payload->config,
2376 faceID);
2377 result.status = rc;
2378 result.request_api = evt;
2379 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2380 result.handle = faceID;
2381 m_parent->signalAPIResult(&result);
2382 }
2383 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2384 case QCAMERA_SM_EVT_STOP_RECORDING:
2385 case QCAMERA_SM_EVT_START_PREVIEW:
2386 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
2387 case QCAMERA_SM_EVT_TAKE_PICTURE:
2388 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
2389 case QCAMERA_SM_EVT_RELEASE:
2390 {
2391 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2392 rc = INVALID_OPERATION;
2393 result.status = rc;
2394 result.request_api = evt;
2395 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2396 m_parent->signalAPIResult(&result);
2397 }
2398 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2399 case QCAMERA_SM_EVT_EVT_INTERNAL:
2400 {
2401 qcamera_sm_internal_evt_payload_t *internal_evt =
2402 (qcamera_sm_internal_evt_payload_t *)payload;
2403 switch (internal_evt->evt_type) {
2404 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2405 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2406 break;
2407 default:
2408 break;
2409 }
2410 }
2411 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2412 case QCAMERA_SM_EVT_EVT_NOTIFY:
2413 {
2414 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2415 switch (cam_evt->server_event_type) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2416 default:
2417 ALOGD("%s: no handling for server evt (%d) at this state",
2418 __func__, cam_evt->server_event_type);
2419 break;
2420 }
2421 }
2422 break;
2423 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
2424 {
2425 qcamera_jpeg_evt_payload_t *jpeg_job =
2426 (qcamera_jpeg_evt_payload_t *)payload;
2427 rc = m_parent->processJpegNotify(jpeg_job);
2428 }
2429 break;
2430 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
2431 {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]2432 if (m_parent->isZSLMode()) {
2433 rc = m_parent->cancelPicture();
2434 } else {
2435 rc = m_parent->cancelLiveSnapshot();
2436 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2437 m_state = QCAMERA_SM_STATE_PREVIEWING;
2438 }
2439 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2440 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2441 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2442 rc = m_parent->updateThermalLevel(
2443 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2444 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2445 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2446 default:
2447 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2448 break;
2449 }
2450
2451 return rc;
2452}
2453
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2454/*===========================================================================
2455 * FUNCTION : isPreviewRunning
2456 *
2457 * DESCRIPTION: check if preview is in process.
2458 *
2459 * PARAMETERS : None
2460 *
2461 * RETURN : true -- preview running
2462 * false -- preview stopped
2463 *==========================================================================*/
2464bool QCameraStateMachine::isPreviewRunning()
2465{
2466 switch (m_state) {
2467 case QCAMERA_SM_STATE_PREVIEWING:
2468 case QCAMERA_SM_STATE_RECORDING:
2469 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
2470 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
2471 return true;
2472 default:
2473 return false;
2474 }
2475}
2476
Shuzhen Wang89635cf2012-12-20 13:47:22 -0800[diff] [blame]2477}; // namespace qcamera