Home | History | Annotate | Download | only in api1
      1 /*
      2  * Copyright (C) 2012 The Android Open Source Project
      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 #ifndef ANDROID_SERVERS_CAMERA_CAMERA2CLIENT_H
     18 #define ANDROID_SERVERS_CAMERA_CAMERA2CLIENT_H
     19 
     20 #include "CameraService.h"
     21 #include "common/CameraDeviceBase.h"
     22 #include "common/Camera2ClientBase.h"
     23 #include "api1/client2/Parameters.h"
     24 #include "api1/client2/FrameProcessor.h"
     25 //#include "api1/client2/StreamingProcessor.h"
     26 //#include "api1/client2/JpegProcessor.h"
     27 //#include "api1/client2/ZslProcessorInterface.h"
     28 //#include "api1/client2/CaptureSequencer.h"
     29 //#include "api1/client2/CallbackProcessor.h"
     30 
     31 namespace android {
     32 
     33 namespace camera2 {
     34 
     35 class StreamingProcessor;
     36 class JpegProcessor;
     37 class ZslProcessorInterface;
     38 class CaptureSequencer;
     39 class CallbackProcessor;
     40 
     41 }
     42 
     43 class IMemory;
     44 /**
     45  * Interface between android.hardware.Camera API and Camera HAL device for versions
     46  * CAMERA_DEVICE_API_VERSION_2_0 and 3_0.
     47  */
     48 class Camera2Client :
     49         public Camera2ClientBase<CameraService::Client>
     50 {
     51 public:
     52     /**
     53      * ICamera interface (see ICamera for details)
     54      */
     55 
     56     virtual void            disconnect();
     57     virtual status_t        connect(const sp<ICameraClient>& client);
     58     virtual status_t        lock();
     59     virtual status_t        unlock();
     60     virtual status_t        setPreviewTarget(
     61         const sp<IGraphicBufferProducer>& bufferProducer);
     62     virtual void            setPreviewCallbackFlag(int flag);
     63     virtual status_t        setPreviewCallbackTarget(
     64         const sp<IGraphicBufferProducer>& callbackProducer);
     65 
     66     virtual status_t        startPreview();
     67     virtual void            stopPreview();
     68     virtual bool            previewEnabled();
     69     virtual status_t        storeMetaDataInBuffers(bool enabled);
     70     virtual status_t        startRecording();
     71     virtual void            stopRecording();
     72     virtual bool            recordingEnabled();
     73     virtual void            releaseRecordingFrame(const sp<IMemory>& mem);
     74     virtual status_t        autoFocus();
     75     virtual status_t        cancelAutoFocus();
     76     virtual status_t        takePicture(int msgType);
     77     virtual status_t        setParameters(const String8& params);
     78     virtual String8         getParameters() const;
     79     virtual status_t        sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
     80     virtual void            notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode,
     81                                         const CaptureResultExtras& resultExtras);
     82 
     83     /**
     84      * Interface used by CameraService
     85      */
     86 
     87     Camera2Client(const sp<CameraService>& cameraService,
     88             const sp<ICameraClient>& cameraClient,
     89             const String16& clientPackageName,
     90             int cameraId,
     91             int cameraFacing,
     92             int clientPid,
     93             uid_t clientUid,
     94             int servicePid,
     95             bool legacyMode);
     96 
     97     virtual ~Camera2Client();
     98 
     99     status_t initialize(CameraModule *module);
    100 
    101     virtual status_t dump(int fd, const Vector<String16>& args);
    102 
    103     /**
    104      * Interface used by CameraDeviceBase
    105      */
    106 
    107     virtual void notifyAutoFocus(uint8_t newState, int triggerId);
    108     virtual void notifyAutoExposure(uint8_t newState, int triggerId);
    109     virtual void notifyShutter(const CaptureResultExtras& resultExtras,
    110                                nsecs_t timestamp);
    111 
    112     /**
    113      * Interface used by independent components of Camera2Client.
    114      */
    115 
    116     camera2::SharedParameters& getParameters();
    117 
    118     int getPreviewStreamId() const;
    119     int getCaptureStreamId() const;
    120     int getCallbackStreamId() const;
    121     int getRecordingStreamId() const;
    122     int getZslStreamId() const;
    123 
    124     status_t registerFrameListener(int32_t minId, int32_t maxId,
    125             wp<camera2::FrameProcessor::FilteredListener> listener,
    126             bool sendPartials = true);
    127     status_t removeFrameListener(int32_t minId, int32_t maxId,
    128             wp<camera2::FrameProcessor::FilteredListener> listener);
    129 
    130     status_t stopStream();
    131 
    132     // For the slowJpegMode to create jpeg stream when precapture sequence is done
    133     status_t createJpegStreamL(camera2::Parameters &params);
    134 
    135     static size_t calculateBufferSize(int width, int height,
    136             int format, int stride);
    137 
    138     static const int32_t kPreviewRequestIdStart = 10000000;
    139     static const int32_t kPreviewRequestIdEnd   = 20000000;
    140 
    141     static const int32_t kRecordingRequestIdStart  = 20000000;
    142     static const int32_t kRecordingRequestIdEnd    = 30000000;
    143 
    144     static const int32_t kCaptureRequestIdStart = 30000000;
    145     static const int32_t kCaptureRequestIdEnd   = 40000000;
    146 
    147     // Constant strings for ATRACE logging
    148     static const char* kAutofocusLabel;
    149     static const char* kTakepictureLabel;
    150 
    151     // Used with stream IDs
    152     static const int NO_STREAM = -1;
    153 
    154 private:
    155     /** ICamera interface-related private members */
    156     typedef camera2::Parameters Parameters;
    157 
    158     status_t setPreviewWindowL(const sp<IBinder>& binder,
    159             sp<Surface> window);
    160     status_t startPreviewL(Parameters &params, bool restart);
    161     void     stopPreviewL();
    162     status_t startRecordingL(Parameters &params, bool restart);
    163     bool     recordingEnabledL();
    164 
    165     // Individual commands for sendCommand()
    166     status_t commandStartSmoothZoomL();
    167     status_t commandStopSmoothZoomL();
    168     status_t commandSetDisplayOrientationL(int degrees);
    169     status_t commandEnableShutterSoundL(bool enable);
    170     status_t commandPlayRecordingSoundL();
    171     status_t commandStartFaceDetectionL(int type);
    172     status_t commandStopFaceDetectionL(Parameters &params);
    173     status_t commandEnableFocusMoveMsgL(bool enable);
    174     status_t commandPingL();
    175     status_t commandSetVideoBufferCountL(size_t count);
    176     status_t commandSetVideoFormatL(int format, android_dataspace dataSpace);
    177 
    178     // Current camera device configuration
    179     camera2::SharedParameters mParameters;
    180 
    181     /** Camera device-related private members */
    182 
    183     void     setPreviewCallbackFlagL(Parameters &params, int flag);
    184     status_t updateRequests(Parameters &params);
    185 
    186     template <typename ProcessorT>
    187     status_t updateProcessorStream(sp<ProcessorT> processor, Parameters params);
    188     template <typename ProcessorT,
    189               status_t (ProcessorT::*updateStreamF)(const Parameters &)>
    190     status_t updateProcessorStream(sp<ProcessorT> processor, Parameters params);
    191 
    192     sp<camera2::FrameProcessor> mFrameProcessor;
    193 
    194     /* Preview/Recording related members */
    195 
    196     sp<IBinder> mPreviewSurface;
    197     sp<camera2::StreamingProcessor> mStreamingProcessor;
    198 
    199     /** Preview callback related members */
    200 
    201     sp<camera2::CallbackProcessor> mCallbackProcessor;
    202 
    203     /* Still image capture related members */
    204 
    205     sp<camera2::CaptureSequencer> mCaptureSequencer;
    206     sp<camera2::JpegProcessor> mJpegProcessor;
    207     sp<camera2::ZslProcessorInterface> mZslProcessor;
    208     sp<Thread> mZslProcessorThread;
    209 
    210     /** Notification-related members */
    211 
    212     bool mAfInMotion;
    213 
    214     /** Utility members */
    215     bool mLegacyMode;
    216 
    217     // Wait until the camera device has received the latest control settings
    218     status_t syncWithDevice();
    219 
    220     // Video snapshot jpeg size overriding helper function
    221     status_t overrideVideoSnapshotSize(Parameters &params);
    222 };
    223 
    224 }; // namespace android
    225 
    226 #endif
    227