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 
23 #include "CameraService.h"
24 #include "common/FrameProcessorBase.h"
25 #include "common/Camera2ClientBase.h"
26 
27 namespace android {
28 
29 struct CameraDeviceClientBase :
30         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();
82 
83     // Returns -EBUSY if device is not idle
84     virtual status_t      deleteStream(int streamId);
85 
86     virtual status_t      createStream(
87             int width,
88             int height,
89             int format,
90             const sp<IGraphicBufferProducer>& bufferProducer);
91 
92     // Create a request object from a template.
93     virtual status_t      createDefaultRequest(int templateId,
94                                                /*out*/
95                                                CameraMetadata* request);
96 
97     // Get the static metadata for the camera
98     // -- Caller owns the newly allocated metadata
99     virtual status_t      getCameraInfo(/*out*/CameraMetadata* info);
100 
101     // Wait until all the submitted requests have finished processing
102     virtual status_t      waitUntilIdle();
103 
104     // Flush all active and pending requests as fast as possible
105     virtual status_t      flush(/*out*/
106                                 int64_t* lastFrameNumber = NULL);
107 
108     /**
109      * Interface used by CameraService
110      */
111 
112     CameraDeviceClient(const sp<CameraService>& cameraService,
113             const sp<ICameraDeviceCallbacks>& remoteCallback,
114             const String16& clientPackageName,
115             int cameraId,
116             int cameraFacing,
117             int clientPid,
118             uid_t clientUid,
119             int servicePid);
120     virtual ~CameraDeviceClient();
121 
122     virtual status_t      initialize(camera_module_t *module);
123 
124     virtual status_t      dump(int fd, const Vector<String16>& args);
125 
126     /**
127      * Device listener interface
128      */
129 
130     virtual void notifyIdle();
131     virtual void notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode,
132                              const CaptureResultExtras& resultExtras);
133     virtual void notifyShutter(const CaptureResultExtras& resultExtras, nsecs_t timestamp);
134 
135     /**
136      * Interface used by independent components of CameraDeviceClient.
137      */
138 protected:
139     /** FilteredListener implementation **/
140     virtual void          onResultAvailable(const CaptureResult& result);
141     virtual void          detachDevice();
142 
143     // Calculate the ANativeWindow transform from android.sensor.orientation
144     status_t              getRotationTransformLocked(/*out*/int32_t* transform);
145 
146 private:
147     /** ICameraDeviceUser interface-related private members */
148 
149     /** Preview callback related members */
150     sp<camera2::FrameProcessorBase> mFrameProcessor;
151     static const int32_t FRAME_PROCESSOR_LISTENER_MIN_ID = 0;
152     static const int32_t FRAME_PROCESSOR_LISTENER_MAX_ID = 0x7fffffffL;
153 
154     /** Utility members */
155     bool enforceRequestPermissions(CameraMetadata& metadata);
156 
157     // Find the square of the euclidean distance between two points
158     static int64_t euclidDistSquare(int32_t x0, int32_t y0, int32_t x1, int32_t y1);
159 
160     // Find the closest dimensions for a given format in available stream configurations with
161     // a width <= ROUNDING_WIDTH_CAP
162     static const int32_t ROUNDING_WIDTH_CAP = 1080;
163     static bool roundBufferDimensionNearest(int32_t width, int32_t height, int32_t format,
164             const CameraMetadata& info, /*out*/int32_t* outWidth, /*out*/int32_t* outHeight);
165 
166     // IGraphicsBufferProducer binder -> Stream ID
167     KeyedVector<sp<IBinder>, int> mStreamMap;
168 
169     // Stream ID
170     Vector<int> mStreamingRequestList;
171 
172     int32_t mRequestIdCounter;
173 };
174 
175 }; // namespace android
176 
177 #endif
178