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