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