1 /*
2  * Copyright (C) 2013 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_PHOTOGRAPHY_CAMERADEVICECLIENT_H
18 #define ANDROID_SERVERS_CAMERA_PHOTOGRAPHY_CAMERADEVICECLIENT_H
19 
20 #include <android/hardware/camera2/BnCameraDeviceUser.h>
21 #include <android/hardware/camera2/ICameraDeviceCallbacks.h>
22 #include <camera/camera2/OutputConfiguration.h>
23 #include <camera/camera2/SubmitInfo.h>
24 
25 #include "CameraService.h"
26 #include "common/FrameProcessorBase.h"
27 #include "common/Camera2ClientBase.h"
28 
29 namespace android {
30 
31 struct CameraDeviceClientBase :
32          public CameraService::BasicClient,
33          public hardware::camera2::BnCameraDeviceUser
34 {
35     typedef hardware::camera2::ICameraDeviceCallbacks TCamCallbacks;
36 
getRemoteCallbackCameraDeviceClientBase37     const sp<hardware::camera2::ICameraDeviceCallbacks>& getRemoteCallback() {
38         return mRemoteCallback;
39     }
40 
41 protected:
42     CameraDeviceClientBase(const sp<CameraService>& cameraService,
43             const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,
44             const String16& clientPackageName,
45             int cameraId,
46             int cameraFacing,
47             int clientPid,
48             uid_t clientUid,
49             int servicePid);
50 
51     sp<hardware::camera2::ICameraDeviceCallbacks> mRemoteCallback;
52 };
53 
54 /**
55  * Implements the binder ICameraDeviceUser API,
56  * meant for HAL3-public implementation of
57  * android.hardware.photography.CameraDevice
58  */
59 class CameraDeviceClient :
60         public Camera2ClientBase<CameraDeviceClientBase>,
61         public camera2::FrameProcessorBase::FilteredListener
62 {
63 public:
64     /**
65      * ICameraDeviceUser interface (see ICameraDeviceUser for details)
66      */
67 
68     // Note that the callee gets a copy of the metadata.
69     virtual binder::Status submitRequest(
70             const hardware::camera2::CaptureRequest& request,
71             bool streaming = false,
72             /*out*/
73             hardware::camera2::utils::SubmitInfo *submitInfo = nullptr);
74     // List of requests are copied.
75     virtual binder::Status submitRequestList(
76             const std::vector<hardware::camera2::CaptureRequest>& requests,
77             bool streaming = false,
78             /*out*/
79             hardware::camera2::utils::SubmitInfo *submitInfo = nullptr);
80     virtual binder::Status cancelRequest(int requestId,
81             /*out*/
82             int64_t* lastFrameNumber = NULL);
83 
84     virtual binder::Status beginConfigure();
85 
86     virtual binder::Status endConfigure(bool isConstrainedHighSpeed = false);
87 
88     // Returns -EBUSY if device is not idle
89     virtual binder::Status deleteStream(int streamId);
90 
91     virtual binder::Status createStream(
92             const hardware::camera2::params::OutputConfiguration &outputConfiguration,
93             /*out*/
94             int32_t* newStreamId = NULL);
95 
96     // Create an input stream of width, height, and format.
97     virtual binder::Status createInputStream(int width, int height, int format,
98             /*out*/
99             int32_t* newStreamId = NULL);
100 
101     // Get the buffer producer of the input stream
102     virtual binder::Status getInputSurface(
103             /*out*/
104             view::Surface *inputSurface);
105 
106     // Create a request object from a template.
107     virtual binder::Status createDefaultRequest(int templateId,
108             /*out*/
109             hardware::camera2::impl::CameraMetadataNative* request);
110 
111     // Get the static metadata for the camera
112     // -- Caller owns the newly allocated metadata
113     virtual binder::Status getCameraInfo(
114             /*out*/
115             hardware::camera2::impl::CameraMetadataNative* cameraCharacteristics);
116 
117     // Wait until all the submitted requests have finished processing
118     virtual binder::Status waitUntilIdle();
119 
120     // Flush all active and pending requests as fast as possible
121     virtual binder::Status flush(
122             /*out*/
123             int64_t* lastFrameNumber = NULL);
124 
125     // Prepare stream by preallocating its buffers
126     virtual binder::Status prepare(int32_t streamId);
127 
128     // Tear down stream resources by freeing its unused buffers
129     virtual binder::Status tearDown(int32_t streamId);
130 
131     // Prepare stream by preallocating up to maxCount of its buffers
132     virtual binder::Status prepare2(int32_t maxCount, int32_t streamId);
133 
134     /**
135      * Interface used by CameraService
136      */
137 
138     CameraDeviceClient(const sp<CameraService>& cameraService,
139             const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,
140             const String16& clientPackageName,
141             int cameraId,
142             int cameraFacing,
143             int clientPid,
144             uid_t clientUid,
145             int servicePid);
146     virtual ~CameraDeviceClient();
147 
148     virtual status_t      initialize(CameraModule *module);
149 
150     virtual status_t      dump(int fd, const Vector<String16>& args);
151 
152     virtual status_t      dumpClient(int fd, const Vector<String16>& args);
153 
154     /**
155      * Device listener interface
156      */
157 
158     virtual void notifyIdle();
159     virtual void notifyError(int32_t errorCode,
160                              const CaptureResultExtras& resultExtras);
161     virtual void notifyShutter(const CaptureResultExtras& resultExtras, nsecs_t timestamp);
162     virtual void notifyPrepared(int streamId);
163     virtual void notifyRepeatingRequestError(long lastFrameNumber);
164 
165     /**
166      * Interface used by independent components of CameraDeviceClient.
167      */
168 protected:
169     /** FilteredListener implementation **/
170     virtual void          onResultAvailable(const CaptureResult& result);
171     virtual void          detachDevice();
172 
173     // Calculate the ANativeWindow transform from android.sensor.orientation
174     status_t              getRotationTransformLocked(/*out*/int32_t* transform);
175 
176 private:
177     /** ICameraDeviceUser interface-related private members */
178 
179     /** Preview callback related members */
180     sp<camera2::FrameProcessorBase> mFrameProcessor;
181     static const int32_t FRAME_PROCESSOR_LISTENER_MIN_ID = 0;
182     static const int32_t FRAME_PROCESSOR_LISTENER_MAX_ID = 0x7fffffffL;
183 
184     /** Utility members */
185     binder::Status checkPidStatus(const char* checkLocation);
186     bool enforceRequestPermissions(CameraMetadata& metadata);
187 
188     // Find the square of the euclidean distance between two points
189     static int64_t euclidDistSquare(int32_t x0, int32_t y0, int32_t x1, int32_t y1);
190 
191     // Find the closest dimensions for a given format in available stream configurations with
192     // a width <= ROUNDING_WIDTH_CAP
193     static const int32_t ROUNDING_WIDTH_CAP = 1920;
194     static bool roundBufferDimensionNearest(int32_t width, int32_t height, int32_t format,
195             android_dataspace dataSpace, const CameraMetadata& info,
196             /*out*/int32_t* outWidth, /*out*/int32_t* outHeight);
197 
198     // IGraphicsBufferProducer binder -> Stream ID for output streams
199     KeyedVector<sp<IBinder>, int> mStreamMap;
200 
201     struct InputStreamConfiguration {
202         bool configured;
203         int32_t width;
204         int32_t height;
205         int32_t format;
206         int32_t id;
207     } mInputStream;
208 
209     // Streaming request ID
210     int32_t mStreamingRequestId;
211     Mutex mStreamingRequestIdLock;
212     static const int32_t REQUEST_ID_NONE = -1;
213 
214     int32_t mRequestIdCounter;
215 
216 };
217 
218 }; // namespace android
219 
220 #endif
221