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