Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / hardware / qcom / camera / d972ac13ecbf60a2c95580436c525b8a1fad6511 / . / QCamera2 / HAL / QCameraStateMachine.cpp
blob: 7aaa20232c93477ae1a4222567e6b0684a889f5b [file] [log] [blame]
Sai Kumar Sanagavarapud972ac12014-01-07 14:23:52 +0530[diff] [blame^]1/* Copyright (c) 2012-2014, 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);
Emilian Peev9afd73b2013-10-31 08:19:57 -0700[diff] [blame]355 if (needRestart) {
356 // Clear memory pools
357 m_parent->m_memoryPool.clear();
358 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]359 if (rc == NO_ERROR) {
360 rc = m_parent->commitParameterChanges();
361 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]362 result.status = rc;
363 result.request_api = evt;
364 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
365 m_parent->signalAPIResult(&result);
366 }
367 break;
368 case QCAMERA_SM_EVT_GET_PARAMS:
369 {
370 result.params = m_parent->getParameters();
371 rc = NO_ERROR;
372 result.status = rc;
373 result.request_api = evt;
374 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
375 m_parent->signalAPIResult(&result);
376 }
377 break;
378 case QCAMERA_SM_EVT_PUT_PARAMS:
379 {
380 rc = m_parent->putParameters((char*)payload);
381 result.status = rc;
382 result.request_api = evt;
383 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
384 m_parent->signalAPIResult(&result);
385 }
386 break;
387 case QCAMERA_SM_EVT_START_PREVIEW:
388 {
389 if (m_parent->mPreviewWindow == NULL) {
Mansoor Aftab06c809c2013-01-23 19:44:47 -0800[diff] [blame]390 rc = m_parent->preparePreview();
391 if(rc == NO_ERROR) {
392 // preview window is not set yet, move to previewReady state
393 m_state = QCAMERA_SM_STATE_PREVIEW_READY;
394 } else {
395 ALOGE("%s: preparePreview failed",__func__);
396 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]397 } else {
398 rc = m_parent->preparePreview();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]399 if (rc == NO_ERROR) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]400 rc = m_parent->startPreview();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]401 if (rc != NO_ERROR) {
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]402 m_parent->unpreparePreview();
403 } else {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]404 // start preview success, move to previewing state
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]405 m_state = QCAMERA_SM_STATE_PREVIEWING;
406 }
407 }
408 }
409 result.status = rc;
410 result.request_api = evt;
411 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
412 m_parent->signalAPIResult(&result);
413 }
414 break;
415 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
416 {
417 rc = m_parent->preparePreview();
418 if (rc == NO_ERROR) {
419 rc = m_parent->startPreview();
420 if (rc != NO_ERROR) {
421 m_parent->unpreparePreview();
422 } else {
423 m_state = QCAMERA_SM_STATE_PREVIEWING;
424 }
425 }
426 result.status = rc;
427 result.request_api = evt;
428 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
429 m_parent->signalAPIResult(&result);
430 }
431 break;
432 case QCAMERA_SM_EVT_STOP_PREVIEW:
433 {
434 // no op needed here
435 ALOGD("%s: already in preview stopped state, do nothing", __func__);
436 result.status = NO_ERROR;
437 result.request_api = evt;
438 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
439 m_parent->signalAPIResult(&result);
440 }
441 break;
442 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
443 case QCAMERA_SM_EVT_RECORDING_ENABLED:
444 {
445 result.status = NO_ERROR;
446 result.request_api = evt;
447 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
448 result.enabled = 0;
449 m_parent->signalAPIResult(&result);
450 }
451 break;
452 case QCAMERA_SM_EVT_RELEASE:
453 {
454 rc = m_parent->release();
455 result.status = rc;
456 result.request_api = evt;
457 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
458 m_parent->signalAPIResult(&result);
459 }
460 break;
461 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
462 {
463 rc = m_parent->storeMetaDataInBuffers(int(payload));
464 result.status = rc;
465 result.request_api = evt;
466 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
467 m_parent->signalAPIResult(&result);
468 }
469 break;
470 case QCAMERA_SM_EVT_DUMP:
471 {
472 rc = m_parent->dump((int)payload);
473 result.status = rc;
474 result.request_api = evt;
475 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
476 m_parent->signalAPIResult(&result);
477 }
478 break;
Ankit Premrajka3b00dc62012-12-14 18:37:52 -0800[diff] [blame]479 case QCAMERA_SM_EVT_SEND_COMMAND:
480 {
481 qcamera_sm_evt_command_payload_t *cmd_payload =
482 (qcamera_sm_evt_command_payload_t *)payload;
483 rc = m_parent->sendCommand(cmd_payload->cmd,
484 cmd_payload->arg1,
485 cmd_payload->arg2);
486 result.status = rc;
487 result.request_api = evt;
488 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
489 m_parent->signalAPIResult(&result);
490 }
491 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]492 case QCAMERA_SM_EVT_START_RECORDING:
493 case QCAMERA_SM_EVT_STOP_RECORDING:
494 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]495 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]496 case QCAMERA_SM_EVT_TAKE_PICTURE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]497 {
498 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
499 rc = INVALID_OPERATION;
500 result.status = rc;
501 result.request_api = evt;
502 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
503 m_parent->signalAPIResult(&result);
504 }
505 break;
Georgi Hristv72d768f2013-10-02 17:47:59 +0300[diff] [blame]506 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
Muhua Li1612f422013-01-03 11:07:39 -0800[diff] [blame]507 case QCAMERA_SM_EVT_CANCEL_PICTURE:
Muhua Li1612f422013-01-03 11:07:39 -0800[diff] [blame]508 {
509 // no op needed here
510 ALOGD("%s: No ops for evt(%d) in state(%d)", __func__, evt, m_state);
511 result.status = NO_ERROR;
512 result.request_api = evt;
513 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
514 m_parent->signalAPIResult(&result);
515 }
516 break;
Muhua Li0c14e432013-03-06 15:50:17 -0800[diff] [blame]517 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
518 {
519 rc = m_parent->cancelAutoFocus();
520 result.status = rc;
521 result.request_api = evt;
522 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
523 m_parent->signalAPIResult(&result);
524 }
525 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]526 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
527 {
528 int32_t faceID = 0;
529 qcamera_sm_evt_reg_face_payload_t *reg_payload =
530 (qcamera_sm_evt_reg_face_payload_t *)payload;
531 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
532 reg_payload->config,
533 faceID);
534 result.status = rc;
535 result.request_api = evt;
536 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
537 result.handle = faceID;
538 m_parent->signalAPIResult(&result);
539 }
540 break;
Emilian Peev2ae455e2013-04-18 10:41:56 +0300[diff] [blame]541 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
542 {
543 rc = m_parent->updateThermalLevel(
544 *(qcamera_thermal_level_enum_t *)&payload);
545 }
546 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]547 case QCAMERA_SM_EVT_EVT_NOTIFY:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]548 {
549 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
550 switch (cam_evt->server_event_type) {
551 case CAM_EVENT_TYPE_DAEMON_DIED:
552 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]553 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
554 CAMERA_ERROR_SERVER_DIED,
555 0);
556 }
557 break;
558 default:
559 ALOGE("%s: Invalid internal event %d in state(%d)",
560 __func__, cam_evt->server_event_type, m_state);
561 break;
562 }
563 }
564 break;
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]565 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
566 {
567 // No ops, but need to notify
568 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
569 result.status = rc;
570 result.request_api = evt;
571 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
572 m_parent->signalEvtResult(&result);
573 }
574 break;
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]575 case QCAMERA_SM_EVT_EVT_INTERNAL:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]576 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
577 default:
578 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
579 break;
580 }
581
582 return rc;
583}
584
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]585/*===========================================================================
586 * FUNCTION : procEvtPreviewReadyState
587 *
588 * DESCRIPTION: finite state machine function to handle event in state of
589 * QCAMERA_SM_STATE_PREVIEW_READY.
590 *
591 * PARAMETERS :
592 * @evt : event to be processed
593 * @payload : event payload. Can be NULL if not needed.
594 *
595 * RETURN : int32_t type of status
596 * NO_ERROR -- success
597 * none-zero failure code
598 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]599int32_t QCameraStateMachine::procEvtPreviewReadyState(qcamera_sm_evt_enum_t evt,
600 void *payload)
601{
602 int32_t rc = NO_ERROR;
603 qcamera_api_result_t result;
604 memset(&result, 0, sizeof(qcamera_api_result_t));
605
606 switch (evt) {
607 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
608 {
609 m_parent->setPreviewWindow((struct preview_stream_ops *)payload);
610 if (m_parent->mPreviewWindow != NULL) {
611 rc = m_parent->startPreview();
612 if (rc != NO_ERROR) {
613 m_parent->unpreparePreview();
614 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
615 } else {
616 m_state = QCAMERA_SM_STATE_PREVIEWING;
617 }
618 }
619
620 result.status = rc;
621 result.request_api = evt;
622 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
623 m_parent->signalAPIResult(&result);
624 }
625 break;
626 case QCAMERA_SM_EVT_SET_CALLBACKS:
627 {
628 qcamera_sm_evt_setcb_payload_t *setcbs =
629 (qcamera_sm_evt_setcb_payload_t *)payload;
630 rc = m_parent->setCallBacks(setcbs->notify_cb,
631 setcbs->data_cb,
632 setcbs->data_cb_timestamp,
633 setcbs->get_memory,
634 setcbs->user);
635 result.status = rc;
636 result.request_api = evt;
637 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
638 m_parent->signalAPIResult(&result);
639 }
640 break;
641 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
642 {
643 rc = m_parent->enableMsgType(int32_t(payload));
644 result.status = rc;
645 result.request_api = evt;
646 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
647 m_parent->signalAPIResult(&result);
648 }
649 break;
650 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
651 {
652 rc = m_parent->disableMsgType(int32_t(payload));
653 result.status = rc;
654 result.request_api = evt;
655 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
656 m_parent->signalAPIResult(&result);
657 }
658 break;
659 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
660 {
661 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
662 result.status = rc;
663 result.request_api = evt;
664 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
665 result.enabled = enabled;
666 m_parent->signalAPIResult(&result);
667 }
668 break;
669 case QCAMERA_SM_EVT_SET_PARAMS:
670 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]671 bool needRestart = false;
672 rc = m_parent->updateParameters((char*)payload, needRestart);
673 if (rc == NO_ERROR) {
Muhua Li6d69e932013-01-24 16:39:27 -0800[diff] [blame]674 if (needRestart) {
675 // need restart preview for parameters to take effect
676 m_parent->unpreparePreview();
Emilian Peev9afd73b2013-10-31 08:19:57 -0700[diff] [blame]677 // Clear memory pools
678 m_parent->m_memoryPool.clear();
Muhua Li6d69e932013-01-24 16:39:27 -0800[diff] [blame]679 // commit parameter changes to server
680 m_parent->commitParameterChanges();
681 // prepare preview again
682 rc = m_parent->preparePreview();
683 if (rc != NO_ERROR) {
684 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
685 }
686 } else {
687 rc = m_parent->commitParameterChanges();
688 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]689 }
Muhua Li6d69e932013-01-24 16:39:27 -0800[diff] [blame]690
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]691 result.status = rc;
692 result.request_api = evt;
693 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
694 m_parent->signalAPIResult(&result);
695 }
696 break;
697 case QCAMERA_SM_EVT_GET_PARAMS:
698 {
699 result.params = m_parent->getParameters();
700 rc = NO_ERROR;
701 result.status = rc;
702 result.request_api = evt;
703 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
704 m_parent->signalAPIResult(&result);
705 }
706 break;
707 case QCAMERA_SM_EVT_PUT_PARAMS:
708 {
709 rc = m_parent->putParameters((char*)payload);
710 result.status = rc;
711 result.request_api = evt;
712 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
713 m_parent->signalAPIResult(&result);
714 }
715 break;
716 case QCAMERA_SM_EVT_START_PREVIEW:
717 {
718 // no ops here
719 rc = NO_ERROR;
720 result.status = rc;
721 result.request_api = evt;
722 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
723 m_parent->signalAPIResult(&result);
724 }
725 break;
726 case QCAMERA_SM_EVT_STOP_PREVIEW:
727 {
728 m_parent->unpreparePreview();
729 rc = 0;
730 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
731 result.status = rc;
732 result.request_api = evt;
733 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
734 m_parent->signalAPIResult(&result);
735 }
736 break;
737 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
738 {
739 rc = NO_ERROR;
740 result.status = rc;
741 result.request_api = evt;
742 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
743 result.enabled = 1;
744 m_parent->signalAPIResult(&result);
745 }
746 break;
747 case QCAMERA_SM_EVT_RECORDING_ENABLED:
748 {
749 rc = 0;
750 result.status = rc;
751 result.request_api = evt;
752 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
753 result.enabled = 0;
754 m_parent->signalAPIResult(&result);
755 }
756 break;
757 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
758 {
759 rc = m_parent->storeMetaDataInBuffers(int(payload));
760 result.status = rc;
761 result.request_api = evt;
762 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
763 m_parent->signalAPIResult(&result);
764 }
765 break;
766 case QCAMERA_SM_EVT_DUMP:
767 {
768 rc = m_parent->dump((int)payload);
769 result.status = rc;
770 result.request_api = evt;
771 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
772 m_parent->signalAPIResult(&result);
773 }
774 break;
775 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
776 {
777 rc = m_parent->autoFocus();
778 result.status = rc;
779 result.request_api = evt;
780 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
781 m_parent->signalAPIResult(&result);
782 }
783 break;
784 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
785 {
786 rc = m_parent->cancelAutoFocus();
787 result.status = rc;
788 result.request_api = evt;
789 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
790 m_parent->signalAPIResult(&result);
791 }
792 break;
793 case QCAMERA_SM_EVT_SEND_COMMAND:
794 {
795 qcamera_sm_evt_command_payload_t *cmd_payload =
796 (qcamera_sm_evt_command_payload_t *)payload;
797 rc = m_parent->sendCommand(cmd_payload->cmd,
798 cmd_payload->arg1,
799 cmd_payload->arg2);
800 result.status = rc;
801 result.request_api = evt;
802 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
803 m_parent->signalAPIResult(&result);
804 }
805 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]806 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
807 {
808 int32_t faceID = 0;
809 qcamera_sm_evt_reg_face_payload_t *reg_payload =
810 (qcamera_sm_evt_reg_face_payload_t *)payload;
811 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
812 reg_payload->config,
813 faceID);
814 result.status = rc;
815 result.request_api = evt;
816 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
817 result.handle = faceID;
818 m_parent->signalAPIResult(&result);
819 }
820 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]821 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
822 case QCAMERA_SM_EVT_START_RECORDING:
823 case QCAMERA_SM_EVT_STOP_RECORDING:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]824 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]825 case QCAMERA_SM_EVT_TAKE_PICTURE:
826 case QCAMERA_SM_EVT_CANCEL_PICTURE:
827 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
828 case QCAMERA_SM_EVT_RELEASE:
829 {
830 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
831 rc = INVALID_OPERATION;
832 result.status = rc;
833 result.request_api = evt;
834 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
835 m_parent->signalAPIResult(&result);
836 }
837 break;
838 case QCAMERA_SM_EVT_EVT_NOTIFY:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]839 {
840 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
841 switch (cam_evt->server_event_type) {
842 case CAM_EVENT_TYPE_DAEMON_DIED:
843 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]844 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
845 CAMERA_ERROR_SERVER_DIED,
846 0);
847 }
848 break;
849 default:
850 ALOGE("%s: Invalid internal event %d in state(%d)",
851 __func__, cam_evt->server_event_type, m_state);
852 break;
853 }
854 }
855 break;
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]856 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
857 {
858 // No ops, but need to notify
859 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
860 result.status = rc;
861 result.request_api = evt;
862 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
863 m_parent->signalEvtResult(&result);
864 }
865 break;
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]866 case QCAMERA_SM_EVT_EVT_INTERNAL:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]867 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]868 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]869 default:
870 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
871 break;
872 }
873
874 return rc;
875}
876
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]877/*===========================================================================
878 * FUNCTION : procEvtPreviewingState
879 *
880 * DESCRIPTION: finite state machine function to handle event in state of
881 * QCAMERA_SM_STATE_PREVIEWING.
882 *
883 * PARAMETERS :
884 * @evt : event to be processed
885 * @payload : event payload. Can be NULL if not needed.
886 *
887 * RETURN : int32_t type of status
888 * NO_ERROR -- success
889 * none-zero failure code
890 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]891int32_t QCameraStateMachine::procEvtPreviewingState(qcamera_sm_evt_enum_t evt,
892 void *payload)
893{
894 int32_t rc = NO_ERROR;
895 qcamera_api_result_t result;
896 memset(&result, 0, sizeof(qcamera_api_result_t));
897
898 switch (evt) {
899 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
900 {
901 // Error setting preview window during previewing
902 ALOGE("Cannot set preview window when preview is running");
903 rc = INVALID_OPERATION;
904 result.status = rc;
905 result.request_api = evt;
906 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
907 m_parent->signalAPIResult(&result);
908 }
909 break;
910 case QCAMERA_SM_EVT_SET_CALLBACKS:
911 {
912 qcamera_sm_evt_setcb_payload_t *setcbs =
913 (qcamera_sm_evt_setcb_payload_t *)payload;
914 rc = m_parent->setCallBacks(setcbs->notify_cb,
915 setcbs->data_cb,
916 setcbs->data_cb_timestamp,
917 setcbs->get_memory,
918 setcbs->user);
919 result.status = rc;
920 result.request_api = evt;
921 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
922 m_parent->signalAPIResult(&result);
923 }
924 break;
925 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
926 {
927 rc = m_parent->enableMsgType(int32_t(payload));
928 result.status = rc;
929 result.request_api = evt;
930 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
931 m_parent->signalAPIResult(&result);
932 }
933 break;
934 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
935 {
936 rc = m_parent->disableMsgType(int32_t(payload));
937 result.status = rc;
938 result.request_api = evt;
939 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
940 m_parent->signalAPIResult(&result);
941 }
942 break;
943 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
944 {
945 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
946 result.status = rc;
947 result.request_api = evt;
948 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
949 result.enabled = enabled;
950 m_parent->signalAPIResult(&result);
951 }
952 break;
953 case QCAMERA_SM_EVT_SET_PARAMS:
954 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]955 bool needRestart = false;
956 rc = m_parent->updateParameters((char*)payload, needRestart);
957 if (rc == NO_ERROR) {
958 if (needRestart) {
959 // need restart preview for parameters to take effect
960 // stop preview
961 m_parent->stopPreview();
Emilian Peev9afd73b2013-10-31 08:19:57 -0700[diff] [blame]962 // Clear memory pools
963 m_parent->m_memoryPool.clear();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]964 // commit parameter changes to server
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]965 m_parent->commitParameterChanges();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]966 // start preview again
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]967 rc = m_parent->preparePreview();
968 if (rc == NO_ERROR) {
969 rc = m_parent->startPreview();
970 if (rc != NO_ERROR) {
971 m_parent->unpreparePreview();
972 }
973 }
974 if (rc != NO_ERROR) {
975 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
976 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]977 } else {
978 rc = m_parent->commitParameterChanges();
979 }
980 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]981 result.status = rc;
982 result.request_api = evt;
983 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
984 m_parent->signalAPIResult(&result);
985 }
986 break;
987 case QCAMERA_SM_EVT_GET_PARAMS:
988 {
989 result.params = m_parent->getParameters();
990 rc = NO_ERROR;
991 result.status = rc;
992 result.request_api = evt;
993 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
994 m_parent->signalAPIResult(&result);
995 }
996 break;
997 case QCAMERA_SM_EVT_PUT_PARAMS:
998 {
999 rc = m_parent->putParameters((char*)payload);
1000 result.status = rc;
1001 result.request_api = evt;
1002 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1003 m_parent->signalAPIResult(&result);
1004 }
1005 break;
1006 case QCAMERA_SM_EVT_START_PREVIEW:
1007 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1008 {
1009 // no ops here
1010 ALOGD("%s: Already in previewing, no ops here to start preview", __func__);
1011 rc = NO_ERROR;
1012 result.status = rc;
1013 result.request_api = evt;
1014 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1015 m_parent->signalAPIResult(&result);
1016 }
1017 break;
1018 case QCAMERA_SM_EVT_STOP_PREVIEW:
1019 {
1020 rc = m_parent->stopPreview();
1021 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1022 result.status = rc;
1023 result.request_api = evt;
1024 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1025 m_parent->signalAPIResult(&result);
1026 }
1027 break;
1028 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1029 {
1030 rc = NO_ERROR;
1031 result.status = rc;
1032 result.request_api = evt;
1033 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1034 result.enabled = 1;
1035 m_parent->signalAPIResult(&result);
1036 }
1037 break;
1038 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1039 {
1040 rc = NO_ERROR;
1041 result.status = rc;
1042 result.request_api = evt;
1043 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1044 result.enabled = 0;
1045 m_parent->signalAPIResult(&result);
1046 }
1047 break;
1048 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1049 {
1050 rc = m_parent->storeMetaDataInBuffers(int(payload));
1051 result.status = rc;
1052 result.request_api = evt;
1053 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1054 m_parent->signalAPIResult(&result);
1055 }
1056 break;
1057 case QCAMERA_SM_EVT_DUMP:
1058 {
1059 rc = m_parent->dump((int)payload);
1060 result.status = rc;
1061 result.request_api = evt;
1062 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1063 m_parent->signalAPIResult(&result);
1064 }
1065 break;
1066 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1067 {
1068 rc = m_parent->autoFocus();
1069 result.status = rc;
1070 result.request_api = evt;
1071 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1072 m_parent->signalAPIResult(&result);
1073 }
1074 break;
1075 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1076 {
1077 rc = m_parent->cancelAutoFocus();
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;
1084 case QCAMERA_SM_EVT_START_RECORDING:
1085 {
1086 rc = m_parent->startRecording();
1087 if (rc == NO_ERROR) {
1088 // move state to recording state
1089 m_state = QCAMERA_SM_STATE_RECORDING;
1090 }
1091 result.status = rc;
1092 result.request_api = evt;
1093 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1094 m_parent->signalAPIResult(&result);
1095 }
1096 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1097 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1098 {
Muhua Li0c14e432013-03-06 15:50:17 -0800[diff] [blame]1099 rc = m_parent->prepareHardwareForSnapshot(FALSE);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1100 if (rc == NO_ERROR) {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1101 // Do not signal API result in this case.
1102 // Need to wait for snapshot done in metadta.
1103 m_state = QCAMERA_SM_STATE_PREPARE_SNAPSHOT;
1104 } else {
1105 // Do not change state in this case.
1106 ALOGE("%s: prepareHardwareForSnapshot failed %d",
1107 __func__, rc);
1108
1109 result.status = rc;
1110 result.request_api = evt;
1111 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1112 m_parent->signalAPIResult(&result);
1113 }
1114 }
1115 break;
1116 case QCAMERA_SM_EVT_TAKE_PICTURE:
1117 {
Muhua Li8e614bc2013-04-17 17:38:42 -0700[diff] [blame]1118 if ( m_parent->mParameters.getRecordingHintValue() == false) {
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]1119 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1120 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
Muhua Lia9dca012013-05-03 22:37:42 -0700[diff] [blame]1121 rc = m_parent->takePicture();
1122 if (rc != NO_ERROR) {
1123 // move state to previewing state
1124 m_state = QCAMERA_SM_STATE_PREVIEWING;
1125 }
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1126 } else {
1127 m_state = QCAMERA_SM_STATE_PIC_TAKING;
Muhua Lia9dca012013-05-03 22:37:42 -0700[diff] [blame]1128 rc = m_parent->takePicture();
1129 if (rc != NO_ERROR) {
1130 // move state to preview stopped state
1131 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1132 }
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1133 }
Muhua Lia9dca012013-05-03 22:37:42 -0700[diff] [blame]1134
1135 result.status = rc;
1136 result.request_api = evt;
1137 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1138 m_parent->signalAPIResult(&result);
Muhua Li8e614bc2013-04-17 17:38:42 -0700[diff] [blame]1139 } else {
Muhua Lia9dca012013-05-03 22:37:42 -0700[diff] [blame]1140 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
Muhua Li8e614bc2013-04-17 17:38:42 -0700[diff] [blame]1141 rc = m_parent->takeLiveSnapshot();
Muhua Lia9dca012013-05-03 22:37:42 -0700[diff] [blame]1142 if (rc != NO_ERROR ) {
1143 m_state = QCAMERA_SM_STATE_PREVIEWING;
Muhua Li8e614bc2013-04-17 17:38:42 -0700[diff] [blame]1144 }
Muhua Lia9dca012013-05-03 22:37:42 -0700[diff] [blame]1145 result.status = rc;
1146 result.request_api = evt;
1147 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1148 m_parent->signalAPIResult(&result);
Muhua Li8e614bc2013-04-17 17:38:42 -0700[diff] [blame]1149 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1150 }
1151 break;
1152 case QCAMERA_SM_EVT_SEND_COMMAND:
1153 {
1154 qcamera_sm_evt_command_payload_t *cmd_payload =
1155 (qcamera_sm_evt_command_payload_t *)payload;
1156 rc = m_parent->sendCommand(cmd_payload->cmd,
1157 cmd_payload->arg1,
1158 cmd_payload->arg2);
1159 result.status = rc;
1160 result.request_api = evt;
1161 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1162 m_parent->signalAPIResult(&result);
1163 }
1164 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1165 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1166 {
1167 int32_t faceID = 0;
1168 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1169 (qcamera_sm_evt_reg_face_payload_t *)payload;
1170 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1171 reg_payload->config,
1172 faceID);
1173 result.status = rc;
1174 result.request_api = evt;
1175 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1176 result.handle = faceID;
1177 m_parent->signalAPIResult(&result);
1178 }
1179 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1180 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1181 case QCAMERA_SM_EVT_STOP_RECORDING:
1182 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1183 case QCAMERA_SM_EVT_RELEASE:
1184 {
1185 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1186 rc = INVALID_OPERATION;
1187 result.status = rc;
1188 result.request_api = evt;
1189 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1190 m_parent->signalAPIResult(&result);
1191 }
1192 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1193 case QCAMERA_SM_EVT_EVT_INTERNAL:
1194 {
1195 qcamera_sm_internal_evt_payload_t *internal_evt =
1196 (qcamera_sm_internal_evt_payload_t *)payload;
1197 switch (internal_evt->evt_type) {
1198 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1199 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1200 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1201 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
1202 break;
1203 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
1204 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
1205 break;
1206 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
1207 rc = m_parent->processHistogramStats(internal_evt->stats_data);
1208 break;
1209 case QCAMERA_INTERNAL_EVT_CROP_INFO:
1210 rc = m_parent->processZoomEvent(internal_evt->crop_data);
1211 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]1212 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
1213 rc = m_parent->processASDUpdate(internal_evt->asd_data);
1214 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1215 default:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1216 ALOGE("%s: Invalid internal event %d in state(%d)",
1217 __func__, internal_evt->evt_type, m_state);
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1218 break;
1219 }
1220 }
1221 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1222 case QCAMERA_SM_EVT_EVT_NOTIFY:
1223 {
1224 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1225 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1226 case CAM_EVENT_TYPE_DAEMON_DIED:
1227 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1228 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
1229 CAMERA_ERROR_SERVER_DIED,
1230 0);
1231 }
1232 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1233 default:
1234 ALOGD("%s: no handling for server evt (%d) at this state",
1235 __func__, cam_evt->server_event_type);
1236 break;
1237 }
1238 }
1239 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1240 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1241 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]1242 rc = m_parent->updateThermalLevel(
1243 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1244 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1245 break;
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1246 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]1247 {
1248 // No ops, but need to notify
1249 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1250 result.status = rc;
1251 result.request_api = evt;
1252 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1253 m_parent->signalEvtResult(&result);
1254 }
1255 break;
1256 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1257 default:
1258 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1259 break;
1260 }
1261
1262 return rc;
1263}
1264
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1265/*===========================================================================
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1266 * FUNCTION : procEvtPrepareSnapshotState
1267 *
1268 * DESCRIPTION: finite state machine function to handle event in state of
1269 * QCAMERA_SM_STATE_PREPARE_SNAPSHOT.
1270 *
1271 * PARAMETERS :
1272 * @evt : event to be processed
1273 * @payload : event payload. Can be NULL if not needed.
1274 *
1275 * RETURN : int32_t type of status
1276 * NO_ERROR -- success
1277 * none-zero failure code
1278 *==========================================================================*/
1279int32_t QCameraStateMachine::procEvtPrepareSnapshotState(qcamera_sm_evt_enum_t evt,
1280 void *payload)
1281{
1282 int32_t rc = NO_ERROR;
1283 qcamera_api_result_t result;
1284 memset(&result, 0, sizeof(qcamera_api_result_t));
1285
1286 switch (evt) {
1287 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1288 case QCAMERA_SM_EVT_SET_CALLBACKS:
1289 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1290 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1291 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1292 case QCAMERA_SM_EVT_SET_PARAMS:
1293 case QCAMERA_SM_EVT_GET_PARAMS:
1294 case QCAMERA_SM_EVT_PUT_PARAMS:
1295 case QCAMERA_SM_EVT_START_PREVIEW:
1296 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1297 case QCAMERA_SM_EVT_STOP_PREVIEW:
1298 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1299 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1300 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1301 case QCAMERA_SM_EVT_DUMP:
1302 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1303 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1304 case QCAMERA_SM_EVT_START_RECORDING:
1305 case QCAMERA_SM_EVT_TAKE_PICTURE:
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1306 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1307 case QCAMERA_SM_EVT_SEND_COMMAND:
1308 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1309 case QCAMERA_SM_EVT_STOP_RECORDING:
1310 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1311 case QCAMERA_SM_EVT_RELEASE:
1312 {
1313 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1314 rc = INVALID_OPERATION;
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_EVT_INTERNAL:
1322 {
1323 qcamera_sm_internal_evt_payload_t *internal_evt =
1324 (qcamera_sm_internal_evt_payload_t *)payload;
1325 switch (internal_evt->evt_type) {
Muhua Li6f3c5322013-05-08 17:20:17 -0700[diff] [blame]1326 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1327 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1328 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1329 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
1330 ALOGI("%s: Received QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE event",
1331 __func__);
1332 m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state);
1333 m_state = QCAMERA_SM_STATE_PREVIEWING;
1334
1335 result.status = NO_ERROR;
1336 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT;
1337 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1338 m_parent->signalAPIResult(&result);
1339 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1340 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
1341 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
1342 break;
1343 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
1344 rc = m_parent->processHistogramStats(internal_evt->stats_data);
1345 break;
1346 case QCAMERA_INTERNAL_EVT_CROP_INFO:
1347 rc = m_parent->processZoomEvent(internal_evt->crop_data);
1348 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]1349 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
1350 rc = m_parent->processASDUpdate(internal_evt->asd_data);
1351 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1352 default:
1353 ALOGE("%s: Invalid internal event %d in state(%d)",
1354 __func__, internal_evt->evt_type, m_state);
1355 break;
1356 }
1357 }
1358 break;
1359 case QCAMERA_SM_EVT_EVT_NOTIFY:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1360 {
1361 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1362 switch (cam_evt->server_event_type) {
1363 case CAM_EVENT_TYPE_DAEMON_DIED:
1364 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1365 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
1366 CAMERA_ERROR_SERVER_DIED,
1367 0);
1368 }
1369 break;
1370 default:
1371 ALOGE("%s: Invalid internal event %d in state(%d)",
1372 __func__, cam_evt->server_event_type, m_state);
1373 break;
1374 }
1375 }
1376 break;
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]1377 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1378 {
1379 // No ops, but need to notify
1380 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1381 result.status = rc;
1382 result.request_api = evt;
1383 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1384 m_parent->signalEvtResult(&result);
1385 }
1386 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1387 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
1388 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1389 default:
1390 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1391 break;
1392 }
1393
1394 return rc;
1395}
1396
1397/*===========================================================================
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1398 * FUNCTION : procEvtPicTakingState
1399 *
1400 * DESCRIPTION: finite state machine function to handle event in state of
1401 * QCAMERA_SM_STATE_PIC_TAKING.
1402 *
1403 * PARAMETERS :
1404 * @evt : event to be processed
1405 * @payload : event payload. Can be NULL if not needed.
1406 *
1407 * RETURN : int32_t type of status
1408 * NO_ERROR -- success
1409 * none-zero failure code
1410 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1411int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt,
1412 void *payload)
1413{
1414 int32_t rc = NO_ERROR;
1415 qcamera_api_result_t result;
1416 memset(&result, 0, sizeof(qcamera_api_result_t));
1417
1418 switch (evt) {
1419 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1420 {
1421 // Error setting preview window during previewing
1422 ALOGE("Cannot set preview window when preview is running");
1423 rc = INVALID_OPERATION;
1424 result.status = rc;
1425 result.request_api = evt;
1426 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1427 m_parent->signalAPIResult(&result);
1428 }
1429 break;
1430 case QCAMERA_SM_EVT_SET_CALLBACKS:
1431 {
1432 qcamera_sm_evt_setcb_payload_t *setcbs =
1433 (qcamera_sm_evt_setcb_payload_t *)payload;
1434 rc = m_parent->setCallBacks(setcbs->notify_cb,
1435 setcbs->data_cb,
1436 setcbs->data_cb_timestamp,
1437 setcbs->get_memory,
1438 setcbs->user);
1439 result.status = rc;
1440 result.request_api = evt;
1441 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1442 m_parent->signalAPIResult(&result);
1443 }
1444 break;
1445 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1446 {
1447 rc = m_parent->enableMsgType(int32_t(payload));
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;
1454 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1455 {
1456 rc = m_parent->disableMsgType(int32_t(payload));
1457 result.status = rc;
1458 result.request_api = evt;
1459 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1460 m_parent->signalAPIResult(&result);
1461 }
1462 break;
1463 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1464 {
1465 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1466 result.status = rc;
1467 result.request_api = evt;
1468 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1469 result.enabled = enabled;
1470 m_parent->signalAPIResult(&result);
1471 }
1472 break;
1473 case QCAMERA_SM_EVT_SET_PARAMS:
1474 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1475 bool needRestart = false;
1476 rc = m_parent->updateParameters((char*)payload, needRestart);
1477 if (rc == NO_ERROR) {
1478 rc = m_parent->commitParameterChanges();
1479 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1480 result.status = rc;
1481 result.request_api = evt;
1482 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1483 m_parent->signalAPIResult(&result);
1484 }
1485 break;
1486 case QCAMERA_SM_EVT_GET_PARAMS:
1487 {
1488 result.params = m_parent->getParameters();
1489 rc = NO_ERROR;
1490 result.status = rc;
1491 result.request_api = evt;
1492 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1493 m_parent->signalAPIResult(&result);
1494 }
1495 break;
1496 case QCAMERA_SM_EVT_PUT_PARAMS:
1497 {
1498 rc = m_parent->putParameters((char*)payload);
1499 result.status = rc;
1500 result.request_api = evt;
1501 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1502 m_parent->signalAPIResult(&result);
1503 }
1504 break;
1505 case QCAMERA_SM_EVT_STOP_PREVIEW:
1506 {
Muhua Libd1b6122013-03-05 15:25:27 -0800[diff] [blame]1507 // cancel picture first
1508 rc = m_parent->cancelPicture();
1509 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1510
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1511 result.status = rc;
1512 result.request_api = evt;
1513 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1514 m_parent->signalAPIResult(&result);
1515 }
1516 break;
1517 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1518 {
1519 rc = NO_ERROR;
1520 result.status = rc;
1521 result.request_api = evt;
1522 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1523 result.enabled = 0;
1524 m_parent->signalAPIResult(&result);
1525 }
1526 break;
1527 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1528 {
1529 rc = NO_ERROR;
1530 result.status = rc;
1531 result.request_api = evt;
1532 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1533 result.enabled = 0;
1534 m_parent->signalAPIResult(&result);
1535 }
1536 break;
1537 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1538 {
1539 rc = m_parent->storeMetaDataInBuffers(int(payload));
1540 result.status = rc;
1541 result.request_api = evt;
1542 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1543 m_parent->signalAPIResult(&result);
1544 }
1545 break;
1546 case QCAMERA_SM_EVT_DUMP:
1547 {
1548 rc = m_parent->dump((int)payload);
1549 result.status = rc;
1550 result.request_api = evt;
1551 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1552 m_parent->signalAPIResult(&result);
1553 }
1554 break;
1555 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1556 {
1557 rc = m_parent->autoFocus();
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_STOP_AUTO_FOCUS:
1565 {
1566 rc = m_parent->cancelAutoFocus();
1567 result.status = rc;
1568 result.request_api = evt;
1569 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1570 m_parent->signalAPIResult(&result);
1571 }
1572 break;
1573 case QCAMERA_SM_EVT_SEND_COMMAND:
1574 {
1575 qcamera_sm_evt_command_payload_t *cmd_payload =
1576 (qcamera_sm_evt_command_payload_t *)payload;
1577 rc = m_parent->sendCommand(cmd_payload->cmd,
1578 cmd_payload->arg1,
1579 cmd_payload->arg2);
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]1580 if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) {
1581 // move state to previewing state
1582 m_state = QCAMERA_SM_STATE_PREVIEWING;
1583 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]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_CANCEL_PICTURE:
1591 {
1592 rc = m_parent->cancelPicture();
1593 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1594 result.status = rc;
1595 result.request_api = evt;
1596 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1597 m_parent->signalAPIResult(&result);
1598 }
1599 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1600 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1601 {
1602 int32_t faceID = 0;
1603 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1604 (qcamera_sm_evt_reg_face_payload_t *)payload;
1605 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1606 reg_payload->config,
1607 faceID);
1608 result.status = rc;
1609 result.request_api = evt;
1610 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1611 result.handle = faceID;
1612 m_parent->signalAPIResult(&result);
1613 }
1614 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1615 case QCAMERA_SM_EVT_TAKE_PICTURE:
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]1616 {
1617 if ( m_parent->isLongshotEnabled() ) {
1618 rc = m_parent->longShot();
1619 } else {
1620 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1621 rc = INVALID_OPERATION;
1622 }
1623
1624 result.status = rc;
1625 result.request_api = evt;
1626 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1627 m_parent->signalAPIResult(&result);
1628 }
1629 break;
1630 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1631 case QCAMERA_SM_EVT_START_RECORDING:
1632 case QCAMERA_SM_EVT_STOP_RECORDING:
1633 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1634 case QCAMERA_SM_EVT_START_PREVIEW:
1635 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1636 case QCAMERA_SM_EVT_RELEASE:
1637 {
1638 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1639 rc = INVALID_OPERATION;
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;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1646 case QCAMERA_SM_EVT_EVT_INTERNAL:
1647 {
1648 qcamera_sm_internal_evt_payload_t *internal_evt =
1649 (qcamera_sm_internal_evt_payload_t *)payload;
1650 switch (internal_evt->evt_type) {
1651 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1652 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1653 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1654 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
1655 break;
1656 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
1657 break;
1658 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
1659 break;
1660 case QCAMERA_INTERNAL_EVT_CROP_INFO:
1661 rc = m_parent->processZoomEvent(internal_evt->crop_data);
1662 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]1663 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
1664 rc = m_parent->processASDUpdate(internal_evt->asd_data);
1665 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1666 default:
1667 break;
1668 }
1669 }
1670 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1671 case QCAMERA_SM_EVT_EVT_NOTIFY:
1672 {
1673 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1674 switch (cam_evt->server_event_type) {
Emilian Peev9c53a9e2013-12-12 15:58:13 +0200[diff] [blame]1675 case CAM_EVENT_TYPE_REPROCESS_STAGE_DONE:
1676 {
1677 if ( m_parent->isLongshotEnabled() ) {
1678 if(!m_parent->m_postprocessor.getMultipleStages()) {
1679 m_parent->m_postprocessor.setMultipleStages(true);
1680 }
1681 m_parent->playShutter();
1682 }
1683 }
1684 break;
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1685 case CAM_EVENT_TYPE_DAEMON_DIED:
1686 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1687 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
1688 CAMERA_ERROR_SERVER_DIED,
1689 0);
1690 }
1691 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1692 default:
1693 ALOGD("%s: no handling for server evt (%d) at this state",
1694 __func__, cam_evt->server_event_type);
1695 break;
1696 }
1697 }
1698 break;
1699 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1700 {
1701 qcamera_jpeg_evt_payload_t *jpeg_job =
1702 (qcamera_jpeg_evt_payload_t *)payload;
1703 rc = m_parent->processJpegNotify(jpeg_job);
1704 }
1705 break;
Emilian Peev7d36a812013-11-20 00:15:54 -0800[diff] [blame]1706 case QCAMERA_SM_EVT_STOP_CAPTURE_CHANNEL:
1707 {
Emilian Peev8a977232013-11-04 07:56:32 -0800[diff] [blame]1708 bool restartPreview = m_parent->isPreviewRestartEnabled();
1709 rc = m_parent->stopCaptureChannel(restartPreview);
1710
1711 if (restartPreview && (NO_ERROR == rc)) {
1712 rc = m_parent->preparePreview();
1713 if (NO_ERROR == rc) {
1714 m_parent->m_bPreviewStarted = true;
1715 rc = m_parent->startPreview();
1716 }
1717 }
1718
Emilian Peev7d36a812013-11-20 00:15:54 -0800[diff] [blame]1719 result.status = rc;
1720 result.request_api = evt;
1721 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1722 m_parent->signalAPIResult(&result);
1723 }
1724 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1725 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1726 {
1727 rc = m_parent->cancelPicture();
Emilian Peev8a977232013-11-04 07:56:32 -0800[diff] [blame]1728
1729 bool restartPreview = m_parent->isPreviewRestartEnabled();
1730 if (restartPreview) {
1731 m_state = QCAMERA_SM_STATE_PREVIEWING;
1732 } else {
1733 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1734 }
1735
Emilian Peev6d90c1f2013-04-12 09:33:06 +0300[diff] [blame]1736 result.status = rc;
1737 result.request_api = evt;
1738 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1739 m_parent->signalEvtResult(&result);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1740 }
1741 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1742 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peev2ae455e2013-04-18 10:41:56 +0300[diff] [blame]1743 {
1744 rc = m_parent->updateThermalLevel(
1745 *(qcamera_thermal_level_enum_t *)&payload);
1746 }
1747 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1748 default:
1749 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1750 break;
1751 }
1752
1753 return rc;
1754}
1755
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1756/*===========================================================================
1757 * FUNCTION : procEvtRecordingState
1758 *
1759 * DESCRIPTION: finite state machine function to handle event in state of
1760 * QCAMERA_SM_STATE_RECORDING.
1761 *
1762 * PARAMETERS :
1763 * @evt : event to be processed
1764 * @payload : event payload. Can be NULL if not needed.
1765 *
1766 * RETURN : int32_t type of status
1767 * NO_ERROR -- success
1768 * none-zero failure code
1769 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1770int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt,
1771 void *payload)
1772{
1773 int32_t rc = NO_ERROR;
1774 qcamera_api_result_t result;
1775 memset(&result, 0, sizeof(qcamera_api_result_t));
1776
1777 switch (evt) {
Emilian Peev88293e92013-06-07 12:37:18 +0300[diff] [blame]1778 case QCAMERA_SM_EVT_START_PREVIEW:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1779 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1780 {
Emilian Peev88293e92013-06-07 12:37:18 +0300[diff] [blame]1781 // WA: CTS test VideoSnapshot will try to
1782 // start preview during video recording.
1783 ALOGE("CTS video restart op");
1784 rc = NO_ERROR;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1785 result.status = rc;
1786 result.request_api = evt;
1787 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1788 m_parent->signalAPIResult(&result);
1789 }
1790 break;
1791 case QCAMERA_SM_EVT_SET_CALLBACKS:
1792 {
1793 qcamera_sm_evt_setcb_payload_t *setcbs =
1794 (qcamera_sm_evt_setcb_payload_t *)payload;
1795 rc = m_parent->setCallBacks(setcbs->notify_cb,
1796 setcbs->data_cb,
1797 setcbs->data_cb_timestamp,
1798 setcbs->get_memory,
1799 setcbs->user);
1800 result.status = rc;
1801 result.request_api = evt;
1802 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1803 m_parent->signalAPIResult(&result);
1804 }
1805 break;
1806 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1807 {
1808 rc = m_parent->enableMsgType(int32_t(payload));
1809 result.status = rc;
1810 result.request_api = evt;
1811 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1812 m_parent->signalAPIResult(&result);
1813 }
1814 break;
1815 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1816 {
1817 rc = m_parent->disableMsgType(int32_t(payload));
1818 result.status = rc;
1819 result.request_api = evt;
1820 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1821 m_parent->signalAPIResult(&result);
1822 }
1823 break;
1824 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1825 {
1826 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1827 result.status = rc;
1828 result.request_api = evt;
1829 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1830 result.enabled = enabled;
1831 m_parent->signalAPIResult(&result);
1832 }
1833 break;
1834 case QCAMERA_SM_EVT_SET_PARAMS:
1835 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1836 bool needRestart = false;
1837 rc = m_parent->updateParameters((char*)payload, needRestart);
1838 if (rc == NO_ERROR) {
1839 if (needRestart) {
1840 // cannot set parameters that requires restart during recording
1841 ALOGE("%s: Cannot set parameters that requires restart during recording",
1842 __func__);
1843 rc = BAD_VALUE;
1844 } else {
1845 rc = m_parent->commitParameterChanges();
1846 }
1847 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1848 result.status = rc;
1849 result.request_api = evt;
1850 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1851 m_parent->signalAPIResult(&result);
1852 }
1853 break;
1854 case QCAMERA_SM_EVT_GET_PARAMS:
1855 {
1856 result.params = m_parent->getParameters();
1857 rc = NO_ERROR;
1858 result.status = rc;
1859 result.request_api = evt;
1860 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1861 m_parent->signalAPIResult(&result);
1862 }
1863 break;
1864 case QCAMERA_SM_EVT_PUT_PARAMS:
1865 {
1866 rc = m_parent->putParameters((char*)payload);
1867 result.status = rc;
1868 result.request_api = evt;
1869 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1870 m_parent->signalAPIResult(&result);
1871 }
1872 break;
1873 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1874 {
1875 rc = NO_ERROR;
1876 result.status = rc;
1877 result.request_api = evt;
1878 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1879 result.enabled = 0;
1880 m_parent->signalAPIResult(&result);
1881 }
1882 break;
1883 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1884 {
1885 rc = NO_ERROR;
1886 result.status = rc;
1887 result.request_api = evt;
1888 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1889 result.enabled = 1;
1890 m_parent->signalAPIResult(&result);
1891 }
1892 break;
1893 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1894 {
1895 rc = m_parent->storeMetaDataInBuffers(int(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_DUMP:
1903 {
1904 rc = m_parent->dump((int)payload);
1905 result.status = rc;
1906 result.request_api = evt;
1907 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1908 m_parent->signalAPIResult(&result);
1909 }
1910 break;
1911 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1912 {
1913 rc = m_parent->autoFocus();
1914 result.status = rc;
1915 result.request_api = evt;
1916 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1917 m_parent->signalAPIResult(&result);
1918 }
1919 break;
1920 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1921 {
1922 rc = m_parent->cancelAutoFocus();
1923 result.status = rc;
1924 result.request_api = evt;
1925 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1926 m_parent->signalAPIResult(&result);
1927 }
1928 break;
1929 case QCAMERA_SM_EVT_SEND_COMMAND:
1930 {
1931 qcamera_sm_evt_command_payload_t *cmd_payload =
1932 (qcamera_sm_evt_command_payload_t *)payload;
1933 rc = m_parent->sendCommand(cmd_payload->cmd,
1934 cmd_payload->arg1,
1935 cmd_payload->arg2);
1936 result.status = rc;
1937 result.request_api = evt;
1938 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1939 m_parent->signalAPIResult(&result);
1940 }
1941 break;
1942 case QCAMERA_SM_EVT_TAKE_PICTURE:
1943 {
Muhua Li1d0c4772013-02-22 15:39:45 -0800[diff] [blame]1944 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1945 rc = m_parent->takeLiveSnapshot();
Muhua Li1d0c4772013-02-22 15:39:45 -0800[diff] [blame]1946 if (rc != NO_ERROR) {
1947 m_state = QCAMERA_SM_STATE_RECORDING;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1948 }
1949 result.status = rc;
1950 result.request_api = evt;
1951 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1952 m_parent->signalAPIResult(&result);
1953 }
1954 break;
1955 case QCAMERA_SM_EVT_START_RECORDING:
1956 {
1957 // no ops here
1958 ALOGD("%s: already in recording state, no ops for start_recording", __func__);
1959 rc = 0;
1960 result.status = rc;
1961 result.request_api = evt;
1962 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1963 m_parent->signalAPIResult(&result);
1964 }
1965 break;
1966 case QCAMERA_SM_EVT_STOP_RECORDING:
1967 {
1968 rc = m_parent->stopRecording();
1969 m_state = QCAMERA_SM_STATE_PREVIEWING;
1970 result.status = rc;
1971 result.request_api = evt;
1972 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1973 m_parent->signalAPIResult(&result);
1974 }
1975 break;
Emilian Peevf392f172013-05-13 16:29:53 -0700[diff] [blame]1976 case QCAMERA_SM_EVT_STOP_PREVIEW:
1977 {
1978 rc = m_parent->stopRecording();
1979 m_state = QCAMERA_SM_STATE_PREVIEWING;
1980
1981 rc = m_parent->stopPreview();
1982 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1983
1984 result.status = rc;
1985 result.request_api = evt;
1986 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1987 m_parent->signalAPIResult(&result);
1988 }
1989 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1990 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1991 {
1992 rc = m_parent->releaseRecordingFrame((const void *)payload);
1993 result.status = rc;
1994 result.request_api = evt;
1995 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1996 m_parent->signalAPIResult(&result);
1997 }
1998 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1999 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
2000 {
2001 int32_t faceID = 0;
2002 qcamera_sm_evt_reg_face_payload_t *reg_payload =
2003 (qcamera_sm_evt_reg_face_payload_t *)payload;
2004 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
2005 reg_payload->config,
2006 faceID);
2007 result.status = rc;
2008 result.request_api = evt;
2009 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2010 result.handle = faceID;
2011 m_parent->signalAPIResult(&result);
2012 }
2013 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]2014 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
2015 {
2016 //In Video snapshot, prepare hardware is a no-op.
2017 result.status = NO_ERROR;
2018 result.request_api = evt;
2019 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2020 m_parent->signalAPIResult(&result);
2021 }
2022 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2023 case QCAMERA_SM_EVT_CANCEL_PICTURE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2024 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2025 case QCAMERA_SM_EVT_RELEASE:
2026 {
2027 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2028 rc = INVALID_OPERATION;
2029 result.status = rc;
2030 result.request_api = evt;
2031 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2032 m_parent->signalAPIResult(&result);
2033 }
2034 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2035 case QCAMERA_SM_EVT_EVT_INTERNAL:
2036 {
2037 qcamera_sm_internal_evt_payload_t *internal_evt =
2038 (qcamera_sm_internal_evt_payload_t *)payload;
2039 switch (internal_evt->evt_type) {
2040 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2041 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2042 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2043 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
2044 break;
2045 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
2046 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
2047 break;
2048 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
2049 rc = m_parent->processHistogramStats(internal_evt->stats_data);
2050 break;
2051 case QCAMERA_INTERNAL_EVT_CROP_INFO:
2052 rc = m_parent->processZoomEvent(internal_evt->crop_data);
2053 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]2054 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
2055 rc = m_parent->processASDUpdate(internal_evt->asd_data);
2056 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2057 default:
2058 break;
2059 }
2060 }
2061 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2062 case QCAMERA_SM_EVT_EVT_NOTIFY:
2063 {
2064 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2065 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2066 case CAM_EVENT_TYPE_DAEMON_DIED:
2067 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2068 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
2069 CAMERA_ERROR_SERVER_DIED,
2070 0);
2071 }
2072 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2073 default:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2074 ALOGE("%s: Invalid internal event %d in state(%d)",
2075 __func__, cam_evt->server_event_type, m_state);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2076 break;
2077 }
2078 }
2079 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2080 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2081 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2082 rc = m_parent->updateThermalLevel(
2083 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2084 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2085 break;
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2086 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]2087 {
2088 // No ops, but need to notify
2089 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2090 result.status = rc;
2091 result.request_api = evt;
2092 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2093 m_parent->signalEvtResult(&result);
2094 }
2095 break;
2096 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2097 default:
2098 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2099 break;
2100 }
2101
2102 return rc;
2103}
2104
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2105/*===========================================================================
2106 * FUNCTION : procEvtVideoPicTakingState
2107 *
2108 * DESCRIPTION: finite state machine function to handle event in state of
2109 * QCAMERA_SM_STATE_VIDEO_PIC_TAKING.
2110 *
2111 * PARAMETERS :
2112 * @evt : event to be processed
2113 * @payload : event payload. Can be NULL if not needed.
2114 *
2115 * RETURN : int32_t type of status
2116 * NO_ERROR -- success
2117 * none-zero failure code
2118 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2119int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt,
2120 void *payload)
2121{
2122 int32_t rc = NO_ERROR;
2123 qcamera_api_result_t result;
2124 memset(&result, 0, sizeof(qcamera_api_result_t));
2125
2126 switch (evt) {
2127 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
2128 {
2129 // Error setting preview window during previewing
2130 ALOGE("Cannot set preview window when preview is running");
2131 rc = INVALID_OPERATION;
2132 result.status = rc;
2133 result.request_api = evt;
2134 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2135 m_parent->signalAPIResult(&result);
2136 }
2137 break;
2138 case QCAMERA_SM_EVT_SET_CALLBACKS:
2139 {
2140 qcamera_sm_evt_setcb_payload_t *setcbs =
2141 (qcamera_sm_evt_setcb_payload_t *)payload;
2142 rc = m_parent->setCallBacks(setcbs->notify_cb,
2143 setcbs->data_cb,
2144 setcbs->data_cb_timestamp,
2145 setcbs->get_memory,
2146 setcbs->user);
2147 result.status = rc;
2148 result.request_api = evt;
2149 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2150 m_parent->signalAPIResult(&result);
2151 }
2152 break;
2153 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
2154 {
2155 rc = m_parent->enableMsgType(int32_t(payload));
2156 result.status = rc;
2157 result.request_api = evt;
2158 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2159 m_parent->signalAPIResult(&result);
2160 }
2161 break;
2162 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
2163 {
2164 rc = m_parent->disableMsgType(int32_t(payload));
2165 result.status = rc;
2166 result.request_api = evt;
2167 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2168 m_parent->signalAPIResult(&result);
2169 }
2170 break;
2171 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
2172 {
2173 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
2174 result.status = rc;
2175 result.request_api = evt;
2176 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2177 result.enabled = enabled;
2178 m_parent->signalAPIResult(&result);
2179 }
2180 break;
2181 case QCAMERA_SM_EVT_SET_PARAMS:
2182 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2183 bool needRestart = false;
2184 rc = m_parent->updateParameters((char*)payload, needRestart);
2185 if (rc == NO_ERROR) {
2186 if (needRestart) {
2187 // cannot set parameters that requires restart during recording
2188 ALOGE("%s: Cannot set parameters that requires restart during recording",
2189 __func__);
2190 rc = BAD_VALUE;
2191 } else {
2192 rc = m_parent->commitParameterChanges();
2193 }
2194 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2195 result.status = rc;
2196 result.request_api = evt;
2197 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2198 m_parent->signalAPIResult(&result);
2199 }
2200 break;
2201 case QCAMERA_SM_EVT_GET_PARAMS:
2202 {
2203 result.params = m_parent->getParameters();
2204 rc = NO_ERROR;
2205 result.status = rc;
2206 result.request_api = evt;
2207 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
2208 m_parent->signalAPIResult(&result);
2209 }
2210 break;
2211 case QCAMERA_SM_EVT_PUT_PARAMS:
2212 {
2213 rc = m_parent->putParameters((char*)payload);
2214 result.status = rc;
2215 result.request_api = evt;
2216 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2217 m_parent->signalAPIResult(&result);
2218 }
2219 break;
2220 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
2221 {
2222 rc = NO_ERROR;
2223 result.status = rc;
2224 result.request_api = evt;
2225 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2226 result.enabled = 1;
2227 m_parent->signalAPIResult(&result);
2228 }
2229 break;
2230 case QCAMERA_SM_EVT_RECORDING_ENABLED:
2231 {
2232 rc = NO_ERROR;
2233 result.status = rc;
2234 result.request_api = evt;
2235 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2236 result.enabled = 1;
2237 m_parent->signalAPIResult(&result);
2238 }
2239 break;
2240 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
2241 {
2242 rc = m_parent->storeMetaDataInBuffers(int(payload));
2243 result.status = rc;
2244 result.request_api = evt;
2245 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2246 m_parent->signalAPIResult(&result);
2247 }
2248 break;
2249 case QCAMERA_SM_EVT_DUMP:
2250 {
2251 rc = m_parent->dump((int)payload);
2252 result.status = rc;
2253 result.request_api = evt;
2254 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2255 m_parent->signalAPIResult(&result);
2256 }
2257 break;
2258 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
2259 {
2260 rc = m_parent->autoFocus();
2261 result.status = rc;
2262 result.request_api = evt;
2263 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2264 m_parent->signalAPIResult(&result);
2265 }
2266 break;
2267 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
2268 {
2269 rc = m_parent->cancelAutoFocus();
2270 result.status = rc;
2271 result.request_api = evt;
2272 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2273 m_parent->signalAPIResult(&result);
2274 }
2275 break;
2276 case QCAMERA_SM_EVT_SEND_COMMAND:
2277 {
2278 qcamera_sm_evt_command_payload_t *cmd_payload =
2279 (qcamera_sm_evt_command_payload_t *)payload;
2280 rc = m_parent->sendCommand(cmd_payload->cmd,
2281 cmd_payload->arg1,
2282 cmd_payload->arg2);
2283 result.status = rc;
2284 result.request_api = evt;
2285 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2286 m_parent->signalAPIResult(&result);
2287 }
2288 break;
2289 case QCAMERA_SM_EVT_STOP_RECORDING:
2290 {
Sai Kumar Sanagavarapud972ac12014-01-07 14:23:52 +0530[diff] [blame^]2291 rc = m_parent->cancelLiveSnapshot();
2292 m_state = QCAMERA_SM_STATE_RECORDING;
2293
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2294 rc = m_parent->stopRecording();
Sai Kumar Sanagavarapud972ac12014-01-07 14:23:52 +0530[diff] [blame^]2295 m_state = QCAMERA_SM_STATE_PREVIEWING;
2296
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2297 result.status = rc;
2298 result.request_api = evt;
2299 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2300 m_parent->signalAPIResult(&result);
2301 }
2302 break;
2303 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2304 {
2305 rc = m_parent->releaseRecordingFrame((const void *)payload);
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_CANCEL_PICTURE:
2313 {
2314 rc = m_parent->cancelLiveSnapshot();
2315 m_state = QCAMERA_SM_STATE_RECORDING;
2316 result.status = rc;
2317 result.request_api = evt;
2318 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2319 m_parent->signalAPIResult(&result);
2320 }
2321 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]2322 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
2323 {
2324 int32_t faceID = 0;
2325 qcamera_sm_evt_reg_face_payload_t *reg_payload =
2326 (qcamera_sm_evt_reg_face_payload_t *)payload;
2327 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
2328 reg_payload->config,
2329 faceID);
2330 result.status = rc;
2331 result.request_api = evt;
2332 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2333 result.handle = faceID;
2334 m_parent->signalAPIResult(&result);
2335 }
2336 break;
Emilian Peevf392f172013-05-13 16:29:53 -0700[diff] [blame]2337 case QCAMERA_SM_EVT_STOP_PREVIEW:
2338 {
2339 rc = m_parent->cancelLiveSnapshot();
2340 m_state = QCAMERA_SM_STATE_RECORDING;
2341
2342 rc = m_parent->stopRecording();
2343 m_state = QCAMERA_SM_STATE_PREVIEWING;
2344
2345 rc = m_parent->stopPreview();
2346 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
2347
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;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2354 case QCAMERA_SM_EVT_START_RECORDING:
2355 case QCAMERA_SM_EVT_START_PREVIEW:
2356 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2357 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2358 case QCAMERA_SM_EVT_TAKE_PICTURE:
2359 case QCAMERA_SM_EVT_RELEASE:
2360 {
2361 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2362 rc = INVALID_OPERATION;
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 Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2369 case QCAMERA_SM_EVT_EVT_INTERNAL:
2370 {
2371 qcamera_sm_internal_evt_payload_t *internal_evt =
2372 (qcamera_sm_internal_evt_payload_t *)payload;
2373 switch (internal_evt->evt_type) {
2374 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2375 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2376 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2377 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
2378 break;
2379 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
2380 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
2381 break;
2382 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
2383 rc = m_parent->processHistogramStats(internal_evt->stats_data);
2384 break;
2385 case QCAMERA_INTERNAL_EVT_CROP_INFO:
2386 rc = m_parent->processZoomEvent(internal_evt->crop_data);
2387 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]2388 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
2389 rc = m_parent->processASDUpdate(internal_evt->asd_data);
2390 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2391 default:
2392 break;
2393 }
2394 }
2395 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2396 case QCAMERA_SM_EVT_EVT_NOTIFY:
2397 {
2398 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2399 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2400 case CAM_EVENT_TYPE_DAEMON_DIED:
2401 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2402 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
2403 CAMERA_ERROR_SERVER_DIED,
2404 0);
2405 }
2406 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2407 default:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2408 ALOGE("%s: Invalid internal event %d in state(%d)",
2409 __func__, cam_evt->server_event_type, m_state);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2410 break;
2411 }
2412 }
2413 break;
2414 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
2415 {
2416 qcamera_jpeg_evt_payload_t *jpeg_job =
2417 (qcamera_jpeg_evt_payload_t *)payload;
2418 rc = m_parent->processJpegNotify(jpeg_job);
2419 }
2420 break;
2421 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
2422 {
2423 rc = m_parent->cancelLiveSnapshot();
2424 m_state = QCAMERA_SM_STATE_RECORDING;
Emilian Peev6d90c1f2013-04-12 09:33:06 +0300[diff] [blame]2425 result.status = rc;
2426 result.request_api = evt;
2427 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2428 m_parent->signalEvtResult(&result);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2429 }
2430 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2431 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2432 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2433 rc = m_parent->updateThermalLevel(
2434 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2435 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2436 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2437 default:
2438 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2439 break;
2440 }
2441
2442 return rc;
2443}
2444
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2445/*===========================================================================
2446 * FUNCTION : procEvtPreviewPicTakingState
2447 *
2448 * DESCRIPTION: finite state machine function to handle event in state of
2449 * QCAMERA_SM_STATE_PREVIEW_PIC_TAKING.
2450 *
2451 * PARAMETERS :
2452 * @evt : event to be processed
2453 * @payload : event payload. Can be NULL if not needed.
2454 *
2455 * RETURN : int32_t type of status
2456 * NO_ERROR -- success
2457 * none-zero failure code
2458 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2459int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt,
2460 void *payload)
2461{
2462 int32_t rc = NO_ERROR;
2463 qcamera_api_result_t result;
2464 memset(&result, 0, sizeof(qcamera_api_result_t));
2465
2466 switch (evt) {
2467 case QCAMERA_SM_EVT_SET_CALLBACKS:
2468 {
2469 qcamera_sm_evt_setcb_payload_t *setcbs =
2470 (qcamera_sm_evt_setcb_payload_t *)payload;
2471 rc = m_parent->setCallBacks(setcbs->notify_cb,
2472 setcbs->data_cb,
2473 setcbs->data_cb_timestamp,
2474 setcbs->get_memory,
2475 setcbs->user);
2476 result.status = rc;
2477 result.request_api = evt;
2478 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2479 m_parent->signalAPIResult(&result);
2480 }
2481 break;
2482 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
2483 {
2484 rc = m_parent->enableMsgType(int32_t(payload));
2485 result.status = rc;
2486 result.request_api = evt;
2487 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2488 m_parent->signalAPIResult(&result);
2489 }
2490 break;
2491 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
2492 {
2493 rc = m_parent->disableMsgType(int32_t(payload));
2494 result.status = rc;
2495 result.request_api = evt;
2496 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2497 m_parent->signalAPIResult(&result);
2498 }
2499 break;
2500 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
2501 {
2502 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
2503 result.status = rc;
2504 result.request_api = evt;
2505 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2506 result.enabled = enabled;
2507 m_parent->signalAPIResult(&result);
2508 }
2509 break;
2510 case QCAMERA_SM_EVT_SET_PARAMS:
2511 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2512 bool needRestart = false;
2513 rc = m_parent->updateParameters((char*)payload, needRestart);
2514 if (rc == NO_ERROR) {
2515 if (needRestart) {
2516 // need restart preview for parameters to take effect
2517 // stop preview
2518 m_parent->stopPreview();
Emilian Peev9afd73b2013-10-31 08:19:57 -0700[diff] [blame]2519 // Clear memory pools
2520 m_parent->m_memoryPool.clear();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2521 // commit parameter changes to server
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]2522 m_parent->commitParameterChanges();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2523 // start preview again
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]2524 rc = m_parent->preparePreview();
2525 if (rc == NO_ERROR) {
2526 rc = m_parent->startPreview();
2527 if (rc != NO_ERROR) {
2528 m_parent->unpreparePreview();
2529 }
2530 }
2531 if (rc != NO_ERROR) {
2532 m_state = QCAMERA_SM_STATE_PIC_TAKING;
2533 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2534 } else {
2535 rc = m_parent->commitParameterChanges();
2536 }
2537 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2538 result.status = rc;
2539 result.request_api = evt;
2540 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2541 m_parent->signalAPIResult(&result);
2542 }
2543 break;
2544 case QCAMERA_SM_EVT_GET_PARAMS:
2545 {
2546 result.params = m_parent->getParameters();
2547 rc = NO_ERROR;
2548 result.status = rc;
2549 result.request_api = evt;
2550 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
2551 m_parent->signalAPIResult(&result);
2552 }
2553 break;
2554 case QCAMERA_SM_EVT_PUT_PARAMS:
2555 {
2556 rc = m_parent->putParameters((char*)payload);
2557 result.status = rc;
2558 result.request_api = evt;
2559 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2560 m_parent->signalAPIResult(&result);
2561 }
2562 break;
2563 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
2564 {
2565 rc = NO_ERROR;
2566 result.status = rc;
2567 result.request_api = evt;
2568 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2569 result.enabled = 1;
2570 m_parent->signalAPIResult(&result);
2571 }
2572 break;
2573 case QCAMERA_SM_EVT_RECORDING_ENABLED:
2574 {
2575 rc = NO_ERROR;
2576 result.status = rc;
2577 result.request_api = evt;
2578 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2579 result.enabled = 0;
2580 m_parent->signalAPIResult(&result);
2581 }
2582 break;
2583 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
2584 {
2585 rc = m_parent->storeMetaDataInBuffers(int(payload));
2586 result.status = rc;
2587 result.request_api = evt;
2588 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2589 m_parent->signalAPIResult(&result);
2590 }
2591 break;
2592 case QCAMERA_SM_EVT_DUMP:
2593 {
2594 rc = m_parent->dump((int)payload);
2595 result.status = rc;
2596 result.request_api = evt;
2597 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2598 m_parent->signalAPIResult(&result);
2599 }
2600 break;
2601 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
2602 {
2603 rc = m_parent->autoFocus();
2604 result.status = rc;
2605 result.request_api = evt;
2606 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2607 m_parent->signalAPIResult(&result);
2608 }
2609 break;
2610 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
2611 {
2612 rc = m_parent->cancelAutoFocus();
2613 result.status = rc;
2614 result.request_api = evt;
2615 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2616 m_parent->signalAPIResult(&result);
2617 }
2618 break;
2619 case QCAMERA_SM_EVT_SEND_COMMAND:
2620 {
2621 qcamera_sm_evt_command_payload_t *cmd_payload =
2622 (qcamera_sm_evt_command_payload_t *)payload;
2623 rc = m_parent->sendCommand(cmd_payload->cmd,
2624 cmd_payload->arg1,
2625 cmd_payload->arg2);
Emilian Peeve32d03b2013-08-13 16:15:41 +0300[diff] [blame]2626 if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) {
2627 // move state to previewing state
2628 m_state = QCAMERA_SM_STATE_PREVIEWING;
2629 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2630 result.status = rc;
2631 result.request_api = evt;
2632 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2633 m_parent->signalAPIResult(&result);
2634 }
2635 break;
2636 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2637 {
2638 rc = m_parent->releaseRecordingFrame((const void *)payload);
2639 result.status = rc;
2640 result.request_api = evt;
2641 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2642 m_parent->signalAPIResult(&result);
2643 }
2644 break;
2645 case QCAMERA_SM_EVT_CANCEL_PICTURE:
2646 {
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]2647 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]2648 rc = m_parent->cancelPicture();
2649 } else {
2650 rc = m_parent->cancelLiveSnapshot();
2651 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2652 m_state = QCAMERA_SM_STATE_PREVIEWING;
2653 result.status = rc;
2654 result.request_api = evt;
2655 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2656 m_parent->signalAPIResult(&result);
2657 }
2658 break;
2659 case QCAMERA_SM_EVT_STOP_PREVIEW:
2660 {
Muhua Libd1b6122013-03-05 15:25:27 -0800[diff] [blame]2661 if (m_parent->isZSLMode()) {
2662 // cancel picture first
2663 rc = m_parent->cancelPicture();
2664 m_parent->stopChannel(QCAMERA_CH_TYPE_ZSL);
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]2665 } else if (m_parent->isLongshotEnabled()) {
2666 // just cancel picture
2667 rc = m_parent->cancelPicture();
Muhua Libd1b6122013-03-05 15:25:27 -0800[diff] [blame]2668 } else {
2669 rc = m_parent->cancelLiveSnapshot();
2670 m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW);
2671 }
2672 // unprepare preview
2673 m_parent->unpreparePreview();
2674 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2675 result.status = rc;
2676 result.request_api = evt;
2677 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2678 m_parent->signalAPIResult(&result);
2679 }
2680 break;
2681 case QCAMERA_SM_EVT_START_RECORDING:
2682 {
Muhua Licf1cf672013-05-10 09:42:50 -0700[diff] [blame]2683 if (m_parent->isZSLMode()) {
2684 ALOGE("%s: cannot handle evt(%d) in state(%d) in ZSL mode",
2685 __func__, evt, m_state);
2686 rc = INVALID_OPERATION;
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]2687 } else if (m_parent->isLongshotEnabled()) {
2688 ALOGE("%s: cannot handle evt(%d) in state(%d) in Longshot mode",
2689 __func__, evt, m_state);
2690 rc = INVALID_OPERATION;
Muhua Licf1cf672013-05-10 09:42:50 -0700[diff] [blame]2691 } else {
2692 rc = m_parent->startRecording();
2693 if (rc == NO_ERROR) {
2694 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
2695 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2696 }
2697 result.status = rc;
2698 result.request_api = evt;
2699 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2700 m_parent->signalAPIResult(&result);
2701 }
2702 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]2703 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
2704 {
2705 int32_t faceID = 0;
2706 qcamera_sm_evt_reg_face_payload_t *reg_payload =
2707 (qcamera_sm_evt_reg_face_payload_t *)payload;
2708 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
2709 reg_payload->config,
2710 faceID);
2711 result.status = rc;
2712 result.request_api = evt;
2713 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2714 result.handle = faceID;
2715 m_parent->signalAPIResult(&result);
2716 }
2717 break;
Emilian Peeve32d03b2013-08-13 16:15:41 +0300[diff] [blame]2718 case QCAMERA_SM_EVT_TAKE_PICTURE:
2719 {
2720 if ( m_parent->isLongshotEnabled() ) {
2721 rc = m_parent->longShot();
2722 } else {
2723 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2724 rc = INVALID_OPERATION;
2725 }
2726
2727 result.status = rc;
2728 result.request_api = evt;
2729 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2730 m_parent->signalAPIResult(&result);
2731 }
2732 break;
2733 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2734 case QCAMERA_SM_EVT_STOP_RECORDING:
2735 case QCAMERA_SM_EVT_START_PREVIEW:
2736 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2737 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
2738 case QCAMERA_SM_EVT_RELEASE:
2739 {
2740 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2741 rc = INVALID_OPERATION;
2742 result.status = rc;
2743 result.request_api = evt;
2744 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2745 m_parent->signalAPIResult(&result);
2746 }
2747 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2748 case QCAMERA_SM_EVT_EVT_INTERNAL:
2749 {
2750 qcamera_sm_internal_evt_payload_t *internal_evt =
2751 (qcamera_sm_internal_evt_payload_t *)payload;
2752 switch (internal_evt->evt_type) {
2753 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2754 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2755 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2756 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
2757 break;
2758 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
2759 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
2760 break;
2761 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
2762 rc = m_parent->processHistogramStats(internal_evt->stats_data);
2763 break;
2764 case QCAMERA_INTERNAL_EVT_CROP_INFO:
2765 rc = m_parent->processZoomEvent(internal_evt->crop_data);
2766 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]2767 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
2768 rc = m_parent->processASDUpdate(internal_evt->asd_data);
2769 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2770 default:
2771 break;
2772 }
2773 }
2774 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2775 case QCAMERA_SM_EVT_EVT_NOTIFY:
2776 {
2777 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2778 switch (cam_evt->server_event_type) {
Emilian Peev9c53a9e2013-12-12 15:58:13 +0200[diff] [blame]2779 case CAM_EVENT_TYPE_REPROCESS_STAGE_DONE:
2780 {
2781 if ( m_parent->isLongshotEnabled() ) {
2782 if(!m_parent->m_postprocessor.getMultipleStages()) {
2783 m_parent->m_postprocessor.setMultipleStages(true);
2784 }
2785 m_parent->playShutter();
2786 }
2787 }
2788 break;
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2789 case CAM_EVENT_TYPE_DAEMON_DIED:
2790 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2791 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
2792 CAMERA_ERROR_SERVER_DIED,
2793 0);
2794 }
2795 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2796 default:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2797 ALOGE("%s: Invalid internal event %d in state(%d)",
2798 __func__, cam_evt->server_event_type, m_state);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2799 break;
2800 }
2801 }
2802 break;
2803 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
2804 {
2805 qcamera_jpeg_evt_payload_t *jpeg_job =
2806 (qcamera_jpeg_evt_payload_t *)payload;
2807 rc = m_parent->processJpegNotify(jpeg_job);
2808 }
2809 break;
2810 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
2811 {
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]2812 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]2813 rc = m_parent->cancelPicture();
2814 } else {
2815 rc = m_parent->cancelLiveSnapshot();
2816 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2817 m_state = QCAMERA_SM_STATE_PREVIEWING;
Emilian Peev6d90c1f2013-04-12 09:33:06 +0300[diff] [blame]2818 result.status = rc;
2819 result.request_api = evt;
2820 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2821 m_parent->signalEvtResult(&result);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2822 }
2823 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2824 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2825 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2826 rc = m_parent->updateThermalLevel(
2827 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2828 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2829 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2830 default:
2831 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2832 break;
2833 }
2834
2835 return rc;
2836}
2837
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2838/*===========================================================================
2839 * FUNCTION : isPreviewRunning
2840 *
2841 * DESCRIPTION: check if preview is in process.
2842 *
2843 * PARAMETERS : None
2844 *
2845 * RETURN : true -- preview running
2846 * false -- preview stopped
2847 *==========================================================================*/
2848bool QCameraStateMachine::isPreviewRunning()
2849{
2850 switch (m_state) {
2851 case QCAMERA_SM_STATE_PREVIEWING:
2852 case QCAMERA_SM_STATE_RECORDING:
2853 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
2854 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
Muhua Libf818e52013-04-23 18:05:26 -0700[diff] [blame]2855 case QCAMERA_SM_STATE_PREPARE_SNAPSHOT:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2856 return true;
2857 default:
2858 return false;
2859 }
2860}
2861
Emilian Peeve32d03b2013-08-13 16:15:41 +0300[diff] [blame]2862/*===========================================================================
2863 * FUNCTION : isCaptureRunning
2864 *
2865 * DESCRIPTION: check if image capture is in process.
2866 *
2867 * PARAMETERS : None
2868 *
2869 * RETURN : true -- capture running
2870 * false -- capture stopped
2871 *==========================================================================*/
2872bool QCameraStateMachine::isCaptureRunning()
2873{
2874 switch (m_state) {
2875 case QCAMERA_SM_STATE_PIC_TAKING:
2876 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
2877 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
2878 return true;
2879 default:
2880 return false;
2881 }
2882}
Vijay kumar Tumatifa8d9b32013-09-23 16:09:07 +0530[diff] [blame]2883/*===========================================================================
2884 * FUNCTION : isNonZSLCaptureRunning
2885 *
2886 * DESCRIPTION: check if image capture is in process in non ZSL mode.
2887 *
2888 * PARAMETERS : None
2889 *
2890 * RETURN : true -- capture running in non ZSL mode
2891 * false -- Either in not capture mode or captur is not in non ZSL mode
2892 *==========================================================================*/
2893bool QCameraStateMachine::isNonZSLCaptureRunning()
2894{
2895 switch (m_state) {
2896 case QCAMERA_SM_STATE_PIC_TAKING:
2897 return true;
2898 default:
2899 return false;
2900 }
2901}
2902
Emilian Peeve32d03b2013-08-13 16:15:41 +0300[diff] [blame]2903
Shuzhen Wang89635cf2012-12-20 13:47:22 -0800[diff] [blame]2904}; // namespace qcamera