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_CAMERA2CLIENT_BASE_H 18 #define ANDROID_SERVERS_CAMERA_CAMERA2CLIENT_BASE_H 19 20 #include "common/CameraDeviceBase.h" 21 #include "camera/CaptureResult.h" 22 23 namespace android { 24 25 class IMemory; 26 27 class CameraService; 28 29 template <typename TClientBase> 30 class Camera2ClientBase : 31 public TClientBase, 32 public NotificationListener 33 { 34 public: 35 typedef typename TClientBase::TCamCallbacks TCamCallbacks; 36 37 /** 38 * Base binder interface (see ICamera/ICameraDeviceUser for details) 39 */ 40 virtual status_t connect(const sp<TCamCallbacks>& callbacks); 41 virtual binder::Status disconnect(); 42 43 /** 44 * Interface used by CameraService 45 */ 46 47 // TODO: too many params, move into a ClientArgs<T> 48 Camera2ClientBase(const sp<CameraService>& cameraService, 49 const sp<TCamCallbacks>& remoteCallback, 50 const String16& clientPackageName, 51 const std::optional<String16>& clientFeatureId, 52 const String8& cameraId, 53 int api1CameraId, 54 int cameraFacing, 55 int sensorOrientation, 56 int clientPid, 57 uid_t clientUid, 58 int servicePid, 59 bool overrideForPerfClass); 60 virtual ~Camera2ClientBase(); 61 62 virtual status_t initialize(sp<CameraProviderManager> manager, const String8& monitorTags); 63 virtual status_t dumpClient(int fd, const Vector<String16>& args); 64 65 /** 66 * NotificationListener implementation 67 */ 68 69 virtual void notifyError(int32_t errorCode, 70 const CaptureResultExtras& resultExtras); 71 virtual status_t notifyActive(); // Returns errors on app ops permission failures 72 virtual void notifyIdle(int64_t requestCount, int64_t resultErrorCount, 73 bool deviceError, 74 const std::vector<hardware::CameraStreamStats>& streamStats); 75 virtual void notifyShutter(const CaptureResultExtras& resultExtras, 76 nsecs_t timestamp); 77 virtual void notifyAutoFocus(uint8_t newState, int triggerId); 78 virtual void notifyAutoExposure(uint8_t newState, int triggerId); 79 virtual void notifyAutoWhitebalance(uint8_t newState, 80 int triggerId); 81 virtual void notifyPrepared(int streamId); 82 virtual void notifyRequestQueueEmpty(); 83 virtual void notifyRepeatingRequestError(long lastFrameNumber); 84 85 int getCameraId() const; 86 const sp<CameraDeviceBase>& 87 getCameraDevice(); 88 int getCameraDeviceVersion() const; 89 const sp<CameraService>& 90 getCameraService(); 91 92 /** 93 * Interface used by independent components of CameraClient2Base. 94 */ 95 96 // Simple class to ensure that access to TCamCallbacks is serialized 97 // by requiring mRemoteCallbackLock to be locked before access to 98 // mRemoteCallback is possible. 99 class SharedCameraCallbacks { 100 public: 101 class Lock { 102 public: 103 explicit Lock(SharedCameraCallbacks &client); 104 ~Lock(); 105 sp<TCamCallbacks> &mRemoteCallback; 106 private: 107 SharedCameraCallbacks &mSharedClient; 108 }; 109 explicit SharedCameraCallbacks(const sp<TCamCallbacks>& client); 110 SharedCameraCallbacks& operator=(const sp<TCamCallbacks>& client); 111 void clear(); 112 private: 113 sp<TCamCallbacks> mRemoteCallback; 114 mutable Mutex mRemoteCallbackLock; 115 } mSharedCameraCallbacks; 116 117 protected: 118 119 // The PID provided in the constructor call 120 pid_t mInitialClientPid; 121 asBinderWrapper()122 virtual sp<IBinder> asBinderWrapper() { 123 return IInterface::asBinder(this); 124 } 125 126 virtual status_t dumpDevice(int fd, const Vector<String16>& args); 127 128 /** Binder client interface-related private members */ 129 130 // Mutex that must be locked by methods implementing the binder client 131 // interface. Ensures serialization between incoming client calls. 132 // All methods in this class hierarchy that append 'L' to the name assume 133 // that mBinderSerializationLock is locked when they're called 134 mutable Mutex mBinderSerializationLock; 135 136 /** CameraDeviceBase instance wrapping HAL3+ entry */ 137 138 const int mDeviceVersion; 139 140 // Set to const to avoid mDevice being updated (update of sp<> is racy) during 141 // dumpDevice (which is important to be lock free for debugging purpose) 142 const sp<CameraDeviceBase> mDevice; 143 144 /** Utility members */ 145 146 // Verify that caller is the owner of the camera 147 status_t checkPid(const char *checkLocation) const; 148 149 virtual void detachDevice(); 150 151 bool mDeviceActive; 152 153 const int mApi1CameraId; // -1 if client is API2 154 155 private: 156 template<typename TProviderPtr> 157 status_t initializeImpl(TProviderPtr providerPtr, const String8& monitorTags); 158 }; 159 160 }; // namespace android 161 162 #endif 163