Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / hardware / qcom / camera / bc9a808ae45c97b34b71c91105c0d8c5a7e35de0 / . / QCamera2 / HAL / QCameraStateMachine.cpp
blob: acde9b070ecde30af4086ed177b63652a8ce7c43 [file] [log] [blame]
Muhua Libc9a8082012-11-07 15:51:28 -0800[diff] [blame^]1/* Copyright (c) 2012, The Linux Foundataion. All rights reserved.
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
37namespace android {
38
39void *QCameraStateMachine::smEvtProcRoutine(void *data)
40{
41 int running = 1, ret;
42 QCameraStateMachine *pme = (QCameraStateMachine *)data;
43
44 ALOGD("%s: E", __func__);
45 do {
46 do {
47 ret = sem_wait(&pme->cmd_sem);
48 if (ret != 0 && errno != EINVAL) {
49 ALOGE("%s: sem_wait error (%s)",
50 __func__, strerror(errno));
51 return NULL;
52 }
53 } while (ret != 0);
54
55 // we got notified about new cmd avail in cmd queue
56 // first check API cmd queue
57 qcamera_sm_cmd_t *node = (qcamera_sm_cmd_t *)pme->api_queue.dequeue();
58 if (node == NULL) {
59 // no API cmd, then check evt cmd queue
60 node = (qcamera_sm_cmd_t *)pme->evt_queue.dequeue();
61 }
62 if (node != NULL) {
63 switch (node->cmd) {
64 case QCAMERA_SM_CMD_TYPE_API:
65 case QCAMERA_SM_CMD_TYPE_EVT:
66 pme->stateMachine(node->evt, node->evt_payload);
67 break;
68 case QCAMERA_SM_CMD_TYPE_EXIT:
69 running = 0;
70 break;
71 default:
72 break;
73 }
74 }
75 } while (running);
76 ALOGD("%s: X", __func__);
77 return NULL;
78}
79
80QCameraStateMachine::QCameraStateMachine(QCamera2HardwareInterface *ctrl) :
81 api_queue(),
82 evt_queue()
83{
84 m_parent = ctrl;
85 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
86 cmd_pid = 0;
87 sem_init(&cmd_sem, 0, 0);
88 pthread_create(&cmd_pid,
89 NULL,
90 smEvtProcRoutine,
91 this);
92}
93
94QCameraStateMachine::~QCameraStateMachine()
95{
96 if (cmd_pid != 0) {
97 qcamera_sm_cmd_t *node =
98 (qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t));
99 if (NULL != node) {
100 memset(node, 0, sizeof(qcamera_sm_cmd_t));
101 node->cmd = QCAMERA_SM_CMD_TYPE_EXIT;
102
103 api_queue.enqueue((void *)node);
104 sem_post(&cmd_sem);
105
106 /* wait until cmd thread exits */
107 if (pthread_join(cmd_pid, NULL) != 0) {
108 ALOGD("%s: pthread dead already\n", __func__);
109 }
110 }
111 cmd_pid = 0;
112 }
113 sem_destroy(&cmd_sem);
114}
115
116int32_t QCameraStateMachine::procAPI(qcamera_sm_evt_enum_t evt,
117 void *api_payload)
118{
119 qcamera_sm_cmd_t *node =
120 (qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t));
121 if (NULL != node) {
122 memset(node, 0, sizeof(qcamera_sm_cmd_t));
123 node->cmd = QCAMERA_SM_CMD_TYPE_API;
124 node->evt = evt;
125 node->evt_payload = api_payload;
126 api_queue.enqueue((void *)node);
127 sem_post(&cmd_sem);
128 }
129 return NO_ERROR;
130}
131
132int32_t QCameraStateMachine::procEvt(qcamera_sm_evt_enum_t evt,
133 void *evt_payload)
134{
135 qcamera_sm_cmd_t *node =
136 (qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t));
137 if (NULL != node) {
138 memset(node, 0, sizeof(qcamera_sm_cmd_t));
139 node->cmd = QCAMERA_SM_CMD_TYPE_EVT;
140 node->evt = evt;
141 node->evt_payload = evt_payload;
142 evt_queue.enqueue((void *)node);
143 sem_post(&cmd_sem);
144 }
145 return NO_ERROR;
146}
147
148int32_t QCameraStateMachine::stateMachine(qcamera_sm_evt_enum_t evt, void *payload)
149{
150 int32_t rc = NO_ERROR;
151 switch (m_state) {
152 case QCAMERA_SM_STATE_PREVIEW_STOPPED:
153 rc = procEvtPreviewStoppedState(evt, payload);
154 break;
155 case QCAMERA_SM_STATE_PREVIEW_READY:
156 rc = procEvtPreviewReadyState(evt, payload);
157 break;
158 case QCAMERA_SM_STATE_PREVIEWING:
159 rc = procEvtPreviewingState(evt, payload);
160 break;
161 case QCAMERA_SM_STATE_PIC_TAKING:
162 rc = procEvtPicTakingState(evt, payload);
163 break;
164 case QCAMERA_SM_STATE_RECORDING:
165 rc = procEvtRecordingState(evt, payload);
166 break;
167 case QCAMERA_SM_STATE_VIDEO_PIC_TAKING:
168 rc = procEvtVideoPicTakingState(evt, payload);
169 break;
170 case QCAMERA_SM_STATE_PREVIEW_PIC_TAKING:
171 rc = procEvtPreviewPicTakingState(evt, payload);
172 break;
173 default:
174 break;
175 }
176
177 return rc;
178}
179
180int32_t QCameraStateMachine::procEvtPreviewStoppedState(qcamera_sm_evt_enum_t evt,
181 void *payload)
182{
183 int32_t rc = NO_ERROR;
184 qcamera_api_result_t result;
185 memset(&result, 0, sizeof(qcamera_api_result_t));
186
187 switch (evt) {
188 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
189 {
190 rc = m_parent->setPreviewWindow((struct preview_stream_ops *)payload);
191 result.status = rc;
192 result.request_api = evt;
193 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
194 m_parent->signalAPIResult(&result);
195 }
196 break;
197 case QCAMERA_SM_EVT_SET_CALLBACKS:
198 {
199 qcamera_sm_evt_setcb_payload_t *setcbs =
200 (qcamera_sm_evt_setcb_payload_t *)payload;
201 rc = m_parent->setCallBacks(setcbs->notify_cb,
202 setcbs->data_cb,
203 setcbs->data_cb_timestamp,
204 setcbs->get_memory,
205 setcbs->user);
206 result.status = rc;
207 result.request_api = evt;
208 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
209 m_parent->signalAPIResult(&result);
210 }
211 break;
212 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
213 {
214 rc = m_parent->enableMsgType(int32_t(payload));
215 result.status = rc;
216 result.request_api = evt;
217 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
218 m_parent->signalAPIResult(&result);
219 }
220 break;
221 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
222 {
223 rc = m_parent->disableMsgType(int32_t(payload));
224 result.status = rc;
225 result.request_api = evt;
226 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
227 m_parent->signalAPIResult(&result);
228 }
229 break;
230 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
231 {
232 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
233 result.status = rc;
234 result.request_api = evt;
235 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
236 result.enabled = enabled;
237 m_parent->signalAPIResult(&result);
238 }
239 break;
240 case QCAMERA_SM_EVT_SET_PARAMS:
241 {
242 rc = m_parent->setParameters((char*)payload);
243 result.status = rc;
244 result.request_api = evt;
245 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
246 m_parent->signalAPIResult(&result);
247 }
248 break;
249 case QCAMERA_SM_EVT_GET_PARAMS:
250 {
251 result.params = m_parent->getParameters();
252 rc = NO_ERROR;
253 result.status = rc;
254 result.request_api = evt;
255 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
256 m_parent->signalAPIResult(&result);
257 }
258 break;
259 case QCAMERA_SM_EVT_PUT_PARAMS:
260 {
261 rc = m_parent->putParameters((char*)payload);
262 result.status = rc;
263 result.request_api = evt;
264 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
265 m_parent->signalAPIResult(&result);
266 }
267 break;
268 case QCAMERA_SM_EVT_START_PREVIEW:
269 {
270 if (m_parent->mPreviewWindow == NULL) {
271 // preview is not set yet, move to previewReady state
272 m_state = QCAMERA_SM_STATE_PREVIEW_READY;
273 rc = NO_ERROR;
274 } else {
275 rc = m_parent->preparePreview();
276 if (rc == 0) {
277 rc = m_parent->startPreview();
278 if (rc != 0) {
279 m_parent->unpreparePreview();
280 } else {
281 m_state = QCAMERA_SM_STATE_PREVIEWING;
282 }
283 }
284 }
285 result.status = rc;
286 result.request_api = evt;
287 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
288 m_parent->signalAPIResult(&result);
289 }
290 break;
291 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
292 {
293 rc = m_parent->preparePreview();
294 if (rc == NO_ERROR) {
295 rc = m_parent->startPreview();
296 if (rc != NO_ERROR) {
297 m_parent->unpreparePreview();
298 } else {
299 m_state = QCAMERA_SM_STATE_PREVIEWING;
300 }
301 }
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_STOP_PREVIEW:
309 {
310 // no op needed here
311 ALOGD("%s: already in preview stopped state, do nothing", __func__);
312 result.status = NO_ERROR;
313 result.request_api = evt;
314 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
315 m_parent->signalAPIResult(&result);
316 }
317 break;
318 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
319 case QCAMERA_SM_EVT_RECORDING_ENABLED:
320 {
321 result.status = NO_ERROR;
322 result.request_api = evt;
323 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
324 result.enabled = 0;
325 m_parent->signalAPIResult(&result);
326 }
327 break;
328 case QCAMERA_SM_EVT_RELEASE:
329 {
330 rc = m_parent->release();
331 result.status = rc;
332 result.request_api = evt;
333 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
334 m_parent->signalAPIResult(&result);
335 }
336 break;
337 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
338 {
339 rc = m_parent->storeMetaDataInBuffers(int(payload));
340 result.status = rc;
341 result.request_api = evt;
342 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
343 m_parent->signalAPIResult(&result);
344 }
345 break;
346 case QCAMERA_SM_EVT_DUMP:
347 {
348 rc = m_parent->dump((int)payload);
349 result.status = rc;
350 result.request_api = evt;
351 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
352 m_parent->signalAPIResult(&result);
353 }
354 break;
355 case QCAMERA_SM_EVT_START_RECORDING:
356 case QCAMERA_SM_EVT_STOP_RECORDING:
357 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
358 case QCAMERA_SM_EVT_TAKE_PICTURE:
359 case QCAMERA_SM_EVT_CANCEL_PICTURE:
360 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
361 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
362 case QCAMERA_SM_EVT_SEND_COMMAND:
363 {
364 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
365 rc = INVALID_OPERATION;
366 result.status = rc;
367 result.request_api = evt;
368 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
369 m_parent->signalAPIResult(&result);
370 }
371 break;
372 case QCAMERA_SM_EVT_EVT_NOTIFY:
373 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
374 default:
375 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
376 break;
377 }
378
379 return rc;
380}
381
382int32_t QCameraStateMachine::procEvtPreviewReadyState(qcamera_sm_evt_enum_t evt,
383 void *payload)
384{
385 int32_t rc = NO_ERROR;
386 qcamera_api_result_t result;
387 memset(&result, 0, sizeof(qcamera_api_result_t));
388
389 switch (evt) {
390 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
391 {
392 m_parent->setPreviewWindow((struct preview_stream_ops *)payload);
393 if (m_parent->mPreviewWindow != NULL) {
394 rc = m_parent->startPreview();
395 if (rc != NO_ERROR) {
396 m_parent->unpreparePreview();
397 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
398 } else {
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_SET_CALLBACKS:
410 {
411 qcamera_sm_evt_setcb_payload_t *setcbs =
412 (qcamera_sm_evt_setcb_payload_t *)payload;
413 rc = m_parent->setCallBacks(setcbs->notify_cb,
414 setcbs->data_cb,
415 setcbs->data_cb_timestamp,
416 setcbs->get_memory,
417 setcbs->user);
418 result.status = rc;
419 result.request_api = evt;
420 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
421 m_parent->signalAPIResult(&result);
422 }
423 break;
424 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
425 {
426 rc = m_parent->enableMsgType(int32_t(payload));
427 result.status = rc;
428 result.request_api = evt;
429 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
430 m_parent->signalAPIResult(&result);
431 }
432 break;
433 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
434 {
435 rc = m_parent->disableMsgType(int32_t(payload));
436 result.status = rc;
437 result.request_api = evt;
438 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
439 m_parent->signalAPIResult(&result);
440 }
441 break;
442 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
443 {
444 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
445 result.status = rc;
446 result.request_api = evt;
447 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
448 result.enabled = enabled;
449 m_parent->signalAPIResult(&result);
450 }
451 break;
452 case QCAMERA_SM_EVT_SET_PARAMS:
453 {
454 rc = m_parent->setParameters((char*)payload);
455 result.status = rc;
456 result.request_api = evt;
457 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
458 m_parent->signalAPIResult(&result);
459 }
460 break;
461 case QCAMERA_SM_EVT_GET_PARAMS:
462 {
463 result.params = m_parent->getParameters();
464 rc = NO_ERROR;
465 result.status = rc;
466 result.request_api = evt;
467 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
468 m_parent->signalAPIResult(&result);
469 }
470 break;
471 case QCAMERA_SM_EVT_PUT_PARAMS:
472 {
473 rc = m_parent->putParameters((char*)payload);
474 result.status = rc;
475 result.request_api = evt;
476 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
477 m_parent->signalAPIResult(&result);
478 }
479 break;
480 case QCAMERA_SM_EVT_START_PREVIEW:
481 {
482 // no ops here
483 rc = NO_ERROR;
484 result.status = rc;
485 result.request_api = evt;
486 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
487 m_parent->signalAPIResult(&result);
488 }
489 break;
490 case QCAMERA_SM_EVT_STOP_PREVIEW:
491 {
492 m_parent->unpreparePreview();
493 rc = 0;
494 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
495 result.status = rc;
496 result.request_api = evt;
497 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
498 m_parent->signalAPIResult(&result);
499 }
500 break;
501 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
502 {
503 rc = NO_ERROR;
504 result.status = rc;
505 result.request_api = evt;
506 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
507 result.enabled = 1;
508 m_parent->signalAPIResult(&result);
509 }
510 break;
511 case QCAMERA_SM_EVT_RECORDING_ENABLED:
512 {
513 rc = 0;
514 result.status = rc;
515 result.request_api = evt;
516 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
517 result.enabled = 0;
518 m_parent->signalAPIResult(&result);
519 }
520 break;
521 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
522 {
523 rc = m_parent->storeMetaDataInBuffers(int(payload));
524 result.status = rc;
525 result.request_api = evt;
526 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
527 m_parent->signalAPIResult(&result);
528 }
529 break;
530 case QCAMERA_SM_EVT_DUMP:
531 {
532 rc = m_parent->dump((int)payload);
533 result.status = rc;
534 result.request_api = evt;
535 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
536 m_parent->signalAPIResult(&result);
537 }
538 break;
539 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
540 {
541 rc = m_parent->autoFocus();
542 result.status = rc;
543 result.request_api = evt;
544 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
545 m_parent->signalAPIResult(&result);
546 }
547 break;
548 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
549 {
550 rc = m_parent->cancelAutoFocus();
551 result.status = rc;
552 result.request_api = evt;
553 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
554 m_parent->signalAPIResult(&result);
555 }
556 break;
557 case QCAMERA_SM_EVT_SEND_COMMAND:
558 {
559 qcamera_sm_evt_command_payload_t *cmd_payload =
560 (qcamera_sm_evt_command_payload_t *)payload;
561 rc = m_parent->sendCommand(cmd_payload->cmd,
562 cmd_payload->arg1,
563 cmd_payload->arg2);
564 result.status = rc;
565 result.request_api = evt;
566 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
567 m_parent->signalAPIResult(&result);
568 }
569 break;
570 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
571 case QCAMERA_SM_EVT_START_RECORDING:
572 case QCAMERA_SM_EVT_STOP_RECORDING:
573 case QCAMERA_SM_EVT_TAKE_PICTURE:
574 case QCAMERA_SM_EVT_CANCEL_PICTURE:
575 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
576 case QCAMERA_SM_EVT_RELEASE:
577 {
578 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
579 rc = INVALID_OPERATION;
580 result.status = rc;
581 result.request_api = evt;
582 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
583 m_parent->signalAPIResult(&result);
584 }
585 break;
586 case QCAMERA_SM_EVT_EVT_NOTIFY:
587 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
588 default:
589 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
590 break;
591 }
592
593 return rc;
594}
595
596int32_t QCameraStateMachine::procEvtPreviewingState(qcamera_sm_evt_enum_t evt,
597 void *payload)
598{
599 int32_t rc = NO_ERROR;
600 qcamera_api_result_t result;
601 memset(&result, 0, sizeof(qcamera_api_result_t));
602
603 switch (evt) {
604 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
605 {
606 // Error setting preview window during previewing
607 ALOGE("Cannot set preview window when preview is running");
608 rc = INVALID_OPERATION;
609 result.status = rc;
610 result.request_api = evt;
611 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
612 m_parent->signalAPIResult(&result);
613 }
614 break;
615 case QCAMERA_SM_EVT_SET_CALLBACKS:
616 {
617 qcamera_sm_evt_setcb_payload_t *setcbs =
618 (qcamera_sm_evt_setcb_payload_t *)payload;
619 rc = m_parent->setCallBacks(setcbs->notify_cb,
620 setcbs->data_cb,
621 setcbs->data_cb_timestamp,
622 setcbs->get_memory,
623 setcbs->user);
624 result.status = rc;
625 result.request_api = evt;
626 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
627 m_parent->signalAPIResult(&result);
628 }
629 break;
630 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
631 {
632 rc = m_parent->enableMsgType(int32_t(payload));
633 result.status = rc;
634 result.request_api = evt;
635 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
636 m_parent->signalAPIResult(&result);
637 }
638 break;
639 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
640 {
641 rc = m_parent->disableMsgType(int32_t(payload));
642 result.status = rc;
643 result.request_api = evt;
644 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
645 m_parent->signalAPIResult(&result);
646 }
647 break;
648 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
649 {
650 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
651 result.status = rc;
652 result.request_api = evt;
653 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
654 result.enabled = enabled;
655 m_parent->signalAPIResult(&result);
656 }
657 break;
658 case QCAMERA_SM_EVT_SET_PARAMS:
659 {
660 rc = m_parent->setParameters((char*)payload);
661 result.status = rc;
662 result.request_api = evt;
663 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
664 m_parent->signalAPIResult(&result);
665 }
666 break;
667 case QCAMERA_SM_EVT_GET_PARAMS:
668 {
669 result.params = m_parent->getParameters();
670 rc = NO_ERROR;
671 result.status = rc;
672 result.request_api = evt;
673 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
674 m_parent->signalAPIResult(&result);
675 }
676 break;
677 case QCAMERA_SM_EVT_PUT_PARAMS:
678 {
679 rc = m_parent->putParameters((char*)payload);
680 result.status = rc;
681 result.request_api = evt;
682 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
683 m_parent->signalAPIResult(&result);
684 }
685 break;
686 case QCAMERA_SM_EVT_START_PREVIEW:
687 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
688 {
689 // no ops here
690 ALOGD("%s: Already in previewing, no ops here to start preview", __func__);
691 rc = NO_ERROR;
692 result.status = rc;
693 result.request_api = evt;
694 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
695 m_parent->signalAPIResult(&result);
696 }
697 break;
698 case QCAMERA_SM_EVT_STOP_PREVIEW:
699 {
700 rc = m_parent->stopPreview();
701 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
702 result.status = rc;
703 result.request_api = evt;
704 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
705 m_parent->signalAPIResult(&result);
706 }
707 break;
708 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
709 {
710 rc = NO_ERROR;
711 result.status = rc;
712 result.request_api = evt;
713 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
714 result.enabled = 1;
715 m_parent->signalAPIResult(&result);
716 }
717 break;
718 case QCAMERA_SM_EVT_RECORDING_ENABLED:
719 {
720 rc = NO_ERROR;
721 result.status = rc;
722 result.request_api = evt;
723 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
724 result.enabled = 0;
725 m_parent->signalAPIResult(&result);
726 }
727 break;
728 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
729 {
730 rc = m_parent->storeMetaDataInBuffers(int(payload));
731 result.status = rc;
732 result.request_api = evt;
733 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
734 m_parent->signalAPIResult(&result);
735 }
736 break;
737 case QCAMERA_SM_EVT_DUMP:
738 {
739 rc = m_parent->dump((int)payload);
740 result.status = rc;
741 result.request_api = evt;
742 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
743 m_parent->signalAPIResult(&result);
744 }
745 break;
746 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
747 {
748 rc = m_parent->autoFocus();
749 result.status = rc;
750 result.request_api = evt;
751 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
752 m_parent->signalAPIResult(&result);
753 }
754 break;
755 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
756 {
757 rc = m_parent->cancelAutoFocus();
758 result.status = rc;
759 result.request_api = evt;
760 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
761 m_parent->signalAPIResult(&result);
762 }
763 break;
764 case QCAMERA_SM_EVT_START_RECORDING:
765 {
766 rc = m_parent->startRecording();
767 if (rc == NO_ERROR) {
768 // move state to recording state
769 m_state = QCAMERA_SM_STATE_RECORDING;
770 }
771 result.status = rc;
772 result.request_api = evt;
773 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
774 m_parent->signalAPIResult(&result);
775 }
776 break;
777 case QCAMERA_SM_EVT_TAKE_PICTURE:
778 {
779 rc = m_parent->takePicture();
780 if (rc == NO_ERROR) {
781 // move state to picture taking state
782 m_state = QCAMERA_SM_STATE_PIC_TAKING;
783 } else {
784 // move state to preview stopped state
785 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
786 }
787 result.status = rc;
788 result.request_api = evt;
789 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
790 m_parent->signalAPIResult(&result);
791 }
792 break;
793 case QCAMERA_SM_EVT_SEND_COMMAND:
794 {
795 qcamera_sm_evt_command_payload_t *cmd_payload =
796 (qcamera_sm_evt_command_payload_t *)payload;
797 rc = m_parent->sendCommand(cmd_payload->cmd,
798 cmd_payload->arg1,
799 cmd_payload->arg2);
800 result.status = rc;
801 result.request_api = evt;
802 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
803 m_parent->signalAPIResult(&result);
804 }
805 break;
806 case QCAMERA_SM_EVT_CANCEL_PICTURE:
807 case QCAMERA_SM_EVT_STOP_RECORDING:
808 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
809 case QCAMERA_SM_EVT_RELEASE:
810 {
811 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
812 rc = INVALID_OPERATION;
813 result.status = rc;
814 result.request_api = evt;
815 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
816 m_parent->signalAPIResult(&result);
817 }
818 break;
819 case QCAMERA_SM_EVT_EVT_NOTIFY:
820 {
821 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
822 switch (cam_evt->server_event_type) {
823 case CAM_EVENT_TYPE_AUTO_FOCUS_DONE:
824 rc = m_parent->processAutoFocusEvent(cam_evt->status);
825 break;
826 case CAM_EVENT_TYPE_ZOOM_DONE:
827 rc = m_parent->processZoomEvent(cam_evt->status);
828 break;
829 default:
830 ALOGD("%s: no handling for server evt (%d) at this state",
831 __func__, cam_evt->server_event_type);
832 break;
833 }
834 }
835 break;
836 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
837 default:
838 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
839 break;
840 }
841
842 return rc;
843}
844
845int32_t QCameraStateMachine::procEvtPicTakingState(qcamera_sm_evt_enum_t evt,
846 void *payload)
847{
848 int32_t rc = NO_ERROR;
849 qcamera_api_result_t result;
850 memset(&result, 0, sizeof(qcamera_api_result_t));
851
852 switch (evt) {
853 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
854 {
855 // Error setting preview window during previewing
856 ALOGE("Cannot set preview window when preview is running");
857 rc = INVALID_OPERATION;
858 result.status = rc;
859 result.request_api = evt;
860 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
861 m_parent->signalAPIResult(&result);
862 }
863 break;
864 case QCAMERA_SM_EVT_SET_CALLBACKS:
865 {
866 qcamera_sm_evt_setcb_payload_t *setcbs =
867 (qcamera_sm_evt_setcb_payload_t *)payload;
868 rc = m_parent->setCallBacks(setcbs->notify_cb,
869 setcbs->data_cb,
870 setcbs->data_cb_timestamp,
871 setcbs->get_memory,
872 setcbs->user);
873 result.status = rc;
874 result.request_api = evt;
875 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
876 m_parent->signalAPIResult(&result);
877 }
878 break;
879 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
880 {
881 rc = m_parent->enableMsgType(int32_t(payload));
882 result.status = rc;
883 result.request_api = evt;
884 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
885 m_parent->signalAPIResult(&result);
886 }
887 break;
888 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
889 {
890 rc = m_parent->disableMsgType(int32_t(payload));
891 result.status = rc;
892 result.request_api = evt;
893 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
894 m_parent->signalAPIResult(&result);
895 }
896 break;
897 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
898 {
899 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
900 result.status = rc;
901 result.request_api = evt;
902 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
903 result.enabled = enabled;
904 m_parent->signalAPIResult(&result);
905 }
906 break;
907 case QCAMERA_SM_EVT_SET_PARAMS:
908 {
909 rc = m_parent->setParameters((char*)payload);
910 result.status = rc;
911 result.request_api = evt;
912 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
913 m_parent->signalAPIResult(&result);
914 }
915 break;
916 case QCAMERA_SM_EVT_GET_PARAMS:
917 {
918 result.params = m_parent->getParameters();
919 rc = NO_ERROR;
920 result.status = rc;
921 result.request_api = evt;
922 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
923 m_parent->signalAPIResult(&result);
924 }
925 break;
926 case QCAMERA_SM_EVT_PUT_PARAMS:
927 {
928 rc = m_parent->putParameters((char*)payload);
929 result.status = rc;
930 result.request_api = evt;
931 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
932 m_parent->signalAPIResult(&result);
933 }
934 break;
935 case QCAMERA_SM_EVT_STOP_PREVIEW:
936 {
937 // no ops, since preview is stopped (normal),
938 // or preview msg type is disabled (ZSL)
939 rc = NO_ERROR;
940 result.status = rc;
941 result.request_api = evt;
942 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
943 m_parent->signalAPIResult(&result);
944 }
945 break;
946 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
947 {
948 rc = NO_ERROR;
949 result.status = rc;
950 result.request_api = evt;
951 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
952 result.enabled = 0;
953 m_parent->signalAPIResult(&result);
954 }
955 break;
956 case QCAMERA_SM_EVT_RECORDING_ENABLED:
957 {
958 rc = NO_ERROR;
959 result.status = rc;
960 result.request_api = evt;
961 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
962 result.enabled = 0;
963 m_parent->signalAPIResult(&result);
964 }
965 break;
966 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
967 {
968 rc = m_parent->storeMetaDataInBuffers(int(payload));
969 result.status = rc;
970 result.request_api = evt;
971 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
972 m_parent->signalAPIResult(&result);
973 }
974 break;
975 case QCAMERA_SM_EVT_DUMP:
976 {
977 rc = m_parent->dump((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_START_AUTO_FOCUS:
985 {
986 rc = m_parent->autoFocus();
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_STOP_AUTO_FOCUS:
994 {
995 rc = m_parent->cancelAutoFocus();
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_SEND_COMMAND:
1003 {
1004 qcamera_sm_evt_command_payload_t *cmd_payload =
1005 (qcamera_sm_evt_command_payload_t *)payload;
1006 rc = m_parent->sendCommand(cmd_payload->cmd,
1007 cmd_payload->arg1,
1008 cmd_payload->arg2);
1009 result.status = rc;
1010 result.request_api = evt;
1011 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1012 m_parent->signalAPIResult(&result);
1013 }
1014 break;
1015 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1016 {
1017 rc = m_parent->cancelPicture();
1018 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1019 result.status = rc;
1020 result.request_api = evt;
1021 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1022 m_parent->signalAPIResult(&result);
1023 }
1024 break;
1025 case QCAMERA_SM_EVT_TAKE_PICTURE:
1026 case QCAMERA_SM_EVT_START_RECORDING:
1027 case QCAMERA_SM_EVT_STOP_RECORDING:
1028 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1029 case QCAMERA_SM_EVT_START_PREVIEW:
1030 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1031 case QCAMERA_SM_EVT_RELEASE:
1032 {
1033 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1034 rc = INVALID_OPERATION;
1035 result.status = rc;
1036 result.request_api = evt;
1037 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1038 m_parent->signalAPIResult(&result);
1039 }
1040 break;
1041 case QCAMERA_SM_EVT_EVT_NOTIFY:
1042 {
1043 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1044 switch (cam_evt->server_event_type) {
1045 case CAM_EVENT_TYPE_AUTO_FOCUS_DONE:
1046 rc = m_parent->processAutoFocusEvent(cam_evt->status);
1047 break;
1048 case CAM_EVENT_TYPE_ZOOM_DONE:
1049 rc = m_parent->processZoomEvent(cam_evt->status);
1050 break;
1051 default:
1052 ALOGD("%s: no handling for server evt (%d) at this state",
1053 __func__, cam_evt->server_event_type);
1054 break;
1055 }
1056 }
1057 break;
1058 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1059 {
1060 qcamera_jpeg_evt_payload_t *jpeg_job =
1061 (qcamera_jpeg_evt_payload_t *)payload;
1062 rc = m_parent->processJpegNotify(jpeg_job);
1063 }
1064 break;
1065 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1066 {
1067 rc = m_parent->cancelPicture();
1068 m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
1069 }
1070 break;
1071 default:
1072 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1073 break;
1074 }
1075
1076 return rc;
1077}
1078
1079int32_t QCameraStateMachine::procEvtRecordingState(qcamera_sm_evt_enum_t evt,
1080 void *payload)
1081{
1082 int32_t rc = NO_ERROR;
1083 qcamera_api_result_t result;
1084 memset(&result, 0, sizeof(qcamera_api_result_t));
1085
1086 switch (evt) {
1087 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1088 {
1089 // Error setting preview window during previewing
1090 ALOGE("Cannot set preview window when preview is running");
1091 rc = INVALID_OPERATION;
1092 result.status = rc;
1093 result.request_api = evt;
1094 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1095 m_parent->signalAPIResult(&result);
1096 }
1097 break;
1098 case QCAMERA_SM_EVT_SET_CALLBACKS:
1099 {
1100 qcamera_sm_evt_setcb_payload_t *setcbs =
1101 (qcamera_sm_evt_setcb_payload_t *)payload;
1102 rc = m_parent->setCallBacks(setcbs->notify_cb,
1103 setcbs->data_cb,
1104 setcbs->data_cb_timestamp,
1105 setcbs->get_memory,
1106 setcbs->user);
1107 result.status = rc;
1108 result.request_api = evt;
1109 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1110 m_parent->signalAPIResult(&result);
1111 }
1112 break;
1113 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1114 {
1115 rc = m_parent->enableMsgType(int32_t(payload));
1116 result.status = rc;
1117 result.request_api = evt;
1118 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1119 m_parent->signalAPIResult(&result);
1120 }
1121 break;
1122 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1123 {
1124 rc = m_parent->disableMsgType(int32_t(payload));
1125 result.status = rc;
1126 result.request_api = evt;
1127 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1128 m_parent->signalAPIResult(&result);
1129 }
1130 break;
1131 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1132 {
1133 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1134 result.status = rc;
1135 result.request_api = evt;
1136 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1137 result.enabled = enabled;
1138 m_parent->signalAPIResult(&result);
1139 }
1140 break;
1141 case QCAMERA_SM_EVT_SET_PARAMS:
1142 {
1143 rc = m_parent->setParameters((char*)payload);
1144 result.status = rc;
1145 result.request_api = evt;
1146 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1147 m_parent->signalAPIResult(&result);
1148 }
1149 break;
1150 case QCAMERA_SM_EVT_GET_PARAMS:
1151 {
1152 result.params = m_parent->getParameters();
1153 rc = NO_ERROR;
1154 result.status = rc;
1155 result.request_api = evt;
1156 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1157 m_parent->signalAPIResult(&result);
1158 }
1159 break;
1160 case QCAMERA_SM_EVT_PUT_PARAMS:
1161 {
1162 rc = m_parent->putParameters((char*)payload);
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_PREVIEW_ENABLED:
1170 {
1171 rc = NO_ERROR;
1172 result.status = rc;
1173 result.request_api = evt;
1174 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1175 result.enabled = 0;
1176 m_parent->signalAPIResult(&result);
1177 }
1178 break;
1179 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1180 {
1181 rc = NO_ERROR;
1182 result.status = rc;
1183 result.request_api = evt;
1184 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1185 result.enabled = 1;
1186 m_parent->signalAPIResult(&result);
1187 }
1188 break;
1189 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1190 {
1191 rc = m_parent->storeMetaDataInBuffers(int(payload));
1192 result.status = rc;
1193 result.request_api = evt;
1194 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1195 m_parent->signalAPIResult(&result);
1196 }
1197 break;
1198 case QCAMERA_SM_EVT_DUMP:
1199 {
1200 rc = m_parent->dump((int)payload);
1201 result.status = rc;
1202 result.request_api = evt;
1203 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1204 m_parent->signalAPIResult(&result);
1205 }
1206 break;
1207 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1208 {
1209 rc = m_parent->autoFocus();
1210 result.status = rc;
1211 result.request_api = evt;
1212 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1213 m_parent->signalAPIResult(&result);
1214 }
1215 break;
1216 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1217 {
1218 rc = m_parent->cancelAutoFocus();
1219 result.status = rc;
1220 result.request_api = evt;
1221 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1222 m_parent->signalAPIResult(&result);
1223 }
1224 break;
1225 case QCAMERA_SM_EVT_SEND_COMMAND:
1226 {
1227 qcamera_sm_evt_command_payload_t *cmd_payload =
1228 (qcamera_sm_evt_command_payload_t *)payload;
1229 rc = m_parent->sendCommand(cmd_payload->cmd,
1230 cmd_payload->arg1,
1231 cmd_payload->arg2);
1232 result.status = rc;
1233 result.request_api = evt;
1234 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1235 m_parent->signalAPIResult(&result);
1236 }
1237 break;
1238 case QCAMERA_SM_EVT_TAKE_PICTURE:
1239 {
1240 rc = m_parent->takeLiveSnapshot();
1241 if (rc == 0) {
1242 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
1243 }
1244 result.status = rc;
1245 result.request_api = evt;
1246 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1247 m_parent->signalAPIResult(&result);
1248 }
1249 break;
1250 case QCAMERA_SM_EVT_START_RECORDING:
1251 {
1252 // no ops here
1253 ALOGD("%s: already in recording state, no ops for start_recording", __func__);
1254 rc = 0;
1255 result.status = rc;
1256 result.request_api = evt;
1257 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1258 m_parent->signalAPIResult(&result);
1259 }
1260 break;
1261 case QCAMERA_SM_EVT_STOP_RECORDING:
1262 {
1263 rc = m_parent->stopRecording();
1264 m_state = QCAMERA_SM_STATE_PREVIEWING;
1265 result.status = rc;
1266 result.request_api = evt;
1267 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1268 m_parent->signalAPIResult(&result);
1269 }
1270 break;
1271 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1272 {
1273 rc = m_parent->releaseRecordingFrame((const void *)payload);
1274 result.status = rc;
1275 result.request_api = evt;
1276 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1277 m_parent->signalAPIResult(&result);
1278 }
1279 break;
1280 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1281 case QCAMERA_SM_EVT_START_PREVIEW:
1282 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1283 case QCAMERA_SM_EVT_STOP_PREVIEW:
1284 case QCAMERA_SM_EVT_RELEASE:
1285 {
1286 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1287 rc = INVALID_OPERATION;
1288 result.status = rc;
1289 result.request_api = evt;
1290 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1291 m_parent->signalAPIResult(&result);
1292 }
1293 break;
1294 case QCAMERA_SM_EVT_EVT_NOTIFY:
1295 {
1296 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1297 switch (cam_evt->server_event_type) {
1298 case CAM_EVENT_TYPE_AUTO_FOCUS_DONE:
1299 rc = m_parent->processAutoFocusEvent(cam_evt->status);
1300 break;
1301 case CAM_EVENT_TYPE_ZOOM_DONE:
1302 rc = m_parent->processZoomEvent(cam_evt->status);
1303 break;
1304 default:
1305 ALOGD("%s: no handling for server evt (%d) at this state",
1306 __func__, cam_evt->server_event_type);
1307 break;
1308 }
1309 }
1310 break;
1311 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1312 default:
1313 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1314 break;
1315 }
1316
1317 return rc;
1318}
1319
1320int32_t QCameraStateMachine::procEvtVideoPicTakingState(qcamera_sm_evt_enum_t evt,
1321 void *payload)
1322{
1323 int32_t rc = NO_ERROR;
1324 qcamera_api_result_t result;
1325 memset(&result, 0, sizeof(qcamera_api_result_t));
1326
1327 switch (evt) {
1328 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1329 {
1330 // Error setting preview window during previewing
1331 ALOGE("Cannot set preview window when preview is running");
1332 rc = INVALID_OPERATION;
1333 result.status = rc;
1334 result.request_api = evt;
1335 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1336 m_parent->signalAPIResult(&result);
1337 }
1338 break;
1339 case QCAMERA_SM_EVT_SET_CALLBACKS:
1340 {
1341 qcamera_sm_evt_setcb_payload_t *setcbs =
1342 (qcamera_sm_evt_setcb_payload_t *)payload;
1343 rc = m_parent->setCallBacks(setcbs->notify_cb,
1344 setcbs->data_cb,
1345 setcbs->data_cb_timestamp,
1346 setcbs->get_memory,
1347 setcbs->user);
1348 result.status = rc;
1349 result.request_api = evt;
1350 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1351 m_parent->signalAPIResult(&result);
1352 }
1353 break;
1354 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1355 {
1356 rc = m_parent->enableMsgType(int32_t(payload));
1357 result.status = rc;
1358 result.request_api = evt;
1359 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1360 m_parent->signalAPIResult(&result);
1361 }
1362 break;
1363 case QCAMERA_SM_EVT_DISABLE_MSG_TYPE:
1364 {
1365 rc = m_parent->disableMsgType(int32_t(payload));
1366 result.status = rc;
1367 result.request_api = evt;
1368 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1369 m_parent->signalAPIResult(&result);
1370 }
1371 break;
1372 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1373 {
1374 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1375 result.status = rc;
1376 result.request_api = evt;
1377 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1378 result.enabled = enabled;
1379 m_parent->signalAPIResult(&result);
1380 }
1381 break;
1382 case QCAMERA_SM_EVT_SET_PARAMS:
1383 {
1384 rc = m_parent->setParameters((char*)payload);
1385 result.status = rc;
1386 result.request_api = evt;
1387 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1388 m_parent->signalAPIResult(&result);
1389 }
1390 break;
1391 case QCAMERA_SM_EVT_GET_PARAMS:
1392 {
1393 result.params = m_parent->getParameters();
1394 rc = NO_ERROR;
1395 result.status = rc;
1396 result.request_api = evt;
1397 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1398 m_parent->signalAPIResult(&result);
1399 }
1400 break;
1401 case QCAMERA_SM_EVT_PUT_PARAMS:
1402 {
1403 rc = m_parent->putParameters((char*)payload);
1404 result.status = rc;
1405 result.request_api = evt;
1406 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1407 m_parent->signalAPIResult(&result);
1408 }
1409 break;
1410 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1411 {
1412 rc = NO_ERROR;
1413 result.status = rc;
1414 result.request_api = evt;
1415 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1416 result.enabled = 1;
1417 m_parent->signalAPIResult(&result);
1418 }
1419 break;
1420 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1421 {
1422 rc = NO_ERROR;
1423 result.status = rc;
1424 result.request_api = evt;
1425 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1426 result.enabled = 1;
1427 m_parent->signalAPIResult(&result);
1428 }
1429 break;
1430 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1431 {
1432 rc = m_parent->storeMetaDataInBuffers(int(payload));
1433 result.status = rc;
1434 result.request_api = evt;
1435 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1436 m_parent->signalAPIResult(&result);
1437 }
1438 break;
1439 case QCAMERA_SM_EVT_DUMP:
1440 {
1441 rc = m_parent->dump((int)payload);
1442 result.status = rc;
1443 result.request_api = evt;
1444 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1445 m_parent->signalAPIResult(&result);
1446 }
1447 break;
1448 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1449 {
1450 rc = m_parent->autoFocus();
1451 result.status = rc;
1452 result.request_api = evt;
1453 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1454 m_parent->signalAPIResult(&result);
1455 }
1456 break;
1457 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1458 {
1459 rc = m_parent->cancelAutoFocus();
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;
1466 case QCAMERA_SM_EVT_SEND_COMMAND:
1467 {
1468 qcamera_sm_evt_command_payload_t *cmd_payload =
1469 (qcamera_sm_evt_command_payload_t *)payload;
1470 rc = m_parent->sendCommand(cmd_payload->cmd,
1471 cmd_payload->arg1,
1472 cmd_payload->arg2);
1473 result.status = rc;
1474 result.request_api = evt;
1475 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1476 m_parent->signalAPIResult(&result);
1477 }
1478 break;
1479 case QCAMERA_SM_EVT_STOP_RECORDING:
1480 {
1481 rc = m_parent->stopRecording();
1482 m_state = QCAMERA_SM_STATE_PREVIEW_PIC_TAKING;
1483 result.status = rc;
1484 result.request_api = evt;
1485 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1486 m_parent->signalAPIResult(&result);
1487 }
1488 break;
1489 case QCAMERA_SM_EVT_RELEASE_RECORIDNG_FRAME:
1490 {
1491 rc = m_parent->releaseRecordingFrame((const void *)payload);
1492 result.status = rc;
1493 result.request_api = evt;
1494 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1495 m_parent->signalAPIResult(&result);
1496 }
1497 break;
1498 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1499 {
1500 rc = m_parent->cancelLiveSnapshot();
1501 m_state = QCAMERA_SM_STATE_RECORDING;
1502 result.status = rc;
1503 result.request_api = evt;
1504 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1505 m_parent->signalAPIResult(&result);
1506 }
1507 break;
1508 case QCAMERA_SM_EVT_START_RECORDING:
1509 case QCAMERA_SM_EVT_START_PREVIEW:
1510 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1511 case QCAMERA_SM_EVT_STOP_PREVIEW:
1512 case QCAMERA_SM_EVT_TAKE_PICTURE:
1513 case QCAMERA_SM_EVT_RELEASE:
1514 {
1515 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1516 rc = INVALID_OPERATION;
1517 result.status = rc;
1518 result.request_api = evt;
1519 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1520 m_parent->signalAPIResult(&result);
1521 }
1522 break;
1523 case QCAMERA_SM_EVT_EVT_NOTIFY:
1524 {
1525 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1526 switch (cam_evt->server_event_type) {
1527 case CAM_EVENT_TYPE_AUTO_FOCUS_DONE:
1528 rc = m_parent->processAutoFocusEvent(cam_evt->status);
1529 break;
1530 case CAM_EVENT_TYPE_ZOOM_DONE:
1531 rc = m_parent->processZoomEvent(cam_evt->status);
1532 break;
1533 default:
1534 ALOGD("%s: no handling for server evt (%d) at this state",
1535 __func__, cam_evt->server_event_type);
1536 break;
1537 }
1538 }
1539 break;
1540 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1541 {
1542 qcamera_jpeg_evt_payload_t *jpeg_job =
1543 (qcamera_jpeg_evt_payload_t *)payload;
1544 rc = m_parent->processJpegNotify(jpeg_job);
1545 }
1546 break;
1547 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1548 {
1549 rc = m_parent->cancelLiveSnapshot();
1550 m_state = QCAMERA_SM_STATE_RECORDING;
1551 }
1552 break;
1553 default:
1554 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1555 break;
1556 }
1557
1558 return rc;
1559}
1560
1561int32_t QCameraStateMachine::procEvtPreviewPicTakingState(qcamera_sm_evt_enum_t evt,
1562 void *payload)
1563{
1564 int32_t rc = NO_ERROR;
1565 qcamera_api_result_t result;
1566 memset(&result, 0, sizeof(qcamera_api_result_t));
1567
1568 switch (evt) {
1569 case QCAMERA_SM_EVT_SET_CALLBACKS:
1570 {
1571 qcamera_sm_evt_setcb_payload_t *setcbs =
1572 (qcamera_sm_evt_setcb_payload_t *)payload;
1573 rc = m_parent->setCallBacks(setcbs->notify_cb,
1574 setcbs->data_cb,
1575 setcbs->data_cb_timestamp,
1576 setcbs->get_memory,
1577 setcbs->user);
1578 result.status = rc;
1579 result.request_api = evt;
1580 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1581 m_parent->signalAPIResult(&result);
1582 }
1583 break;
1584 case QCAMERA_SM_EVT_ENABLE_MSG_TYPE:
1585 {
1586 rc = m_parent->enableMsgType(int32_t(payload));
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_DISABLE_MSG_TYPE:
1594 {
1595 rc = m_parent->disableMsgType(int32_t(payload));
1596 result.status = rc;
1597 result.request_api = evt;
1598 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1599 m_parent->signalAPIResult(&result);
1600 }
1601 break;
1602 case QCAMERA_SM_EVT_MSG_TYPE_ENABLED:
1603 {
1604 int enabled = m_parent->msgTypeEnabled(int32_t(payload));
1605 result.status = rc;
1606 result.request_api = evt;
1607 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1608 result.enabled = enabled;
1609 m_parent->signalAPIResult(&result);
1610 }
1611 break;
1612 case QCAMERA_SM_EVT_SET_PARAMS:
1613 {
1614 rc = m_parent->setParameters((char*)payload);
1615 result.status = rc;
1616 result.request_api = evt;
1617 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1618 m_parent->signalAPIResult(&result);
1619 }
1620 break;
1621 case QCAMERA_SM_EVT_GET_PARAMS:
1622 {
1623 result.params = m_parent->getParameters();
1624 rc = NO_ERROR;
1625 result.status = rc;
1626 result.request_api = evt;
1627 result.result_type = QCAMERA_API_RESULT_TYPE_PARAMS;
1628 m_parent->signalAPIResult(&result);
1629 }
1630 break;
1631 case QCAMERA_SM_EVT_PUT_PARAMS:
1632 {
1633 rc = m_parent->putParameters((char*)payload);
1634 result.status = rc;
1635 result.request_api = evt;
1636 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1637 m_parent->signalAPIResult(&result);
1638 }
1639 break;
1640 case QCAMERA_SM_EVT_PREVIEW_ENABLED:
1641 {
1642 rc = NO_ERROR;
1643 result.status = rc;
1644 result.request_api = evt;
1645 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1646 result.enabled = 1;
1647 m_parent->signalAPIResult(&result);
1648 }
1649 break;
1650 case QCAMERA_SM_EVT_RECORDING_ENABLED:
1651 {
1652 rc = NO_ERROR;
1653 result.status = rc;
1654 result.request_api = evt;
1655 result.result_type = QCAMERA_API_RESULT_TYPE_ENABLE_FLAG;
1656 result.enabled = 0;
1657 m_parent->signalAPIResult(&result);
1658 }
1659 break;
1660 case QCAMERA_SM_EVT_STORE_METADATA_IN_BUFS:
1661 {
1662 rc = m_parent->storeMetaDataInBuffers(int(payload));
1663 result.status = rc;
1664 result.request_api = evt;
1665 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1666 m_parent->signalAPIResult(&result);
1667 }
1668 break;
1669 case QCAMERA_SM_EVT_DUMP:
1670 {
1671 rc = m_parent->dump((int)payload);
1672 result.status = rc;
1673 result.request_api = evt;
1674 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1675 m_parent->signalAPIResult(&result);
1676 }
1677 break;
1678 case QCAMERA_SM_EVT_START_AUTO_FOCUS:
1679 {
1680 rc = m_parent->autoFocus();
1681 result.status = rc;
1682 result.request_api = evt;
1683 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1684 m_parent->signalAPIResult(&result);
1685 }
1686 break;
1687 case QCAMERA_SM_EVT_STOP_AUTO_FOCUS:
1688 {
1689 rc = m_parent->cancelAutoFocus();
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_SEND_COMMAND:
1697 {
1698 qcamera_sm_evt_command_payload_t *cmd_payload =
1699 (qcamera_sm_evt_command_payload_t *)payload;
1700 rc = m_parent->sendCommand(cmd_payload->cmd,
1701 cmd_payload->arg1,
1702 cmd_payload->arg2);
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_RELEASE_RECORIDNG_FRAME:
1710 {
1711 rc = m_parent->releaseRecordingFrame((const void *)payload);
1712 result.status = rc;
1713 result.request_api = evt;
1714 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1715 m_parent->signalAPIResult(&result);
1716 }
1717 break;
1718 case QCAMERA_SM_EVT_CANCEL_PICTURE:
1719 {
1720 rc = m_parent->cancelLiveSnapshot();
1721 m_state = QCAMERA_SM_STATE_PREVIEWING;
1722 result.status = rc;
1723 result.request_api = evt;
1724 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1725 m_parent->signalAPIResult(&result);
1726 }
1727 break;
1728 case QCAMERA_SM_EVT_STOP_PREVIEW:
1729 {
1730 m_parent->stopChannel(QCAMERA_CH_TYPE_PREVIEW);
1731 m_parent->delChannel(QCAMERA_CH_TYPE_PREVIEW);
1732 m_parent->delChannel(QCAMERA_CH_TYPE_VIDEO);
1733 m_state = QCAMERA_SM_STATE_PIC_TAKING;
1734 rc = NO_ERROR;
1735 result.status = rc;
1736 result.request_api = evt;
1737 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1738 m_parent->signalAPIResult(&result);
1739 }
1740 break;
1741 case QCAMERA_SM_EVT_START_RECORDING:
1742 {
1743 rc = m_parent->stopRecording();
1744 if (rc == NO_ERROR) {
1745 m_state = QCAMERA_SM_STATE_VIDEO_PIC_TAKING;
1746 }
1747 result.status = rc;
1748 result.request_api = evt;
1749 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1750 m_parent->signalAPIResult(&result);
1751 }
1752 break;
1753 case QCAMERA_SM_EVT_STOP_RECORDING:
1754 case QCAMERA_SM_EVT_START_PREVIEW:
1755 case QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW:
1756 case QCAMERA_SM_EVT_TAKE_PICTURE:
1757 case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
1758 case QCAMERA_SM_EVT_RELEASE:
1759 {
1760 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1761 rc = INVALID_OPERATION;
1762 result.status = rc;
1763 result.request_api = evt;
1764 result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
1765 m_parent->signalAPIResult(&result);
1766 }
1767 break;
1768 case QCAMERA_SM_EVT_EVT_NOTIFY:
1769 {
1770 mm_camera_event_t *cam_evt = (mm_camera_event_t *)payload;
1771 switch (cam_evt->server_event_type) {
1772 case CAM_EVENT_TYPE_AUTO_FOCUS_DONE:
1773 rc = m_parent->processAutoFocusEvent(cam_evt->status);
1774 break;
1775 case CAM_EVENT_TYPE_ZOOM_DONE:
1776 rc = m_parent->processZoomEvent(cam_evt->status);
1777 break;
1778 default:
1779 ALOGD("%s: no handling for server evt (%d) at this state",
1780 __func__, cam_evt->server_event_type);
1781 break;
1782 }
1783 }
1784 break;
1785 case QCAMERA_SM_EVT_JPEG_EVT_NOTIFY:
1786 {
1787 qcamera_jpeg_evt_payload_t *jpeg_job =
1788 (qcamera_jpeg_evt_payload_t *)payload;
1789 rc = m_parent->processJpegNotify(jpeg_job);
1790 }
1791 break;
1792 case QCAMERA_SM_EVT_SNAPSHOT_DONE:
1793 {
1794 rc = m_parent->cancelLiveSnapshot();
1795 m_state = QCAMERA_SM_STATE_PREVIEWING;
1796 }
1797 break;
1798 default:
1799 ALOGE("%s: cannot handle evt(%d) in state(%d)", __func__, evt, m_state);
1800 break;
1801 }
1802
1803 return rc;
1804}
1805
1806}; // namespace android