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/ZslProcessor.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 ZslProcessor;
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_3_0 and above.
47  */
48 class Camera2Client :
49         public Camera2ClientBase<CameraService::Client>
50 {
51 public:
52     /**
53      * ICamera interface (see ICamera for details)
54      */
55 
56     virtual binder::Status  disconnect();
57     virtual status_t        connect(const sp<hardware::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        setVideoBufferMode(int32_t videoBufferMode);
70     virtual status_t        startRecording();
71     virtual void            stopRecording();
72     virtual bool            recordingEnabled();
73     virtual void            releaseRecordingFrame(const sp<IMemory>& mem);
74     virtual void            releaseRecordingFrameHandle(native_handle_t *handle);
75     virtual void            releaseRecordingFrameHandleBatch(
76                                     const std::vector<native_handle_t*>& handles);
77     virtual status_t        autoFocus();
78     virtual status_t        cancelAutoFocus();
79     virtual status_t        takePicture(int msgType);
80     virtual status_t        setParameters(const String8& params);
81     virtual String8         getParameters() const;
82     virtual status_t        sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
83     virtual void            notifyError(int32_t errorCode,
84                                         const CaptureResultExtras& resultExtras);
85     virtual status_t        setVideoTarget(const sp<IGraphicBufferProducer>& bufferProducer);
86     virtual status_t        setAudioRestriction(int mode);
87     virtual int32_t         getGlobalAudioRestriction();
88     virtual status_t        setRotateAndCropOverride(uint8_t rotateAndCrop);
89 
90     /**
91      * Interface used by CameraService
92      */
93 
94     Camera2Client(const sp<CameraService>& cameraService,
95             const sp<hardware::ICameraClient>& cameraClient,
96             const String16& clientPackageName,
97             const std::unique_ptr<String16>& clientFeatureId,
98             const String8& cameraDeviceId,
99             int api1CameraId,
100             int cameraFacing,
101             int clientPid,
102             uid_t clientUid,
103             int servicePid);
104 
105     virtual ~Camera2Client();
106 
107     virtual status_t initialize(sp<CameraProviderManager> manager,
108             const String8& monitorTags) override;
109 
110     virtual status_t dump(int fd, const Vector<String16>& args);
111 
112     virtual status_t dumpClient(int fd, const Vector<String16>& args);
113 
114     /**
115      * Interface used by CameraDeviceBase
116      */
117 
118     virtual void notifyAutoFocus(uint8_t newState, int triggerId);
119     virtual void notifyAutoExposure(uint8_t newState, int triggerId);
120     virtual void notifyShutter(const CaptureResultExtras& resultExtras,
121                                nsecs_t timestamp);
122 
123     /**
124      * Interface used by independent components of Camera2Client.
125      */
126 
127     camera2::SharedParameters& getParameters();
128 
129     void notifyRequestId(int32_t requestId);
130 
131     int getPreviewStreamId() const;
132     int getCaptureStreamId() const;
133     int getCallbackStreamId() const;
134     int getRecordingStreamId() const;
135     int getZslStreamId() const;
136 
137     status_t registerFrameListener(int32_t minId, int32_t maxId,
138             const wp<camera2::FrameProcessor::FilteredListener>& listener,
139             bool sendPartials = true);
140     status_t removeFrameListener(int32_t minId, int32_t maxId,
141             const wp<camera2::FrameProcessor::FilteredListener>& listener);
142 
143     status_t stopStream();
144 
145     // For the slowJpegMode to create jpeg stream when precapture sequence is done
146     status_t createJpegStreamL(camera2::Parameters &params);
147 
148     static size_t calculateBufferSize(int width, int height,
149             int format, int stride);
150 
151     static const int32_t kPreviewRequestIdStart = 10000000;
152     static const int32_t kPreviewRequestIdEnd   = 20000000;
153 
154     static const int32_t kRecordingRequestIdStart  = 20000000;
155     static const int32_t kRecordingRequestIdEnd    = 30000000;
156 
157     static const int32_t kCaptureRequestIdStart = 30000000;
158     static const int32_t kCaptureRequestIdEnd   = 40000000;
159 
160     // Constant strings for ATRACE logging
161     static const char* kAutofocusLabel;
162     static const char* kTakepictureLabel;
163 
164     // Used with stream IDs
165     static const int NO_STREAM = -1;
166 
167 private:
168     /** ICamera interface-related private members */
169     typedef camera2::Parameters Parameters;
170 
171     status_t setPreviewWindowL(const sp<IBinder>& binder,
172             const sp<Surface>& window);
173     status_t startPreviewL(Parameters &params, bool restart);
174     void     stopPreviewL();
175     status_t startRecordingL(Parameters &params, bool restart);
176     bool     recordingEnabledL();
177 
178     // Individual commands for sendCommand()
179     status_t commandStartSmoothZoomL();
180     status_t commandStopSmoothZoomL();
181     status_t commandSetDisplayOrientationL(int degrees);
182     status_t commandEnableShutterSoundL(bool enable);
183     status_t commandPlayRecordingSoundL();
184     status_t commandStartFaceDetectionL(int type);
185     status_t commandStopFaceDetectionL(Parameters &params);
186     status_t commandEnableFocusMoveMsgL(bool enable);
187     status_t commandPingL();
188     status_t commandSetVideoBufferCountL(size_t count);
189     status_t commandSetVideoFormatL(int format, android_dataspace dataSpace);
190 
191     // Current camera device configuration
192     camera2::SharedParameters mParameters;
193 
194     /** Camera device-related private members */
195 
196     void     setPreviewCallbackFlagL(Parameters &params, int flag);
197     status_t updateRequests(Parameters &params);
198 
199     template <typename ProcessorT>
200     status_t updateProcessorStream(sp<ProcessorT> processor, Parameters params);
201     template <typename ProcessorT,
202               status_t (ProcessorT::*updateStreamF)(const Parameters &)>
203     status_t updateProcessorStream(sp<ProcessorT> processor, Parameters params);
204 
205     sp<camera2::FrameProcessor> mFrameProcessor;
206 
207     /* Preview/Recording related members */
208 
209     sp<IBinder> mPreviewSurface;
210     sp<IBinder> mVideoSurface;
211     sp<camera2::StreamingProcessor> mStreamingProcessor;
212 
213     /** Preview callback related members */
214 
215     sp<camera2::CallbackProcessor> mCallbackProcessor;
216 
217     /* Still image capture related members */
218 
219     sp<camera2::CaptureSequencer> mCaptureSequencer;
220     sp<camera2::JpegProcessor> mJpegProcessor;
221     sp<camera2::ZslProcessor> mZslProcessor;
222 
223     /** Utility members */
224     bool mLegacyMode;
225 
226     // Wait until the camera device has received the latest control settings
227     status_t syncWithDevice();
228 
229     // Video snapshot jpeg size overriding helper function
230     status_t overrideVideoSnapshotSize(Parameters &params);
231 
232     template<typename TProviderPtr>
233     status_t initializeImpl(TProviderPtr providerPtr, const String8& monitorTags);
234 
235     bool isZslEnabledInStillTemplate();
236 
237     mutable Mutex mLatestRequestMutex;
238     Condition mLatestRequestSignal;
239     int32_t mLatestRequestId = -1;
240     int32_t mLatestFailedRequestId = -1;
241     status_t waitUntilRequestIdApplied(int32_t requestId, nsecs_t timeout);
242     status_t waitUntilCurrentRequestIdLocked();
243 };
244 
245 }; // namespace android
246 
247 #endif
248