BaseCameraAdapter.cpp revision 85c859b69b3c003b8db810371e24fe41599fc7de 
1/*
2 * Copyright (C) Texas Instruments - http://www.ti.com/
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17
18
19#define LOG_TAG "CameraHAL"
20
21#include "BaseCameraAdapter.h"
22
23namespace android {
24
25/*--------------------Camera Adapter Class STARTS here-----------------------------*/
26
27BaseCameraAdapter::BaseCameraAdapter()
28{
29    mReleaseImageBuffersCallback = NULL;
30    mEndImageCaptureCallback = NULL;
31    mErrorNotifier = NULL;
32    mEndCaptureData = NULL;
33    mReleaseData = NULL;
34    mRecording = false;
35
36    mPreviewBuffers = NULL;
37    mPreviewBufferCount = 0;
38    mPreviewBuffersLength = 0;
39
40    mVideoBuffers = NULL;
41    mVideoBuffersCount = 0;
42    mVideoBuffersLength = 0;
43
44    mCaptureBuffers = NULL;
45    mCaptureBuffersCount = 0;
46    mCaptureBuffersLength = 0;
47
48    mPreviewDataBuffers = NULL;
49    mPreviewDataBuffersCount = 0;
50    mPreviewDataBuffersLength = 0;
51
52    mAdapterState = INTIALIZED_STATE;
53
54#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
55    mStartFocus.tv_sec = 0;
56    mStartFocus.tv_usec = 0;
57    mStartCapture.tv_sec = 0;
58    mStartCapture.tv_usec = 0;
59#endif
60
61}
62
63BaseCameraAdapter::~BaseCameraAdapter()
64{
65     LOG_FUNCTION_NAME;
66
67     Mutex::Autolock lock(mSubscriberLock);
68
69     mFrameSubscribers.clear();
70     mImageSubscribers.clear();
71     mRawSubscribers.clear();
72     mVideoSubscribers.clear();
73     mFocusSubscribers.clear();
74     mShutterSubscribers.clear();
75     mZoomSubscribers.clear();
76     mFaceSubscribers.clear();
77
78     LOG_FUNCTION_NAME_EXIT;
79}
80
81status_t BaseCameraAdapter::registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data)
82{
83    status_t ret = NO_ERROR;
84
85    LOG_FUNCTION_NAME;
86
87    mReleaseImageBuffersCallback = callback;
88    mReleaseData = user_data;
89
90    LOG_FUNCTION_NAME_EXIT;
91
92    return ret;
93}
94
95status_t BaseCameraAdapter::registerEndCaptureCallback(end_image_capture_callback callback, void *user_data)
96{
97    status_t ret = NO_ERROR;
98
99    LOG_FUNCTION_NAME;
100
101    mEndImageCaptureCallback= callback;
102    mEndCaptureData = user_data;
103
104    LOG_FUNCTION_NAME_EXIT;
105
106    return ret;
107}
108
109status_t BaseCameraAdapter::setErrorHandler(ErrorNotifier *errorNotifier)
110{
111    status_t ret = NO_ERROR;
112
113    LOG_FUNCTION_NAME;
114
115    if ( NULL == errorNotifier )
116        {
117        CAMHAL_LOGEA("Invalid Error Notifier reference");
118        ret = -EINVAL;
119        }
120
121    if ( NO_ERROR == ret )
122        {
123        mErrorNotifier = errorNotifier;
124        }
125
126    LOG_FUNCTION_NAME_EXIT;
127
128    return ret;
129}
130
131void BaseCameraAdapter::enableMsgType(int32_t msgs, frame_callback callback, event_callback eventCb, void* cookie)
132{
133    Mutex::Autolock lock(mSubscriberLock);
134
135    LOG_FUNCTION_NAME;
136
137    if ( CameraFrame::PREVIEW_FRAME_SYNC == msgs )
138        {
139        mFrameSubscribers.add((int) cookie, callback);
140        }
141    else if ( CameraFrame::FRAME_DATA_SYNC == msgs )
142        {
143        mFrameDataSubscribers.add((int) cookie, callback);
144        }
145    else if ( CameraFrame::IMAGE_FRAME == msgs)
146        {
147        mImageSubscribers.add((int) cookie, callback);
148        }
149    else if ( CameraFrame::RAW_FRAME == msgs)
150        {
151        mRawSubscribers.add((int) cookie, callback);
152        }
153    else if ( CameraFrame::VIDEO_FRAME_SYNC == msgs)
154        {
155        mVideoSubscribers.add((int) cookie, callback);
156        }
157    else if ( CameraHalEvent::ALL_EVENTS == msgs)
158        {
159        mFocusSubscribers.add((int) cookie, eventCb);
160        mShutterSubscribers.add((int) cookie, eventCb);
161        mZoomSubscribers.add((int) cookie, eventCb);
162        mFaceSubscribers.add((int) cookie, eventCb);
163        }
164    else
165        {
166        CAMHAL_LOGEA("Message type subscription no supported yet!");
167        }
168
169    LOG_FUNCTION_NAME_EXIT;
170}
171
172void BaseCameraAdapter::disableMsgType(int32_t msgs, void* cookie)
173{
174    Mutex::Autolock lock(mSubscriberLock);
175
176    LOG_FUNCTION_NAME;
177
178    if ( CameraFrame::PREVIEW_FRAME_SYNC == msgs )
179        {
180        mFrameSubscribers.removeItem((int) cookie);
181        }
182    else if ( CameraFrame::FRAME_DATA_SYNC == msgs )
183        {
184        mFrameDataSubscribers.removeItem((int) cookie);
185        }
186    else if ( CameraFrame::IMAGE_FRAME == msgs)
187        {
188        mImageSubscribers.removeItem((int) cookie);
189        }
190    else if ( CameraFrame::RAW_FRAME == msgs)
191        {
192        mRawSubscribers.removeItem((int) cookie);
193        }
194    else if ( CameraFrame::VIDEO_FRAME_SYNC == msgs)
195        {
196        mVideoSubscribers.removeItem((int) cookie);
197        }
198    else if ( CameraFrame::ALL_FRAMES  == msgs )
199        {
200        mFrameSubscribers.removeItem((int) cookie);
201        mFrameDataSubscribers.removeItem((int) cookie);
202        mImageSubscribers.removeItem((int) cookie);
203        mRawSubscribers.removeItem((int) cookie);
204        mVideoSubscribers.removeItem((int) cookie);
205        }
206    else if ( CameraHalEvent::ALL_EVENTS == msgs)
207        {
208         //Subscribe only for focus
209         //TODO: Process case by case
210        mFocusSubscribers.removeItem((int) cookie);
211        mShutterSubscribers.removeItem((int) cookie);
212        mZoomSubscribers.removeItem((int) cookie);
213        mFaceSubscribers.removeItem((int) cookie);
214        }
215    else
216        {
217        CAMHAL_LOGEB("Message type 0x%x subscription no supported yet!", msgs);
218        }
219
220    LOG_FUNCTION_NAME_EXIT;
221}
222
223void BaseCameraAdapter::returnFrame(void* frameBuf, CameraFrame::FrameType frameType)
224{
225    status_t res = NO_ERROR;
226    size_t subscriberCount = 0;
227    int refCount = -1;
228
229    Mutex::Autolock lock(mReturnFrameLock);
230
231    if ( NULL == frameBuf )
232        {
233        CAMHAL_LOGEA("Invalid frameBuf");
234        return;
235        }
236
237    if ( NO_ERROR == res)
238        {
239
240        refCount = getFrameRefCount(frameBuf,  frameType);
241
242        if ( 0 < refCount )
243            {
244
245            refCount--;
246            setFrameRefCount(frameBuf, frameType, refCount);
247
248            if ( ( mRecording ) && (  CameraFrame::VIDEO_FRAME_SYNC == frameType ) )
249                {
250                refCount += getFrameRefCount(frameBuf, CameraFrame::PREVIEW_FRAME_SYNC);
251                }
252            else if ( ( mRecording ) && (  CameraFrame::PREVIEW_FRAME_SYNC == frameType ) )
253                {
254                refCount += getFrameRefCount(frameBuf, CameraFrame::VIDEO_FRAME_SYNC);
255                }
256
257            }
258        else
259            {
260            return;
261            }
262        }
263
264    if ( NO_ERROR == res )
265        {
266        //check if someone is holding this buffer
267        if ( 0 == refCount )
268            {
269            res = fillThisBuffer(frameBuf, frameType);
270            }
271        }
272
273}
274
275status_t BaseCameraAdapter::sendCommand(CameraCommands operation, int value1, int value2, int value3)
276{
277    status_t ret = NO_ERROR;
278    struct timeval *refTimestamp;
279    BuffersDescriptor *desc = NULL;
280    CameraFrame *frame = NULL;
281
282    LOG_FUNCTION_NAME;
283
284    switch ( operation ) {
285        case CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW:
286                CAMHAL_LOGDA("Use buffers for preview");
287                desc = ( BuffersDescriptor * ) value1;
288
289                if ( NULL == desc )
290                    {
291                    CAMHAL_LOGEA("Invalid preview buffers!");
292                    return -EINVAL;
293                    }
294
295                if ( ret == NO_ERROR )
296                    {
297                    ret = setState(operation);
298                    }
299
300                if ( ret == NO_ERROR )
301                    {
302                    Mutex::Autolock lock(mPreviewBufferLock);
303                    mPreviewBuffers = (int *) desc->mBuffers;
304                    mPreviewBuffersLength = desc->mLength;
305                    mPreviewBuffersAvailable.clear();
306                    for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ )
307                        {
308                        mPreviewBuffersAvailable.add(mPreviewBuffers[i], 0);
309                        }
310                    // initial ref count for undeqeueued buffers is 1 since buffer provider
311                    // is still holding on to it
312                    for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ )
313                        {
314                        mPreviewBuffersAvailable.add(mPreviewBuffers[i], 1);
315                        }
316                    }
317
318                if ( NULL != desc )
319                    {
320                    ret = useBuffers(CameraAdapter::CAMERA_PREVIEW,
321                                     desc->mBuffers,
322                                     desc->mCount,
323                                     desc->mLength,
324                                     desc->mMaxQueueable);
325                    }
326
327                if ( ret == NO_ERROR )
328                    {
329                    ret = commitState();
330                    }
331                else
332                    {
333                    ret |= rollbackState();
334                    }
335
336                break;
337
338        case CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA:
339                    CAMHAL_LOGDA("Use buffers for preview data");
340                    desc = ( BuffersDescriptor * ) value1;
341
342                    if ( NULL == desc )
343                        {
344                        CAMHAL_LOGEA("Invalid preview data buffers!");
345                        return -EINVAL;
346                        }
347
348                    if ( ret == NO_ERROR )
349                        {
350                        ret = setState(operation);
351                        }
352
353                    if ( ret == NO_ERROR )
354                        {
355                        Mutex::Autolock lock(mPreviewDataBufferLock);
356                        mPreviewDataBuffers = (int *) desc->mBuffers;
357                        mPreviewDataBuffersLength = desc->mLength;
358                        mPreviewDataBuffersAvailable.clear();
359                        for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ )
360                            {
361                            mPreviewDataBuffersAvailable.add(mPreviewDataBuffers[i], true);
362                            }
363                        // initial ref count for undeqeueued buffers is 1 since buffer provider
364                        // is still holding on to it
365                        for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ )
366                            {
367                            mPreviewDataBuffersAvailable.add(mPreviewBuffers[i], 1);
368                            }
369                        }
370
371                    if ( NULL != desc )
372                        {
373                        ret = useBuffers(CameraAdapter::CAMERA_MEASUREMENT,
374                                         desc->mBuffers,
375                                         desc->mCount,
376                                         desc->mLength,
377                                         desc->mMaxQueueable);
378                        }
379
380                    if ( ret == NO_ERROR )
381                        {
382                        ret = commitState();
383                        }
384                    else
385                        {
386                        ret |= rollbackState();
387                        }
388
389                    break;
390
391        case CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE:
392                CAMHAL_LOGDA("Use buffers for image capture");
393                desc = ( BuffersDescriptor * ) value1;
394
395                if ( NULL == desc )
396                    {
397                    CAMHAL_LOGEA("Invalid capture buffers!");
398                    return -EINVAL;
399                    }
400
401                if ( ret == NO_ERROR )
402                    {
403                    ret = setState(operation);
404                    }
405
406                if ( ret == NO_ERROR )
407                    {
408                    Mutex::Autolock lock(mCaptureBufferLock);
409                    mCaptureBuffers = (int *) desc->mBuffers;
410                    mCaptureBuffersLength = desc->mLength;
411                    mCaptureBuffersAvailable.clear();
412                    for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ )
413                        {
414                        mCaptureBuffersAvailable.add(mCaptureBuffers[i], true);
415                        }
416                    // initial ref count for undeqeueued buffers is 1 since buffer provider
417                    // is still holding on to it
418                    for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ )
419                        {
420                        mCaptureBuffersAvailable.add(mPreviewBuffers[i], 1);
421                        }
422                    }
423
424                if ( NULL != desc )
425                    {
426                    ret = useBuffers(CameraAdapter::CAMERA_IMAGE_CAPTURE,
427                                     desc->mBuffers,
428                                     desc->mCount,
429                                     desc->mLength,
430                                     desc->mMaxQueueable);
431                    }
432
433                if ( ret == NO_ERROR )
434                    {
435                    ret = commitState();
436                    }
437                else
438                    {
439                    ret |= rollbackState();
440                    }
441
442                break;
443
444        case CameraAdapter::CAMERA_START_SMOOTH_ZOOM:
445            {
446
447            if ( ret == NO_ERROR )
448                {
449                ret = setState(operation);
450                }
451
452            if ( ret == NO_ERROR )
453                {
454                ret = startSmoothZoom(value1);
455                }
456
457            if ( ret == NO_ERROR )
458                {
459                ret = commitState();
460                }
461            else
462                {
463                ret |= rollbackState();
464                }
465
466            break;
467
468            }
469
470        case CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM:
471            {
472
473            if ( ret == NO_ERROR )
474                {
475                ret = setState(operation);
476                }
477
478            if ( ret == NO_ERROR )
479                {
480                ret = stopSmoothZoom();
481                }
482
483            if ( ret == NO_ERROR )
484                {
485                ret = commitState();
486                }
487            else
488                {
489                ret |= rollbackState();
490                }
491
492            break;
493
494            }
495
496        case CameraAdapter::CAMERA_START_PREVIEW:
497            {
498
499                CAMHAL_LOGDA("Start Preview");
500
501            if ( ret == NO_ERROR )
502                {
503                ret = setState(operation);
504                }
505
506            if ( ret == NO_ERROR )
507                {
508                ret = startPreview();
509                }
510
511            if ( ret == NO_ERROR )
512                {
513                ret = commitState();
514                }
515            else
516                {
517                ret |= rollbackState();
518                }
519
520            break;
521
522            }
523
524        case CameraAdapter::CAMERA_STOP_PREVIEW:
525            {
526
527            CAMHAL_LOGDA("Stop Preview");
528
529            if ( ret == NO_ERROR )
530                {
531                ret = setState(operation);
532                }
533
534            if ( ret == NO_ERROR )
535                {
536                ret = stopPreview();
537                }
538
539            if ( ret == NO_ERROR )
540                {
541                ret = commitState();
542                }
543            else
544                {
545                ret |= rollbackState();
546                }
547
548            break;
549
550            }
551
552        case CameraAdapter::CAMERA_START_VIDEO:
553            {
554
555            CAMHAL_LOGDA("Start video recording");
556
557            if ( ret == NO_ERROR )
558                {
559                ret = setState(operation);
560                }
561
562            if ( ret == NO_ERROR )
563                {
564                ret = startVideoCapture();
565                }
566
567            if ( ret == NO_ERROR )
568                {
569                ret = commitState();
570                }
571            else
572                {
573                ret |= rollbackState();
574                }
575
576            break;
577
578            }
579
580        case CameraAdapter::CAMERA_STOP_VIDEO:
581            {
582
583            CAMHAL_LOGDA("Stop video recording");
584
585            if ( ret == NO_ERROR )
586                {
587                ret = setState(operation);
588                }
589
590            if ( ret == NO_ERROR )
591                {
592                ret = stopVideoCapture();
593                }
594
595            if ( ret == NO_ERROR )
596                {
597                ret = commitState();
598                }
599            else
600                {
601                ret |= rollbackState();
602                }
603
604            break;
605
606            }
607
608        case CameraAdapter::CAMERA_PREVIEW_FLUSH_BUFFERS:
609            {
610
611            if ( ret == NO_ERROR )
612                {
613                ret = setState(operation);
614                }
615
616            if ( ret == NO_ERROR )
617                {
618                ret = flushBuffers();
619                }
620
621            if ( ret == NO_ERROR )
622                {
623                ret = commitState();
624                }
625            else
626                {
627                ret |= rollbackState();
628                }
629
630            break;
631
632            }
633
634        case CameraAdapter::CAMERA_START_IMAGE_CAPTURE:
635            {
636
637#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
638
639            refTimestamp = ( struct timeval * ) value1;
640            if ( NULL != refTimestamp )
641                {
642                memcpy( &mStartCapture, refTimestamp, sizeof( struct timeval ));
643                }
644
645#endif
646
647            if ( ret == NO_ERROR )
648                {
649                ret = setState(operation);
650                }
651
652            if ( ret == NO_ERROR )
653                {
654                ret = takePicture();
655                }
656
657            if ( ret == NO_ERROR )
658                {
659                ret = commitState();
660                }
661            else
662                {
663                ret |= rollbackState();
664                }
665
666            break;
667
668            }
669
670        case CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE:
671            {
672
673            if ( ret == NO_ERROR )
674                {
675                ret = setState(operation);
676                }
677
678            if ( ret == NO_ERROR )
679                {
680                ret = stopImageCapture();
681                }
682
683            if ( ret == NO_ERROR )
684                {
685                ret = commitState();
686                }
687            else
688                {
689                ret |= rollbackState();
690                }
691
692            break;
693
694            }
695
696        case CameraAdapter::CAMERA_START_BRACKET_CAPTURE:
697            {
698
699#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
700
701            refTimestamp = ( struct timeval * ) value2;
702            if ( NULL != refTimestamp )
703                {
704                memcpy( &mStartCapture, refTimestamp, sizeof( struct timeval ));
705                }
706
707#endif
708
709            if ( ret == NO_ERROR )
710                {
711                ret = setState(operation);
712                }
713
714            if ( ret == NO_ERROR )
715                {
716                ret = startBracketing(value1);
717                }
718
719            if ( ret == NO_ERROR )
720                {
721                ret = commitState();
722                }
723            else
724                {
725                ret |= rollbackState();
726                }
727
728            break;
729
730            }
731
732        case CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE:
733            {
734
735            if ( ret == NO_ERROR )
736                {
737                ret = setState(operation);
738                }
739
740            if ( ret == NO_ERROR )
741                {
742                ret = stopBracketing();
743                }
744
745            if ( ret == NO_ERROR )
746                {
747                ret = commitState();
748                }
749            else
750                {
751                ret |= rollbackState();
752                }
753
754            break;
755
756            }
757
758        case CameraAdapter::CAMERA_PERFORM_AUTOFOCUS:
759
760#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
761
762            refTimestamp = ( struct timeval * ) value1;
763            if ( NULL != refTimestamp )
764                {
765                memcpy( &mStartFocus, refTimestamp, sizeof( struct timeval ));
766                }
767
768#endif
769
770            if ( ret == NO_ERROR )
771                {
772                ret = setState(operation);
773                }
774
775            if ( ret == NO_ERROR )
776                {
777                ret = autoFocus();
778                }
779
780            if ( ret == NO_ERROR )
781                {
782                ret = commitState();
783                }
784            else
785                {
786                ret |= rollbackState();
787                }
788
789            break;
790
791        case CameraAdapter::CAMERA_CANCEL_AUTOFOCUS:
792
793            if ( ret == NO_ERROR )
794                {
795                ret = setState(operation);
796                }
797
798            if ( ret == NO_ERROR )
799                {
800                ret = cancelAutoFocus();
801                }
802
803            if ( ret == NO_ERROR )
804                {
805                ret = commitState();
806                }
807            else
808                {
809                ret |= rollbackState();
810                }
811
812            break;
813
814        case CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW:
815
816             if ( ret == NO_ERROR )
817                 {
818                 ret = setState(operation);
819                 }
820
821             if ( ret == NO_ERROR )
822                 {
823                 frame = ( CameraFrame * ) value1;
824
825                 if ( NULL != frame )
826                     {
827                     ret = getFrameSize(frame->mWidth, frame->mHeight);
828                     }
829                 else
830                     {
831                     ret = -EINVAL;
832                     }
833                 }
834
835             if ( ret == NO_ERROR )
836                 {
837                 ret = commitState();
838                 }
839             else
840                 {
841                 ret |= rollbackState();
842                 }
843
844             break;
845
846         case CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
847
848             if ( ret == NO_ERROR )
849                 {
850                 ret = setState(operation);
851                 }
852
853             if ( ret == NO_ERROR )
854                 {
855                 frame = ( CameraFrame * ) value1;
856
857                 if ( NULL != frame )
858                     {
859                     ret = getPictureBufferSize(frame->mLength, value2);
860                     }
861                 else
862                     {
863                     ret = -EINVAL;
864                     }
865                 }
866
867             if ( ret == NO_ERROR )
868                 {
869                 ret = commitState();
870                 }
871             else
872                 {
873                 ret |= rollbackState();
874                 }
875
876             break;
877
878         case CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA:
879
880             if ( ret == NO_ERROR )
881                 {
882                 ret = setState(operation);
883                 }
884
885             if ( ret == NO_ERROR )
886                 {
887                 frame = ( CameraFrame * ) value1;
888
889                 if ( NULL != frame )
890                     {
891                     ret = getFrameDataSize(frame->mLength, value2);
892                     }
893                 else
894                     {
895                     ret = -EINVAL;
896                     }
897                 }
898
899             if ( ret == NO_ERROR )
900                 {
901                 ret = commitState();
902                 }
903             else
904                 {
905                 ret |= rollbackState();
906                 }
907
908             break;
909
910         case CameraAdapter::CAMERA_START_FD:
911
912             ret = startFaceDetection();
913
914             break;
915
916         case CameraAdapter::CAMERA_STOP_FD:
917
918             ret = stopFaceDetection();
919
920             break;
921
922        default:
923            CAMHAL_LOGEB("Command 0x%x unsupported!", operation);
924            break;
925    };
926
927    LOG_FUNCTION_NAME_EXIT;
928    return ret;
929}
930
931status_t BaseCameraAdapter::notifyFocusSubscribers(bool status)
932{
933    event_callback eventCb;
934    CameraHalEvent focusEvent;
935    status_t ret = NO_ERROR;
936
937    LOG_FUNCTION_NAME;
938
939    if ( mFocusSubscribers.size() == 0 ) {
940        CAMHAL_LOGDA("No Focus Subscribers!");
941        return NO_INIT;
942    }
943
944#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
945
946     //dump the AF latency
947     CameraHal::PPM("Focus finished in: ", &mStartFocus);
948
949#endif
950
951    focusEvent.mEventData = new CameraHalEvent::CameraHalEventData();
952    if ( NULL == focusEvent.mEventData.get() ) {
953        return -ENOMEM;
954    }
955
956    focusEvent.mEventType = CameraHalEvent::EVENT_FOCUS_LOCKED;
957    focusEvent.mEventData->focusEvent.focusLocked = status;
958    focusEvent.mEventData->focusEvent.focusError = !status;
959
960    for (unsigned int i = 0 ; i < mFocusSubscribers.size(); i++ )
961        {
962        focusEvent.mCookie = (void *) mFocusSubscribers.keyAt(i);
963        eventCb = (event_callback) mFocusSubscribers.valueAt(i);
964        eventCb ( &focusEvent );
965        }
966
967    focusEvent.mEventData.clear();
968
969    LOG_FUNCTION_NAME_EXIT;
970
971    return ret;
972}
973
974status_t BaseCameraAdapter::notifyShutterSubscribers()
975{
976    CameraHalEvent shutterEvent;
977    event_callback eventCb;
978    status_t ret = NO_ERROR;
979
980    LOG_FUNCTION_NAME;
981
982    if ( mShutterSubscribers.size() == 0 )
983        {
984        CAMHAL_LOGEA("No shutter Subscribers!");
985        return NO_INIT;
986        }
987
988    shutterEvent.mEventData = new CameraHalEvent::CameraHalEventData();
989    if ( NULL == shutterEvent.mEventData.get() ) {
990        return -ENOMEM;
991    }
992
993    shutterEvent.mEventType = CameraHalEvent::EVENT_SHUTTER;
994    shutterEvent.mEventData->shutterEvent.shutterClosed = true;
995
996    for (unsigned int i = 0 ; i < mShutterSubscribers.size() ; i++ ) {
997        shutterEvent.mCookie = ( void * ) mShutterSubscribers.keyAt(i);
998        eventCb = ( event_callback ) mShutterSubscribers.valueAt(i);
999
1000        CAMHAL_LOGEA("Sending shutter callback");
1001
1002        eventCb ( &shutterEvent );
1003    }
1004
1005    shutterEvent.mEventData.clear();
1006
1007    LOG_FUNCTION_NAME;
1008
1009    return ret;
1010}
1011
1012status_t BaseCameraAdapter::notifyZoomSubscribers(int zoomIdx, bool targetReached)
1013{
1014    event_callback eventCb;
1015    CameraHalEvent zoomEvent;
1016    status_t ret = NO_ERROR;
1017
1018    LOG_FUNCTION_NAME;
1019
1020    if ( mZoomSubscribers.size() == 0 ) {
1021        CAMHAL_LOGDA("No zoom Subscribers!");
1022        return NO_INIT;
1023    }
1024
1025    zoomEvent.mEventData = new CameraHalEvent::CameraHalEventData();
1026    if ( NULL == zoomEvent.mEventData.get() ) {
1027        return -ENOMEM;
1028    }
1029
1030    zoomEvent.mEventType = CameraHalEvent::EVENT_ZOOM_INDEX_REACHED;
1031    zoomEvent.mEventData->zoomEvent.currentZoomIndex = zoomIdx;
1032    zoomEvent.mEventData->zoomEvent.targetZoomIndexReached = targetReached;
1033
1034    for (unsigned int i = 0 ; i < mZoomSubscribers.size(); i++ ) {
1035        zoomEvent.mCookie = (void *) mZoomSubscribers.keyAt(i);
1036        eventCb = (event_callback) mZoomSubscribers.valueAt(i);
1037
1038        eventCb ( &zoomEvent );
1039    }
1040
1041    zoomEvent.mEventData.clear();
1042
1043    LOG_FUNCTION_NAME_EXIT;
1044
1045    return ret;
1046}
1047
1048status_t BaseCameraAdapter::notifyFaceSubscribers(sp<CameraFDResult> &faces)
1049{
1050    event_callback eventCb;
1051    CameraHalEvent faceEvent;
1052    status_t ret = NO_ERROR;
1053
1054    LOG_FUNCTION_NAME;
1055
1056    if ( mFaceSubscribers.size() == 0 ) {
1057        CAMHAL_LOGDA("No face detection subscribers!");
1058        return NO_INIT;
1059    }
1060
1061    faceEvent.mEventData = new CameraHalEvent::CameraHalEventData();
1062    if ( NULL == faceEvent.mEventData.get() ) {
1063        return -ENOMEM;
1064    }
1065
1066    faceEvent.mEventType = CameraHalEvent::EVENT_FACE;
1067    faceEvent.mEventData->faceEvent = faces;
1068
1069    for (unsigned int i = 0 ; i < mFaceSubscribers.size(); i++ ) {
1070        faceEvent.mCookie = (void *) mFaceSubscribers.keyAt(i);
1071        eventCb = (event_callback) mFaceSubscribers.valueAt(i);
1072
1073        eventCb ( &faceEvent );
1074    }
1075
1076    faceEvent.mEventData.clear();
1077
1078    LOG_FUNCTION_NAME_EXIT;
1079
1080    return ret;
1081}
1082
1083status_t BaseCameraAdapter::sendFrameToSubscribers(CameraFrame *frame)
1084{
1085    status_t ret = NO_ERROR;
1086    frame_callback callback;
1087    uint32_t i = 0;
1088    KeyedVector<int, frame_callback> *subscribers = NULL;
1089    size_t refCount = 0;
1090
1091    if ( NULL == frame )
1092        {
1093        CAMHAL_LOGEA("Invalid CameraFrame");
1094        ret = -EINVAL;
1095        }
1096
1097    if ( NO_ERROR == ret )
1098        {
1099
1100        switch(frame->mFrameType)
1101            {
1102                case CameraFrame::IMAGE_FRAME:
1103                    {
1104
1105#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
1106
1107                    CameraHal::PPM("Shot to Jpeg: ", &mStartCapture);
1108
1109#endif
1110
1111                    subscribers = &mImageSubscribers;
1112                    break;
1113                    }
1114                case CameraFrame::RAW_FRAME:
1115                    {
1116                    subscribers = &mRawSubscribers;
1117                    break;
1118                    }
1119                case CameraFrame::VIDEO_FRAME_SYNC:
1120                    {
1121                    subscribers = &mVideoSubscribers;
1122                    break;
1123                    }
1124                case CameraFrame::FRAME_DATA_SYNC:
1125                    {
1126                    subscribers = &mFrameDataSubscribers;
1127                    break;
1128                    }
1129                case CameraFrame::PREVIEW_FRAME_SYNC:
1130                case CameraFrame::SNAPSHOT_FRAME:
1131                    {
1132                    subscribers = &mFrameSubscribers;
1133                    break;
1134                    }
1135                default:
1136                    {
1137                    ret = -EINVAL;
1138                    break;
1139                    }
1140            };
1141
1142        }
1143
1144    if ( ( NO_ERROR == ret ) &&
1145         ( NULL != subscribers ) )
1146        {
1147        Mutex::Autolock lock(mSubscriberLock);
1148
1149        refCount = subscribers->size();
1150        CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
1151                                    frame->mFrameType,
1152                                    ( uint32_t ) frame->mBuffer,
1153                                    refCount);
1154
1155        setFrameRefCount(frame->mBuffer,
1156                         (  CameraFrame::FrameType ) frame->mFrameType,
1157                         refCount);
1158
1159        for ( i = 0 ; i < subscribers->size(); i++ )
1160            {
1161            frame->mCookie = ( void * ) subscribers->keyAt(i);
1162            callback = (frame_callback) subscribers->valueAt(i);
1163            callback(frame);
1164            }
1165        }
1166
1167    if ( 0 == i )
1168        {
1169        //No subscribers for this frame
1170        ret = -1;
1171        }
1172
1173    return ret;
1174}
1175
1176int BaseCameraAdapter::getFrameRefCount(void* frameBuf, CameraFrame::FrameType frameType)
1177{
1178    int res = -1;
1179
1180    LOG_FUNCTION_NAME;
1181
1182    switch ( frameType )
1183        {
1184        case CameraFrame::IMAGE_FRAME:
1185        case CameraFrame::RAW_FRAME:
1186                {
1187                Mutex::Autolock lock(mCaptureBufferLock);
1188                res = mCaptureBuffersAvailable.valueFor( ( unsigned int ) frameBuf );
1189                }
1190            break;
1191        case CameraFrame::PREVIEW_FRAME_SYNC:
1192        case CameraFrame::SNAPSHOT_FRAME:
1193                {
1194                Mutex::Autolock lock(mPreviewBufferLock);
1195                res = mPreviewBuffersAvailable.valueFor( ( unsigned int ) frameBuf );
1196                }
1197            break;
1198        case CameraFrame::FRAME_DATA_SYNC:
1199                {
1200                Mutex::Autolock lock(mPreviewDataBufferLock);
1201                res = mPreviewDataBuffersAvailable.valueFor( ( unsigned int ) frameBuf );
1202                }
1203            break;
1204        case CameraFrame::VIDEO_FRAME_SYNC:
1205                {
1206                Mutex::Autolock lock(mVideoBufferLock);
1207                res = mVideoBuffersAvailable.valueFor( ( unsigned int ) frameBuf );
1208                }
1209            break;
1210        default:
1211            break;
1212        };
1213
1214    LOG_FUNCTION_NAME_EXIT;
1215
1216    return res;
1217}
1218
1219void BaseCameraAdapter::setFrameRefCount(void* frameBuf, CameraFrame::FrameType frameType, int refCount)
1220{
1221
1222    LOG_FUNCTION_NAME;
1223
1224    switch ( frameType )
1225        {
1226        case CameraFrame::IMAGE_FRAME:
1227        case CameraFrame::RAW_FRAME:
1228                {
1229                Mutex::Autolock lock(mCaptureBufferLock);
1230                mCaptureBuffersAvailable.replaceValueFor(  ( unsigned int ) frameBuf, refCount);
1231                }
1232            break;
1233        case CameraFrame::PREVIEW_FRAME_SYNC:
1234        case CameraFrame::SNAPSHOT_FRAME:
1235                {
1236                Mutex::Autolock lock(mPreviewBufferLock);
1237                mPreviewBuffersAvailable.replaceValueFor(  ( unsigned int ) frameBuf, refCount);
1238                }
1239            break;
1240        case CameraFrame::FRAME_DATA_SYNC:
1241                {
1242                Mutex::Autolock lock(mPreviewDataBufferLock);
1243                mPreviewDataBuffersAvailable.replaceValueFor(  ( unsigned int ) frameBuf, refCount);
1244                }
1245            break;
1246        case CameraFrame::VIDEO_FRAME_SYNC:
1247                {
1248                Mutex::Autolock lock(mVideoBufferLock);
1249                mVideoBuffersAvailable.replaceValueFor(  ( unsigned int ) frameBuf, refCount);
1250                }
1251            break;
1252        default:
1253            break;
1254        };
1255
1256    LOG_FUNCTION_NAME_EXIT;
1257
1258}
1259
1260status_t BaseCameraAdapter::startVideoCapture()
1261{
1262    status_t ret = NO_ERROR;
1263
1264    LOG_FUNCTION_NAME;
1265
1266    Mutex::Autolock lock(mVideoBufferLock);
1267
1268    //If the capture is already ongoing, return from here.
1269    if ( mRecording )
1270        {
1271        ret = NO_INIT;
1272        }
1273
1274
1275    if ( NO_ERROR == ret )
1276        {
1277
1278        for ( unsigned int i = 0 ; i < mPreviewBuffersAvailable.size() ; i++ )
1279            {
1280            mVideoBuffersAvailable.add(mPreviewBuffersAvailable.keyAt(i), 0);
1281            }
1282
1283        mRecording = true;
1284        }
1285
1286    LOG_FUNCTION_NAME_EXIT;
1287
1288    return ret;
1289}
1290
1291status_t BaseCameraAdapter::stopVideoCapture()
1292{
1293    status_t ret = NO_ERROR;
1294
1295    LOG_FUNCTION_NAME;
1296
1297    if ( !mRecording )
1298        {
1299        ret = NO_INIT;
1300        }
1301
1302    if ( NO_ERROR == ret )
1303        {
1304        for ( unsigned int i = 0 ; i < mVideoBuffersAvailable.size() ; i++ )
1305            {
1306            void *frameBuf = ( void * ) mVideoBuffersAvailable.keyAt(i);
1307            if( getFrameRefCount(frameBuf,  CameraFrame::VIDEO_FRAME_SYNC) > 0)
1308                {
1309                returnFrame(frameBuf, CameraFrame::VIDEO_FRAME_SYNC);
1310                }
1311            }
1312
1313        mVideoBuffersAvailable.clear();
1314
1315        mRecording = false;
1316        }
1317
1318    LOG_FUNCTION_NAME_EXIT;
1319
1320    return ret;
1321}
1322
1323//-----------------Stub implementation of the interface ------------------------------
1324
1325status_t BaseCameraAdapter::takePicture()
1326{
1327    status_t ret = NO_ERROR;
1328
1329    LOG_FUNCTION_NAME;
1330
1331    LOG_FUNCTION_NAME_EXIT;
1332
1333    return ret;
1334}
1335
1336status_t BaseCameraAdapter::stopImageCapture()
1337{
1338    status_t ret = NO_ERROR;
1339
1340    LOG_FUNCTION_NAME;
1341
1342    LOG_FUNCTION_NAME_EXIT;
1343
1344    return ret;
1345}
1346
1347status_t BaseCameraAdapter::startBracketing(int range)
1348{
1349    status_t ret = NO_ERROR;
1350
1351    LOG_FUNCTION_NAME;
1352
1353    LOG_FUNCTION_NAME_EXIT;
1354
1355    return ret;
1356}
1357
1358status_t BaseCameraAdapter::stopBracketing()
1359{
1360    status_t ret = NO_ERROR;
1361
1362    LOG_FUNCTION_NAME;
1363
1364    LOG_FUNCTION_NAME_EXIT;
1365
1366    return ret;
1367}
1368
1369status_t BaseCameraAdapter::autoFocus()
1370{
1371    status_t ret = NO_ERROR;
1372
1373    LOG_FUNCTION_NAME;
1374
1375    notifyFocusSubscribers(false);
1376
1377    LOG_FUNCTION_NAME_EXIT;
1378
1379    return ret;
1380}
1381
1382status_t BaseCameraAdapter::cancelAutoFocus()
1383{
1384    status_t ret = NO_ERROR;
1385
1386    LOG_FUNCTION_NAME;
1387
1388    LOG_FUNCTION_NAME_EXIT;
1389
1390    return ret;
1391}
1392
1393status_t BaseCameraAdapter::startSmoothZoom(int targetIdx)
1394{
1395    status_t ret = NO_ERROR;
1396
1397    LOG_FUNCTION_NAME;
1398
1399    LOG_FUNCTION_NAME_EXIT;
1400
1401    return ret;
1402}
1403
1404status_t BaseCameraAdapter::stopSmoothZoom()
1405{
1406    status_t ret = NO_ERROR;
1407
1408    LOG_FUNCTION_NAME;
1409
1410    LOG_FUNCTION_NAME_EXIT;
1411
1412    return ret;
1413}
1414
1415status_t BaseCameraAdapter::startPreview()
1416{
1417    status_t ret = NO_ERROR;
1418
1419    LOG_FUNCTION_NAME;
1420
1421    LOG_FUNCTION_NAME_EXIT;
1422
1423    return ret;
1424}
1425
1426status_t BaseCameraAdapter::stopPreview()
1427{
1428    status_t ret = NO_ERROR;
1429
1430    LOG_FUNCTION_NAME;
1431
1432    LOG_FUNCTION_NAME_EXIT;
1433
1434    return ret;
1435}
1436
1437status_t BaseCameraAdapter::useBuffers(CameraMode mode, void* bufArr, int num, size_t length, unsigned int queueable)
1438{
1439    status_t ret = NO_ERROR;
1440
1441    LOG_FUNCTION_NAME;
1442
1443    LOG_FUNCTION_NAME_EXIT;
1444
1445    return ret;
1446}
1447
1448status_t BaseCameraAdapter::fillThisBuffer(void* frameBuf, CameraFrame::FrameType frameType)
1449{
1450    status_t ret = NO_ERROR;
1451
1452    LOG_FUNCTION_NAME;
1453
1454    LOG_FUNCTION_NAME_EXIT;
1455
1456    return ret;
1457}
1458
1459status_t BaseCameraAdapter::getFrameSize(size_t &width, size_t &height)
1460{
1461    status_t ret = NO_ERROR;
1462
1463    LOG_FUNCTION_NAME;
1464
1465    LOG_FUNCTION_NAME_EXIT;
1466
1467    return ret;
1468}
1469
1470status_t BaseCameraAdapter::getFrameDataSize(size_t &dataFrameSize, size_t bufferCount)
1471{
1472    status_t ret = NO_ERROR;
1473
1474    LOG_FUNCTION_NAME;
1475
1476    LOG_FUNCTION_NAME_EXIT;
1477
1478    return ret;
1479}
1480
1481status_t BaseCameraAdapter::getPictureBufferSize(size_t &length, size_t bufferCount)
1482{
1483    status_t ret = NO_ERROR;
1484
1485    LOG_FUNCTION_NAME;
1486
1487    LOG_FUNCTION_NAME_EXIT;
1488
1489    return ret;
1490}
1491
1492status_t BaseCameraAdapter::startFaceDetection()
1493{
1494    status_t ret = NO_ERROR;
1495
1496    LOG_FUNCTION_NAME;
1497
1498    LOG_FUNCTION_NAME_EXIT;
1499
1500    return ret;
1501}
1502
1503status_t BaseCameraAdapter::stopFaceDetection()
1504{
1505    status_t ret = NO_ERROR;
1506
1507    LOG_FUNCTION_NAME;
1508
1509    LOG_FUNCTION_NAME_EXIT;
1510
1511    return ret;
1512}
1513
1514status_t BaseCameraAdapter::setState(CameraCommands operation)
1515{
1516    status_t ret = NO_ERROR;
1517
1518    LOG_FUNCTION_NAME;
1519
1520    mLock.lock();
1521
1522    switch ( mAdapterState )
1523        {
1524
1525        case INTIALIZED_STATE:
1526
1527            switch ( operation )
1528                {
1529
1530                case CAMERA_USE_BUFFERS_PREVIEW:
1531                    CAMHAL_LOGDB("Adapter state switch INTIALIZED_STATE->LOADED_PREVIEW_STATE event = 0x%x",
1532                                 operation);
1533                    mNextState = LOADED_PREVIEW_STATE;
1534                    break;
1535
1536                //These events don't change the current state
1537                case CAMERA_QUERY_RESOLUTION_PREVIEW:
1538                case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
1539                case CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA:
1540                    CAMHAL_LOGDB("Adapter state switch INTIALIZED_STATE->INTIALIZED_STATE event = 0x%x",
1541                                 operation);
1542                    mNextState = INTIALIZED_STATE;
1543                    break;
1544
1545                default:
1546                    CAMHAL_LOGEB("Adapter state switch INTIALIZED_STATE Invalid Op! event = 0x%x",
1547                                 operation);
1548                    ret = INVALID_OPERATION;
1549                    break;
1550
1551                }
1552
1553            break;
1554
1555        case LOADED_PREVIEW_STATE:
1556
1557            switch ( operation )
1558                {
1559
1560                case CAMERA_START_PREVIEW:
1561                    CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->PREVIEW_STATE event = 0x%x",
1562                                 operation);
1563                    mNextState = PREVIEW_STATE;
1564                    break;
1565
1566                //These events don't change the current state
1567                case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
1568                case CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA:
1569                case CAMERA_USE_BUFFERS_PREVIEW_DATA:
1570                    CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->LOADED_PREVIEW_STATE event = 0x%x",
1571                                 operation);
1572                    mNextState = LOADED_PREVIEW_STATE;
1573                    break;
1574
1575                default:
1576                    CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW Invalid Op! event = 0x%x",
1577                                 operation);
1578                    ret = INVALID_OPERATION;
1579                    break;
1580
1581                }
1582
1583            break;
1584
1585        case PREVIEW_STATE:
1586
1587            switch ( operation )
1588                {
1589
1590                case CAMERA_STOP_PREVIEW:
1591                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->INTIALIZED_STATE event = 0x%x",
1592                                 operation);
1593                    mNextState = INTIALIZED_STATE;
1594                    break;
1595
1596                case CAMERA_PERFORM_AUTOFOCUS:
1597                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->AF_STATE event = 0x%x",
1598                                 operation);
1599                    mNextState = AF_STATE;
1600                    break;
1601
1602                case CAMERA_START_SMOOTH_ZOOM:
1603                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->ZOOM_STATE event = 0x%x",
1604                                 operation);
1605                    mNextState = ZOOM_STATE;
1606                    break;
1607
1608                case CAMERA_USE_BUFFERS_IMAGE_CAPTURE:
1609                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->LOADED_CAPTURE_STATE event = 0x%x",
1610                                 operation);
1611                    mNextState = LOADED_CAPTURE_STATE;
1612                    break;
1613
1614                case CAMERA_START_VIDEO:
1615                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->VIDEO_STATE event = 0x%x",
1616                                 operation);
1617                    mNextState = VIDEO_STATE;
1618                    break;
1619
1620                case CAMERA_CANCEL_AUTOFOCUS:
1621                case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
1622                case CAMERA_STOP_SMOOTH_ZOOM:
1623                    CAMHAL_LOGDB("Adapter state switch PREVIEW_ACTIVE->PREVIEW_ACTIVE event = 0x%x",
1624                                 operation);
1625                    mNextState = PREVIEW_STATE;
1626                    break;
1627
1628                default:
1629                    CAMHAL_LOGEB("Adapter state switch PREVIEW_ACTIVE Invalid Op! event = 0x%x",
1630                                 operation);
1631                    ret = INVALID_OPERATION;
1632                    break;
1633
1634                }
1635
1636            break;
1637
1638        case LOADED_CAPTURE_STATE:
1639
1640            switch ( operation )
1641                {
1642
1643                case CAMERA_START_IMAGE_CAPTURE:
1644                    CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->CAPTURE_STATE event = 0x%x",
1645                                 operation);
1646                    mNextState = CAPTURE_STATE;
1647                    break;
1648
1649                case CAMERA_START_BRACKET_CAPTURE:
1650                    CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->BRACKETING_STATE event = 0x%x",
1651                                 operation);
1652                    mNextState = BRACKETING_STATE;
1653                    break;
1654
1655                default:
1656                    CAMHAL_LOGEB("Adapter state switch LOADED_CAPTURE_STATE Invalid Op! event = 0x%x",
1657                                 operation);
1658                    ret = INVALID_OPERATION;
1659                    break;
1660
1661                }
1662
1663            break;
1664
1665        case CAPTURE_STATE:
1666
1667            switch ( operation )
1668                {
1669                case CAMERA_STOP_IMAGE_CAPTURE:
1670                    CAMHAL_LOGDB("Adapter state switch CAPTURE_STATE->PREVIEW_STATE event = 0x%x",
1671                                 operation);
1672                    mNextState = PREVIEW_STATE;
1673                    break;
1674
1675                default:
1676                    CAMHAL_LOGEB("Adapter state switch CAPTURE_STATE Invalid Op! event = 0x%x",
1677                                 operation);
1678                    ret = INVALID_OPERATION;
1679                    break;
1680
1681                }
1682
1683            break;
1684
1685        case BRACKETING_STATE:
1686
1687            switch ( operation )
1688                {
1689
1690                case CAMERA_STOP_BRACKET_CAPTURE:
1691                    CAMHAL_LOGDB("Adapter state switch BRACKETING_STATE->PREVIEW_STATE event = 0x%x",
1692                                 operation);
1693                    mNextState = PREVIEW_STATE;
1694                    break;
1695
1696                case CAMERA_START_IMAGE_CAPTURE:
1697                    CAMHAL_LOGDB("Adapter state switch BRACKETING_STATE->CAPTURE_STATE event = 0x%x",
1698                                 operation);
1699                    mNextState = CAPTURE_STATE;
1700                    break;
1701
1702                default:
1703                    CAMHAL_LOGEB("Adapter state switch BRACKETING_STATE Invalid Op! event = 0x%x",
1704                                 operation);
1705                    ret = INVALID_OPERATION;
1706                    break;
1707
1708                }
1709
1710            break;
1711
1712        case AF_STATE:
1713
1714            switch ( operation )
1715                {
1716
1717                case CAMERA_CANCEL_AUTOFOCUS:
1718                    CAMHAL_LOGDB("Adapter state switch AF_STATE->PREVIEW_STATE event = 0x%x",
1719                                 operation);
1720                    mNextState = PREVIEW_STATE;
1721                    break;
1722
1723                case CAMERA_START_SMOOTH_ZOOM:
1724                    CAMHAL_LOGDB("Adapter state switch AF_STATE->AF_ZOOM_STATE event = 0x%x",
1725                                 operation);
1726                    mNextState = AF_ZOOM_STATE;
1727                    break;
1728
1729                default:
1730                    CAMHAL_LOGEB("Adapter state switch AF_STATE Invalid Op! event = 0x%x",
1731                                 operation);
1732                    ret = INVALID_OPERATION;
1733                    break;
1734
1735                }
1736
1737            break;
1738
1739        case ZOOM_STATE:
1740
1741            switch ( operation )
1742                {
1743
1744                case CAMERA_STOP_SMOOTH_ZOOM:
1745                    CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->PREVIEW_STATE event = 0x%x",
1746                                 operation);
1747                    mNextState = PREVIEW_STATE;
1748                    break;
1749
1750                case CAMERA_PERFORM_AUTOFOCUS:
1751                    CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->AF_ZOOM_STATE event = 0x%x",
1752                                 operation);
1753                    mNextState = AF_ZOOM_STATE;
1754                    break;
1755
1756                case CAMERA_START_VIDEO:
1757                    CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->VIDEO_ZOOM_STATE event = 0x%x",
1758                                 operation);
1759                    mNextState = VIDEO_ZOOM_STATE;
1760                    break;
1761
1762                default:
1763                    CAMHAL_LOGEB("Adapter state switch ZOOM_STATE Invalid Op! event = 0x%x",
1764                                 operation);
1765                    ret = INVALID_OPERATION;
1766                    break;
1767
1768                }
1769
1770            break;
1771
1772        case VIDEO_STATE:
1773
1774            switch ( operation )
1775                {
1776
1777                case CAMERA_STOP_VIDEO:
1778                    CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->PREVIEW_STATE event = 0x%x",
1779                                 operation);
1780                    mNextState = PREVIEW_STATE;
1781                    break;
1782
1783                case CAMERA_START_SMOOTH_ZOOM:
1784                    CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->VIDEO_ZOOM_STATE event = 0x%x",
1785                                 operation);
1786                    mNextState = VIDEO_ZOOM_STATE;
1787                    break;
1788
1789                default:
1790                    CAMHAL_LOGEB("Adapter state switch VIDEO_STATE Invalid Op! event = 0x%x",
1791                                 operation);
1792                    ret = INVALID_OPERATION;
1793                    break;
1794
1795                }
1796
1797            break;
1798
1799        case AF_ZOOM_STATE:
1800
1801            switch ( operation )
1802                {
1803
1804                case CAMERA_STOP_SMOOTH_ZOOM:
1805                    CAMHAL_LOGDB("Adapter state switch AF_ZOOM_STATE->AF_STATE event = 0x%x",
1806                                 operation);
1807                    mNextState = AF_STATE;
1808                    break;
1809
1810                case CAMERA_CANCEL_AUTOFOCUS:
1811                    CAMHAL_LOGDB("Adapter state switch AF_ZOOM_STATE->ZOOM_STATE event = 0x%x",
1812                                 operation);
1813                    mNextState = ZOOM_STATE;
1814                    break;
1815
1816                default:
1817                    CAMHAL_LOGEB("Adapter state switch AF_ZOOM_STATE Invalid Op! event = 0x%x",
1818                                 operation);
1819                    ret = INVALID_OPERATION;
1820                    break;
1821
1822                }
1823
1824            break;
1825
1826        case VIDEO_ZOOM_STATE:
1827
1828            switch ( operation )
1829                {
1830
1831                case CAMERA_STOP_SMOOTH_ZOOM:
1832                    CAMHAL_LOGDB("Adapter state switch VIDEO_ZOOM_STATE->VIDEO_STATE event = 0x%x",
1833                                 operation);
1834                    mNextState = VIDEO_STATE;
1835                    break;
1836
1837                case CAMERA_STOP_VIDEO:
1838                    CAMHAL_LOGDB("Adapter state switch VIDEO_ZOOM_STATE->ZOOM_STATE event = 0x%x",
1839                                 operation);
1840                    mNextState = ZOOM_STATE;
1841                    break;
1842
1843                default:
1844                    CAMHAL_LOGEB("Adapter state switch VIDEO_ZOOM_STATE Invalid Op! event = 0x%x",
1845                                 operation);
1846                    ret = INVALID_OPERATION;
1847                    break;
1848
1849                }
1850
1851            break;
1852
1853        case BRACKETING_ZOOM_STATE:
1854
1855            switch ( operation )
1856                {
1857
1858                case CAMERA_STOP_SMOOTH_ZOOM:
1859                    CAMHAL_LOGDB("Adapter state switch BRACKETING_ZOOM_STATE->BRACKETING_STATE event = 0x%x",
1860                                 operation);
1861                    mNextState = BRACKETING_STATE;
1862                    break;
1863
1864                default:
1865                    CAMHAL_LOGEB("Adapter state switch BRACKETING_ZOOM_STATE Invalid Op! event = 0x%x",
1866                                 operation);
1867                    ret = INVALID_OPERATION;
1868                    break;
1869
1870                }
1871
1872            break;
1873
1874        default:
1875            CAMHAL_LOGEA("Invalid Adapter state!");
1876            ret = INVALID_OPERATION;
1877        }
1878
1879    LOG_FUNCTION_NAME_EXIT;
1880
1881    return ret;
1882}
1883
1884//State transition finished successfully.
1885//Commit the state and unlock the adapter state.
1886status_t BaseCameraAdapter::commitState()
1887{
1888    status_t ret = NO_ERROR;
1889
1890    LOG_FUNCTION_NAME;
1891
1892    mAdapterState = mNextState;
1893
1894    mLock.unlock();
1895
1896    LOG_FUNCTION_NAME_EXIT;
1897
1898    return ret;
1899}
1900
1901status_t BaseCameraAdapter::rollbackState()
1902{
1903    status_t ret = NO_ERROR;
1904
1905    LOG_FUNCTION_NAME;
1906
1907    mNextState = mAdapterState;
1908
1909    mLock.unlock();
1910
1911    LOG_FUNCTION_NAME_EXIT;
1912
1913    return ret;
1914}
1915
1916// getNextState() and getState()
1917// publicly exposed functions to retrieve the adapter states
1918// please notice that these functions are locked
1919CameraAdapter::AdapterState BaseCameraAdapter::getState()
1920{
1921    status_t ret = NO_ERROR;
1922
1923    LOG_FUNCTION_NAME;
1924
1925    Mutex::Autolock lock(mLock);
1926
1927    LOG_FUNCTION_NAME_EXIT;
1928
1929    return mAdapterState;
1930}
1931
1932CameraAdapter::AdapterState BaseCameraAdapter::getNextState()
1933{
1934    status_t ret = NO_ERROR;
1935
1936    LOG_FUNCTION_NAME;
1937
1938    Mutex::Autolock lock(mLock);
1939
1940    LOG_FUNCTION_NAME_EXIT;
1941
1942    return mNextState;
1943}
1944
1945// getNextState() and getState()
1946// internal protected functions to retrieve the adapter states
1947// please notice that these functions are NOT locked to help
1948// internal functions query state in the middle of state
1949// transition
1950status_t BaseCameraAdapter::getState(AdapterState &state)
1951{
1952    status_t ret = NO_ERROR;
1953
1954    LOG_FUNCTION_NAME;
1955
1956    state = mAdapterState;
1957
1958    LOG_FUNCTION_NAME_EXIT;
1959
1960    return ret;
1961}
1962
1963status_t BaseCameraAdapter::getNextState(AdapterState &state)
1964{
1965    status_t ret = NO_ERROR;
1966
1967    LOG_FUNCTION_NAME;
1968
1969    state = mNextState;
1970
1971    LOG_FUNCTION_NAME_EXIT;
1972
1973    return ret;
1974}
1975
1976void BaseCameraAdapter::onOrientationEvent(uint32_t orientation, uint32_t tilt)
1977{
1978    LOG_FUNCTION_NAME;
1979    LOG_FUNCTION_NAME_EXIT;
1980}
1981//-----------------------------------------------------------------------------
1982
1983
1984
1985};
1986
1987/*--------------------Camera Adapter Class ENDS here-----------------------------*/
1988
1989