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 31namespace android { 32 33using namespace ::android::hardware::camera; 34using namespace ::android::hardware::camera::common::V1_0; 35 36namespace { 37// Hardcoded name for the passthrough HAL implementation, since it can't be discovered via the 38// service manager 39const std::string kLegacyProviderName("legacy/0"); 40const std::string kExternalProviderName("external/0"); 41 42} // anonymous namespace 43 44CameraProviderManager::HardwareServiceInteractionProxy 45CameraProviderManager::sHardwareServiceInteractionProxy{}; 46 47CameraProviderManager::~CameraProviderManager() { 48} 49 50status_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 77int 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 86std::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 97std::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 131bool 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 136bool 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 147bool 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 156status_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 167status_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 177status_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 183status_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 206bool 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 228status_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 237status_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 279status_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 309status_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 335hardware::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 353status_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 362CameraProviderManager::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 376metadata_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 395bool 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 426status_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 460status_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 492sp<CameraProviderManager::StatusListener> CameraProviderManager::getStatusListener() const { 493 return mListener.promote(); 494} 495 496/**** Methods for ProviderInfo ****/ 497 498 499CameraProviderManager::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 511status_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 584const std::string& CameraProviderManager::ProviderInfo::getType() const { 585 return mType; 586} 587 588status_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 643void 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 658status_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 712hardware::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 756hardware::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 787void 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 798template<class DeviceInfoT> 799std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo> 800 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 837template<class InterfaceT> 838sp<InterfaceT> 839CameraProviderManager::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 845template<> 846sp<device::V1_0::ICameraDevice> 847CameraProviderManager::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 870template<> 871sp<device::V3_2::ICameraDevice> 872CameraProviderManager::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 895CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {} 896 897template<class InterfaceT> 898status_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 904CameraProviderManager::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; 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 947CameraProviderManager::ProviderInfo::DeviceInfo1::~DeviceInfo1() {} 948 949status_t CameraProviderManager::ProviderInfo::DeviceInfo1::setTorchMode(bool enabled) { 950 return DeviceInfo::setTorchMode(mInterface, enabled); 951} 952 953status_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 992status_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 1003CameraProviderManager::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, 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 1052CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {} 1053 1054status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) { 1055 return DeviceInfo::setTorchMode(mInterface, enabled); 1056} 1057 1058status_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} 1091bool 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 1106status_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 1117status_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 1125status_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 1173metadata_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 1184status_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 1287CameraProviderManager::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 1293status_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 1316const 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 1339const 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 1352const 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 1366status_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 1454status_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 1462void 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