1 /*
2  * Copyright (C) 2015 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 //#define LOG_NDEBUG 0
18 #define LOG_TAG "ACameraManager"
19 
20 #include "ACameraManager.h"
21 #include <android_companion_virtualdevice_flags.h>
22 #include <camera/CameraUtils.h>
23 #include <camera/StringUtils.h>
24 #include <camera/VendorTagDescriptor.h>
25 #include <cutils/properties.h>
26 #include <stdlib.h>
27 #include <utils/Vector.h>
28 #include <memory>
29 #include "ACameraDevice.h"
30 #include "ACameraMetadata.h"
31 
32 using namespace android::acam;
33 namespace vd_flags = android::companion::virtualdevice::flags;
34 
35 namespace android {
36 namespace acam {
37 namespace {
38 
39 using ::android::binder::Status;
40 using ::android::companion::virtualnative::IVirtualDeviceManagerNative;
41 
42 // Return binder connection to VirtualDeviceManager.
43 //
44 // Subsequent calls return the same cached instance.
getVirtualDeviceManager()45 sp<IVirtualDeviceManagerNative> getVirtualDeviceManager() {
46     auto connectToVirtualDeviceManagerNative = []() {
47         sp<IBinder> binder =
48                 defaultServiceManager()->checkService(String16("virtualdevice_native"));
49         if (binder == nullptr) {
50             ALOGW("%s: Cannot get virtualdevice_native service", __func__);
51             return interface_cast<IVirtualDeviceManagerNative>(nullptr);
52         }
53         return interface_cast<IVirtualDeviceManagerNative>(binder);
54     };
55 
56     static sp<IVirtualDeviceManagerNative> vdm = connectToVirtualDeviceManagerNative();
57     return vdm;
58 }
59 
60 // Returns device id calling process is running on.
61 // If the process cannot be attributed to single virtual device id, returns default device id.
getCurrentDeviceId()62 int getCurrentDeviceId() {
63     if (!vd_flags::camera_device_awareness()) {
64         return kDefaultDeviceId;
65     }
66 
67     auto vdm = getVirtualDeviceManager();
68     if (vdm == nullptr) {
69         return kDefaultDeviceId;
70     }
71 
72     const uid_t myUid = getuid();
73     std::vector<int> deviceIds;
74     Status status = vdm->getDeviceIdsForUid(myUid, &deviceIds);
75     if (!status.isOk() || deviceIds.empty()) {
76         ALOGE("%s: Failed to call getDeviceIdsForUid to determine device id for uid %d: %s",
77               __func__, myUid, status.toString8().c_str());
78         return kDefaultDeviceId;
79     }
80 
81     // If the UID is associated with multiple virtual devices, use the default device's
82     // camera as we cannot disambiguate here. This effectively means that the app has
83     // activities on different devices at the same time.
84     if (deviceIds.size() != 1) {
85         return kDefaultDeviceId;
86     }
87     return deviceIds[0];
88 }
89 
90 // Returns device policy for POLICY_TYPE_CAMERA corresponding to deviceId.
getDevicePolicyForDeviceId(const int deviceId)91 DevicePolicy getDevicePolicyForDeviceId(const int deviceId) {
92     if (!vd_flags::camera_device_awareness() || deviceId == kDefaultDeviceId) {
93         return DevicePolicy::DEVICE_POLICY_DEFAULT;
94     }
95 
96     auto vdm = getVirtualDeviceManager();
97     if (vdm == nullptr) {
98         return DevicePolicy::DEVICE_POLICY_DEFAULT;
99     }
100 
101     int policy = IVirtualDeviceManagerNative::DEVICE_POLICY_DEFAULT;
102     Status status = vdm->getDevicePolicy(deviceId, IVirtualDeviceManagerNative::POLICY_TYPE_CAMERA,
103                                          &policy);
104     if (!status.isOk()) {
105         ALOGE("%s: Failed to call getDevicePolicy to determine camera policy for device id %d: %s",
106               __func__, deviceId, status.toString8().c_str());
107         return DevicePolicy::DEVICE_POLICY_DEFAULT;
108     }
109     return static_cast<DevicePolicy>(policy);
110 }
111 
112 // Returns true if camera owned by device cameraDeviceId can be accessed within deviceContext.
isCameraAccessible(const DeviceContext deviceContext,const int cameraDeviceId)113 bool isCameraAccessible(const DeviceContext deviceContext, const int cameraDeviceId) {
114     if (!vd_flags::camera_device_awareness() ||
115         deviceContext.policy == DevicePolicy::DEVICE_POLICY_DEFAULT) {
116         return cameraDeviceId == kDefaultDeviceId;
117     }
118     return deviceContext.deviceId == cameraDeviceId;
119 }
120 
121 }  // namespace
122 
123 // Static member definitions
124 const char* CameraManagerGlobal::kCameraIdKey   = "CameraId";
125 const char* CameraManagerGlobal::kPhysicalCameraIdKey   = "PhysicalCameraId";
126 const char* CameraManagerGlobal::kCallbackFpKey = "CallbackFp";
127 const char* CameraManagerGlobal::kContextKey    = "CallbackContext";
128 const nsecs_t CameraManagerGlobal::kCallbackDrainTimeout = 5000000; // 5 ms
129 Mutex                CameraManagerGlobal::sLock;
130 wp<CameraManagerGlobal> CameraManagerGlobal::sInstance = nullptr;
131 
DeviceContext()132 DeviceContext::DeviceContext() {
133     deviceId = getCurrentDeviceId();
134     policy = getDevicePolicyForDeviceId(deviceId);
135 }
136 
getInstance()137 sp<CameraManagerGlobal> CameraManagerGlobal::getInstance() {
138     Mutex::Autolock _l(sLock);
139     sp<CameraManagerGlobal> instance = sInstance.promote();
140     if (instance == nullptr) {
141         instance = new CameraManagerGlobal();
142         sInstance = instance;
143     }
144     return instance;
145 }
146 
~CameraManagerGlobal()147 CameraManagerGlobal::~CameraManagerGlobal() {
148     // clear sInstance so next getInstance call knows to create a new one
149     Mutex::Autolock _sl(sLock);
150     sInstance = nullptr;
151     Mutex::Autolock _l(mLock);
152     if (mCameraService != nullptr) {
153         IInterface::asBinder(mCameraService)->unlinkToDeath(mDeathNotifier);
154         mCameraService->removeListener(mCameraServiceListener);
155     }
156     mDeathNotifier.clear();
157     if (mCbLooper != nullptr) {
158         mCbLooper->unregisterHandler(mHandler->id());
159         mCbLooper->stop();
160     }
161     mCbLooper.clear();
162     mHandler.clear();
163     mCameraServiceListener.clear();
164     mCameraService.clear();
165 }
166 
getCameraService()167 sp<hardware::ICameraService> CameraManagerGlobal::getCameraService() {
168     Mutex::Autolock _l(mLock);
169     return getCameraServiceLocked();
170 }
171 
getCameraServiceLocked()172 sp<hardware::ICameraService> CameraManagerGlobal::getCameraServiceLocked() {
173     if (mCameraService.get() == nullptr) {
174         if (CameraUtils::isCameraServiceDisabled()) {
175             return mCameraService;
176         }
177 
178         sp<IServiceManager> sm = defaultServiceManager();
179         sp<IBinder> binder;
180         do {
181             binder = sm->getService(toString16(kCameraServiceName));
182             if (binder != nullptr) {
183                 break;
184             }
185             ALOGW("CameraService not published, waiting...");
186             usleep(kCameraServicePollDelay);
187         } while(true);
188         if (mDeathNotifier == nullptr) {
189             mDeathNotifier = new DeathNotifier(this);
190         }
191         binder->linkToDeath(mDeathNotifier);
192         mCameraService = interface_cast<hardware::ICameraService>(binder);
193 
194         // Setup looper thread to perfrom availiability callbacks
195         if (mCbLooper == nullptr) {
196             mCbLooper = new ALooper;
197             mCbLooper->setName("C2N-mgr-looper");
198             status_t err = mCbLooper->start(
199                     /*runOnCallingThread*/false,
200                     /*canCallJava*/       true,
201                     PRIORITY_DEFAULT);
202             if (err != OK) {
203                 ALOGE("%s: Unable to start camera service listener looper: %s (%d)",
204                         __FUNCTION__, strerror(-err), err);
205                 mCbLooper.clear();
206                 return nullptr;
207             }
208             if (mHandler == nullptr) {
209                 mHandler = new CallbackHandler(this);
210             }
211             mCbLooper->registerHandler(mHandler);
212         }
213 
214         // register ICameraServiceListener
215         if (mCameraServiceListener == nullptr) {
216             mCameraServiceListener = new CameraServiceListener(this);
217         }
218         std::vector<hardware::CameraStatus> cameraStatuses{};
219         mCameraService->addListener(mCameraServiceListener, &cameraStatuses);
220         for (auto& c : cameraStatuses) {
221             onStatusChangedLocked(c.status, c.deviceId, c.cameraId);
222 
223             for (auto& unavailablePhysicalId : c.unavailablePhysicalIds) {
224                 onStatusChangedLocked(hardware::ICameraServiceListener::STATUS_NOT_PRESENT,
225                                       c.deviceId, c.cameraId, unavailablePhysicalId);
226             }
227         }
228 
229         // setup vendor tags
230         sp<VendorTagDescriptor> desc = new VendorTagDescriptor();
231         binder::Status ret = mCameraService->getCameraVendorTagDescriptor(/*out*/desc.get());
232 
233         if (ret.isOk()) {
234             if (0 < desc->getTagCount()) {
235                 status_t err = VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc);
236                 if (err != OK) {
237                     ALOGE("%s: Failed to set vendor tag descriptors, received error %s (%d)",
238                             __FUNCTION__, strerror(-err), err);
239                 }
240             } else {
241                 sp<VendorTagDescriptorCache> cache =
242                         new VendorTagDescriptorCache();
243                 binder::Status res =
244                         mCameraService->getCameraVendorTagCache(
245                                 /*out*/cache.get());
246                 if (res.serviceSpecificErrorCode() ==
247                         hardware::ICameraService::ERROR_DISCONNECTED) {
248                     // No camera module available, not an error on devices with no cameras
249                     VendorTagDescriptorCache::clearGlobalVendorTagCache();
250                 } else if (res.isOk()) {
251                     status_t err =
252                             VendorTagDescriptorCache::setAsGlobalVendorTagCache(
253                                     cache);
254                     if (err != OK) {
255                         ALOGE("%s: Failed to set vendor tag cache,"
256                                 "received error %s (%d)", __FUNCTION__,
257                                 strerror(-err), err);
258                     }
259                 } else {
260                     VendorTagDescriptorCache::clearGlobalVendorTagCache();
261                     ALOGE("%s: Failed to setup vendor tag cache: %s",
262                             __FUNCTION__, res.toString8().c_str());
263                 }
264             }
265         } else if (ret.serviceSpecificErrorCode() ==
266                 hardware::ICameraService::ERROR_DEPRECATED_HAL) {
267             ALOGW("%s: Camera HAL too old; does not support vendor tags",
268                     __FUNCTION__);
269             VendorTagDescriptor::clearGlobalVendorTagDescriptor();
270         } else {
271             ALOGE("%s: Failed to get vendor tag descriptors: %s",
272                     __FUNCTION__, ret.toString8().c_str());
273         }
274     }
275     ALOGE_IF(mCameraService == nullptr, "no CameraService!?");
276     return mCameraService;
277 }
278 
binderDied(const wp<IBinder> &)279 void CameraManagerGlobal::DeathNotifier::binderDied(const wp<IBinder>&)
280 {
281     ALOGE("Camera service binderDied!");
282     sp<CameraManagerGlobal> cm = mCameraManager.promote();
283     if (cm != nullptr) {
284         AutoMutex lock(cm->mLock);
285         std::vector<DeviceStatusMapKey> keysToRemove;
286         keysToRemove.reserve(cm->mDeviceStatusMap.size());
287         for (auto& pair : cm->mDeviceStatusMap) {
288             keysToRemove.push_back(pair.first);
289         }
290 
291         for (const DeviceStatusMapKey& key : keysToRemove) {
292             cm->onStatusChangedLocked(CameraServiceListener::STATUS_NOT_PRESENT, key.deviceId,
293                                       key.cameraId);
294         }
295         cm->mCameraService.clear();
296         // TODO: consider adding re-connect call here?
297     }
298 }
299 
registerExtendedAvailabilityCallback(const DeviceContext & deviceContext,const ACameraManager_ExtendedAvailabilityCallbacks * callback)300 void CameraManagerGlobal::registerExtendedAvailabilityCallback(
301         const DeviceContext& deviceContext,
302         const ACameraManager_ExtendedAvailabilityCallbacks* callback) {
303     return registerAvailCallback<ACameraManager_ExtendedAvailabilityCallbacks>(deviceContext,
304                                                                                callback);
305 }
306 
unregisterExtendedAvailabilityCallback(const DeviceContext & deviceContext,const ACameraManager_ExtendedAvailabilityCallbacks * callback)307 void CameraManagerGlobal::unregisterExtendedAvailabilityCallback(
308         const DeviceContext& deviceContext,
309         const ACameraManager_ExtendedAvailabilityCallbacks* callback) {
310     Mutex::Autolock _l(mLock);
311 
312     drainPendingCallbacksLocked();
313 
314     Callback cb(deviceContext, callback);
315     mCallbacks.erase(cb);
316 }
317 
registerAvailabilityCallback(const DeviceContext & deviceContext,const ACameraManager_AvailabilityCallbacks * callback)318 void CameraManagerGlobal::registerAvailabilityCallback(
319         const DeviceContext& deviceContext, const ACameraManager_AvailabilityCallbacks* callback) {
320     return registerAvailCallback<ACameraManager_AvailabilityCallbacks>(deviceContext, callback);
321 }
322 
unregisterAvailabilityCallback(const DeviceContext & deviceContext,const ACameraManager_AvailabilityCallbacks * callback)323 void CameraManagerGlobal::unregisterAvailabilityCallback(
324         const DeviceContext& deviceContext, const ACameraManager_AvailabilityCallbacks* callback) {
325     Mutex::Autolock _l(mLock);
326 
327     drainPendingCallbacksLocked();
328 
329     Callback cb(deviceContext, callback);
330     mCallbacks.erase(cb);
331 }
332 
onCallbackCalled()333 void CameraManagerGlobal::onCallbackCalled() {
334     Mutex::Autolock _l(mLock);
335     if (mPendingCallbackCnt > 0) {
336         mPendingCallbackCnt--;
337     }
338     mCallbacksCond.signal();
339 }
340 
drainPendingCallbacksLocked()341 void CameraManagerGlobal::drainPendingCallbacksLocked() {
342     while (mPendingCallbackCnt > 0) {
343         auto res = mCallbacksCond.waitRelative(mLock, kCallbackDrainTimeout);
344         if (res != NO_ERROR) {
345             ALOGE("%s: Error waiting to drain callbacks: %s(%d)",
346                     __FUNCTION__, strerror(-res), res);
347             break;
348         }
349     }
350 }
351 
352 template <class T>
registerAvailCallback(const DeviceContext & deviceContext,const T * callback)353 void CameraManagerGlobal::registerAvailCallback(const DeviceContext& deviceContext,
354                                                 const T* callback) {
355     Mutex::Autolock _l(mLock);
356     getCameraServiceLocked();
357     Callback cb(deviceContext, callback);
358     const auto& [_, newlyRegistered] = mCallbacks.insert(cb);
359     // Send initial callbacks if callback is newly registered
360     if (newlyRegistered) {
361         for (auto& [key, statusAndHAL3Support] : mDeviceStatusMap) {
362             if (!isCameraAccessible(deviceContext, key.deviceId)) {
363                 continue;
364             }
365             const std::string& cameraId = key.cameraId;
366             int32_t status = statusAndHAL3Support.getStatus();
367             // Don't send initial callbacks for camera ids which don't support
368             // camera2
369             if (!statusAndHAL3Support.supportsHAL3) {
370                 continue;
371             }
372 
373             // Camera available/unavailable callback
374             sp<AMessage> msg = new AMessage(kWhatSendSingleCallback, mHandler);
375             ACameraManager_AvailabilityCallback cbFunc = isStatusAvailable(status) ?
376                     cb.mAvailable : cb.mUnavailable;
377             msg->setPointer(kCallbackFpKey, (void *) cbFunc);
378             msg->setPointer(kContextKey, cb.mContext);
379             msg->setString(kCameraIdKey, AString(cameraId.c_str()));
380             mPendingCallbackCnt++;
381             msg->post();
382 
383             // Physical camera unavailable callback
384             std::set<std::string> unavailablePhysicalCameras =
385                     statusAndHAL3Support.getUnavailablePhysicalIds();
386             for (const auto& physicalCameraId : unavailablePhysicalCameras) {
387                 sp<AMessage> msg = new AMessage(kWhatSendSinglePhysicalCameraCallback, mHandler);
388                 ACameraManager_PhysicalCameraAvailabilityCallback cbFunc =
389                         cb.mPhysicalCamUnavailable;
390                 msg->setPointer(kCallbackFpKey, (void *) cbFunc);
391                 msg->setPointer(kContextKey, cb.mContext);
392                 msg->setString(kCameraIdKey, AString(cameraId.c_str()));
393                 msg->setString(kPhysicalCameraIdKey, AString(physicalCameraId.c_str()));
394                 mPendingCallbackCnt++;
395                 msg->post();
396             }
397         }
398     }
399 }
400 
supportsCamera2ApiLocked(const std::string & cameraId)401 bool CameraManagerGlobal::supportsCamera2ApiLocked(const std::string &cameraId) {
402     bool camera2Support = false;
403     auto cs = getCameraServiceLocked();
404     binder::Status serviceRet =
405         cs->supportsCameraApi(cameraId,
406                 hardware::ICameraService::API_VERSION_2, &camera2Support);
407     if (!serviceRet.isOk()) {
408         ALOGE("%s: supportsCameraApi2Locked() call failed for cameraId  %s",
409                 __FUNCTION__, cameraId.c_str());
410         return false;
411     }
412     return camera2Support;
413 }
414 
getCameraIdList(const DeviceContext & context,std::vector<std::string> * cameraIds)415 void CameraManagerGlobal::getCameraIdList(const DeviceContext& context,
416         std::vector<std::string>* cameraIds) {
417     // Ensure that we have initialized/refreshed the list of available devices
418     Mutex::Autolock _l(mLock);
419     // Needed to make sure we're connected to cameraservice
420     getCameraServiceLocked();
421     for (auto& [key, statusAndHAL3Support] : mDeviceStatusMap) {
422         if (!isCameraAccessible(context, key.deviceId)) {
423             continue;
424         }
425 
426         int32_t status = statusAndHAL3Support.getStatus();
427         if (status == hardware::ICameraServiceListener::STATUS_NOT_PRESENT ||
428                 status == hardware::ICameraServiceListener::STATUS_ENUMERATING) {
429             continue;
430         }
431         if (!statusAndHAL3Support.supportsHAL3) {
432             continue;
433         }
434         cameraIds->push_back(key.cameraId);
435     }
436 }
437 
validStatus(int32_t status)438 bool CameraManagerGlobal::validStatus(int32_t status) {
439     switch (status) {
440         case hardware::ICameraServiceListener::STATUS_NOT_PRESENT:
441         case hardware::ICameraServiceListener::STATUS_PRESENT:
442         case hardware::ICameraServiceListener::STATUS_ENUMERATING:
443         case hardware::ICameraServiceListener::STATUS_NOT_AVAILABLE:
444             return true;
445         default:
446             return false;
447     }
448 }
449 
isStatusAvailable(int32_t status)450 bool CameraManagerGlobal::isStatusAvailable(int32_t status) {
451     switch (status) {
452         case hardware::ICameraServiceListener::STATUS_PRESENT:
453             return true;
454         default:
455             return false;
456     }
457 }
458 
onMessageReceived(const sp<AMessage> & msg)459 void CameraManagerGlobal::CallbackHandler::onMessageReceived(
460       const sp<AMessage> &msg) {
461     onMessageReceivedInternal(msg);
462     if (msg->what() == kWhatSendSingleCallback ||
463             msg->what() == kWhatSendSingleAccessCallback ||
464             msg->what() == kWhatSendSinglePhysicalCameraCallback) {
465         notifyParent();
466     }
467 }
468 
onMessageReceivedInternal(const sp<AMessage> & msg)469 void CameraManagerGlobal::CallbackHandler::onMessageReceivedInternal(
470         const sp<AMessage> &msg) {
471     switch (msg->what()) {
472         case kWhatSendSingleCallback:
473         {
474             ACameraManager_AvailabilityCallback cb;
475             void* context;
476             AString cameraId;
477             bool found = msg->findPointer(kCallbackFpKey, (void**) &cb);
478             if (!found) {
479                 ALOGE("%s: Cannot find camera callback fp!", __FUNCTION__);
480                 return;
481             }
482             found = msg->findPointer(kContextKey, &context);
483             if (!found) {
484                 ALOGE("%s: Cannot find callback context!", __FUNCTION__);
485                 return;
486             }
487             found = msg->findString(kCameraIdKey, &cameraId);
488             if (!found) {
489                 ALOGE("%s: Cannot find camera ID!", __FUNCTION__);
490                 return;
491             }
492             (*cb)(context, cameraId.c_str());
493             break;
494         }
495         case kWhatSendSingleAccessCallback:
496         {
497             ACameraManager_AccessPrioritiesChangedCallback cb;
498             void* context;
499             AString cameraId;
500             bool found = msg->findPointer(kCallbackFpKey, (void**) &cb);
501             if (!found) {
502                 ALOGE("%s: Cannot find camera callback fp!", __FUNCTION__);
503                 return;
504             }
505             found = msg->findPointer(kContextKey, &context);
506             if (!found) {
507                 ALOGE("%s: Cannot find callback context!", __FUNCTION__);
508                 return;
509             }
510             (*cb)(context);
511             break;
512         }
513         case kWhatSendSinglePhysicalCameraCallback:
514         {
515             ACameraManager_PhysicalCameraAvailabilityCallback cb;
516             void* context;
517             AString cameraId;
518             AString physicalCameraId;
519             bool found = msg->findPointer(kCallbackFpKey, (void**) &cb);
520             if (!found) {
521                 ALOGE("%s: Cannot find camera callback fp!", __FUNCTION__);
522                 return;
523             }
524             if (cb == nullptr) {
525                 // Physical camera callback is null
526                 return;
527             }
528             found = msg->findPointer(kContextKey, &context);
529             if (!found) {
530                 ALOGE("%s: Cannot find callback context!", __FUNCTION__);
531                 return;
532             }
533             found = msg->findString(kCameraIdKey, &cameraId);
534             if (!found) {
535                 ALOGE("%s: Cannot find camera ID!", __FUNCTION__);
536                 return;
537             }
538             found = msg->findString(kPhysicalCameraIdKey, &physicalCameraId);
539             if (!found) {
540                 ALOGE("%s: Cannot find physical camera ID!", __FUNCTION__);
541                 return;
542             }
543             (*cb)(context, cameraId.c_str(), physicalCameraId.c_str());
544             break;
545         }
546         default:
547             ALOGE("%s: unknown message type %d", __FUNCTION__, msg->what());
548             break;
549     }
550 }
551 
notifyParent()552 void CameraManagerGlobal::CallbackHandler::notifyParent() {
553     sp<CameraManagerGlobal> parent = mParent.promote();
554     if (parent != nullptr) {
555         parent->onCallbackCalled();
556     }
557 }
558 
onCameraAccessPrioritiesChanged()559 binder::Status CameraManagerGlobal::CameraServiceListener::onCameraAccessPrioritiesChanged() {
560     sp<CameraManagerGlobal> cm = mCameraManager.promote();
561     if (cm != nullptr) {
562         cm->onCameraAccessPrioritiesChanged();
563     } else {
564         ALOGE("Cannot deliver camera access priority callback. Global camera manager died");
565     }
566     return binder::Status::ok();
567 }
568 
onStatusChanged(int32_t status,const std::string & cameraId,int deviceId)569 binder::Status CameraManagerGlobal::CameraServiceListener::onStatusChanged(
570         int32_t status, const std::string& cameraId, int deviceId) {
571     sp<CameraManagerGlobal> cm = mCameraManager.promote();
572     if (cm != nullptr) {
573         cm->onStatusChanged(status, deviceId, cameraId);
574     }
575     ALOGE_IF(cm == nullptr,
576              "Cannot deliver physical camera status change. Global camera manager died");
577     return binder::Status::ok();
578 }
579 
onPhysicalCameraStatusChanged(int32_t status,const std::string & cameraId,const std::string & physicalCameraId,int deviceId)580 binder::Status CameraManagerGlobal::CameraServiceListener::onPhysicalCameraStatusChanged(
581         int32_t status, const std::string& cameraId, const std::string& physicalCameraId,
582         int deviceId) {
583     sp<CameraManagerGlobal> cm = mCameraManager.promote();
584     if (cm != nullptr) {
585         cm->onStatusChanged(status, deviceId, cameraId, physicalCameraId);
586     }
587     ALOGE_IF(cm == nullptr,
588              "Cannot deliver physical camera status change. Global camera manager died");
589     return binder::Status::ok();
590 }
591 
onCameraAccessPrioritiesChanged()592 void CameraManagerGlobal::onCameraAccessPrioritiesChanged() {
593     Mutex::Autolock _l(mLock);
594     for (auto cb : mCallbacks) {
595         sp<AMessage> msg = new AMessage(kWhatSendSingleAccessCallback, mHandler);
596         ACameraManager_AccessPrioritiesChangedCallback cbFp = cb.mAccessPriorityChanged;
597         if (cbFp != nullptr) {
598             msg->setPointer(kCallbackFpKey, (void *) cbFp);
599             msg->setPointer(kContextKey, cb.mContext);
600             mPendingCallbackCnt++;
601             msg->post();
602         }
603     }
604 }
605 
onStatusChanged(int32_t status,const int deviceId,const std::string & cameraId)606 void CameraManagerGlobal::onStatusChanged(int32_t status, const int deviceId,
607         const std::string& cameraId) {
608     Mutex::Autolock _l(mLock);
609     onStatusChangedLocked(status, deviceId, cameraId);
610 }
611 
onStatusChangedLocked(int32_t status,const int deviceId,const std::string & cameraId)612 void CameraManagerGlobal::onStatusChangedLocked(int32_t status, const int deviceId,
613         const std::string& cameraId) {
614     if (!validStatus(status)) {
615         ALOGE("%s: Invalid status %d", __FUNCTION__, status);
616         return;
617     }
618 
619     DeviceStatusMapKey key{.deviceId = deviceId, .cameraId = cameraId};
620 
621     bool firstStatus = (mDeviceStatusMap.count(key) == 0);
622     int32_t oldStatus = firstStatus ? status :  // first status
623                                 mDeviceStatusMap[key].getStatus();
624 
625     if (!firstStatus &&
626             isStatusAvailable(status) == isStatusAvailable(oldStatus)) {
627         // No status update. No need to send callback
628         return;
629     }
630 
631     bool supportsHAL3 = supportsCamera2ApiLocked(cameraId);
632     if (firstStatus) {
633         mDeviceStatusMap.emplace(std::piecewise_construct, std::forward_as_tuple(key),
634                                  std::forward_as_tuple(status, supportsHAL3));
635     } else {
636         mDeviceStatusMap[key].updateStatus(status);
637     }
638     // Iterate through all registered callbacks
639     if (supportsHAL3) {
640         for (auto cb : mCallbacks) {
641             if (!isCameraAccessible(cb.mDeviceContext, deviceId)) {
642                 continue;
643             }
644             sp<AMessage> msg = new AMessage(kWhatSendSingleCallback, mHandler);
645             ACameraManager_AvailabilityCallback cbFp = isStatusAvailable(status) ?
646                     cb.mAvailable : cb.mUnavailable;
647             msg->setPointer(kCallbackFpKey, (void *) cbFp);
648             msg->setPointer(kContextKey, cb.mContext);
649             msg->setString(kCameraIdKey, AString(cameraId.c_str()));
650             mPendingCallbackCnt++;
651             msg->post();
652         }
653     }
654     if (status == hardware::ICameraServiceListener::STATUS_NOT_PRESENT) {
655         mDeviceStatusMap.erase(key);
656     }
657 }
658 
onStatusChanged(int32_t status,const int deviceId,const std::string & cameraId,const std::string & physicalCameraId)659 void CameraManagerGlobal::onStatusChanged(int32_t status, const int deviceId,
660         const std::string& cameraId, const std::string& physicalCameraId) {
661     Mutex::Autolock _l(mLock);
662     onStatusChangedLocked(status, deviceId, cameraId, physicalCameraId);
663 }
664 
onStatusChangedLocked(int32_t status,const int deviceId,const std::string & cameraId,const std::string & physicalCameraId)665 void CameraManagerGlobal::onStatusChangedLocked(int32_t status, const int deviceId,
666         const std::string& cameraId, const std::string& physicalCameraId) {
667     if (!validStatus(status)) {
668         ALOGE("%s: Invalid status %d", __FUNCTION__, status);
669         return;
670     }
671 
672     DeviceStatusMapKey key{.deviceId = deviceId, .cameraId = cameraId};
673     auto logicalStatus = mDeviceStatusMap.find(key);
674     if (logicalStatus == mDeviceStatusMap.end()) {
675         ALOGE("%s: Physical camera id %s status change on a non-present id %s",
676                 __FUNCTION__, physicalCameraId.c_str(), cameraId.c_str());
677         return;
678     }
679     int32_t logicalCamStatus = mDeviceStatusMap[key].getStatus();
680     if (logicalCamStatus != hardware::ICameraServiceListener::STATUS_PRESENT &&
681             logicalCamStatus != hardware::ICameraServiceListener::STATUS_NOT_AVAILABLE) {
682         ALOGE("%s: Physical camera id %s status %d change for an invalid logical camera state %d",
683                 __FUNCTION__, physicalCameraId.c_str(), status, logicalCamStatus);
684         return;
685     }
686 
687     bool supportsHAL3 = supportsCamera2ApiLocked(cameraId);
688 
689     bool updated = false;
690     if (status == hardware::ICameraServiceListener::STATUS_PRESENT) {
691         updated = mDeviceStatusMap[key].removeUnavailablePhysicalId(physicalCameraId);
692     } else {
693         updated = mDeviceStatusMap[key].addUnavailablePhysicalId(physicalCameraId);
694     }
695 
696     // Iterate through all registered callbacks
697     if (supportsHAL3 && updated) {
698         for (auto cb : mCallbacks) {
699             if (!isCameraAccessible(cb.mDeviceContext, deviceId)) {
700                 continue;
701             }
702             sp<AMessage> msg = new AMessage(kWhatSendSinglePhysicalCameraCallback, mHandler);
703             ACameraManager_PhysicalCameraAvailabilityCallback cbFp = isStatusAvailable(status) ?
704                     cb.mPhysicalCamAvailable : cb.mPhysicalCamUnavailable;
705             msg->setPointer(kCallbackFpKey, (void *) cbFp);
706             msg->setPointer(kContextKey, cb.mContext);
707             msg->setString(kCameraIdKey, AString(cameraId.c_str()));
708             msg->setString(kPhysicalCameraIdKey, AString(physicalCameraId.c_str()));
709             mPendingCallbackCnt++;
710             msg->post();
711         }
712     }
713 }
714 
getStatus()715 int32_t CameraManagerGlobal::StatusAndHAL3Support::getStatus() {
716     std::lock_guard<std::mutex> lock(mLock);
717     return status;
718 }
719 
updateStatus(int32_t newStatus)720 void CameraManagerGlobal::StatusAndHAL3Support::updateStatus(int32_t newStatus) {
721     std::lock_guard<std::mutex> lock(mLock);
722     status = newStatus;
723 }
724 
addUnavailablePhysicalId(const std::string & physicalCameraId)725 bool CameraManagerGlobal::StatusAndHAL3Support::addUnavailablePhysicalId(
726         const std::string& physicalCameraId) {
727     std::lock_guard<std::mutex> lock(mLock);
728     auto result = unavailablePhysicalIds.insert(physicalCameraId);
729     return result.second;
730 }
731 
removeUnavailablePhysicalId(const std::string & physicalCameraId)732 bool CameraManagerGlobal::StatusAndHAL3Support::removeUnavailablePhysicalId(
733         const std::string& physicalCameraId) {
734     std::lock_guard<std::mutex> lock(mLock);
735     auto count = unavailablePhysicalIds.erase(physicalCameraId);
736     return count > 0;
737 }
738 
getUnavailablePhysicalIds()739 std::set<std::string> CameraManagerGlobal::StatusAndHAL3Support::getUnavailablePhysicalIds() {
740     std::lock_guard<std::mutex> lock(mLock);
741     return unavailablePhysicalIds;
742 }
743 
744 } // namespace acam
745 } // namespace android
746 
747 /**
748  * ACameraManger Implementation
749  */
750 camera_status_t
getCameraIdList(ACameraIdList ** cameraIdList)751 ACameraManager::getCameraIdList(ACameraIdList** cameraIdList) {
752     Mutex::Autolock _l(mLock);
753 
754     std::vector<std::string> idList;
755     mGlobalManager->getCameraIdList(mDeviceContext, &idList);
756 
757     int numCameras = idList.size();
758     ACameraIdList *out = new ACameraIdList;
759     if (!out) {
760         ALOGE("Allocate memory for ACameraIdList failed!");
761         return ACAMERA_ERROR_NOT_ENOUGH_MEMORY;
762     }
763     out->numCameras = numCameras;
764     out->cameraIds = new const char*[numCameras];
765     if (!out->cameraIds) {
766         ALOGE("Allocate memory for ACameraIdList failed!");
767         deleteCameraIdList(out);
768         return ACAMERA_ERROR_NOT_ENOUGH_MEMORY;
769     }
770     for (int i = 0; i < numCameras; i++) {
771         const char* src = idList[i].c_str();
772         size_t dstSize = strlen(src) + 1;
773         char* dst = new char[dstSize];
774         if (!dst) {
775             ALOGE("Allocate memory for ACameraIdList failed!");
776             deleteCameraIdList(out);
777             return ACAMERA_ERROR_NOT_ENOUGH_MEMORY;
778         }
779         strlcpy(dst, src, dstSize);
780         out->cameraIds[i] = dst;
781     }
782     *cameraIdList = out;
783     return ACAMERA_OK;
784 }
785 
786 void
deleteCameraIdList(ACameraIdList * cameraIdList)787 ACameraManager::deleteCameraIdList(ACameraIdList* cameraIdList) {
788     if (cameraIdList != nullptr) {
789         if (cameraIdList->cameraIds != nullptr) {
790             for (int i = 0; i < cameraIdList->numCameras; i ++) {
791                 if (cameraIdList->cameraIds[i] != nullptr) {
792                     delete[] cameraIdList->cameraIds[i];
793                 }
794             }
795             delete[] cameraIdList->cameraIds;
796         }
797         delete cameraIdList;
798     }
799 }
800 
getCameraCharacteristics(const char * cameraIdStr,sp<ACameraMetadata> * characteristics)801 camera_status_t ACameraManager::getCameraCharacteristics(
802         const char* cameraIdStr, sp<ACameraMetadata>* characteristics) {
803     Mutex::Autolock _l(mLock);
804 
805     sp<hardware::ICameraService> cs = mGlobalManager->getCameraService();
806     if (cs == nullptr) {
807         ALOGE("%s: Cannot reach camera service!", __FUNCTION__);
808         return ACAMERA_ERROR_CAMERA_DISCONNECTED;
809     }
810 
811     CameraMetadata rawMetadata;
812     int targetSdkVersion = android_get_application_target_sdk_version();
813     binder::Status serviceRet = cs->getCameraCharacteristics(cameraIdStr,
814             targetSdkVersion, /*rotationOverride*/hardware::ICameraService::ROTATION_OVERRIDE_NONE,
815             mDeviceContext.deviceId, static_cast<int32_t>(mDeviceContext.policy),
816             &rawMetadata);
817     if (!serviceRet.isOk()) {
818         switch(serviceRet.serviceSpecificErrorCode()) {
819             case hardware::ICameraService::ERROR_DISCONNECTED:
820                 ALOGE("%s: Camera %s has been disconnected", __FUNCTION__, cameraIdStr);
821                 return ACAMERA_ERROR_CAMERA_DISCONNECTED;
822             case hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT:
823                 ALOGE("%s: Camera ID %s does not exist!", __FUNCTION__, cameraIdStr);
824                 return ACAMERA_ERROR_INVALID_PARAMETER;
825             default:
826                 ALOGE("Get camera characteristics from camera service failed: %s",
827                         serviceRet.toString8().c_str());
828                 return ACAMERA_ERROR_UNKNOWN; // should not reach here
829         }
830     }
831 
832     *characteristics = new ACameraMetadata(
833             rawMetadata.release(), ACameraMetadata::ACM_CHARACTERISTICS);
834     return ACAMERA_OK;
835 }
836 
837 camera_status_t
openCamera(const char * cameraId,ACameraDevice_StateCallbacks * callback,ACameraDevice ** outDevice)838 ACameraManager::openCamera(
839         const char* cameraId,
840         ACameraDevice_StateCallbacks* callback,
841         /*out*/ACameraDevice** outDevice) {
842     sp<ACameraMetadata> chars;
843     camera_status_t ret = getCameraCharacteristics(cameraId, &chars);
844     Mutex::Autolock _l(mLock);
845     if (ret != ACAMERA_OK) {
846         ALOGE("%s: cannot get camera characteristics for camera %s. err %d",
847                 __FUNCTION__, cameraId, ret);
848         return ACAMERA_ERROR_INVALID_PARAMETER;
849     }
850 
851     ACameraDevice* device = new ACameraDevice(cameraId, callback, chars);
852 
853     sp<hardware::ICameraService> cs = mGlobalManager->getCameraService();
854     if (cs == nullptr) {
855         ALOGE("%s: Cannot reach camera service!", __FUNCTION__);
856         delete device;
857         return ACAMERA_ERROR_CAMERA_DISCONNECTED;
858     }
859 
860     sp<hardware::camera2::ICameraDeviceCallbacks> callbacks = device->getServiceCallback();
861     sp<hardware::camera2::ICameraDeviceUser> deviceRemote;
862     int targetSdkVersion = android_get_application_target_sdk_version();
863     // No way to get package name from native.
864     // Send a zero length package name and let camera service figure it out from UID
865     binder::Status serviceRet = cs->connectDevice(
866             callbacks, cameraId, "", {},
867             hardware::ICameraService::USE_CALLING_UID, /*oomScoreOffset*/0,
868             targetSdkVersion, /*rotationOverride*/hardware::ICameraService::ROTATION_OVERRIDE_NONE,
869             mDeviceContext.deviceId, static_cast<int32_t>(mDeviceContext.policy),
870             /*out*/&deviceRemote);
871 
872     if (!serviceRet.isOk()) {
873         ALOGE("%s: connect camera device failed: %s", __FUNCTION__, serviceRet.toString8().c_str());
874         // Convert serviceRet to camera_status_t
875         switch(serviceRet.serviceSpecificErrorCode()) {
876             case hardware::ICameraService::ERROR_DISCONNECTED:
877                 ret = ACAMERA_ERROR_CAMERA_DISCONNECTED;
878                 break;
879             case hardware::ICameraService::ERROR_CAMERA_IN_USE:
880                 ret = ACAMERA_ERROR_CAMERA_IN_USE;
881                 break;
882             case hardware::ICameraService::ERROR_MAX_CAMERAS_IN_USE:
883                 ret = ACAMERA_ERROR_MAX_CAMERA_IN_USE;
884                 break;
885             case hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT:
886                 ret = ACAMERA_ERROR_INVALID_PARAMETER;
887                 break;
888             case hardware::ICameraService::ERROR_DEPRECATED_HAL:
889                 // Should not reach here since we filtered legacy HALs earlier
890                 ret = ACAMERA_ERROR_INVALID_PARAMETER;
891                 break;
892             case hardware::ICameraService::ERROR_DISABLED:
893                 ret = ACAMERA_ERROR_CAMERA_DISABLED;
894                 break;
895             case hardware::ICameraService::ERROR_PERMISSION_DENIED:
896                 ret = ACAMERA_ERROR_PERMISSION_DENIED;
897                 break;
898             case hardware::ICameraService::ERROR_INVALID_OPERATION:
899             default:
900                 ret = ACAMERA_ERROR_UNKNOWN;
901                 break;
902         }
903 
904         delete device;
905         return ret;
906     }
907     if (deviceRemote == nullptr) {
908         ALOGE("%s: connect camera device failed! remote device is null", __FUNCTION__);
909         delete device;
910         return ACAMERA_ERROR_CAMERA_DISCONNECTED;
911     }
912     device->setRemoteDevice(deviceRemote);
913     *outDevice = device;
914     return ACAMERA_OK;
915 }
916 
registerAvailabilityCallback(const ACameraManager_AvailabilityCallbacks * callback)917 void ACameraManager::registerAvailabilityCallback(
918         const ACameraManager_AvailabilityCallbacks* callback) {
919     mGlobalManager->registerAvailabilityCallback(mDeviceContext, callback);
920 }
921 
unregisterAvailabilityCallback(const ACameraManager_AvailabilityCallbacks * callback)922 void ACameraManager::unregisterAvailabilityCallback(
923         const ACameraManager_AvailabilityCallbacks* callback) {
924     mGlobalManager->unregisterAvailabilityCallback(mDeviceContext, callback);
925 }
926 
registerExtendedAvailabilityCallback(const ACameraManager_ExtendedAvailabilityCallbacks * callback)927 void ACameraManager::registerExtendedAvailabilityCallback(
928         const ACameraManager_ExtendedAvailabilityCallbacks* callback) {
929     mGlobalManager->registerExtendedAvailabilityCallback(mDeviceContext, callback);
930 }
931 
unregisterExtendedAvailabilityCallback(const ACameraManager_ExtendedAvailabilityCallbacks * callback)932 void ACameraManager::unregisterExtendedAvailabilityCallback(
933         const ACameraManager_ExtendedAvailabilityCallbacks* callback) {
934     mGlobalManager->unregisterExtendedAvailabilityCallback(mDeviceContext, callback);
935 }
936