Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / hardware / qcom / camera / 159ab6af4710c7075ba979d5968367a7866f8f52 / . / QCamera2 / HAL / QCameraStateMachine.cpp
blob: 39f89e1d76083ada84233b55cd63176dd1675258 [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;
Yonggui Mao301cc0d2013-12-05 11:18:15 +0800[diff] [blame]1215 case QCAMERA_INTERNAL_EVT_AWB_UPDATE:
1216 rc = m_parent->processAWBUpdate(internal_evt->awb_data);
1217 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1218 default:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1219 ALOGE("%s: Invalid internal event %d in state(%d)",
1220 __func__, internal_evt->evt_type, m_state);
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1221 break;
1222 }
1223 }
1224 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1225 case QCAMERA_SM_EVT_EVT_NOTIFY:
1226 {
1227 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1228 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1229 case CAM_EVENT_TYPE_DAEMON_DIED:
1230 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1231 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
1232 CAMERA_ERROR_SERVER_DIED,
1233 0);
1234 }
1235 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1236 default:
1237 ALOGD("%s: no handling for server evt (%d) at this state",
1238 __func__, cam_evt->server_event_type);
1239 break;
1240 }
1241 }
1242 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1243 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1244 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]1245 rc = m_parent->updateThermalLevel(
1246 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]1247 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1248 break;
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1249 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]1250 {
1251 // No ops, but need to notify
1252 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1253 result.status = rc;
1254 result.request_api = evt;
1255 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1256 m_parent->signalEvtResult(&result);
1257 }
1258 break;
1259 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1260 default:
1261 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1262 break;
1263 }
1264
1265 return rc;
1266}
1267
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1268/*===========================================================================
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1269 * FUNCTION : procEvtPrepareSnapshotState
1270 *
1271 * DESCRIPTION: finite state machine function to handle event in state of
1272 * QCAMERA_SM_STATE_PREPARE_SNAPSHOT.
1273 *
1274 * PARAMETERS :
1275 * @evt : event to be processed
1276 * @payload : event payload. Can be NULL if not needed.
1277 *
1278 * RETURN : int32_t type of status
1279 * NO_ERROR -- success
1280 * none-zero failure code
1281 *==========================================================================*/
1282int32_t QCameraStateMachine::procEvtPrepareSnapshotState(qcamera_sm_evt_enum_t evt,
1283 void *payload)
1284{
1285 int32_t rc = NO_ERROR;
1286 qcamera_api_result_t result;
1287 memset(&result, 0, sizeof(qcamera_api_result_t));
1288
1289 switch (evt) {
1290 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1291 case QCAMERA_SM_EVT_SET_CALLBACKS:
1292 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1293 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1294 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1295 case QCAMERA_SM_EVT_SET_PARAMS:
1296 case QCAMERA_SM_EVT_GET_PARAMS:
1297 case QCAMERA_SM_EVT_PUT_PARAMS:
1298 case QCAMERA_SM_EVT_START_PREVIEW:
1299 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1300 case QCAMERA_SM_EVT_STOP_PREVIEW:
1301 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1302 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1303 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1304 case QCAMERA_SM_EVT_DUMP:
1305 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1306 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1307 case QCAMERA_SM_EVT_START_RECORDING:
1308 case QCAMERA_SM_EVT_TAKE_PICTURE:
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1309 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1310 case QCAMERA_SM_EVT_SEND_COMMAND:
1311 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1312 case QCAMERA_SM_EVT_STOP_RECORDING:
1313 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1314 case QCAMERA_SM_EVT_RELEASE:
1315 {
1316 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1317 rc = INVALID_OPERATION;
1318 result.status = rc;
1319 result.request_api = evt;
1320 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1321 m_parent->signalAPIResult(&result);
1322 }
1323 break;
1324 case QCAMERA_SM_EVT_EVT_INTERNAL:
1325 {
1326 qcamera_sm_internal_evt_payload_t *internal_evt =
1327 (qcamera_sm_internal_evt_payload_t *)payload;
1328 switch (internal_evt->evt_type) {
Muhua Li6f3c5322013-05-08 17:20:17 -0700[diff] [blame]1329 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1330 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1331 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1332 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
1333 ALOGI("%s: Received QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE event",
1334 __func__);
1335 m_parent->processPrepSnapshotDoneEvent(internal_evt->prep_snapshot_state);
1336 m_state = QCAMERA_SM_STATE_PREVIEWING;
1337
1338 result.status = NO_ERROR;
1339 result.request_api = QCAMERA_SM_EVT_PREPARE_SNAPSHOT;
1340 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1341 m_parent->signalAPIResult(&result);
1342 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1343 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
1344 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
1345 break;
1346 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
1347 rc = m_parent->processHistogramStats(internal_evt->stats_data);
1348 break;
1349 case QCAMERA_INTERNAL_EVT_CROP_INFO:
1350 rc = m_parent->processZoomEvent(internal_evt->crop_data);
1351 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]1352 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
1353 rc = m_parent->processASDUpdate(internal_evt->asd_data);
1354 break;
Yonggui Mao301cc0d2013-12-05 11:18:15 +0800[diff] [blame]1355 case QCAMERA_INTERNAL_EVT_AWB_UPDATE:
1356 rc = m_parent->processAWBUpdate(internal_evt->awb_data);
1357 break;
1358
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1359 default:
1360 ALOGE("%s: Invalid internal event %d in state(%d)",
1361 __func__, internal_evt->evt_type, m_state);
1362 break;
1363 }
1364 }
1365 break;
1366 case QCAMERA_SM_EVT_EVT_NOTIFY:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1367 {
1368 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1369 switch (cam_evt->server_event_type) {
1370 case CAM_EVENT_TYPE_DAEMON_DIED:
1371 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1372 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
1373 CAMERA_ERROR_SERVER_DIED,
1374 0);
1375 }
1376 break;
1377 default:
1378 ALOGE("%s: Invalid internal event %d in state(%d)",
1379 __func__, cam_evt->server_event_type, m_state);
1380 break;
1381 }
1382 }
1383 break;
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]1384 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1385 {
1386 // No ops, but need to notify
1387 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1388 result.status = rc;
1389 result.request_api = evt;
1390 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1391 m_parent->signalEvtResult(&result);
1392 }
1393 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1394 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
1395 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]1396 default:
1397 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1398 break;
1399 }
1400
1401 return rc;
1402}
1403
1404/*===========================================================================
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1405 * FUNCTION : procEvtPicTakingState
1406 *
1407 * DESCRIPTION: finite state machine function to handle event in state of
1408 * QCAMERA_SM_STATE_PIC_TAKING.
1409 *
1410 * PARAMETERS :
1411 * @evt : event to be processed
1412 * @payload : event payload. Can be NULL if not needed.
1413 *
1414 * RETURN : int32_t type of status
1415 * NO_ERROR -- success
1416 * none-zero failure code
1417 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1418int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt,
1419 void *payload)
1420{
1421 int32_t rc = NO_ERROR;
1422 qcamera_api_result_t result;
1423 memset(&result, 0, sizeof(qcamera_api_result_t));
1424
1425 switch (evt) {
1426 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1427 {
1428 // Error setting preview window during previewing
1429 ALOGE("Cannot set preview window when preview is running");
1430 rc = INVALID_OPERATION;
1431 result.status = rc;
1432 result.request_api = evt;
1433 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1434 m_parent->signalAPIResult(&result);
1435 }
1436 break;
1437 case QCAMERA_SM_EVT_SET_CALLBACKS:
1438 {
1439 qcamera_sm_evt_setcb_payload_t *setcbs =
1440 (qcamera_sm_evt_setcb_payload_t *)payload;
1441 rc = m_parent->setCallBacks(setcbs->notify_cb,
1442 setcbs->data_cb,
1443 setcbs->data_cb_timestamp,
1444 setcbs->get_memory,
1445 setcbs->user);
1446 result.status = rc;
1447 result.request_api = evt;
1448 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1449 m_parent->signalAPIResult(&result);
1450 }
1451 break;
1452 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1453 {
1454 rc = m_parent->enableMsgType(int32_t(payload));
1455 result.status = rc;
1456 result.request_api = evt;
1457 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1458 m_parent->signalAPIResult(&result);
1459 }
1460 break;
1461 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1462 {
1463 rc = m_parent->disableMsgType(int32_t(payload));
1464 result.status = rc;
1465 result.request_api = evt;
1466 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1467 m_parent->signalAPIResult(&result);
1468 }
1469 break;
1470 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1471 {
1472 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1473 result.status = rc;
1474 result.request_api = evt;
1475 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1476 result.enabled = enabled;
1477 m_parent->signalAPIResult(&result);
1478 }
1479 break;
1480 case QCAMERA_SM_EVT_SET_PARAMS:
1481 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1482 bool needRestart = false;
1483 rc = m_parent->updateParameters((char*)payload, needRestart);
1484 if (rc == NO_ERROR) {
1485 rc = m_parent->commitParameterChanges();
1486 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1487 result.status = rc;
1488 result.request_api = evt;
1489 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1490 m_parent->signalAPIResult(&result);
1491 }
1492 break;
1493 case QCAMERA_SM_EVT_GET_PARAMS:
1494 {
1495 result.params = m_parent->getParameters();
1496 rc = NO_ERROR;
1497 result.status = rc;
1498 result.request_api = evt;
1499 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1500 m_parent->signalAPIResult(&result);
1501 }
1502 break;
1503 case QCAMERA_SM_EVT_PUT_PARAMS:
1504 {
1505 rc = m_parent->putParameters((char*)payload);
1506 result.status = rc;
1507 result.request_api = evt;
1508 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1509 m_parent->signalAPIResult(&result);
1510 }
1511 break;
1512 case QCAMERA_SM_EVT_STOP_PREVIEW:
1513 {
Muhua Libd1b6122013-03-05 15:25:27 -0800[diff] [blame]1514 // cancel picture first
1515 rc = m_parent->cancelPicture();
1516 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1517
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1518 result.status = rc;
1519 result.request_api = evt;
1520 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1521 m_parent->signalAPIResult(&result);
1522 }
1523 break;
1524 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1525 {
1526 rc = NO_ERROR;
1527 result.status = rc;
1528 result.request_api = evt;
1529 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1530 result.enabled = 0;
1531 m_parent->signalAPIResult(&result);
1532 }
1533 break;
1534 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1535 {
1536 rc = NO_ERROR;
1537 result.status = rc;
1538 result.request_api = evt;
1539 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1540 result.enabled = 0;
1541 m_parent->signalAPIResult(&result);
1542 }
1543 break;
1544 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1545 {
1546 rc = m_parent->storeMetaDataInBuffers(int(payload));
1547 result.status = rc;
1548 result.request_api = evt;
1549 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1550 m_parent->signalAPIResult(&result);
1551 }
1552 break;
1553 case QCAMERA_SM_EVT_DUMP:
1554 {
1555 rc = m_parent->dump((int)payload);
1556 result.status = rc;
1557 result.request_api = evt;
1558 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1559 m_parent->signalAPIResult(&result);
1560 }
1561 break;
1562 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1563 {
1564 rc = m_parent->autoFocus();
1565 result.status = rc;
1566 result.request_api = evt;
1567 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1568 m_parent->signalAPIResult(&result);
1569 }
1570 break;
1571 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1572 {
1573 rc = m_parent->cancelAutoFocus();
1574 result.status = rc;
1575 result.request_api = evt;
1576 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1577 m_parent->signalAPIResult(&result);
1578 }
1579 break;
1580 case QCAMERA_SM_EVT_SEND_COMMAND:
1581 {
1582 qcamera_sm_evt_command_payload_t *cmd_payload =
1583 (qcamera_sm_evt_command_payload_t *)payload;
1584 rc = m_parent->sendCommand(cmd_payload->cmd,
1585 cmd_payload->arg1,
1586 cmd_payload->arg2);
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]1587 if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) {
1588 // move state to previewing state
1589 m_state = QCAMERA_SM_STATE_PREVIEWING;
1590 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1591 result.status = rc;
1592 result.request_api = evt;
1593 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1594 m_parent->signalAPIResult(&result);
1595 }
1596 break;
1597 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1598 {
1599 rc = m_parent->cancelPicture();
1600 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1601 result.status = rc;
1602 result.request_api = evt;
1603 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1604 m_parent->signalAPIResult(&result);
1605 }
1606 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]1607 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
1608 {
1609 int32_t faceID = 0;
1610 qcamera_sm_evt_reg_face_payload_t *reg_payload =
1611 (qcamera_sm_evt_reg_face_payload_t *)payload;
1612 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
1613 reg_payload->config,
1614 faceID);
1615 result.status = rc;
1616 result.request_api = evt;
1617 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
1618 result.handle = faceID;
1619 m_parent->signalAPIResult(&result);
1620 }
1621 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1622 case QCAMERA_SM_EVT_TAKE_PICTURE:
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]1623 {
1624 if ( m_parent->isLongshotEnabled() ) {
1625 rc = m_parent->longShot();
1626 } else {
1627 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1628 rc = INVALID_OPERATION;
1629 }
1630
1631 result.status = rc;
1632 result.request_api = evt;
1633 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1634 m_parent->signalAPIResult(&result);
1635 }
1636 break;
1637 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1638 case QCAMERA_SM_EVT_START_RECORDING:
1639 case QCAMERA_SM_EVT_STOP_RECORDING:
1640 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1641 case QCAMERA_SM_EVT_START_PREVIEW:
1642 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1643 case QCAMERA_SM_EVT_RELEASE:
1644 {
1645 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1646 rc = INVALID_OPERATION;
1647 result.status = rc;
1648 result.request_api = evt;
1649 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1650 m_parent->signalAPIResult(&result);
1651 }
1652 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1653 case QCAMERA_SM_EVT_EVT_INTERNAL:
1654 {
1655 qcamera_sm_internal_evt_payload_t *internal_evt =
1656 (qcamera_sm_internal_evt_payload_t *)payload;
1657 switch (internal_evt->evt_type) {
1658 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
1659 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
1660 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]1661 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
1662 break;
1663 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
1664 break;
1665 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
1666 break;
1667 case QCAMERA_INTERNAL_EVT_CROP_INFO:
1668 rc = m_parent->processZoomEvent(internal_evt->crop_data);
1669 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]1670 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
1671 rc = m_parent->processASDUpdate(internal_evt->asd_data);
1672 break;
Yonggui Mao301cc0d2013-12-05 11:18:15 +0800[diff] [blame]1673 case QCAMERA_INTERNAL_EVT_AWB_UPDATE:
1674 rc = m_parent->processAWBUpdate(internal_evt->awb_data);
1675 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]1676 default:
1677 break;
1678 }
1679 }
1680 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1681 case QCAMERA_SM_EVT_EVT_NOTIFY:
1682 {
1683 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1684 switch (cam_evt->server_event_type) {
Emilian Peev9c53a9e2013-12-12 15:58:13 +0200[diff] [blame]1685 case CAM_EVENT_TYPE_REPROCESS_STAGE_DONE:
1686 {
1687 if ( m_parent->isLongshotEnabled() ) {
1688 if(!m_parent->m_postprocessor.getMultipleStages()) {
1689 m_parent->m_postprocessor.setMultipleStages(true);
1690 }
1691 m_parent->playShutter();
1692 }
1693 }
1694 break;
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1695 case CAM_EVENT_TYPE_DAEMON_DIED:
1696 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]1697 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
1698 CAMERA_ERROR_SERVER_DIED,
1699 0);
1700 }
1701 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1702 default:
1703 ALOGD("%s: no handling for server evt (%d) at this state",
1704 __func__, cam_evt->server_event_type);
1705 break;
1706 }
1707 }
1708 break;
1709 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1710 {
1711 qcamera_jpeg_evt_payload_t *jpeg_job =
1712 (qcamera_jpeg_evt_payload_t *)payload;
1713 rc = m_parent->processJpegNotify(jpeg_job);
1714 }
1715 break;
Emilian Peev7d36a812013-11-20 00:15:54 -0800[diff] [blame]1716 case QCAMERA_SM_EVT_STOP_CAPTURE_CHANNEL:
1717 {
Emilian Peev8a977232013-11-04 07:56:32 -0800[diff] [blame]1718 bool restartPreview = m_parent->isPreviewRestartEnabled();
1719 rc = m_parent->stopCaptureChannel(restartPreview);
1720
1721 if (restartPreview && (NO_ERROR == rc)) {
1722 rc = m_parent->preparePreview();
1723 if (NO_ERROR == rc) {
1724 m_parent->m_bPreviewStarted = true;
1725 rc = m_parent->startPreview();
1726 }
1727 }
1728
Emilian Peev7d36a812013-11-20 00:15:54 -0800[diff] [blame]1729 result.status = rc;
1730 result.request_api = evt;
1731 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1732 m_parent->signalAPIResult(&result);
1733 }
1734 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1735 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1736 {
1737 rc = m_parent->cancelPicture();
Emilian Peev8a977232013-11-04 07:56:32 -0800[diff] [blame]1738
1739 bool restartPreview = m_parent->isPreviewRestartEnabled();
1740 if (restartPreview) {
1741 m_state = QCAMERA_SM_STATE_PREVIEWING;
1742 } else {
1743 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1744 }
1745
Emilian Peev6d90c1f2013-04-12 09:33:06 +0300[diff] [blame]1746 result.status = rc;
1747 result.request_api = evt;
1748 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1749 m_parent->signalEvtResult(&result);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1750 }
1751 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]1752 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peev2ae455e2013-04-18 10:41:56 +0300[diff] [blame]1753 {
1754 rc = m_parent->updateThermalLevel(
1755 *(qcamera_thermal_level_enum_t *)&payload);
1756 }
1757 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1758 default:
1759 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1760 break;
1761 }
1762
1763 return rc;
1764}
1765
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1766/*===========================================================================
1767 * FUNCTION : procEvtRecordingState
1768 *
1769 * DESCRIPTION: finite state machine function to handle event in state of
1770 * QCAMERA_SM_STATE_RECORDING.
1771 *
1772 * PARAMETERS :
1773 * @evt : event to be processed
1774 * @payload : event payload. Can be NULL if not needed.
1775 *
1776 * RETURN : int32_t type of status
1777 * NO_ERROR -- success
1778 * none-zero failure code
1779 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1780int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt,
1781 void *payload)
1782{
1783 int32_t rc = NO_ERROR;
1784 qcamera_api_result_t result;
1785 memset(&result, 0, sizeof(qcamera_api_result_t));
1786
1787 switch (evt) {
Emilian Peev88293e92013-06-07 12:37:18 +0300[diff] [blame]1788 case QCAMERA_SM_EVT_START_PREVIEW:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1789 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1790 {
Emilian Peev88293e92013-06-07 12:37:18 +0300[diff] [blame]1791 // WA: CTS test VideoSnapshot will try to
1792 // start preview during video recording.
1793 ALOGE("CTS video restart op");
1794 rc = NO_ERROR;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1795 result.status = rc;
1796 result.request_api = evt;
1797 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1798 m_parent->signalAPIResult(&result);
1799 }
1800 break;
1801 case QCAMERA_SM_EVT_SET_CALLBACKS:
1802 {
1803 qcamera_sm_evt_setcb_payload_t *setcbs =
1804 (qcamera_sm_evt_setcb_payload_t *)payload;
1805 rc = m_parent->setCallBacks(setcbs->notify_cb,
1806 setcbs->data_cb,
1807 setcbs->data_cb_timestamp,
1808 setcbs->get_memory,
1809 setcbs->user);
1810 result.status = rc;
1811 result.request_api = evt;
1812 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1813 m_parent->signalAPIResult(&result);
1814 }
1815 break;
1816 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1817 {
1818 rc = m_parent->enableMsgType(int32_t(payload));
1819 result.status = rc;
1820 result.request_api = evt;
1821 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1822 m_parent->signalAPIResult(&result);
1823 }
1824 break;
1825 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1826 {
1827 rc = m_parent->disableMsgType(int32_t(payload));
1828 result.status = rc;
1829 result.request_api = evt;
1830 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1831 m_parent->signalAPIResult(&result);
1832 }
1833 break;
1834 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1835 {
1836 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1837 result.status = rc;
1838 result.request_api = evt;
1839 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1840 result.enabled = enabled;
1841 m_parent->signalAPIResult(&result);
1842 }
1843 break;
1844 case QCAMERA_SM_EVT_SET_PARAMS:
1845 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]1846 bool needRestart = false;
1847 rc = m_parent->updateParameters((char*)payload, needRestart);
1848 if (rc == NO_ERROR) {
1849 if (needRestart) {
1850 // cannot set parameters that requires restart during recording
1851 ALOGE("%s: Cannot set parameters that requires restart during recording",
1852 __func__);
1853 rc = BAD_VALUE;
1854 } else {
1855 rc = m_parent->commitParameterChanges();
1856 }
1857 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1858 result.status = rc;
1859 result.request_api = evt;
1860 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1861 m_parent->signalAPIResult(&result);
1862 }
1863 break;
1864 case QCAMERA_SM_EVT_GET_PARAMS:
1865 {
1866 result.params = m_parent->getParameters();
1867 rc = NO_ERROR;
1868 result.status = rc;
1869 result.request_api = evt;
1870 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1871 m_parent->signalAPIResult(&result);
1872 }
1873 break;
1874 case QCAMERA_SM_EVT_PUT_PARAMS:
1875 {
1876 rc = m_parent->putParameters((char*)payload);
1877 result.status = rc;
1878 result.request_api = evt;
1879 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1880 m_parent->signalAPIResult(&result);
1881 }
1882 break;
1883 case QCAMERA_SM_EVT_PREVIEW_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 = 0;
1890 m_parent->signalAPIResult(&result);
1891 }
1892 break;
1893 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1894 {
1895 rc = NO_ERROR;
1896 result.status = rc;
1897 result.request_api = evt;
1898 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1899 result.enabled = 1;
1900 m_parent->signalAPIResult(&result);
1901 }
1902 break;
1903 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1904 {
1905 rc = m_parent->storeMetaDataInBuffers(int(payload));
1906 result.status = rc;
1907 result.request_api = evt;
1908 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1909 m_parent->signalAPIResult(&result);
1910 }
1911 break;
1912 case QCAMERA_SM_EVT_DUMP:
1913 {
1914 rc = m_parent->dump((int)payload);
1915 result.status = rc;
1916 result.request_api = evt;
1917 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1918 m_parent->signalAPIResult(&result);
1919 }
1920 break;
1921 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1922 {
1923 rc = m_parent->autoFocus();
1924 result.status = rc;
1925 result.request_api = evt;
1926 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1927 m_parent->signalAPIResult(&result);
1928 }
1929 break;
1930 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1931 {
1932 rc = m_parent->cancelAutoFocus();
1933 result.status = rc;
1934 result.request_api = evt;
1935 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1936 m_parent->signalAPIResult(&result);
1937 }
1938 break;
1939 case QCAMERA_SM_EVT_SEND_COMMAND:
1940 {
1941 qcamera_sm_evt_command_payload_t *cmd_payload =
1942 (qcamera_sm_evt_command_payload_t *)payload;
1943 rc = m_parent->sendCommand(cmd_payload->cmd,
1944 cmd_payload->arg1,
1945 cmd_payload->arg2);
1946 result.status = rc;
1947 result.request_api = evt;
1948 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1949 m_parent->signalAPIResult(&result);
1950 }
1951 break;
1952 case QCAMERA_SM_EVT_TAKE_PICTURE:
1953 {
Muhua Li1d0c4772013-02-22 15:39:45 -0800[diff] [blame]1954 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1955 rc = m_parent->takeLiveSnapshot();
Muhua Li1d0c4772013-02-22 15:39:45 -0800[diff] [blame]1956 if (rc != NO_ERROR) {
1957 m_state = QCAMERA_SM_STATE_RECORDING;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]1958 }
1959 result.status = rc;
1960 result.request_api = evt;
1961 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1962 m_parent->signalAPIResult(&result);
1963 }
1964 break;
1965 case QCAMERA_SM_EVT_START_RECORDING:
1966 {
1967 // no ops here
1968 ALOGD("%s: already in recording state, no ops for start_recording", __func__);
1969 rc = 0;
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;
1976 case QCAMERA_SM_EVT_STOP_RECORDING:
1977 {
1978 rc = m_parent->stopRecording();
1979 m_state = QCAMERA_SM_STATE_PREVIEWING;
1980 result.status = rc;
1981 result.request_api = evt;
1982 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1983 m_parent->signalAPIResult(&result);
1984 }
1985 break;
Emilian Peevf392f172013-05-13 16:29:53 -0700[diff] [blame]1986 case QCAMERA_SM_EVT_STOP_PREVIEW:
1987 {
1988 rc = m_parent->stopRecording();
1989 m_state = QCAMERA_SM_STATE_PREVIEWING;
1990
1991 rc = m_parent->stopPreview();
1992 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1993
1994 result.status = rc;
1995 result.request_api = evt;
1996 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1997 m_parent->signalAPIResult(&result);
1998 }
1999 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2000 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2001 {
2002 rc = m_parent->releaseRecordingFrame((const void *)payload);
2003 result.status = rc;
2004 result.request_api = evt;
2005 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2006 m_parent->signalAPIResult(&result);
2007 }
2008 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]2009 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
2010 {
2011 int32_t faceID = 0;
2012 qcamera_sm_evt_reg_face_payload_t *reg_payload =
2013 (qcamera_sm_evt_reg_face_payload_t *)payload;
2014 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
2015 reg_payload->config,
2016 faceID);
2017 result.status = rc;
2018 result.request_api = evt;
2019 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2020 result.handle = faceID;
2021 m_parent->signalAPIResult(&result);
2022 }
2023 break;
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]2024 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
2025 {
2026 //In Video snapshot, prepare hardware is a no-op.
2027 result.status = NO_ERROR;
2028 result.request_api = evt;
2029 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2030 m_parent->signalAPIResult(&result);
2031 }
2032 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2033 case QCAMERA_SM_EVT_CANCEL_PICTURE:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2034 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2035 case QCAMERA_SM_EVT_RELEASE:
2036 {
2037 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2038 rc = INVALID_OPERATION;
2039 result.status = rc;
2040 result.request_api = evt;
2041 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2042 m_parent->signalAPIResult(&result);
2043 }
2044 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2045 case QCAMERA_SM_EVT_EVT_INTERNAL:
2046 {
2047 qcamera_sm_internal_evt_payload_t *internal_evt =
2048 (qcamera_sm_internal_evt_payload_t *)payload;
2049 switch (internal_evt->evt_type) {
2050 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2051 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2052 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2053 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
2054 break;
2055 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
2056 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
2057 break;
2058 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
2059 rc = m_parent->processHistogramStats(internal_evt->stats_data);
2060 break;
2061 case QCAMERA_INTERNAL_EVT_CROP_INFO:
2062 rc = m_parent->processZoomEvent(internal_evt->crop_data);
2063 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]2064 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
2065 rc = m_parent->processASDUpdate(internal_evt->asd_data);
2066 break;
Yonggui Mao301cc0d2013-12-05 11:18:15 +0800[diff] [blame]2067 case QCAMERA_INTERNAL_EVT_AWB_UPDATE:
2068 rc = m_parent->processAWBUpdate(internal_evt->awb_data);
2069 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2070 default:
2071 break;
2072 }
2073 }
2074 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2075 case QCAMERA_SM_EVT_EVT_NOTIFY:
2076 {
2077 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2078 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2079 case CAM_EVENT_TYPE_DAEMON_DIED:
2080 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2081 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
2082 CAMERA_ERROR_SERVER_DIED,
2083 0);
2084 }
2085 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2086 default:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2087 ALOGE("%s: Invalid internal event %d in state(%d)",
2088 __func__, cam_evt->server_event_type, m_state);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2089 break;
2090 }
2091 }
2092 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2093 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2094 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2095 rc = m_parent->updateThermalLevel(
2096 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2097 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2098 break;
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2099 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
Muhua Lic9390df2013-05-22 17:54:13 -0700[diff] [blame]2100 {
2101 // No ops, but need to notify
2102 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2103 result.status = rc;
2104 result.request_api = evt;
2105 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2106 m_parent->signalEvtResult(&result);
2107 }
2108 break;
2109 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2110 default:
2111 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2112 break;
2113 }
2114
2115 return rc;
2116}
2117
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2118/*===========================================================================
2119 * FUNCTION : procEvtVideoPicTakingState
2120 *
2121 * DESCRIPTION: finite state machine function to handle event in state of
2122 * QCAMERA_SM_STATE_VIDEO_PIC_TAKING.
2123 *
2124 * PARAMETERS :
2125 * @evt : event to be processed
2126 * @payload : event payload. Can be NULL if not needed.
2127 *
2128 * RETURN : int32_t type of status
2129 * NO_ERROR -- success
2130 * none-zero failure code
2131 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2132int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt,
2133 void *payload)
2134{
2135 int32_t rc = NO_ERROR;
2136 qcamera_api_result_t result;
2137 memset(&result, 0, sizeof(qcamera_api_result_t));
2138
2139 switch (evt) {
2140 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
2141 {
2142 // Error setting preview window during previewing
2143 ALOGE("Cannot set preview window when preview is running");
2144 rc = INVALID_OPERATION;
2145 result.status = rc;
2146 result.request_api = evt;
2147 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2148 m_parent->signalAPIResult(&result);
2149 }
2150 break;
2151 case QCAMERA_SM_EVT_SET_CALLBACKS:
2152 {
2153 qcamera_sm_evt_setcb_payload_t *setcbs =
2154 (qcamera_sm_evt_setcb_payload_t *)payload;
2155 rc = m_parent->setCallBacks(setcbs->notify_cb,
2156 setcbs->data_cb,
2157 setcbs->data_cb_timestamp,
2158 setcbs->get_memory,
2159 setcbs->user);
2160 result.status = rc;
2161 result.request_api = evt;
2162 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2163 m_parent->signalAPIResult(&result);
2164 }
2165 break;
2166 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
2167 {
2168 rc = m_parent->enableMsgType(int32_t(payload));
2169 result.status = rc;
2170 result.request_api = evt;
2171 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2172 m_parent->signalAPIResult(&result);
2173 }
2174 break;
2175 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
2176 {
2177 rc = m_parent->disableMsgType(int32_t(payload));
2178 result.status = rc;
2179 result.request_api = evt;
2180 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2181 m_parent->signalAPIResult(&result);
2182 }
2183 break;
2184 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
2185 {
2186 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
2187 result.status = rc;
2188 result.request_api = evt;
2189 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2190 result.enabled = enabled;
2191 m_parent->signalAPIResult(&result);
2192 }
2193 break;
2194 case QCAMERA_SM_EVT_SET_PARAMS:
2195 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2196 bool needRestart = false;
2197 rc = m_parent->updateParameters((char*)payload, needRestart);
2198 if (rc == NO_ERROR) {
2199 if (needRestart) {
2200 // cannot set parameters that requires restart during recording
2201 ALOGE("%s: Cannot set parameters that requires restart during recording",
2202 __func__);
2203 rc = BAD_VALUE;
2204 } else {
2205 rc = m_parent->commitParameterChanges();
2206 }
2207 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2208 result.status = rc;
2209 result.request_api = evt;
2210 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2211 m_parent->signalAPIResult(&result);
2212 }
2213 break;
2214 case QCAMERA_SM_EVT_GET_PARAMS:
2215 {
2216 result.params = m_parent->getParameters();
2217 rc = NO_ERROR;
2218 result.status = rc;
2219 result.request_api = evt;
2220 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
2221 m_parent->signalAPIResult(&result);
2222 }
2223 break;
2224 case QCAMERA_SM_EVT_PUT_PARAMS:
2225 {
2226 rc = m_parent->putParameters((char*)payload);
2227 result.status = rc;
2228 result.request_api = evt;
2229 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2230 m_parent->signalAPIResult(&result);
2231 }
2232 break;
2233 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
2234 {
2235 rc = NO_ERROR;
2236 result.status = rc;
2237 result.request_api = evt;
2238 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2239 result.enabled = 1;
2240 m_parent->signalAPIResult(&result);
2241 }
2242 break;
2243 case QCAMERA_SM_EVT_RECORDING_ENABLED:
2244 {
2245 rc = NO_ERROR;
2246 result.status = rc;
2247 result.request_api = evt;
2248 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2249 result.enabled = 1;
2250 m_parent->signalAPIResult(&result);
2251 }
2252 break;
2253 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
2254 {
2255 rc = m_parent->storeMetaDataInBuffers(int(payload));
2256 result.status = rc;
2257 result.request_api = evt;
2258 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2259 m_parent->signalAPIResult(&result);
2260 }
2261 break;
2262 case QCAMERA_SM_EVT_DUMP:
2263 {
2264 rc = m_parent->dump((int)payload);
2265 result.status = rc;
2266 result.request_api = evt;
2267 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2268 m_parent->signalAPIResult(&result);
2269 }
2270 break;
2271 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
2272 {
2273 rc = m_parent->autoFocus();
2274 result.status = rc;
2275 result.request_api = evt;
2276 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2277 m_parent->signalAPIResult(&result);
2278 }
2279 break;
2280 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
2281 {
2282 rc = m_parent->cancelAutoFocus();
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_SEND_COMMAND:
2290 {
2291 qcamera_sm_evt_command_payload_t *cmd_payload =
2292 (qcamera_sm_evt_command_payload_t *)payload;
2293 rc = m_parent->sendCommand(cmd_payload->cmd,
2294 cmd_payload->arg1,
2295 cmd_payload->arg2);
2296 result.status = rc;
2297 result.request_api = evt;
2298 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2299 m_parent->signalAPIResult(&result);
2300 }
2301 break;
2302 case QCAMERA_SM_EVT_STOP_RECORDING:
2303 {
Sai Kumar Sanagavarapud972ac12014-01-07 14:23:52 +0530[diff] [blame]2304 rc = m_parent->cancelLiveSnapshot();
2305 m_state = QCAMERA_SM_STATE_RECORDING;
2306
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2307 rc = m_parent->stopRecording();
Sai Kumar Sanagavarapud972ac12014-01-07 14:23:52 +0530[diff] [blame]2308 m_state = QCAMERA_SM_STATE_PREVIEWING;
2309
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2310 result.status = rc;
2311 result.request_api = evt;
2312 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2313 m_parent->signalAPIResult(&result);
2314 }
2315 break;
2316 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2317 {
2318 rc = m_parent->releaseRecordingFrame((const void *)payload);
2319 result.status = rc;
2320 result.request_api = evt;
2321 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2322 m_parent->signalAPIResult(&result);
2323 }
2324 break;
2325 case QCAMERA_SM_EVT_CANCEL_PICTURE:
2326 {
2327 rc = m_parent->cancelLiveSnapshot();
2328 m_state = QCAMERA_SM_STATE_RECORDING;
2329 result.status = rc;
2330 result.request_api = evt;
2331 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2332 m_parent->signalAPIResult(&result);
2333 }
2334 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]2335 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
2336 {
2337 int32_t faceID = 0;
2338 qcamera_sm_evt_reg_face_payload_t *reg_payload =
2339 (qcamera_sm_evt_reg_face_payload_t *)payload;
2340 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
2341 reg_payload->config,
2342 faceID);
2343 result.status = rc;
2344 result.request_api = evt;
2345 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2346 result.handle = faceID;
2347 m_parent->signalAPIResult(&result);
2348 }
2349 break;
Emilian Peevf392f172013-05-13 16:29:53 -0700[diff] [blame]2350 case QCAMERA_SM_EVT_STOP_PREVIEW:
2351 {
2352 rc = m_parent->cancelLiveSnapshot();
2353 m_state = QCAMERA_SM_STATE_RECORDING;
2354
2355 rc = m_parent->stopRecording();
2356 m_state = QCAMERA_SM_STATE_PREVIEWING;
2357
2358 rc = m_parent->stopPreview();
2359 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
2360
2361 result.status = rc;
2362 result.request_api = evt;
2363 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2364 m_parent->signalAPIResult(&result);
2365 }
2366 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2367 case QCAMERA_SM_EVT_START_RECORDING:
2368 case QCAMERA_SM_EVT_START_PREVIEW:
2369 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2370 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2371 case QCAMERA_SM_EVT_TAKE_PICTURE:
2372 case QCAMERA_SM_EVT_RELEASE:
2373 {
2374 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2375 rc = INVALID_OPERATION;
2376 result.status = rc;
2377 result.request_api = evt;
2378 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2379 m_parent->signalAPIResult(&result);
2380 }
2381 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2382 case QCAMERA_SM_EVT_EVT_INTERNAL:
2383 {
2384 qcamera_sm_internal_evt_payload_t *internal_evt =
2385 (qcamera_sm_internal_evt_payload_t *)payload;
2386 switch (internal_evt->evt_type) {
2387 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2388 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2389 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2390 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
2391 break;
2392 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
2393 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
2394 break;
2395 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
2396 rc = m_parent->processHistogramStats(internal_evt->stats_data);
2397 break;
2398 case QCAMERA_INTERNAL_EVT_CROP_INFO:
2399 rc = m_parent->processZoomEvent(internal_evt->crop_data);
2400 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]2401 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
2402 rc = m_parent->processASDUpdate(internal_evt->asd_data);
2403 break;
Yonggui Mao301cc0d2013-12-05 11:18:15 +0800[diff] [blame]2404 case QCAMERA_INTERNAL_EVT_AWB_UPDATE:
2405 rc = m_parent->processAWBUpdate(internal_evt->awb_data);
2406 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2407 default:
2408 break;
2409 }
2410 }
2411 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2412 case QCAMERA_SM_EVT_EVT_NOTIFY:
2413 {
2414 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2415 switch (cam_evt->server_event_type) {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2416 case CAM_EVENT_TYPE_DAEMON_DIED:
2417 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2418 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
2419 CAMERA_ERROR_SERVER_DIED,
2420 0);
2421 }
2422 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2423 default:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2424 ALOGE("%s: Invalid internal event %d in state(%d)",
2425 __func__, cam_evt->server_event_type, m_state);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2426 break;
2427 }
2428 }
2429 break;
2430 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
2431 {
2432 qcamera_jpeg_evt_payload_t *jpeg_job =
2433 (qcamera_jpeg_evt_payload_t *)payload;
2434 rc = m_parent->processJpegNotify(jpeg_job);
2435 }
2436 break;
2437 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
2438 {
2439 rc = m_parent->cancelLiveSnapshot();
2440 m_state = QCAMERA_SM_STATE_RECORDING;
Emilian Peev6d90c1f2013-04-12 09:33:06 +0300[diff] [blame]2441 result.status = rc;
2442 result.request_api = evt;
2443 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2444 m_parent->signalEvtResult(&result);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2445 }
2446 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2447 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2448 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2449 rc = m_parent->updateThermalLevel(
2450 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2451 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2452 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2453 default:
2454 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2455 break;
2456 }
2457
2458 return rc;
2459}
2460
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2461/*===========================================================================
2462 * FUNCTION : procEvtPreviewPicTakingState
2463 *
2464 * DESCRIPTION: finite state machine function to handle event in state of
2465 * QCAMERA_SM_STATE_PREVIEW_PIC_TAKING.
2466 *
2467 * PARAMETERS :
2468 * @evt : event to be processed
2469 * @payload : event payload. Can be NULL if not needed.
2470 *
2471 * RETURN : int32_t type of status
2472 * NO_ERROR -- success
2473 * none-zero failure code
2474 *==========================================================================*/
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2475int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt,
2476 void *payload)
2477{
2478 int32_t rc = NO_ERROR;
2479 qcamera_api_result_t result;
2480 memset(&result, 0, sizeof(qcamera_api_result_t));
2481
2482 switch (evt) {
2483 case QCAMERA_SM_EVT_SET_CALLBACKS:
2484 {
2485 qcamera_sm_evt_setcb_payload_t *setcbs =
2486 (qcamera_sm_evt_setcb_payload_t *)payload;
2487 rc = m_parent->setCallBacks(setcbs->notify_cb,
2488 setcbs->data_cb,
2489 setcbs->data_cb_timestamp,
2490 setcbs->get_memory,
2491 setcbs->user);
2492 result.status = rc;
2493 result.request_api = evt;
2494 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2495 m_parent->signalAPIResult(&result);
2496 }
2497 break;
2498 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
2499 {
2500 rc = m_parent->enableMsgType(int32_t(payload));
2501 result.status = rc;
2502 result.request_api = evt;
2503 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2504 m_parent->signalAPIResult(&result);
2505 }
2506 break;
2507 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
2508 {
2509 rc = m_parent->disableMsgType(int32_t(payload));
2510 result.status = rc;
2511 result.request_api = evt;
2512 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2513 m_parent->signalAPIResult(&result);
2514 }
2515 break;
2516 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
2517 {
2518 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
2519 result.status = rc;
2520 result.request_api = evt;
2521 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2522 result.enabled = enabled;
2523 m_parent->signalAPIResult(&result);
2524 }
2525 break;
2526 case QCAMERA_SM_EVT_SET_PARAMS:
2527 {
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2528 bool needRestart = false;
2529 rc = m_parent->updateParameters((char*)payload, needRestart);
2530 if (rc == NO_ERROR) {
2531 if (needRestart) {
2532 // need restart preview for parameters to take effect
2533 // stop preview
2534 m_parent->stopPreview();
Emilian Peev9afd73b2013-10-31 08:19:57 -0700[diff] [blame]2535 // Clear memory pools
2536 m_parent->m_memoryPool.clear();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2537 // commit parameter changes to server
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]2538 m_parent->commitParameterChanges();
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2539 // start preview again
Muhua Li66f3b532013-01-23 17:19:05 -0800[diff] [blame]2540 rc = m_parent->preparePreview();
2541 if (rc == NO_ERROR) {
2542 rc = m_parent->startPreview();
2543 if (rc != NO_ERROR) {
2544 m_parent->unpreparePreview();
2545 }
2546 }
2547 if (rc != NO_ERROR) {
2548 m_state = QCAMERA_SM_STATE_PIC_TAKING;
2549 }
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2550 } else {
2551 rc = m_parent->commitParameterChanges();
2552 }
2553 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2554 result.status = rc;
2555 result.request_api = evt;
2556 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2557 m_parent->signalAPIResult(&result);
2558 }
2559 break;
2560 case QCAMERA_SM_EVT_GET_PARAMS:
2561 {
2562 result.params = m_parent->getParameters();
2563 rc = NO_ERROR;
2564 result.status = rc;
2565 result.request_api = evt;
2566 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
2567 m_parent->signalAPIResult(&result);
2568 }
2569 break;
2570 case QCAMERA_SM_EVT_PUT_PARAMS:
2571 {
2572 rc = m_parent->putParameters((char*)payload);
2573 result.status = rc;
2574 result.request_api = evt;
2575 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2576 m_parent->signalAPIResult(&result);
2577 }
2578 break;
2579 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
2580 {
2581 rc = NO_ERROR;
2582 result.status = rc;
2583 result.request_api = evt;
2584 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2585 result.enabled = 1;
2586 m_parent->signalAPIResult(&result);
2587 }
2588 break;
2589 case QCAMERA_SM_EVT_RECORDING_ENABLED:
2590 {
2591 rc = NO_ERROR;
2592 result.status = rc;
2593 result.request_api = evt;
2594 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
2595 result.enabled = 0;
2596 m_parent->signalAPIResult(&result);
2597 }
2598 break;
2599 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
2600 {
2601 rc = m_parent->storeMetaDataInBuffers(int(payload));
2602 result.status = rc;
2603 result.request_api = evt;
2604 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2605 m_parent->signalAPIResult(&result);
2606 }
2607 break;
2608 case QCAMERA_SM_EVT_DUMP:
2609 {
2610 rc = m_parent->dump((int)payload);
2611 result.status = rc;
2612 result.request_api = evt;
2613 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2614 m_parent->signalAPIResult(&result);
2615 }
2616 break;
2617 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
2618 {
2619 rc = m_parent->autoFocus();
2620 result.status = rc;
2621 result.request_api = evt;
2622 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2623 m_parent->signalAPIResult(&result);
2624 }
2625 break;
2626 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
2627 {
2628 rc = m_parent->cancelAutoFocus();
2629 result.status = rc;
2630 result.request_api = evt;
2631 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2632 m_parent->signalAPIResult(&result);
2633 }
2634 break;
2635 case QCAMERA_SM_EVT_SEND_COMMAND:
2636 {
2637 qcamera_sm_evt_command_payload_t *cmd_payload =
2638 (qcamera_sm_evt_command_payload_t *)payload;
2639 rc = m_parent->sendCommand(cmd_payload->cmd,
2640 cmd_payload->arg1,
2641 cmd_payload->arg2);
Emilian Peeve32d03b2013-08-13 16:15:41 +0300[diff] [blame]2642 if ( CAMERA_CMD_LONGSHOT_OFF == cmd_payload->cmd ) {
2643 // move state to previewing state
2644 m_state = QCAMERA_SM_STATE_PREVIEWING;
2645 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2646 result.status = rc;
2647 result.request_api = evt;
2648 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2649 m_parent->signalAPIResult(&result);
2650 }
2651 break;
2652 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
2653 {
2654 rc = m_parent->releaseRecordingFrame((const void *)payload);
2655 result.status = rc;
2656 result.request_api = evt;
2657 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2658 m_parent->signalAPIResult(&result);
2659 }
2660 break;
2661 case QCAMERA_SM_EVT_CANCEL_PICTURE:
2662 {
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]2663 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]2664 rc = m_parent->cancelPicture();
2665 } else {
2666 rc = m_parent->cancelLiveSnapshot();
2667 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2668 m_state = QCAMERA_SM_STATE_PREVIEWING;
2669 result.status = rc;
2670 result.request_api = evt;
2671 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2672 m_parent->signalAPIResult(&result);
2673 }
2674 break;
2675 case QCAMERA_SM_EVT_STOP_PREVIEW:
2676 {
Muhua Libd1b6122013-03-05 15:25:27 -0800[diff] [blame]2677 if (m_parent->isZSLMode()) {
2678 // cancel picture first
2679 rc = m_parent->cancelPicture();
2680 m_parent->stopChannel(QCAMERA_CH_TYPE_ZSL);
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]2681 } else if (m_parent->isLongshotEnabled()) {
2682 // just cancel picture
2683 rc = m_parent->cancelPicture();
Muhua Libd1b6122013-03-05 15:25:27 -0800[diff] [blame]2684 } else {
2685 rc = m_parent->cancelLiveSnapshot();
2686 m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW);
2687 }
2688 // unprepare preview
2689 m_parent->unpreparePreview();
2690 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2691 result.status = rc;
2692 result.request_api = evt;
2693 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2694 m_parent->signalAPIResult(&result);
2695 }
2696 break;
2697 case QCAMERA_SM_EVT_START_RECORDING:
2698 {
Muhua Licf1cf672013-05-10 09:42:50 -0700[diff] [blame]2699 if (m_parent->isZSLMode()) {
2700 ALOGE("%s: cannot handle evt(%d) in state(%d) in ZSL mode",
2701 __func__, evt, m_state);
2702 rc = INVALID_OPERATION;
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]2703 } else if (m_parent->isLongshotEnabled()) {
2704 ALOGE("%s: cannot handle evt(%d) in state(%d) in Longshot mode",
2705 __func__, evt, m_state);
2706 rc = INVALID_OPERATION;
Muhua Licf1cf672013-05-10 09:42:50 -0700[diff] [blame]2707 } else {
2708 rc = m_parent->startRecording();
2709 if (rc == NO_ERROR) {
2710 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
2711 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2712 }
2713 result.status = rc;
2714 result.request_api = evt;
2715 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2716 m_parent->signalAPIResult(&result);
2717 }
2718 break;
Muhua Li5858c392013-02-04 17:53:34 -0800[diff] [blame]2719 case QCAMERA_SM_EVT_REG_FACE_IMAGE:
2720 {
2721 int32_t faceID = 0;
2722 qcamera_sm_evt_reg_face_payload_t *reg_payload =
2723 (qcamera_sm_evt_reg_face_payload_t *)payload;
2724 rc = m_parent->registerFaceImage(reg_payload->img_ptr,
2725 reg_payload->config,
2726 faceID);
2727 result.status = rc;
2728 result.request_api = evt;
2729 result.result_type = QCAMERA_API_RESULT_TYPE_HANDLE;
2730 result.handle = faceID;
2731 m_parent->signalAPIResult(&result);
2732 }
2733 break;
Emilian Peeve32d03b2013-08-13 16:15:41 +0300[diff] [blame]2734 case QCAMERA_SM_EVT_TAKE_PICTURE:
2735 {
2736 if ( m_parent->isLongshotEnabled() ) {
2737 rc = m_parent->longShot();
2738 } else {
2739 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2740 rc = INVALID_OPERATION;
2741 }
2742
2743 result.status = rc;
2744 result.request_api = evt;
2745 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2746 m_parent->signalAPIResult(&result);
2747 }
2748 break;
2749 case QCAMERA_SM_EVT_PREPARE_SNAPSHOT:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2750 case QCAMERA_SM_EVT_STOP_RECORDING:
2751 case QCAMERA_SM_EVT_START_PREVIEW:
2752 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2753 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
2754 case QCAMERA_SM_EVT_RELEASE:
2755 {
2756 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2757 rc = INVALID_OPERATION;
2758 result.status = rc;
2759 result.request_api = evt;
2760 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2761 m_parent->signalAPIResult(&result);
2762 }
2763 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2764 case QCAMERA_SM_EVT_EVT_INTERNAL:
2765 {
2766 qcamera_sm_internal_evt_payload_t *internal_evt =
2767 (qcamera_sm_internal_evt_payload_t *)payload;
2768 switch (internal_evt->evt_type) {
2769 case QCAMERA_INTERNAL_EVT_FOCUS_UPDATE:
2770 rc = m_parent->processAutoFocusEvent(internal_evt->focus_data);
2771 break;
Muhua Li510aab22013-05-28 17:00:38 -0700[diff] [blame]2772 case QCAMERA_INTERNAL_EVT_PREP_SNAPSHOT_DONE:
2773 break;
2774 case QCAMERA_INTERNAL_EVT_FACE_DETECT_RESULT:
2775 rc = m_parent->processFaceDetectionResult(&internal_evt->faces_data);
2776 break;
2777 case QCAMERA_INTERNAL_EVT_HISTOGRAM_STATS:
2778 rc = m_parent->processHistogramStats(internal_evt->stats_data);
2779 break;
2780 case QCAMERA_INTERNAL_EVT_CROP_INFO:
2781 rc = m_parent->processZoomEvent(internal_evt->crop_data);
2782 break;
Fei Zhangca9f5bc2013-06-28 11:25:21 +0800[diff] [blame]2783 case QCAMERA_INTERNAL_EVT_ASD_UPDATE:
2784 rc = m_parent->processASDUpdate(internal_evt->asd_data);
2785 break;
Yonggui Mao301cc0d2013-12-05 11:18:15 +0800[diff] [blame]2786 case QCAMERA_INTERNAL_EVT_AWB_UPDATE:
2787 rc = m_parent->processAWBUpdate(internal_evt->awb_data);
2788 break;
Muhua Li31eaee02012-12-11 08:56:45 -0800[diff] [blame]2789 default:
2790 break;
2791 }
2792 }
2793 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2794 case QCAMERA_SM_EVT_EVT_NOTIFY:
2795 {
2796 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
2797 switch (cam_evt->server_event_type) {
Emilian Peev9c53a9e2013-12-12 15:58:13 +0200[diff] [blame]2798 case CAM_EVENT_TYPE_REPROCESS_STAGE_DONE:
2799 {
2800 if ( m_parent->isLongshotEnabled() ) {
2801 if(!m_parent->m_postprocessor.getMultipleStages()) {
2802 m_parent->m_postprocessor.setMultipleStages(true);
2803 }
2804 m_parent->playShutter();
2805 }
2806 }
2807 break;
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2808 case CAM_EVENT_TYPE_DAEMON_DIED:
2809 {
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2810 m_parent->sendEvtNotify(CAMERA_MSG_ERROR,
2811 CAMERA_ERROR_SERVER_DIED,
2812 0);
2813 }
2814 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2815 default:
Emilian Peev15690592013-04-19 09:55:40 +0300[diff] [blame]2816 ALOGE("%s: Invalid internal event %d in state(%d)",
2817 __func__, cam_evt->server_event_type, m_state);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2818 break;
2819 }
2820 }
2821 break;
2822 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
2823 {
2824 qcamera_jpeg_evt_payload_t *jpeg_job =
2825 (qcamera_jpeg_evt_payload_t *)payload;
2826 rc = m_parent->processJpegNotify(jpeg_job);
2827 }
2828 break;
2829 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
2830 {
Emilian Peeva43000b2013-09-27 14:27:21 -0700[diff] [blame]2831 if (m_parent->isZSLMode() || m_parent->isLongshotEnabled()) {
Shuzhen Wang93f24112013-02-20 16:01:42 -0800[diff] [blame]2832 rc = m_parent->cancelPicture();
2833 } else {
2834 rc = m_parent->cancelLiveSnapshot();
2835 }
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2836 m_state = QCAMERA_SM_STATE_PREVIEWING;
Emilian Peev6d90c1f2013-04-12 09:33:06 +0300[diff] [blame]2837 result.status = rc;
2838 result.request_api = evt;
2839 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
2840 m_parent->signalEvtResult(&result);
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2841 }
2842 break;
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2843 case QCAMERA_SM_EVT_THERMAL_NOTIFY:
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2844 {
Shuzhen Wangd415beb2013-02-08 10:28:16 -0800[diff] [blame]2845 rc = m_parent->updateThermalLevel(
2846 *(qcamera_thermal_level_enum_t *)&payload);
Emilian Peeve1d5acb2013-02-01 11:29:53 -0800[diff] [blame]2847 }
Shuzhen Wangaa829ce2013-01-09 14:41:49 -0800[diff] [blame]2848 break;
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame]2849 default:
2850 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
2851 break;
2852 }
2853
2854 return rc;
2855}
2856
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2857/*===========================================================================
2858 * FUNCTION : isPreviewRunning
2859 *
2860 * DESCRIPTION: check if preview is in process.
2861 *
2862 * PARAMETERS : None
2863 *
2864 * RETURN : true -- preview running
2865 * false -- preview stopped
2866 *==========================================================================*/
2867bool QCameraStateMachine::isPreviewRunning()
2868{
2869 switch (m_state) {
2870 case QCAMERA_SM_STATE_PREVIEWING:
2871 case QCAMERA_SM_STATE_RECORDING:
2872 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
2873 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
Muhua Libf818e52013-04-23 18:05:26 -0700[diff] [blame]2874 case QCAMERA_SM_STATE_PREPARE_SNAPSHOT:
Muhua Lida2c4be2012-11-26 09:14:16 -0800[diff] [blame]2875 return true;
2876 default:
2877 return false;
2878 }
2879}
2880
Emilian Peeve32d03b2013-08-13 16:15:41 +0300[diff] [blame]2881/*===========================================================================
2882 * FUNCTION : isCaptureRunning
2883 *
2884 * DESCRIPTION: check if image capture is in process.
2885 *
2886 * PARAMETERS : None
2887 *
2888 * RETURN : true -- capture running
2889 * false -- capture stopped
2890 *==========================================================================*/
2891bool QCameraStateMachine::isCaptureRunning()
2892{
2893 switch (m_state) {
2894 case QCAMERA_SM_STATE_PIC_TAKING:
2895 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
2896 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
2897 return true;
2898 default:
2899 return false;
2900 }
2901}
Vijay kumar Tumatifa8d9b32013-09-23 16:09:07 +0530[diff] [blame]2902/*===========================================================================
2903 * FUNCTION : isNonZSLCaptureRunning
2904 *
2905 * DESCRIPTION: check if image capture is in process in non ZSL mode.
2906 *
2907 * PARAMETERS : None
2908 *
2909 * RETURN : true -- capture running in non ZSL mode
2910 * false -- Either in not capture mode or captur is not in non ZSL mode
2911 *==========================================================================*/
2912bool QCameraStateMachine::isNonZSLCaptureRunning()
2913{
2914 switch (m_state) {
2915 case QCAMERA_SM_STATE_PIC_TAKING:
2916 return true;
2917 default:
2918 return false;
2919 }
2920}
2921
Emilian Peeve32d03b2013-08-13 16:15:41 +0300[diff] [blame]2922
Shuzhen Wang89635cf2012-12-20 13:47:22 -0800[diff] [blame]2923}; // namespace qcamera