Home | History | Annotate | Download | only in api2 
      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 
     34     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     // IGraphicsBufferProducer binder -> Stream ID
    158     KeyedVector<sp<IBinder>, int> mStreamMap;
    159 
    160     // Stream ID
    161     Vector<int> mStreamingRequestList;
    162 
    163     int32_t mRequestIdCounter;
    164 };
    165 
    166 }; // namespace android
    167 
    168 #endif
    169