1 /*
2 * Copyright (C) 2016 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_TAG "CameraProviderManager"
18 #define ATRACE_TAG ATRACE_TAG_CAMERA
19 //#define LOG_NDEBUG 0
20
21 #include "CameraProviderManager.h"
22
23 #include <algorithm>
24 #include <chrono>
25 #include <inttypes.h>
26 #include <hidl/ServiceManagement.h>
27 #include <functional>
28 #include <camera_metadata_hidden.h>
29 #include <android-base/parseint.h>
30
31 namespace android {
32
33 using namespace ::android::hardware::camera;
34 using namespace ::android::hardware::camera::common::V1_0;
35
36 namespace {
37 // Hardcoded name for the passthrough HAL implementation, since it can't be discovered via the
38 // service manager
39 const std::string kLegacyProviderName("legacy/0");
40 const std::string kExternalProviderName("external/0");
41
42 } // anonymous namespace
43
44 CameraProviderManager::HardwareServiceInteractionProxy
45 CameraProviderManager::sHardwareServiceInteractionProxy{};
46
~CameraProviderManager()47 CameraProviderManager::~CameraProviderManager() {
48 }
49
initialize(wp<CameraProviderManager::StatusListener> listener,ServiceInteractionProxy * proxy)50 status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
51 ServiceInteractionProxy* proxy) {
52 std::lock_guard<std::mutex> lock(mInterfaceMutex);
53 if (proxy == nullptr) {
54 ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
55 return BAD_VALUE;
56 }
57 mListener = listener;
58 mServiceProxy = proxy;
59
60 // Registering will trigger notifications for all already-known providers
61 bool success = mServiceProxy->registerForNotifications(
62 /* instance name, empty means no filter */ "",
63 this);
64 if (!success) {
65 ALOGE("%s: Unable to register with hardware service manager for notifications "
66 "about camera providers", __FUNCTION__);
67 return INVALID_OPERATION;
68 }
69
70 // See if there's a passthrough HAL, but let's not complain if there's not
71 addProviderLocked(kLegacyProviderName, /*expected*/ false);
72 addProviderLocked(kExternalProviderName, /*expected*/ false);
73
74 return OK;
75 }
76
getCameraCount() const77 int CameraProviderManager::getCameraCount() const {
78 std::lock_guard<std::mutex> lock(mInterfaceMutex);
79 int count = 0;
80 for (auto& provider : mProviders) {
81 count += provider->mUniqueCameraIds.size();
82 }
83 return count;
84 }
85
getCameraDeviceIds() const86 std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const {
87 std::lock_guard<std::mutex> lock(mInterfaceMutex);
88 std::vector<std::string> deviceIds;
89 for (auto& provider : mProviders) {
90 for (auto& id : provider->mUniqueCameraIds) {
91 deviceIds.push_back(id);
92 }
93 }
94 return deviceIds;
95 }
96
getAPI1CompatibleCameraDeviceIds() const97 std::vector<std::string> CameraProviderManager::getAPI1CompatibleCameraDeviceIds() const {
98 std::lock_guard<std::mutex> lock(mInterfaceMutex);
99 std::vector<std::string> deviceIds;
100 for (auto& provider : mProviders) {
101 std::vector<std::string> providerDeviceIds = provider->mUniqueAPI1CompatibleCameraIds;
102
103 // API1 app doesn't handle logical and physical camera devices well. So
104 // for each [logical, physical1, physical2, ...] id combo, only take the
105 // first id advertised by HAL, and filter out the rest.
106 filterLogicalCameraIdsLocked(providerDeviceIds);
107
108 deviceIds.insert(deviceIds.end(), providerDeviceIds.begin(), providerDeviceIds.end());
109 }
110
111 std::sort(deviceIds.begin(), deviceIds.end(),
112 [](const std::string& a, const std::string& b) -> bool {
113 uint32_t aUint = 0, bUint = 0;
114 bool aIsUint = base::ParseUint(a, &aUint);
115 bool bIsUint = base::ParseUint(b, &bUint);
116
117 // Uint device IDs first
118 if (aIsUint && bIsUint) {
119 return aUint < bUint;
120 } else if (aIsUint) {
121 return true;
122 } else if (bIsUint) {
123 return false;
124 }
125 // Simple string compare if both id are not uint
126 return a < b;
127 });
128 return deviceIds;
129 }
130
isValidDevice(const std::string & id,uint16_t majorVersion) const131 bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const {
132 std::lock_guard<std::mutex> lock(mInterfaceMutex);
133 return isValidDeviceLocked(id, majorVersion);
134 }
135
isValidDeviceLocked(const std::string & id,uint16_t majorVersion) const136 bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const {
137 for (auto& provider : mProviders) {
138 for (auto& deviceInfo : provider->mDevices) {
139 if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) {
140 return true;
141 }
142 }
143 }
144 return false;
145 }
146
hasFlashUnit(const std::string & id) const147 bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
148 std::lock_guard<std::mutex> lock(mInterfaceMutex);
149
150 auto deviceInfo = findDeviceInfoLocked(id);
151 if (deviceInfo == nullptr) return false;
152
153 return deviceInfo->hasFlashUnit();
154 }
155
getResourceCost(const std::string & id,CameraResourceCost * cost) const156 status_t CameraProviderManager::getResourceCost(const std::string &id,
157 CameraResourceCost* cost) const {
158 std::lock_guard<std::mutex> lock(mInterfaceMutex);
159
160 auto deviceInfo = findDeviceInfoLocked(id);
161 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
162
163 *cost = deviceInfo->mResourceCost;
164 return OK;
165 }
166
getCameraInfo(const std::string & id,hardware::CameraInfo * info) const167 status_t CameraProviderManager::getCameraInfo(const std::string &id,
168 hardware::CameraInfo* info) const {
169 std::lock_guard<std::mutex> lock(mInterfaceMutex);
170
171 auto deviceInfo = findDeviceInfoLocked(id);
172 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
173
174 return deviceInfo->getCameraInfo(info);
175 }
176
getCameraCharacteristics(const std::string & id,CameraMetadata * characteristics) const177 status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
178 CameraMetadata* characteristics) const {
179 std::lock_guard<std::mutex> lock(mInterfaceMutex);
180 return getCameraCharacteristicsLocked(id, characteristics);
181 }
182
getHighestSupportedVersion(const std::string & id,hardware::hidl_version * v)183 status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
184 hardware::hidl_version *v) {
185 std::lock_guard<std::mutex> lock(mInterfaceMutex);
186
187 hardware::hidl_version maxVersion{0,0};
188 bool found = false;
189 for (auto& provider : mProviders) {
190 for (auto& deviceInfo : provider->mDevices) {
191 if (deviceInfo->mId == id) {
192 if (deviceInfo->mVersion > maxVersion) {
193 maxVersion = deviceInfo->mVersion;
194 found = true;
195 }
196 }
197 }
198 }
199 if (!found) {
200 return NAME_NOT_FOUND;
201 }
202 *v = maxVersion;
203 return OK;
204 }
205
supportSetTorchMode(const std::string & id)206 bool CameraProviderManager::supportSetTorchMode(const std::string &id) {
207 std::lock_guard<std::mutex> lock(mInterfaceMutex);
208 bool support = false;
209 for (auto& provider : mProviders) {
210 auto deviceInfo = findDeviceInfoLocked(id);
211 if (deviceInfo != nullptr) {
212 auto ret = provider->mInterface->isSetTorchModeSupported(
213 [&support](auto status, bool supported) {
214 if (status == Status::OK) {
215 support = supported;
216 }
217 });
218 if (!ret.isOk()) {
219 ALOGE("%s: Transaction error checking torch mode support '%s': %s",
220 __FUNCTION__, provider->mProviderName.c_str(), ret.description().c_str());
221 }
222 break;
223 }
224 }
225 return support;
226 }
227
setTorchMode(const std::string & id,bool enabled)228 status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
229 std::lock_guard<std::mutex> lock(mInterfaceMutex);
230
231 auto deviceInfo = findDeviceInfoLocked(id);
232 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
233
234 return deviceInfo->setTorchMode(enabled);
235 }
236
setUpVendorTags()237 status_t CameraProviderManager::setUpVendorTags() {
238 sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
239
240 for (auto& provider : mProviders) {
241 hardware::hidl_vec<VendorTagSection> vts;
242 Status status;
243 hardware::Return<void> ret;
244 ret = provider->mInterface->getVendorTags(
245 [&](auto s, const auto& vendorTagSecs) {
246 status = s;
247 if (s == Status::OK) {
248 vts = vendorTagSecs;
249 }
250 });
251 if (!ret.isOk()) {
252 ALOGE("%s: Transaction error getting vendor tags from provider '%s': %s",
253 __FUNCTION__, provider->mProviderName.c_str(), ret.description().c_str());
254 return DEAD_OBJECT;
255 }
256 if (status != Status::OK) {
257 return mapToStatusT(status);
258 }
259
260 // Read all vendor tag definitions into a descriptor
261 sp<VendorTagDescriptor> desc;
262 status_t res;
263 if ((res = HidlVendorTagDescriptor::createDescriptorFromHidl(vts, /*out*/desc))
264 != OK) {
265 ALOGE("%s: Could not generate descriptor from vendor tag operations,"
266 "received error %s (%d). Camera clients will not be able to use"
267 "vendor tags", __FUNCTION__, strerror(res), res);
268 return res;
269 }
270
271 tagCache->addVendorDescriptor(provider->mProviderTagid, desc);
272 }
273
274 VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
275
276 return OK;
277 }
278
openSession(const std::string & id,const sp<hardware::camera::device::V3_2::ICameraDeviceCallback> & callback,sp<hardware::camera::device::V3_2::ICameraDeviceSession> * session)279 status_t CameraProviderManager::openSession(const std::string &id,
280 const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback,
281 /*out*/
282 sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session) {
283
284 std::lock_guard<std::mutex> lock(mInterfaceMutex);
285
286 auto deviceInfo = findDeviceInfoLocked(id,
287 /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
288 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
289
290 auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);
291
292 Status status;
293 hardware::Return<void> ret;
294 ret = deviceInfo3->mInterface->open(callback, [&status, &session]
295 (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
296 status = s;
297 if (status == Status::OK) {
298 *session = cameraSession;
299 }
300 });
301 if (!ret.isOk()) {
302 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
303 __FUNCTION__, id.c_str(), ret.description().c_str());
304 return DEAD_OBJECT;
305 }
306 return mapToStatusT(status);
307 }
308
openSession(const std::string & id,const sp<hardware::camera::device::V1_0::ICameraDeviceCallback> & callback,sp<hardware::camera::device::V1_0::ICameraDevice> * session)309 status_t CameraProviderManager::openSession(const std::string &id,
310 const sp<hardware::camera::device::V1_0::ICameraDeviceCallback>& callback,
311 /*out*/
312 sp<hardware::camera::device::V1_0::ICameraDevice> *session) {
313
314 std::lock_guard<std::mutex> lock(mInterfaceMutex);
315
316 auto deviceInfo = findDeviceInfoLocked(id,
317 /*minVersion*/ {1,0}, /*maxVersion*/ {2,0});
318 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
319
320 auto *deviceInfo1 = static_cast<ProviderInfo::DeviceInfo1*>(deviceInfo);
321
322 hardware::Return<Status> status = deviceInfo1->mInterface->open(callback);
323 if (!status.isOk()) {
324 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
325 __FUNCTION__, id.c_str(), status.description().c_str());
326 return DEAD_OBJECT;
327 }
328 if (status == Status::OK) {
329 *session = deviceInfo1->mInterface;
330 }
331 return mapToStatusT(status);
332 }
333
334
onRegistration(const hardware::hidl_string &,const hardware::hidl_string & name,bool)335 hardware::Return<void> CameraProviderManager::onRegistration(
336 const hardware::hidl_string& /*fqName*/,
337 const hardware::hidl_string& name,
338 bool /*preexisting*/) {
339 {
340 std::lock_guard<std::mutex> lock(mInterfaceMutex);
341
342 addProviderLocked(name);
343 }
344
345 sp<StatusListener> listener = getStatusListener();
346 if (nullptr != listener.get()) {
347 listener->onNewProviderRegistered();
348 }
349
350 return hardware::Return<void>();
351 }
352
dump(int fd,const Vector<String16> & args)353 status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
354 std::lock_guard<std::mutex> lock(mInterfaceMutex);
355
356 for (auto& provider : mProviders) {
357 provider->dump(fd, args);
358 }
359 return OK;
360 }
361
findDeviceInfoLocked(const std::string & id,hardware::hidl_version minVersion,hardware::hidl_version maxVersion) const362 CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
363 const std::string& id,
364 hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
365 for (auto& provider : mProviders) {
366 for (auto& deviceInfo : provider->mDevices) {
367 if (deviceInfo->mId == id &&
368 minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
369 return deviceInfo.get();
370 }
371 }
372 }
373 return nullptr;
374 }
375
getProviderTagIdLocked(const std::string & id,hardware::hidl_version minVersion,hardware::hidl_version maxVersion) const376 metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
377 const std::string& id, hardware::hidl_version minVersion,
378 hardware::hidl_version maxVersion) const {
379 metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID;
380
381 std::lock_guard<std::mutex> lock(mInterfaceMutex);
382 for (auto& provider : mProviders) {
383 for (auto& deviceInfo : provider->mDevices) {
384 if (deviceInfo->mId == id &&
385 minVersion <= deviceInfo->mVersion &&
386 maxVersion >= deviceInfo->mVersion) {
387 return provider->mProviderTagid;
388 }
389 }
390 }
391
392 return ret;
393 }
394
isLogicalCamera(const CameraMetadata & staticInfo,std::vector<std::string> * physicalCameraIds)395 bool CameraProviderManager::isLogicalCamera(const CameraMetadata& staticInfo,
396 std::vector<std::string>* physicalCameraIds) {
397 bool isLogicalCam = false;
398 camera_metadata_ro_entry_t entryCap;
399
400 entryCap = staticInfo.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
401 for (size_t i = 0; i < entryCap.count; ++i) {
402 uint8_t capability = entryCap.data.u8[i];
403 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
404 isLogicalCam = true;
405 break;
406 }
407 }
408 if (!isLogicalCam) {
409 return false;
410 }
411
412 camera_metadata_ro_entry_t entryIds = staticInfo.find(ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
413 const uint8_t* ids = entryIds.data.u8;
414 size_t start = 0;
415 for (size_t i = 0; i < entryIds.count; ++i) {
416 if (ids[i] == '\0') {
417 if (start != i) {
418 physicalCameraIds->push_back((const char*)ids+start);
419 }
420 start = i+1;
421 }
422 }
423 return true;
424 }
425
addProviderLocked(const std::string & newProvider,bool expected)426 status_t CameraProviderManager::addProviderLocked(const std::string& newProvider, bool expected) {
427 for (const auto& providerInfo : mProviders) {
428 if (providerInfo->mProviderName == newProvider) {
429 ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__,
430 newProvider.c_str());
431 return ALREADY_EXISTS;
432 }
433 }
434
435 sp<provider::V2_4::ICameraProvider> interface;
436 interface = mServiceProxy->getService(newProvider);
437
438 if (interface == nullptr) {
439 if (expected) {
440 ALOGE("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
441 newProvider.c_str());
442 return BAD_VALUE;
443 } else {
444 return OK;
445 }
446 }
447
448 sp<ProviderInfo> providerInfo =
449 new ProviderInfo(newProvider, interface, this);
450 status_t res = providerInfo->initialize();
451 if (res != OK) {
452 return res;
453 }
454
455 mProviders.push_back(providerInfo);
456
457 return OK;
458 }
459
removeProvider(const std::string & provider)460 status_t CameraProviderManager::removeProvider(const std::string& provider) {
461 std::unique_lock<std::mutex> lock(mInterfaceMutex);
462 std::vector<String8> removedDeviceIds;
463 status_t res = NAME_NOT_FOUND;
464 for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
465 if ((*it)->mProviderName == provider) {
466 removedDeviceIds.reserve((*it)->mDevices.size());
467 for (auto& deviceInfo : (*it)->mDevices) {
468 removedDeviceIds.push_back(String8(deviceInfo->mId.c_str()));
469 }
470 mProviders.erase(it);
471 res = OK;
472 break;
473 }
474 }
475 if (res != OK) {
476 ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
477 provider.c_str());
478 } else {
479 // Inform camera service of loss of presence for all the devices from this provider,
480 // without lock held for reentrancy
481 sp<StatusListener> listener = getStatusListener();
482 if (listener != nullptr) {
483 lock.unlock();
484 for (auto& id : removedDeviceIds) {
485 listener->onDeviceStatusChanged(id, CameraDeviceStatus::NOT_PRESENT);
486 }
487 }
488 }
489 return res;
490 }
491
getStatusListener() const492 sp<CameraProviderManager::StatusListener> CameraProviderManager::getStatusListener() const {
493 return mListener.promote();
494 }
495
496 /**** Methods for ProviderInfo ****/
497
498
ProviderInfo(const std::string & providerName,sp<provider::V2_4::ICameraProvider> & interface,CameraProviderManager * manager)499 CameraProviderManager::ProviderInfo::ProviderInfo(
500 const std::string &providerName,
501 sp<provider::V2_4::ICameraProvider>& interface,
502 CameraProviderManager *manager) :
503 mProviderName(providerName),
504 mInterface(interface),
505 mProviderTagid(generateVendorTagId(providerName)),
506 mUniqueDeviceCount(0),
507 mManager(manager) {
508 (void) mManager;
509 }
510
initialize()511 status_t CameraProviderManager::ProviderInfo::initialize() {
512 status_t res = parseProviderName(mProviderName, &mType, &mId);
513 if (res != OK) {
514 ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);
515 return BAD_VALUE;
516 }
517 ALOGI("Connecting to new camera provider: %s, isRemote? %d",
518 mProviderName.c_str(), mInterface->isRemote());
519 // cameraDeviceStatusChange callbacks may be called (and causing new devices added)
520 // before setCallback returns
521 hardware::Return<Status> status = mInterface->setCallback(this);
522 if (!status.isOk()) {
523 ALOGE("%s: Transaction error setting up callbacks with camera provider '%s': %s",
524 __FUNCTION__, mProviderName.c_str(), status.description().c_str());
525 return DEAD_OBJECT;
526 }
527 if (status != Status::OK) {
528 ALOGE("%s: Unable to register callbacks with camera provider '%s'",
529 __FUNCTION__, mProviderName.c_str());
530 return mapToStatusT(status);
531 }
532
533 hardware::Return<bool> linked = mInterface->linkToDeath(this, /*cookie*/ mId);
534 if (!linked.isOk()) {
535 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
536 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
537 return DEAD_OBJECT;
538 } else if (!linked) {
539 ALOGW("%s: Unable to link to provider '%s' death notifications",
540 __FUNCTION__, mProviderName.c_str());
541 }
542
543 // Get initial list of camera devices, if any
544 std::vector<std::string> devices;
545 hardware::Return<void> ret = mInterface->getCameraIdList([&status, &devices](
546 Status idStatus,
547 const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
548 status = idStatus;
549 if (status == Status::OK) {
550 for (size_t i = 0; i < cameraDeviceNames.size(); i++) {
551 devices.push_back(cameraDeviceNames[i]);
552 }
553 } });
554 if (!ret.isOk()) {
555 ALOGE("%s: Transaction error in getting camera ID list from provider '%s': %s",
556 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
557 return DEAD_OBJECT;
558 }
559 if (status != Status::OK) {
560 ALOGE("%s: Unable to query for camera devices from provider '%s'",
561 __FUNCTION__, mProviderName.c_str());
562 return mapToStatusT(status);
563 }
564
565 sp<StatusListener> listener = mManager->getStatusListener();
566 for (auto& device : devices) {
567 std::string id;
568 status_t res = addDevice(device,
569 hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT, &id);
570 if (res != OK) {
571 ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
572 __FUNCTION__, device.c_str(), strerror(-res), res);
573 continue;
574 }
575 }
576
577 ALOGI("Camera provider %s ready with %zu camera devices",
578 mProviderName.c_str(), mDevices.size());
579
580 mInitialized = true;
581 return OK;
582 }
583
getType() const584 const std::string& CameraProviderManager::ProviderInfo::getType() const {
585 return mType;
586 }
587
addDevice(const std::string & name,CameraDeviceStatus initialStatus,std::string * parsedId)588 status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
589 CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
590
591 ALOGI("Enumerating new camera device: %s", name.c_str());
592
593 uint16_t major, minor;
594 std::string type, id;
595
596 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
597 if (res != OK) {
598 return res;
599 }
600 if (type != mType) {
601 ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
602 type.c_str(), mType.c_str());
603 return BAD_VALUE;
604 }
605 if (mManager->isValidDeviceLocked(id, major)) {
606 ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
607 name.c_str(), id.c_str(), major);
608 return BAD_VALUE;
609 }
610
611 std::unique_ptr<DeviceInfo> deviceInfo;
612 switch (major) {
613 case 1:
614 deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, mProviderTagid,
615 id, minor);
616 break;
617 case 3:
618 deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid,
619 id, minor);
620 break;
621 default:
622 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
623 name.c_str(), major);
624 return BAD_VALUE;
625 }
626 if (deviceInfo == nullptr) return BAD_VALUE;
627 deviceInfo->mStatus = initialStatus;
628 bool isAPI1Compatible = deviceInfo->isAPI1Compatible();
629
630 mDevices.push_back(std::move(deviceInfo));
631
632 mUniqueCameraIds.insert(id);
633 if (isAPI1Compatible) {
634 mUniqueAPI1CompatibleCameraIds.push_back(id);
635 }
636
637 if (parsedId != nullptr) {
638 *parsedId = id;
639 }
640 return OK;
641 }
642
removeDevice(std::string id)643 void CameraProviderManager::ProviderInfo::removeDevice(std::string id) {
644 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
645 if ((*it)->mId == id) {
646 mUniqueCameraIds.erase(id);
647 if ((*it)->isAPI1Compatible()) {
648 mUniqueAPI1CompatibleCameraIds.erase(std::remove(
649 mUniqueAPI1CompatibleCameraIds.begin(),
650 mUniqueAPI1CompatibleCameraIds.end(), id));
651 }
652 mDevices.erase(it);
653 break;
654 }
655 }
656 }
657
dump(int fd,const Vector<String16> &) const658 status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
659 dprintf(fd, "== Camera Provider HAL %s (v2.4, %s) static info: %zu devices: ==\n",
660 mProviderName.c_str(), mInterface->isRemote() ? "remote" : "passthrough",
661 mDevices.size());
662
663 for (auto& device : mDevices) {
664 dprintf(fd, "== Camera HAL device %s (v%d.%d) static information: ==\n", device->mName.c_str(),
665 device->mVersion.get_major(), device->mVersion.get_minor());
666 dprintf(fd, " Resource cost: %d\n", device->mResourceCost.resourceCost);
667 if (device->mResourceCost.conflictingDevices.size() == 0) {
668 dprintf(fd, " Conflicting devices: None\n");
669 } else {
670 dprintf(fd, " Conflicting devices:\n");
671 for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
672 dprintf(fd, " %s\n",
673 device->mResourceCost.conflictingDevices[i].c_str());
674 }
675 }
676 dprintf(fd, " API1 info:\n");
677 dprintf(fd, " Has a flash unit: %s\n",
678 device->hasFlashUnit() ? "true" : "false");
679 hardware::CameraInfo info;
680 status_t res = device->getCameraInfo(&info);
681 if (res != OK) {
682 dprintf(fd, " <Error reading camera info: %s (%d)>\n",
683 strerror(-res), res);
684 } else {
685 dprintf(fd, " Facing: %s\n",
686 info.facing == hardware::CAMERA_FACING_BACK ? "Back" : "Front");
687 dprintf(fd, " Orientation: %d\n", info.orientation);
688 }
689 CameraMetadata info2;
690 res = device->getCameraCharacteristics(&info2);
691 if (res == INVALID_OPERATION) {
692 dprintf(fd, " API2 not directly supported\n");
693 } else if (res != OK) {
694 dprintf(fd, " <Error reading camera characteristics: %s (%d)>\n",
695 strerror(-res), res);
696 } else {
697 dprintf(fd, " API2 camera characteristics:\n");
698 info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
699 }
700
701 dprintf(fd, "== Camera HAL device %s (v%d.%d) dumpState: ==\n", device->mName.c_str(),
702 device->mVersion.get_major(), device->mVersion.get_minor());
703 res = device->dumpState(fd);
704 if (res != OK) {
705 dprintf(fd, " <Error dumping device %s state: %s (%d)>\n",
706 device->mName.c_str(), strerror(-res), res);
707 }
708 }
709 return OK;
710 }
711
cameraDeviceStatusChange(const hardware::hidl_string & cameraDeviceName,CameraDeviceStatus newStatus)712 hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusChange(
713 const hardware::hidl_string& cameraDeviceName,
714 CameraDeviceStatus newStatus) {
715 sp<StatusListener> listener;
716 std::string id;
717 bool initialized = false;
718 {
719 std::lock_guard<std::mutex> lock(mLock);
720 bool known = false;
721 for (auto& deviceInfo : mDevices) {
722 if (deviceInfo->mName == cameraDeviceName) {
723 ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
724 deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
725 deviceInfo->mStatus = newStatus;
726 // TODO: Handle device removal (NOT_PRESENT)
727 id = deviceInfo->mId;
728 known = true;
729 break;
730 }
731 }
732 // Previously unseen device; status must not be NOT_PRESENT
733 if (!known) {
734 if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
735 ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
736 mProviderName.c_str(), cameraDeviceName.c_str());
737 return hardware::Void();
738 }
739 addDevice(cameraDeviceName, newStatus, &id);
740 } else if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
741 removeDevice(id);
742 }
743 listener = mManager->getStatusListener();
744 initialized = mInitialized;
745 }
746 // Call without lock held to allow reentrancy into provider manager
747 // Don't send the callback if providerInfo hasn't been initialized.
748 // CameraService will initialize device status after provider is
749 // initialized
750 if (listener != nullptr && initialized) {
751 listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
752 }
753 return hardware::Void();
754 }
755
torchModeStatusChange(const hardware::hidl_string & cameraDeviceName,TorchModeStatus newStatus)756 hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
757 const hardware::hidl_string& cameraDeviceName,
758 TorchModeStatus newStatus) {
759 sp<StatusListener> listener;
760 std::string id;
761 {
762 std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex);
763 bool known = false;
764 for (auto& deviceInfo : mDevices) {
765 if (deviceInfo->mName == cameraDeviceName) {
766 ALOGI("Camera device %s torch status is now %s", cameraDeviceName.c_str(),
767 torchStatusToString(newStatus));
768 id = deviceInfo->mId;
769 known = true;
770 break;
771 }
772 }
773 if (!known) {
774 ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.",
775 mProviderName.c_str(), cameraDeviceName.c_str(), newStatus);
776 return hardware::Void();
777 }
778 listener = mManager->getStatusListener();
779 }
780 // Call without lock held to allow reentrancy into provider manager
781 if (listener != nullptr) {
782 listener->onTorchStatusChanged(String8(id.c_str()), newStatus);
783 }
784 return hardware::Void();
785 }
786
serviceDied(uint64_t cookie,const wp<hidl::base::V1_0::IBase> & who)787 void CameraProviderManager::ProviderInfo::serviceDied(uint64_t cookie,
788 const wp<hidl::base::V1_0::IBase>& who) {
789 (void) who;
790 ALOGI("Camera provider '%s' has died; removing it", mProviderName.c_str());
791 if (cookie != mId) {
792 ALOGW("%s: Unexpected serviceDied cookie %" PRIu64 ", expected %" PRIu32,
793 __FUNCTION__, cookie, mId);
794 }
795 mManager->removeProvider(mProviderName);
796 }
797
798 template<class DeviceInfoT>
799 std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
initializeDeviceInfo(const std::string & name,const metadata_vendor_id_t tagId,const std::string & id,uint16_t minorVersion) const800 CameraProviderManager::ProviderInfo::initializeDeviceInfo(
801 const std::string &name, const metadata_vendor_id_t tagId,
802 const std::string &id, uint16_t minorVersion) const {
803 Status status;
804
805 auto cameraInterface =
806 getDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
807 if (cameraInterface == nullptr) return nullptr;
808
809 CameraResourceCost resourceCost;
810 cameraInterface->getResourceCost([&status, &resourceCost](
811 Status s, CameraResourceCost cost) {
812 status = s;
813 resourceCost = cost;
814 });
815 if (status != Status::OK) {
816 ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
817 name.c_str(), statusToString(status));
818 return nullptr;
819 }
820
821 for (auto& conflictName : resourceCost.conflictingDevices) {
822 uint16_t major, minor;
823 std::string type, id;
824 status_t res = parseDeviceName(conflictName, &major, &minor, &type, &id);
825 if (res != OK) {
826 ALOGE("%s: Failed to parse conflicting device %s", __FUNCTION__, conflictName.c_str());
827 return nullptr;
828 }
829 conflictName = id;
830 }
831
832 return std::unique_ptr<DeviceInfo>(
833 new DeviceInfoT(name, tagId, id, minorVersion, resourceCost,
834 cameraInterface));
835 }
836
837 template<class InterfaceT>
838 sp<InterfaceT>
getDeviceInterface(const std::string & name) const839 CameraProviderManager::ProviderInfo::getDeviceInterface(const std::string &name) const {
840 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
841 name.c_str(), InterfaceT::version.get_major());
842 return nullptr;
843 }
844
845 template<>
846 sp<device::V1_0::ICameraDevice>
getDeviceInterface(const std::string & name) const847 CameraProviderManager::ProviderInfo::getDeviceInterface
848 <device::V1_0::ICameraDevice>(const std::string &name) const {
849 Status status;
850 sp<device::V1_0::ICameraDevice> cameraInterface;
851 hardware::Return<void> ret;
852 ret = mInterface->getCameraDeviceInterface_V1_x(name, [&status, &cameraInterface](
853 Status s, sp<device::V1_0::ICameraDevice> interface) {
854 status = s;
855 cameraInterface = interface;
856 });
857 if (!ret.isOk()) {
858 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
859 __FUNCTION__, name.c_str(), ret.description().c_str());
860 return nullptr;
861 }
862 if (status != Status::OK) {
863 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
864 name.c_str(), statusToString(status));
865 return nullptr;
866 }
867 return cameraInterface;
868 }
869
870 template<>
871 sp<device::V3_2::ICameraDevice>
getDeviceInterface(const std::string & name) const872 CameraProviderManager::ProviderInfo::getDeviceInterface
873 <device::V3_2::ICameraDevice>(const std::string &name) const {
874 Status status;
875 sp<device::V3_2::ICameraDevice> cameraInterface;
876 hardware::Return<void> ret;
877 ret = mInterface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
878 Status s, sp<device::V3_2::ICameraDevice> interface) {
879 status = s;
880 cameraInterface = interface;
881 });
882 if (!ret.isOk()) {
883 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
884 __FUNCTION__, name.c_str(), ret.description().c_str());
885 return nullptr;
886 }
887 if (status != Status::OK) {
888 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
889 name.c_str(), statusToString(status));
890 return nullptr;
891 }
892 return cameraInterface;
893 }
894
~DeviceInfo()895 CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {}
896
897 template<class InterfaceT>
setTorchMode(InterfaceT & interface,bool enabled)898 status_t CameraProviderManager::ProviderInfo::DeviceInfo::setTorchMode(InterfaceT& interface,
899 bool enabled) {
900 Status s = interface->setTorchMode(enabled ? TorchMode::ON : TorchMode::OFF);
901 return mapToStatusT(s);
902 }
903
DeviceInfo1(const std::string & name,const metadata_vendor_id_t tagId,const std::string & id,uint16_t minorVersion,const CameraResourceCost & resourceCost,sp<InterfaceT> interface)904 CameraProviderManager::ProviderInfo::DeviceInfo1::DeviceInfo1(const std::string& name,
905 const metadata_vendor_id_t tagId, const std::string &id,
906 uint16_t minorVersion,
907 const CameraResourceCost& resourceCost,
908 sp<InterfaceT> interface) :
909 DeviceInfo(name, tagId, id, hardware::hidl_version{1, minorVersion},
910 resourceCost),
911 mInterface(interface) {
912 // Get default parameters and initialize flash unit availability
913 // Requires powering on the camera device
914 hardware::Return<Status> status = mInterface->open(nullptr);
915 if (!status.isOk()) {
916 ALOGE("%s: Transaction error opening camera device %s to check for a flash unit: %s",
917 __FUNCTION__, mId.c_str(), status.description().c_str());
918 return;
919 }
920 if (status != Status::OK) {
921 ALOGE("%s: Unable to open camera device %s to check for a flash unit: %s", __FUNCTION__,
922 mId.c_str(), CameraProviderManager::statusToString(status));
923 return;
924 }
925 hardware::Return<void> ret;
__anon330ebd180a02(const hardware::hidl_string& parms) 926 ret = mInterface->getParameters([this](const hardware::hidl_string& parms) {
927 mDefaultParameters.unflatten(String8(parms.c_str()));
928 });
929 if (!ret.isOk()) {
930 ALOGE("%s: Transaction error reading camera device %s params to check for a flash unit: %s",
931 __FUNCTION__, mId.c_str(), status.description().c_str());
932 return;
933 }
934 const char *flashMode =
935 mDefaultParameters.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
936 if (flashMode && strstr(flashMode, CameraParameters::FLASH_MODE_TORCH)) {
937 mHasFlashUnit = true;
938 }
939
940 ret = mInterface->close();
941 if (!ret.isOk()) {
942 ALOGE("%s: Transaction error closing camera device %s after check for a flash unit: %s",
943 __FUNCTION__, mId.c_str(), status.description().c_str());
944 }
945 }
946
~DeviceInfo1()947 CameraProviderManager::ProviderInfo::DeviceInfo1::~DeviceInfo1() {}
948
setTorchMode(bool enabled)949 status_t CameraProviderManager::ProviderInfo::DeviceInfo1::setTorchMode(bool enabled) {
950 return DeviceInfo::setTorchMode(mInterface, enabled);
951 }
952
getCameraInfo(hardware::CameraInfo * info) const953 status_t CameraProviderManager::ProviderInfo::DeviceInfo1::getCameraInfo(
954 hardware::CameraInfo *info) const {
955 if (info == nullptr) return BAD_VALUE;
956
957 Status status;
958 device::V1_0::CameraInfo cInfo;
959 hardware::Return<void> ret;
960 ret = mInterface->getCameraInfo([&status, &cInfo](Status s, device::V1_0::CameraInfo camInfo) {
961 status = s;
962 cInfo = camInfo;
963 });
964 if (!ret.isOk()) {
965 ALOGE("%s: Transaction error reading camera info from device %s: %s",
966 __FUNCTION__, mId.c_str(), ret.description().c_str());
967 return DEAD_OBJECT;
968 }
969 if (status != Status::OK) {
970 return mapToStatusT(status);
971 }
972
973 switch(cInfo.facing) {
974 case device::V1_0::CameraFacing::BACK:
975 info->facing = hardware::CAMERA_FACING_BACK;
976 break;
977 case device::V1_0::CameraFacing::EXTERNAL:
978 // Map external to front for legacy API
979 case device::V1_0::CameraFacing::FRONT:
980 info->facing = hardware::CAMERA_FACING_FRONT;
981 break;
982 default:
983 ALOGW("%s: Device %s: Unknown camera facing: %d",
984 __FUNCTION__, mId.c_str(), cInfo.facing);
985 info->facing = hardware::CAMERA_FACING_BACK;
986 }
987 info->orientation = cInfo.orientation;
988
989 return OK;
990 }
991
dumpState(int fd) const992 status_t CameraProviderManager::ProviderInfo::DeviceInfo1::dumpState(int fd) const {
993 native_handle_t* handle = native_handle_create(1,0);
994 handle->data[0] = fd;
995 hardware::Return<Status> s = mInterface->dumpState(handle);
996 native_handle_delete(handle);
997 if (!s.isOk()) {
998 return INVALID_OPERATION;
999 }
1000 return mapToStatusT(s);
1001 }
1002
DeviceInfo3(const std::string & name,const metadata_vendor_id_t tagId,const std::string & id,uint16_t minorVersion,const CameraResourceCost & resourceCost,sp<InterfaceT> interface)1003 CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
1004 const metadata_vendor_id_t tagId, const std::string &id,
1005 uint16_t minorVersion,
1006 const CameraResourceCost& resourceCost,
1007 sp<InterfaceT> interface) :
1008 DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
1009 resourceCost),
1010 mInterface(interface) {
1011 // Get camera characteristics and initialize flash unit availability
1012 Status status;
1013 hardware::Return<void> ret;
1014 ret = mInterface->getCameraCharacteristics([&status, this](Status s,
__anon330ebd180c02(Status s, device::V3_2::CameraMetadata metadata) 1015 device::V3_2::CameraMetadata metadata) {
1016 status = s;
1017 if (s == Status::OK) {
1018 camera_metadata_t *buffer =
1019 reinterpret_cast<camera_metadata_t*>(metadata.data());
1020 size_t expectedSize = metadata.size();
1021 int res = validate_camera_metadata_structure(buffer, &expectedSize);
1022 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
1023 set_camera_metadata_vendor_id(buffer, mProviderTagid);
1024 mCameraCharacteristics = buffer;
1025 } else {
1026 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
1027 status = Status::INTERNAL_ERROR;
1028 }
1029 }
1030 });
1031 if (!ret.isOk()) {
1032 ALOGE("%s: Transaction error getting camera characteristics for device %s"
1033 " to check for a flash unit: %s", __FUNCTION__, mId.c_str(),
1034 ret.description().c_str());
1035 return;
1036 }
1037 if (status != Status::OK) {
1038 ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)",
1039 __FUNCTION__, mId.c_str(), CameraProviderManager::statusToString(status), status);
1040 return;
1041 }
1042 camera_metadata_entry flashAvailable =
1043 mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);
1044 if (flashAvailable.count == 1 &&
1045 flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
1046 mHasFlashUnit = true;
1047 } else {
1048 mHasFlashUnit = false;
1049 }
1050 }
1051
~DeviceInfo3()1052 CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {}
1053
setTorchMode(bool enabled)1054 status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) {
1055 return DeviceInfo::setTorchMode(mInterface, enabled);
1056 }
1057
getCameraInfo(hardware::CameraInfo * info) const1058 status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
1059 hardware::CameraInfo *info) const {
1060 if (info == nullptr) return BAD_VALUE;
1061
1062 camera_metadata_ro_entry facing =
1063 mCameraCharacteristics.find(ANDROID_LENS_FACING);
1064 if (facing.count == 1) {
1065 switch (facing.data.u8[0]) {
1066 case ANDROID_LENS_FACING_BACK:
1067 info->facing = hardware::CAMERA_FACING_BACK;
1068 break;
1069 case ANDROID_LENS_FACING_EXTERNAL:
1070 // Map external to front for legacy API
1071 case ANDROID_LENS_FACING_FRONT:
1072 info->facing = hardware::CAMERA_FACING_FRONT;
1073 break;
1074 }
1075 } else {
1076 ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
1077 return NAME_NOT_FOUND;
1078 }
1079
1080 camera_metadata_ro_entry orientation =
1081 mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
1082 if (orientation.count == 1) {
1083 info->orientation = orientation.data.i32[0];
1084 } else {
1085 ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
1086 return NAME_NOT_FOUND;
1087 }
1088
1089 return OK;
1090 }
isAPI1Compatible() const1091 bool CameraProviderManager::ProviderInfo::DeviceInfo3::isAPI1Compatible() const {
1092 bool isBackwardCompatible = false;
1093 camera_metadata_ro_entry_t caps = mCameraCharacteristics.find(
1094 ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
1095 for (size_t i = 0; i < caps.count; i++) {
1096 if (caps.data.u8[i] ==
1097 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
1098 isBackwardCompatible = true;
1099 break;
1100 }
1101 }
1102
1103 return isBackwardCompatible;
1104 }
1105
dumpState(int fd) const1106 status_t CameraProviderManager::ProviderInfo::DeviceInfo3::dumpState(int fd) const {
1107 native_handle_t* handle = native_handle_create(1,0);
1108 handle->data[0] = fd;
1109 auto ret = mInterface->dumpState(handle);
1110 native_handle_delete(handle);
1111 if (!ret.isOk()) {
1112 return INVALID_OPERATION;
1113 }
1114 return OK;
1115 }
1116
getCameraCharacteristics(CameraMetadata * characteristics) const1117 status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
1118 CameraMetadata *characteristics) const {
1119 if (characteristics == nullptr) return BAD_VALUE;
1120
1121 *characteristics = mCameraCharacteristics;
1122 return OK;
1123 }
1124
parseProviderName(const std::string & name,std::string * type,uint32_t * id)1125 status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
1126 std::string *type, uint32_t *id) {
1127 // Format must be "<type>/<id>"
1128 #define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \
1129 "Should match '<type>/<id>' - "
1130
1131 if (!type || !id) return INVALID_OPERATION;
1132
1133 std::string::size_type slashIdx = name.find('/');
1134 if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
1135 ALOGE(ERROR_MSG_PREFIX
1136 "does not have / separator between type and id",
1137 __FUNCTION__, name.c_str());
1138 return BAD_VALUE;
1139 }
1140
1141 std::string typeVal = name.substr(0, slashIdx);
1142
1143 char *endPtr;
1144 errno = 0;
1145 long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
1146 if (errno != 0) {
1147 ALOGE(ERROR_MSG_PREFIX
1148 "cannot parse provider id as an integer: %s (%d)",
1149 __FUNCTION__, name.c_str(), strerror(errno), errno);
1150 return BAD_VALUE;
1151 }
1152 if (endPtr != name.c_str() + name.size()) {
1153 ALOGE(ERROR_MSG_PREFIX
1154 "provider id has unexpected length",
1155 __FUNCTION__, name.c_str());
1156 return BAD_VALUE;
1157 }
1158 if (idVal < 0) {
1159 ALOGE(ERROR_MSG_PREFIX
1160 "id is negative: %ld",
1161 __FUNCTION__, name.c_str(), idVal);
1162 return BAD_VALUE;
1163 }
1164
1165 #undef ERROR_MSG_PREFIX
1166
1167 *type = typeVal;
1168 *id = static_cast<uint32_t>(idVal);
1169
1170 return OK;
1171 }
1172
generateVendorTagId(const std::string & name)1173 metadata_vendor_id_t CameraProviderManager::ProviderInfo::generateVendorTagId(
1174 const std::string &name) {
1175 metadata_vendor_id_t ret = std::hash<std::string> {} (name);
1176 // CAMERA_METADATA_INVALID_VENDOR_ID is not a valid hash value
1177 if (CAMERA_METADATA_INVALID_VENDOR_ID == ret) {
1178 ret = 0;
1179 }
1180
1181 return ret;
1182 }
1183
parseDeviceName(const std::string & name,uint16_t * major,uint16_t * minor,std::string * type,std::string * id)1184 status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
1185 uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
1186
1187 // Format must be "device@<major>.<minor>/<type>/<id>"
1188
1189 #define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
1190 "Should match 'device@<major>.<minor>/<type>/<id>' - "
1191
1192 if (!major || !minor || !type || !id) return INVALID_OPERATION;
1193
1194 // Verify starting prefix
1195 const char expectedPrefix[] = "device@";
1196
1197 if (name.find(expectedPrefix) != 0) {
1198 ALOGE(ERROR_MSG_PREFIX
1199 "does not start with '%s'",
1200 __FUNCTION__, name.c_str(), expectedPrefix);
1201 return BAD_VALUE;
1202 }
1203
1204 // Extract major/minor versions
1205 constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
1206 std::string::size_type dotIdx = name.find('.', atIdx);
1207 if (dotIdx == std::string::npos) {
1208 ALOGE(ERROR_MSG_PREFIX
1209 "does not have @<major>. version section",
1210 __FUNCTION__, name.c_str());
1211 return BAD_VALUE;
1212 }
1213 std::string::size_type typeSlashIdx = name.find('/', dotIdx);
1214 if (typeSlashIdx == std::string::npos) {
1215 ALOGE(ERROR_MSG_PREFIX
1216 "does not have .<minor>/ version section",
1217 __FUNCTION__, name.c_str());
1218 return BAD_VALUE;
1219 }
1220
1221 char *endPtr;
1222 errno = 0;
1223 long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
1224 if (errno != 0) {
1225 ALOGE(ERROR_MSG_PREFIX
1226 "cannot parse major version: %s (%d)",
1227 __FUNCTION__, name.c_str(), strerror(errno), errno);
1228 return BAD_VALUE;
1229 }
1230 if (endPtr != name.c_str() + dotIdx) {
1231 ALOGE(ERROR_MSG_PREFIX
1232 "major version has unexpected length",
1233 __FUNCTION__, name.c_str());
1234 return BAD_VALUE;
1235 }
1236 long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
1237 if (errno != 0) {
1238 ALOGE(ERROR_MSG_PREFIX
1239 "cannot parse minor version: %s (%d)",
1240 __FUNCTION__, name.c_str(), strerror(errno), errno);
1241 return BAD_VALUE;
1242 }
1243 if (endPtr != name.c_str() + typeSlashIdx) {
1244 ALOGE(ERROR_MSG_PREFIX
1245 "minor version has unexpected length",
1246 __FUNCTION__, name.c_str());
1247 return BAD_VALUE;
1248 }
1249 if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
1250 ALOGE(ERROR_MSG_PREFIX
1251 "major/minor version is out of range of uint16_t: %ld.%ld",
1252 __FUNCTION__, name.c_str(), majorVal, minorVal);
1253 return BAD_VALUE;
1254 }
1255
1256 // Extract type and id
1257
1258 std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
1259 if (instanceSlashIdx == std::string::npos) {
1260 ALOGE(ERROR_MSG_PREFIX
1261 "does not have /<type>/ component",
1262 __FUNCTION__, name.c_str());
1263 return BAD_VALUE;
1264 }
1265 std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
1266
1267 if (instanceSlashIdx == name.size() - 1) {
1268 ALOGE(ERROR_MSG_PREFIX
1269 "does not have an /<id> component",
1270 __FUNCTION__, name.c_str());
1271 return BAD_VALUE;
1272 }
1273 std::string idVal = name.substr(instanceSlashIdx + 1);
1274
1275 #undef ERROR_MSG_PREFIX
1276
1277 *major = static_cast<uint16_t>(majorVal);
1278 *minor = static_cast<uint16_t>(minorVal);
1279 *type = typeVal;
1280 *id = idVal;
1281
1282 return OK;
1283 }
1284
1285
1286
~ProviderInfo()1287 CameraProviderManager::ProviderInfo::~ProviderInfo() {
1288 // Destruction of ProviderInfo is only supposed to happen when the respective
1289 // CameraProvider interface dies, so do not unregister callbacks.
1290
1291 }
1292
mapToStatusT(const Status & s)1293 status_t CameraProviderManager::mapToStatusT(const Status& s) {
1294 switch(s) {
1295 case Status::OK:
1296 return OK;
1297 case Status::ILLEGAL_ARGUMENT:
1298 return BAD_VALUE;
1299 case Status::CAMERA_IN_USE:
1300 return -EBUSY;
1301 case Status::MAX_CAMERAS_IN_USE:
1302 return -EUSERS;
1303 case Status::METHOD_NOT_SUPPORTED:
1304 return UNKNOWN_TRANSACTION;
1305 case Status::OPERATION_NOT_SUPPORTED:
1306 return INVALID_OPERATION;
1307 case Status::CAMERA_DISCONNECTED:
1308 return DEAD_OBJECT;
1309 case Status::INTERNAL_ERROR:
1310 return INVALID_OPERATION;
1311 }
1312 ALOGW("Unexpected HAL status code %d", s);
1313 return INVALID_OPERATION;
1314 }
1315
statusToString(const Status & s)1316 const char* CameraProviderManager::statusToString(const Status& s) {
1317 switch(s) {
1318 case Status::OK:
1319 return "OK";
1320 case Status::ILLEGAL_ARGUMENT:
1321 return "ILLEGAL_ARGUMENT";
1322 case Status::CAMERA_IN_USE:
1323 return "CAMERA_IN_USE";
1324 case Status::MAX_CAMERAS_IN_USE:
1325 return "MAX_CAMERAS_IN_USE";
1326 case Status::METHOD_NOT_SUPPORTED:
1327 return "METHOD_NOT_SUPPORTED";
1328 case Status::OPERATION_NOT_SUPPORTED:
1329 return "OPERATION_NOT_SUPPORTED";
1330 case Status::CAMERA_DISCONNECTED:
1331 return "CAMERA_DISCONNECTED";
1332 case Status::INTERNAL_ERROR:
1333 return "INTERNAL_ERROR";
1334 }
1335 ALOGW("Unexpected HAL status code %d", s);
1336 return "UNKNOWN_ERROR";
1337 }
1338
deviceStatusToString(const CameraDeviceStatus & s)1339 const char* CameraProviderManager::deviceStatusToString(const CameraDeviceStatus& s) {
1340 switch(s) {
1341 case CameraDeviceStatus::NOT_PRESENT:
1342 return "NOT_PRESENT";
1343 case CameraDeviceStatus::PRESENT:
1344 return "PRESENT";
1345 case CameraDeviceStatus::ENUMERATING:
1346 return "ENUMERATING";
1347 }
1348 ALOGW("Unexpected HAL device status code %d", s);
1349 return "UNKNOWN_STATUS";
1350 }
1351
torchStatusToString(const TorchModeStatus & s)1352 const char* CameraProviderManager::torchStatusToString(const TorchModeStatus& s) {
1353 switch(s) {
1354 case TorchModeStatus::NOT_AVAILABLE:
1355 return "NOT_AVAILABLE";
1356 case TorchModeStatus::AVAILABLE_OFF:
1357 return "AVAILABLE_OFF";
1358 case TorchModeStatus::AVAILABLE_ON:
1359 return "AVAILABLE_ON";
1360 }
1361 ALOGW("Unexpected HAL torch mode status code %d", s);
1362 return "UNKNOWN_STATUS";
1363 }
1364
1365
createDescriptorFromHidl(const hardware::hidl_vec<hardware::camera::common::V1_0::VendorTagSection> & vts,sp<VendorTagDescriptor> & descriptor)1366 status_t HidlVendorTagDescriptor::createDescriptorFromHidl(
1367 const hardware::hidl_vec<hardware::camera::common::V1_0::VendorTagSection>& vts,
1368 /*out*/
1369 sp<VendorTagDescriptor>& descriptor) {
1370
1371 int tagCount = 0;
1372
1373 for (size_t s = 0; s < vts.size(); s++) {
1374 tagCount += vts[s].tags.size();
1375 }
1376
1377 if (tagCount < 0 || tagCount > INT32_MAX) {
1378 ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount);
1379 return BAD_VALUE;
1380 }
1381
1382 Vector<uint32_t> tagArray;
1383 LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
1384 "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
1385
1386
1387 sp<HidlVendorTagDescriptor> desc = new HidlVendorTagDescriptor();
1388 desc->mTagCount = tagCount;
1389
1390 SortedVector<String8> sections;
1391 KeyedVector<uint32_t, String8> tagToSectionMap;
1392
1393 int idx = 0;
1394 for (size_t s = 0; s < vts.size(); s++) {
1395 const hardware::camera::common::V1_0::VendorTagSection& section = vts[s];
1396 const char *sectionName = section.sectionName.c_str();
1397 if (sectionName == NULL) {
1398 ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s);
1399 return BAD_VALUE;
1400 }
1401 String8 sectionString(sectionName);
1402 sections.add(sectionString);
1403
1404 for (size_t j = 0; j < section.tags.size(); j++) {
1405 uint32_t tag = section.tags[j].tagId;
1406 if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
1407 ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
1408 return BAD_VALUE;
1409 }
1410
1411 tagArray.editItemAt(idx++) = section.tags[j].tagId;
1412
1413 const char *tagName = section.tags[j].tagName.c_str();
1414 if (tagName == NULL) {
1415 ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
1416 return BAD_VALUE;
1417 }
1418 desc->mTagToNameMap.add(tag, String8(tagName));
1419 tagToSectionMap.add(tag, sectionString);
1420
1421 int tagType = (int) section.tags[j].tagType;
1422 if (tagType < 0 || tagType >= NUM_TYPES) {
1423 ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
1424 return BAD_VALUE;
1425 }
1426 desc->mTagToTypeMap.add(tag, tagType);
1427 }
1428 }
1429
1430 desc->mSections = sections;
1431
1432 for (size_t i = 0; i < tagArray.size(); ++i) {
1433 uint32_t tag = tagArray[i];
1434 String8 sectionString = tagToSectionMap.valueFor(tag);
1435
1436 // Set up tag to section index map
1437 ssize_t index = sections.indexOf(sectionString);
1438 LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
1439 desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
1440
1441 // Set up reverse mapping
1442 ssize_t reverseIndex = -1;
1443 if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
1444 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
1445 reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
1446 }
1447 desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
1448 }
1449
1450 descriptor = std::move(desc);
1451 return OK;
1452 }
1453
getCameraCharacteristicsLocked(const std::string & id,CameraMetadata * characteristics) const1454 status_t CameraProviderManager::getCameraCharacteristicsLocked(const std::string &id,
1455 CameraMetadata* characteristics) const {
1456 auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
1457 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
1458
1459 return deviceInfo->getCameraCharacteristics(characteristics);
1460 }
1461
filterLogicalCameraIdsLocked(std::vector<std::string> & deviceIds) const1462 void CameraProviderManager::filterLogicalCameraIdsLocked(
1463 std::vector<std::string>& deviceIds) const
1464 {
1465 std::unordered_set<std::string> removedIds;
1466
1467 for (auto& deviceId : deviceIds) {
1468 CameraMetadata info;
1469 status_t res = getCameraCharacteristicsLocked(deviceId, &info);
1470 if (res != OK) {
1471 ALOGE("%s: Failed to getCameraCharacteristics for id %s", __FUNCTION__,
1472 deviceId.c_str());
1473 return;
1474 }
1475
1476 // idCombo contains the ids of a logical camera and its physical cameras
1477 std::vector<std::string> idCombo;
1478 bool logicalCamera = CameraProviderManager::isLogicalCamera(info, &idCombo);
1479 if (!logicalCamera) {
1480 continue;
1481 }
1482 idCombo.push_back(deviceId);
1483
1484 for (auto& id : deviceIds) {
1485 auto foundId = std::find(idCombo.begin(), idCombo.end(), id);
1486 if (foundId == idCombo.end()) {
1487 continue;
1488 }
1489
1490 idCombo.erase(foundId);
1491 removedIds.insert(idCombo.begin(), idCombo.end());
1492 break;
1493 }
1494 }
1495
1496 deviceIds.erase(std::remove_if(deviceIds.begin(), deviceIds.end(),
1497 [&removedIds](const std::string& s) {return removedIds.find(s) != removedIds.end();}),
1498 deviceIds.end());
1499 }
1500
1501 } // namespace android
1502