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