1 /* 2 * Copyright (C) 2012 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_CAMERACLIENT_H 18 #define ANDROID_SERVERS_CAMERA_CAMERACLIENT_H 19 20 #include "CameraService.h" 21 22 namespace android { 23 24 class MemoryHeapBase; 25 class CameraHardwareInterface; 26 27 /** 28 * Interface between android.hardware.Camera API and Camera HAL device for version 29 * CAMERA_DEVICE_API_VERSION_1_0. 30 */ 31 32 class CameraClient : public CameraService::Client 33 { 34 public: 35 // ICamera interface (see ICamera for details) 36 virtual binder::Status disconnect(); 37 virtual status_t connect(const sp<hardware::ICameraClient>& client); 38 virtual status_t lock(); 39 virtual status_t unlock(); 40 virtual status_t setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer); 41 virtual void setPreviewCallbackFlag(int flag); 42 virtual status_t setPreviewCallbackTarget( 43 const sp<IGraphicBufferProducer>& callbackProducer); 44 virtual status_t startPreview(); 45 virtual void stopPreview(); 46 virtual bool previewEnabled(); 47 virtual status_t setVideoBufferMode(int32_t videoBufferMode); 48 virtual status_t startRecording(); 49 virtual void stopRecording(); 50 virtual bool recordingEnabled(); 51 virtual void releaseRecordingFrame(const sp<IMemory>& mem); 52 virtual void releaseRecordingFrameHandle(native_handle_t *handle); 53 virtual void releaseRecordingFrameHandleBatch( 54 const std::vector<native_handle_t*>& handles); 55 virtual status_t autoFocus(); 56 virtual status_t cancelAutoFocus(); 57 virtual status_t takePicture(int msgType); 58 virtual status_t setParameters(const String8& params); 59 virtual String8 getParameters() const; 60 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2); 61 virtual status_t setVideoTarget(const sp<IGraphicBufferProducer>& bufferProducer); 62 virtual status_t setAudioRestriction(int mode); 63 virtual int32_t getGlobalAudioRestriction(); 64 65 virtual status_t setRotateAndCropOverride(uint8_t override); 66 67 // Interface used by CameraService 68 CameraClient(const sp<CameraService>& cameraService, 69 const sp<hardware::ICameraClient>& cameraClient, 70 const String16& clientPackageName, 71 const std::unique_ptr<String16>& clientFeatureId, 72 int cameraId, 73 int cameraFacing, 74 int clientPid, 75 int clientUid, 76 int servicePid); 77 ~CameraClient(); 78 79 virtual status_t initialize(sp<CameraProviderManager> manager, 80 const String8& monitorTags) override; 81 82 virtual status_t dump(int fd, const Vector<String16>& args); 83 84 virtual status_t dumpClient(int fd, const Vector<String16>& args); 85 86 private: 87 88 // check whether the calling process matches mClientPid. 89 status_t checkPid() const; 90 status_t checkPidAndHardware() const; // also check mHardware != 0 91 92 // these are internal functions used to set up preview buffers 93 status_t registerPreviewBuffers(); 94 95 // camera operation mode 96 enum camera_mode { 97 CAMERA_PREVIEW_MODE = 0, // frame automatically released 98 CAMERA_RECORDING_MODE = 1, // frame has to be explicitly released by releaseRecordingFrame() 99 }; 100 // these are internal functions used for preview/recording 101 status_t startCameraMode(camera_mode mode); 102 status_t startPreviewMode(); 103 status_t startRecordingMode(); 104 105 // internal function used by sendCommand to enable/disable shutter sound. 106 status_t enableShutterSound(bool enable); 107 108 static sp<CameraClient> getClientFromCookie(void* user); 109 110 // these are static callback functions 111 static void notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2, void* user); 112 static void dataCallback(int32_t msgType, const sp<IMemory>& dataPtr, 113 camera_frame_metadata_t *metadata, void* user); 114 static void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr, void* user); 115 static void handleCallbackTimestampBatch( 116 int32_t msgType, const std::vector<HandleTimestampMessage>&, void* user); 117 // handlers for messages 118 void handleShutter(void); 119 void handlePreviewData(int32_t msgType, const sp<IMemory>& mem, 120 camera_frame_metadata_t *metadata); 121 void handlePostview(const sp<IMemory>& mem); 122 void handleRawPicture(const sp<IMemory>& mem); 123 void handleCompressedPicture(const sp<IMemory>& mem); 124 void handleGenericNotify(int32_t msgType, int32_t ext1, int32_t ext2); 125 void handleGenericData(int32_t msgType, const sp<IMemory>& dataPtr, 126 camera_frame_metadata_t *metadata); 127 void handleGenericDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr); 128 129 void copyFrameAndPostCopiedFrame( 130 int32_t msgType, 131 const sp<hardware::ICameraClient>& client, 132 const sp<IMemoryHeap>& heap, 133 size_t offset, size_t size, 134 camera_frame_metadata_t *metadata); 135 136 int getOrientation(int orientation, bool mirror); 137 138 status_t setPreviewWindow( 139 const sp<IBinder>& binder, 140 const sp<ANativeWindow>& window); 141 142 143 // these are initialized in the constructor. 144 sp<CameraHardwareInterface> mHardware; // cleared after disconnect() 145 int mPreviewCallbackFlag; 146 int mOrientation; // Current display orientation 147 bool mPlayShutterSound; 148 bool mLegacyMode; // camera2 api legacy mode? 149 150 // Ensures atomicity among the public methods 151 mutable Mutex mLock; 152 // This is a binder of Surface or Surface. 153 sp<IBinder> mSurface; 154 sp<ANativeWindow> mPreviewWindow; 155 156 // If the user want us to return a copy of the preview frame (instead 157 // of the original one), we allocate mPreviewBuffer and reuse it if possible. 158 sp<MemoryHeapBase> mPreviewBuffer; 159 160 // Debugging information 161 CameraParameters mLatestSetParameters; 162 163 // mAvailableCallbackBuffers stores sp<IMemory> that HAL uses to send VideoNativeHandleMetadata. 164 // It will be used to send VideoNativeHandleMetadata back to HAL when camera receives the 165 // native handle from releaseRecordingFrameHandle. 166 Mutex mAvailableCallbackBuffersLock; 167 std::vector<sp<IMemory>> mAvailableCallbackBuffers; 168 169 // We need to avoid the deadlock when the incoming command thread and 170 // the CameraHardwareInterface callback thread both want to grab mLock. 171 // An extra flag is used to tell the callback thread that it should stop 172 // trying to deliver the callback messages if the client is not 173 // interested in it anymore. For example, if the client is calling 174 // stopPreview(), the preview frame messages do not need to be delivered 175 // anymore. 176 177 // This function takes the same parameter as the enableMsgType() and 178 // disableMsgType() functions in CameraHardwareInterface. 179 void enableMsgType(int32_t msgType); 180 void disableMsgType(int32_t msgType); 181 volatile int32_t mMsgEnabled; 182 183 // This function keeps trying to grab mLock, or give up if the message 184 // is found to be disabled. It returns true if mLock is grabbed. 185 bool lockIfMessageWanted(int32_t msgType); 186 }; 187 188 } 189 190 #endif 191