1 /* 2 * Copyright (C) 2018 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 _ACAMERA_MANAGER_H 18 #define _ACAMERA_MANAGER_H 19 20 #include <camera/NdkCameraManager.h> 21 22 #include <android-base/parseint.h> 23 #include <android/frameworks/cameraservice/service/2.0/ICameraService.h> 24 #include <android/frameworks/cameraservice/service/2.1/ICameraService.h> 25 #include <android/frameworks/cameraservice/service/2.1/ICameraServiceListener.h> 26 27 #include <CameraMetadata.h> 28 #include <utils/StrongPointer.h> 29 #include <utils/Mutex.h> 30 31 #include <media/stagefright/foundation/ALooper.h> 32 #include <media/stagefright/foundation/AHandler.h> 33 #include <media/stagefright/foundation/AMessage.h> 34 35 #include <set> 36 #include <map> 37 38 namespace android { 39 namespace acam { 40 41 using ICameraService = frameworks::cameraservice::service::V2_1::ICameraService; 42 using CameraDeviceStatus = frameworks::cameraservice::service::V2_0::CameraDeviceStatus; 43 using ICameraServiceListener = frameworks::cameraservice::service::V2_1::ICameraServiceListener; 44 using PhysicalCameraStatusAndId = frameworks::cameraservice::service::V2_1::PhysicalCameraStatusAndId; 45 using CameraStatusAndId = frameworks::cameraservice::service::V2_0::CameraStatusAndId; 46 using Status = frameworks::cameraservice::common::V2_0::Status; 47 using VendorTagSection = frameworks::cameraservice::common::V2_0::VendorTagSection; 48 using VendorTag = frameworks::cameraservice::common::V2_0::VendorTag; 49 using IBase = android::hidl::base::V1_0::IBase; 50 using android::hardware::hidl_string; 51 using hardware::Void; 52 53 /** 54 * Per-process singleton instance of CameraManger. Shared by all ACameraManager 55 * instances. Created when first ACameraManager is created and destroyed when 56 * all ACameraManager instances are deleted. 57 * 58 * TODO: maybe CameraManagerGlobal is better suited in libcameraclient? 59 */ 60 class CameraManagerGlobal final : public RefBase { 61 public: 62 static CameraManagerGlobal& getInstance(); 63 sp<ICameraService> getCameraService(); 64 65 void registerAvailabilityCallback( 66 const ACameraManager_AvailabilityCallbacks *callback); 67 void unregisterAvailabilityCallback( 68 const ACameraManager_AvailabilityCallbacks *callback); 69 70 void registerExtendedAvailabilityCallback( 71 const ACameraManager_ExtendedAvailabilityCallbacks* callback); 72 void unregisterExtendedAvailabilityCallback( 73 const ACameraManager_ExtendedAvailabilityCallbacks* callback); 74 75 /** 76 * Return camera IDs that support camera2 77 */ 78 void getCameraIdList(std::vector<hidl_string> *cameraIds); 79 80 private: 81 sp<ICameraService> mCameraService; 82 const int kCameraServicePollDelay = 500000; // 0.5s 83 Mutex mLock; 84 class DeathNotifier : public android::hardware::hidl_death_recipient { 85 public: DeathNotifier(CameraManagerGlobal * cm)86 explicit DeathNotifier(CameraManagerGlobal* cm) : mCameraManager(cm) {} 87 protected: 88 // IBinder::DeathRecipient implementation 89 virtual void serviceDied(uint64_t cookie, const wp<IBase> &who); 90 private: 91 const wp<CameraManagerGlobal> mCameraManager; 92 }; 93 sp<DeathNotifier> mDeathNotifier; 94 95 class CameraServiceListener final : public ICameraServiceListener { 96 public: CameraServiceListener(CameraManagerGlobal * cm)97 explicit CameraServiceListener(CameraManagerGlobal* cm) : mCameraManager(cm) {} 98 android::hardware::Return<void> onStatusChanged( 99 const CameraStatusAndId &statusAndId) override; 100 android::hardware::Return<void> onPhysicalCameraStatusChanged( 101 const PhysicalCameraStatusAndId &statusAndId) override; 102 103 private: 104 const wp<CameraManagerGlobal> mCameraManager; 105 }; 106 sp<CameraServiceListener> mCameraServiceListener; 107 108 // Wrapper of ACameraManager_AvailabilityCallbacks so we can store it in std::set 109 struct Callback { CallbackCallback110 explicit Callback(const ACameraManager_AvailabilityCallbacks *callback) : 111 mAvailable(callback->onCameraAvailable), 112 mUnavailable(callback->onCameraUnavailable), 113 mAccessPriorityChanged(nullptr), 114 mPhysicalCamAvailable(nullptr), 115 mPhysicalCamUnavailable(nullptr), 116 mContext(callback->context) {} 117 CallbackCallback118 explicit Callback(const ACameraManager_ExtendedAvailabilityCallbacks *callback) : 119 mAvailable(callback->availabilityCallbacks.onCameraAvailable), 120 mUnavailable(callback->availabilityCallbacks.onCameraUnavailable), 121 mAccessPriorityChanged(callback->onCameraAccessPrioritiesChanged), 122 mPhysicalCamAvailable(callback->onPhysicalCameraAvailable), 123 mPhysicalCamUnavailable(callback->onPhysicalCameraUnavailable), 124 mContext(callback->availabilityCallbacks.context) {} 125 126 bool operator == (const Callback& other) const { 127 return (mAvailable == other.mAvailable && 128 mUnavailable == other.mUnavailable && 129 mAccessPriorityChanged == other.mAccessPriorityChanged && 130 mPhysicalCamAvailable == other.mPhysicalCamAvailable && 131 mPhysicalCamUnavailable == other.mPhysicalCamUnavailable && 132 mContext == other.mContext); 133 } 134 bool operator != (const Callback& other) const { 135 return !(*this == other); 136 } 137 bool operator < (const Callback& other) const { 138 if (*this == other) return false; 139 if (mContext != other.mContext) return mContext < other.mContext; 140 if (mAvailable != other.mAvailable) return mAvailable < other.mAvailable; 141 if (mAccessPriorityChanged != other.mAccessPriorityChanged) 142 return mAccessPriorityChanged < other.mAccessPriorityChanged; 143 if (mPhysicalCamAvailable != other.mPhysicalCamAvailable) 144 return mPhysicalCamAvailable < other.mPhysicalCamAvailable; 145 if (mPhysicalCamUnavailable != other.mPhysicalCamUnavailable) 146 return mPhysicalCamUnavailable < other.mPhysicalCamUnavailable; 147 return mUnavailable < other.mUnavailable; 148 } 149 bool operator > (const Callback& other) const { 150 return (*this != other && !(*this < other)); 151 } 152 ACameraManager_AvailabilityCallback mAvailable; 153 ACameraManager_AvailabilityCallback mUnavailable; 154 ACameraManager_AccessPrioritiesChangedCallback mAccessPriorityChanged; 155 ACameraManager_PhysicalCameraAvailabilityCallback mPhysicalCamAvailable; 156 ACameraManager_PhysicalCameraAvailabilityCallback mPhysicalCamUnavailable; 157 void* mContext; 158 }; 159 160 android::Condition mCallbacksCond; 161 size_t mPendingCallbackCnt = 0; 162 void onCallbackCalled(); 163 void drainPendingCallbacksLocked(); 164 165 std::set<Callback> mCallbacks; 166 167 // definition of handler and message 168 enum { 169 kWhatSendSingleCallback, 170 kWhatSendSinglePhysicalCameraCallback, 171 }; 172 static const char* kCameraIdKey; 173 static const char* kPhysicalCameraIdKey; 174 static const char* kCallbackFpKey; 175 static const char* kContextKey; 176 static const nsecs_t kCallbackDrainTimeout; 177 class CallbackHandler : public AHandler { 178 public: CallbackHandler(wp<CameraManagerGlobal> parent)179 CallbackHandler(wp<CameraManagerGlobal> parent) : mParent(parent) {} 180 void onMessageReceived(const sp<AMessage> &msg) override; 181 private: 182 wp<CameraManagerGlobal> mParent; 183 void notifyParent(); 184 void onMessageReceivedInternal(const sp<AMessage> &msg); 185 }; 186 sp<CallbackHandler> mHandler; 187 sp<ALooper> mCbLooper; // Looper thread where callbacks actually happen on 188 189 void onStatusChanged(const CameraStatusAndId &statusAndId); 190 void onStatusChangedLocked(const CameraStatusAndId &statusAndId); 191 void onStatusChanged(const PhysicalCameraStatusAndId &statusAndId); 192 void onStatusChangedLocked(const PhysicalCameraStatusAndId &statusAndId); 193 bool setupVendorTags(); 194 195 // Utils for status 196 static bool validStatus(CameraDeviceStatus status); 197 static bool isStatusAvailable(CameraDeviceStatus status); 198 199 // The sort logic must match the logic in 200 // libcameraservice/common/CameraProviderManager.cpp::getAPI1CompatibleCameraDeviceIds 201 struct CameraIdComparator { operatorCameraIdComparator202 bool operator()(const hidl_string& a, const hidl_string& b) const { 203 uint32_t aUint = 0, bUint = 0; 204 bool aIsUint = base::ParseUint(a.c_str(), &aUint); 205 bool bIsUint = base::ParseUint(b.c_str(), &bUint); 206 207 // Uint device IDs first 208 if (aIsUint && bIsUint) { 209 return aUint < bUint; 210 } else if (aIsUint) { 211 return true; 212 } else if (bIsUint) { 213 return false; 214 } 215 // Simple string compare if both id are not uint 216 return a < b; 217 } 218 }; 219 220 struct CameraStatus { 221 private: 222 CameraDeviceStatus status = CameraDeviceStatus::STATUS_NOT_PRESENT; 223 mutable std::mutex mLock; 224 std::set<hidl_string> unavailablePhysicalIds; 225 public: CameraStatusCameraStatus226 CameraStatus(CameraDeviceStatus st): status(st) { }; 227 CameraStatus() = default; 228 229 bool addUnavailablePhysicalId(const hidl_string& physicalCameraId); 230 bool removeUnavailablePhysicalId(const hidl_string& physicalCameraId); 231 CameraDeviceStatus getStatus(); 232 void updateStatus(CameraDeviceStatus newStatus); 233 std::set<hidl_string> getUnavailablePhysicalIds(); 234 }; 235 236 template <class T> 237 void registerAvailCallback(const T *callback); 238 239 // Map camera_id -> status 240 std::map<hidl_string, CameraStatus, CameraIdComparator> mDeviceStatusMap; 241 242 // For the singleton instance 243 static Mutex sLock; 244 static CameraManagerGlobal* sInstance; CameraManagerGlobal()245 CameraManagerGlobal() {}; 246 ~CameraManagerGlobal(); 247 }; 248 249 } // namespace acam; 250 } // namespace android; 251 252 /** 253 * ACameraManager opaque struct definition 254 * Leave outside of android namespace because it's NDK struct 255 */ 256 struct ACameraManager { ACameraManagerACameraManager257 ACameraManager() : 258 mGlobalManager(&(android::acam::CameraManagerGlobal::getInstance())) {} 259 ~ACameraManager(); 260 camera_status_t getCameraIdList(ACameraIdList** cameraIdList); 261 static void deleteCameraIdList(ACameraIdList* cameraIdList); 262 263 camera_status_t getCameraCharacteristics( 264 const char* cameraId, android::sp<ACameraMetadata>* characteristics); 265 266 camera_status_t openCamera(const char* cameraId, 267 ACameraDevice_StateCallbacks* callback, 268 /*out*/ACameraDevice** device); 269 camera_status_t getTagFromName(const char *cameraId, const char *name, uint32_t *tag); 270 271 private: 272 enum { 273 kCameraIdListNotInit = -1 274 }; 275 android::Mutex mLock; 276 android::sp<android::acam::CameraManagerGlobal> mGlobalManager; 277 }; 278 279 #endif //_ACAMERA_MANAGER_H 280