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 "common/CameraModule.h" 22 #include "camera/CaptureResult.h" 23 24 namespace android { 25 26 class IMemory; 27 28 class CameraService; 29 30 template <typename TClientBase> 31 class Camera2ClientBase : 32 public TClientBase, 33 public CameraDeviceBase::NotificationListener 34 { 35 public: 36 typedef typename TClientBase::TCamCallbacks TCamCallbacks; 37 38 /** 39 * Base binder interface (see ICamera/ICameraDeviceUser for details) 40 */ 41 virtual status_t connect(const sp<TCamCallbacks>& callbacks); 42 virtual void disconnect(); 43 44 /** 45 * Interface used by CameraService 46 */ 47 48 // TODO: too many params, move into a ClientArgs<T> 49 Camera2ClientBase(const sp<CameraService>& cameraService, 50 const sp<TCamCallbacks>& remoteCallback, 51 const String16& clientPackageName, 52 int cameraId, 53 int cameraFacing, 54 int clientPid, 55 uid_t clientUid, 56 int servicePid); 57 virtual ~Camera2ClientBase(); 58 59 virtual status_t initialize(CameraModule *module); 60 virtual status_t dump(int fd, const Vector<String16>& args); 61 62 /** 63 * CameraDeviceBase::NotificationListener implementation 64 */ 65 66 virtual void notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode, 67 const CaptureResultExtras& resultExtras); 68 virtual void notifyIdle(); 69 virtual void notifyShutter(const CaptureResultExtras& resultExtras, 70 nsecs_t timestamp); 71 virtual void notifyAutoFocus(uint8_t newState, int triggerId); 72 virtual void notifyAutoExposure(uint8_t newState, int triggerId); 73 virtual void notifyAutoWhitebalance(uint8_t newState, 74 int triggerId); 75 virtual void notifyPrepared(int streamId); 76 77 int getCameraId() const; 78 const sp<CameraDeviceBase>& 79 getCameraDevice(); 80 int getCameraDeviceVersion() const; 81 const sp<CameraService>& 82 getCameraService(); 83 84 /** 85 * Interface used by independent components of CameraClient2Base. 86 */ 87 88 // Simple class to ensure that access to TCamCallbacks is serialized 89 // by requiring mRemoteCallbackLock to be locked before access to 90 // mRemoteCallback is possible. 91 class SharedCameraCallbacks { 92 public: 93 class Lock { 94 public: 95 Lock(SharedCameraCallbacks &client); 96 ~Lock(); 97 sp<TCamCallbacks> &mRemoteCallback; 98 private: 99 SharedCameraCallbacks &mSharedClient; 100 }; 101 SharedCameraCallbacks(const sp<TCamCallbacks>& client); 102 SharedCameraCallbacks& operator=(const sp<TCamCallbacks>& client); 103 void clear(); 104 private: 105 sp<TCamCallbacks> mRemoteCallback; 106 mutable Mutex mRemoteCallbackLock; 107 } mSharedCameraCallbacks; 108 109 protected: 110 111 // The PID provided in the constructor call 112 pid_t mInitialClientPid; 113 114 virtual sp<IBinder> asBinderWrapper() { 115 return IInterface::asBinder(this); 116 } 117 118 virtual status_t dumpDevice(int fd, const Vector<String16>& args); 119 120 /** Binder client interface-related private members */ 121 122 // Mutex that must be locked by methods implementing the binder client 123 // interface. Ensures serialization between incoming client calls. 124 // All methods in this class hierarchy that append 'L' to the name assume 125 // that mBinderSerializationLock is locked when they're called 126 mutable Mutex mBinderSerializationLock; 127 128 /** CameraDeviceBase instance wrapping HAL2+ entry */ 129 130 const int mDeviceVersion; 131 sp<CameraDeviceBase> mDevice; 132 133 /** Utility members */ 134 135 // Verify that caller is the owner of the camera 136 status_t checkPid(const char *checkLocation) const; 137 138 virtual void detachDevice(); 139 }; 140 141 }; // namespace android 142 143 #endif 144