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