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