CameraProviderManager.cpp revision 4c5b1c777680df26af1d28624b99f8388fb9df4c
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 <chrono> 24#include <android/hidl/manager/1.0/IServiceManager.h> 25#include <hidl/ServiceManagement.h> 26 27namespace android { 28 29using namespace ::android::hardware::camera; 30using namespace ::android::hardware::camera::common::V1_0; 31 32namespace { 33// Hardcoded name for the passthrough HAL implementation, since it can't be discovered via the 34// service manager 35const std::string kLegacyProviderName("legacy/0"); 36 37// Slash-separated list of provider types to consider for use via the old camera API 38const std::string kStandardProviderTypes("internal/legacy"); 39 40} // anonymous namespace 41 42CameraProviderManager::HardwareServiceInteractionProxy 43CameraProviderManager::sHardwareServiceInteractionProxy{}; 44 45CameraProviderManager::~CameraProviderManager() { 46} 47 48status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener, 49 ServiceInteractionProxy* proxy) { 50 std::lock_guard<std::mutex> lock(mInterfaceMutex); 51 if (proxy == nullptr) { 52 ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__); 53 return BAD_VALUE; 54 } 55 mListener = listener; 56 mServiceProxy = proxy; 57 58 // Registering will trigger notifications for all already-known providers 59 bool success = mServiceProxy->registerForNotifications( 60 /* instance name, empty means no filter */ "", 61 this); 62 if (!success) { 63 ALOGE("%s: Unable to register with hardware service manager for notifications " 64 "about camera providers", __FUNCTION__); 65 return INVALID_OPERATION; 66 } 67 // See if there's a passthrough HAL, but let's not complain if there's not 68 addProvider(kLegacyProviderName, /*expected*/ false); 69 return OK; 70} 71 72int CameraProviderManager::getCameraCount() const { 73 std::lock_guard<std::mutex> lock(mInterfaceMutex); 74 int count = 0; 75 for (auto& provider : mProviders) { 76 count += provider->mDevices.size(); 77 } 78 return count; 79} 80 81int CameraProviderManager::getStandardCameraCount() const { 82 std::lock_guard<std::mutex> lock(mInterfaceMutex); 83 int count = 0; 84 for (auto& provider : mProviders) { 85 if (kStandardProviderTypes.find(provider->getType()) != std::string::npos) { 86 count += provider->mDevices.size(); 87 } 88 } 89 return count; 90} 91 92std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const { 93 std::lock_guard<std::mutex> lock(mInterfaceMutex); 94 std::vector<std::string> deviceIds; 95 for (auto& provider : mProviders) { 96 for (auto& deviceInfo : provider->mDevices) { 97 deviceIds.push_back(deviceInfo->mId); 98 } 99 } 100 return deviceIds; 101} 102 103bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const { 104 std::lock_guard<std::mutex> lock(mInterfaceMutex); 105 return isValidDeviceLocked(id, majorVersion); 106} 107 108bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const { 109 for (auto& provider : mProviders) { 110 for (auto& deviceInfo : provider->mDevices) { 111 if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) { 112 return true; 113 } 114 } 115 } 116 return false; 117} 118 119bool CameraProviderManager::hasFlashUnit(const std::string &id) const { 120 std::lock_guard<std::mutex> lock(mInterfaceMutex); 121 122 auto deviceInfo = findDeviceInfoLocked(id); 123 if (deviceInfo == nullptr) return false; 124 125 return deviceInfo->hasFlashUnit(); 126} 127 128status_t CameraProviderManager::getResourceCost(const std::string &id, 129 CameraResourceCost* cost) const { 130 std::lock_guard<std::mutex> lock(mInterfaceMutex); 131 132 auto deviceInfo = findDeviceInfoLocked(id); 133 if (deviceInfo == nullptr) return NAME_NOT_FOUND; 134 135 *cost = deviceInfo->mResourceCost; 136 return OK; 137} 138 139status_t CameraProviderManager::getCameraInfo(const std::string &id, 140 hardware::CameraInfo* info) const { 141 std::lock_guard<std::mutex> lock(mInterfaceMutex); 142 143 auto deviceInfo = findDeviceInfoLocked(id); 144 if (deviceInfo == nullptr) return NAME_NOT_FOUND; 145 146 return deviceInfo->getCameraInfo(info); 147} 148 149status_t CameraProviderManager::getCameraCharacteristics(const std::string &id, 150 CameraMetadata* characteristics) const { 151 std::lock_guard<std::mutex> lock(mInterfaceMutex); 152 153 auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {4,0}); 154 if (deviceInfo == nullptr) return NAME_NOT_FOUND; 155 156 return deviceInfo->getCameraCharacteristics(characteristics); 157} 158 159status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id, 160 hardware::hidl_version *v) { 161 std::lock_guard<std::mutex> lock(mInterfaceMutex); 162 163 hardware::hidl_version maxVersion{0,0}; 164 bool found = false; 165 for (auto& provider : mProviders) { 166 for (auto& deviceInfo : provider->mDevices) { 167 if (deviceInfo->mId == id) { 168 if (deviceInfo->mVersion > maxVersion) { 169 maxVersion = deviceInfo->mVersion; 170 found = true; 171 } 172 } 173 } 174 } 175 if (!found) { 176 return NAME_NOT_FOUND; 177 } 178 *v = maxVersion; 179 return OK; 180} 181 182status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) { 183 std::lock_guard<std::mutex> lock(mInterfaceMutex); 184 185 auto deviceInfo = findDeviceInfoLocked(id); 186 if (deviceInfo == nullptr) return NAME_NOT_FOUND; 187 188 return deviceInfo->setTorchMode(enabled); 189} 190 191status_t CameraProviderManager::setUpVendorTags() { 192 // TODO (b/34275821): support aggregating vendor tags for more than one provider 193 for (auto& provider : mProviders) { 194 hardware::hidl_vec<VendorTagSection> vts; 195 Status status; 196 provider->mInterface->getVendorTags( 197 [&](auto s, const auto& vendorTagSecs) { 198 status = s; 199 if (s == Status::OK) { 200 vts = vendorTagSecs; 201 } 202 }); 203 204 if (status != Status::OK) { 205 return mapToStatusT(status); 206 } 207 208 VendorTagDescriptor::clearGlobalVendorTagDescriptor(); 209 210 // Read all vendor tag definitions into a descriptor 211 sp<VendorTagDescriptor> desc; 212 status_t res; 213 if ((res = HidlVendorTagDescriptor::createDescriptorFromHidl(vts, /*out*/desc)) 214 != OK) { 215 ALOGE("%s: Could not generate descriptor from vendor tag operations," 216 "received error %s (%d). Camera clients will not be able to use" 217 "vendor tags", __FUNCTION__, strerror(res), res); 218 return res; 219 } 220 221 // Set the global descriptor to use with camera metadata 222 VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc); 223 } 224 return OK; 225} 226 227status_t CameraProviderManager::openSession(const std::string &id, 228 const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback, 229 /*out*/ 230 sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session) { 231 232 std::lock_guard<std::mutex> lock(mInterfaceMutex); 233 234 auto deviceInfo = findDeviceInfoLocked(id, 235 /*minVersion*/ {3,0}, /*maxVersion*/ {4,0}); 236 if (deviceInfo == nullptr) return NAME_NOT_FOUND; 237 238 auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo); 239 240 Status status; 241 deviceInfo3->mInterface->open(callback, [&status, &session] 242 (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) { 243 status = s; 244 if (status == Status::OK) { 245 *session = cameraSession; 246 } 247 }); 248 return mapToStatusT(status); 249} 250 251status_t CameraProviderManager::openSession(const std::string &id, 252 const sp<hardware::camera::device::V1_0::ICameraDeviceCallback>& callback, 253 /*out*/ 254 sp<hardware::camera::device::V1_0::ICameraDevice> *session) { 255 256 std::lock_guard<std::mutex> lock(mInterfaceMutex); 257 258 auto deviceInfo = findDeviceInfoLocked(id, 259 /*minVersion*/ {1,0}, /*maxVersion*/ {2,0}); 260 if (deviceInfo == nullptr) return NAME_NOT_FOUND; 261 262 auto *deviceInfo1 = static_cast<ProviderInfo::DeviceInfo1*>(deviceInfo); 263 264 Status status = deviceInfo1->mInterface->open(callback); 265 if (status == Status::OK) { 266 *session = deviceInfo1->mInterface; 267 } 268 return mapToStatusT(status); 269} 270 271 272hardware::Return<void> CameraProviderManager::onRegistration( 273 const hardware::hidl_string& /*fqName*/, 274 const hardware::hidl_string& name, 275 bool /*preexisting*/) { 276 std::lock_guard<std::mutex> lock(mInterfaceMutex); 277 278 addProvider(name); 279 return hardware::Return<void>(); 280} 281 282status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) { 283 std::lock_guard<std::mutex> lock(mInterfaceMutex); 284 285 dprintf(fd, "Available camera providers and devices:\n"); 286 for (auto& provider : mProviders) { 287 provider->dump(fd, args); 288 } 289 return OK; 290} 291 292CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked( 293 const std::string& id, 294 hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const { 295 for (auto& provider : mProviders) { 296 for (auto& deviceInfo : provider->mDevices) { 297 if (deviceInfo->mId == id && 298 minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) { 299 return deviceInfo.get(); 300 } 301 } 302 } 303 return nullptr; 304} 305 306 307status_t CameraProviderManager::addProvider(const std::string& newProvider, bool expected) { 308 for (const auto& providerInfo : mProviders) { 309 if (providerInfo->mProviderName == newProvider) { 310 ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__, 311 newProvider.c_str()); 312 return ALREADY_EXISTS; 313 } 314 } 315 sp<provider::V2_4::ICameraProvider> interface = 316 mServiceProxy->getService(newProvider); 317 318 if (interface == nullptr) { 319 ALOGW("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__, 320 newProvider.c_str()); 321 if (expected) { 322 return BAD_VALUE; 323 } else { 324 return OK; 325 } 326 } 327 328 sp<ProviderInfo> providerInfo = 329 new ProviderInfo(newProvider, interface, this); 330 status_t res = providerInfo->initialize(); 331 if (res != OK) { 332 return res; 333 } 334 335 mProviders.push_back(providerInfo); 336 337 return OK; 338} 339 340status_t CameraProviderManager::removeProvider(const std::string& provider) { 341 for (auto it = mProviders.begin(); it != mProviders.end(); it++) { 342 if ((*it)->mProviderName == provider) { 343 mProviders.erase(it); 344 return OK; 345 } 346 } 347 ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__, 348 provider.c_str()); 349 return NAME_NOT_FOUND; 350} 351 352/**** Methods for ProviderInfo ****/ 353 354 355CameraProviderManager::ProviderInfo::ProviderInfo( 356 const std::string &providerName, 357 sp<provider::V2_4::ICameraProvider>& interface, 358 CameraProviderManager *manager) : 359 mProviderName(providerName), 360 mInterface(interface), 361 mManager(manager) { 362 (void) mManager; 363} 364 365status_t CameraProviderManager::ProviderInfo::initialize() { 366 status_t res = parseProviderName(mProviderName, &mType, &mId); 367 if (res != OK) { 368 ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__); 369 return BAD_VALUE; 370 } 371 ALOGI("Connecting to new camera provider: %s, isRemote? %d", 372 mProviderName.c_str(), mInterface->isRemote()); 373 Status status = mInterface->setCallback(this); 374 if (status != Status::OK) { 375 ALOGE("%s: Unable to register callbacks with camera provider '%s'", 376 __FUNCTION__, mProviderName.c_str()); 377 return mapToStatusT(status); 378 } 379 // TODO: Register for hw binder death notifications as well 380 381 // Get initial list of camera devices, if any 382 std::vector<std::string> devices; 383 mInterface->getCameraIdList([&status, &devices]( 384 Status idStatus, 385 const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) { 386 status = idStatus; 387 if (status == Status::OK) { 388 for (size_t i = 0; i < cameraDeviceNames.size(); i++) { 389 devices.push_back(cameraDeviceNames[i]); 390 } 391 } }); 392 393 if (status != Status::OK) { 394 ALOGE("%s: Unable to query for camera devices from provider '%s'", 395 __FUNCTION__, mProviderName.c_str()); 396 return mapToStatusT(status); 397 } 398 399 for (auto& device : devices) { 400 status_t res = addDevice(device); 401 if (res != OK) { 402 ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)", 403 __FUNCTION__, device.c_str(), strerror(-res), res); 404 } 405 } 406 407 ALOGI("Camera provider %s ready with %zu camera devices", 408 mProviderName.c_str(), mDevices.size()); 409 410 return OK; 411} 412 413const std::string& CameraProviderManager::ProviderInfo::getType() const { 414 return mType; 415} 416 417status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name, 418 CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) { 419 420 ALOGI("Enumerating new camera device: %s", name.c_str()); 421 422 uint16_t major, minor; 423 std::string type, id; 424 425 status_t res = parseDeviceName(name, &major, &minor, &type, &id); 426 if (res != OK) { 427 return res; 428 } 429 if (type != mType) { 430 ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__, 431 type.c_str(), mType.c_str()); 432 return BAD_VALUE; 433 } 434 if (mManager->isValidDeviceLocked(id, major)) { 435 ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__, 436 name.c_str(), id.c_str(), major); 437 return BAD_VALUE; 438 } 439 440 std::unique_ptr<DeviceInfo> deviceInfo; 441 switch (major) { 442 case 1: 443 deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, id, minor); 444 break; 445 case 3: 446 deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, id, minor); 447 break; 448 default: 449 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__, 450 name.c_str(), major); 451 return BAD_VALUE; 452 } 453 if (deviceInfo == nullptr) return BAD_VALUE; 454 deviceInfo->mStatus = initialStatus; 455 456 mDevices.push_back(std::move(deviceInfo)); 457 458 if (parsedId != nullptr) { 459 *parsedId = id; 460 } 461 return OK; 462} 463 464status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const { 465 dprintf(fd, " %s: %zu devices:\n", mProviderName.c_str(), mDevices.size()); 466 467 for (auto& device : mDevices) { 468 dprintf(fd, " %s: Resource cost: %d\n", device->mName.c_str(), 469 device->mResourceCost.resourceCost); 470 if (device->mResourceCost.conflictingDevices.size() > 0) { 471 dprintf(fd, " Conflicting devices:\n"); 472 for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) { 473 dprintf(fd, " %s\n", 474 device->mResourceCost.conflictingDevices[i].c_str()); 475 } 476 } 477 } 478 return OK; 479} 480 481hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusChange( 482 const hardware::hidl_string& cameraDeviceName, 483 CameraDeviceStatus newStatus) { 484 sp<StatusListener> listener; 485 std::string id; 486 { 487 std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex); 488 bool known = false; 489 for (auto& deviceInfo : mDevices) { 490 if (deviceInfo->mName == cameraDeviceName) { 491 ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(), 492 deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus)); 493 deviceInfo->mStatus = newStatus; 494 // TODO: Handle device removal (NOT_PRESENT) 495 id = deviceInfo->mId; 496 known = true; 497 break; 498 } 499 } 500 // Previously unseen device; status must not be NOT_PRESENT 501 if (!known) { 502 if (newStatus == CameraDeviceStatus::NOT_PRESENT) { 503 ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.", 504 mProviderName.c_str(), cameraDeviceName.c_str()); 505 return hardware::Void(); 506 } 507 addDevice(cameraDeviceName, newStatus, &id); 508 } 509 listener = mManager->mListener.promote(); 510 } 511 // Call without lock held to allow reentrancy into provider manager 512 if (listener != nullptr) { 513 listener->onDeviceStatusChanged(String8(id.c_str()), newStatus); 514 } 515 return hardware::Void(); 516} 517 518hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange( 519 const hardware::hidl_string& cameraDeviceName, 520 TorchModeStatus newStatus) { 521 sp<StatusListener> listener; 522 std::string id; 523 { 524 std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex); 525 bool known = false; 526 for (auto& deviceInfo : mDevices) { 527 if (deviceInfo->mName == cameraDeviceName) { 528 ALOGI("Camera device %s torch status is now %s", cameraDeviceName.c_str(), 529 torchStatusToString(newStatus)); 530 id = deviceInfo->mId; 531 known = true; 532 break; 533 } 534 } 535 if (!known) { 536 ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.", 537 mProviderName.c_str(), cameraDeviceName.c_str(), newStatus); 538 return hardware::Void(); 539 } 540 listener = mManager->mListener.promote(); 541 } 542 // Call without lock held to allow reentrancy into provider manager 543 if (listener != nullptr) { 544 listener->onTorchStatusChanged(String8(id.c_str()), newStatus); 545 } 546 return hardware::Void(); 547} 548 549 550template<class DeviceInfoT> 551std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo> 552 CameraProviderManager::ProviderInfo::initializeDeviceInfo( 553 const std::string &name, 554 const std::string &id, uint16_t minorVersion) const { 555 Status status; 556 557 auto cameraInterface = 558 getDeviceInterface<typename DeviceInfoT::InterfaceT>(name); 559 if (cameraInterface == nullptr) return nullptr; 560 561 CameraResourceCost resourceCost; 562 cameraInterface->getResourceCost([&status, &resourceCost]( 563 Status s, CameraResourceCost cost) { 564 status = s; 565 resourceCost = cost; 566 }); 567 if (status != Status::OK) { 568 ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__, 569 name.c_str(), statusToString(status)); 570 return nullptr; 571 } 572 return std::unique_ptr<DeviceInfo>( 573 new DeviceInfoT(name, id, minorVersion, resourceCost, cameraInterface)); 574} 575 576template<class InterfaceT> 577sp<InterfaceT> 578CameraProviderManager::ProviderInfo::getDeviceInterface(const std::string &name) const { 579 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__, 580 name.c_str(), InterfaceT::version.get_major()); 581 return nullptr; 582} 583 584template<> 585sp<device::V1_0::ICameraDevice> 586CameraProviderManager::ProviderInfo::getDeviceInterface 587 <device::V1_0::ICameraDevice>(const std::string &name) const { 588 Status status; 589 sp<device::V1_0::ICameraDevice> cameraInterface; 590 mInterface->getCameraDeviceInterface_V1_x(name, [&status, &cameraInterface]( 591 Status s, sp<device::V1_0::ICameraDevice> interface) { 592 status = s; 593 cameraInterface = interface; 594 }); 595 if (status != Status::OK) { 596 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__, 597 name.c_str(), statusToString(status)); 598 return nullptr; 599 } 600 return cameraInterface; 601} 602 603template<> 604sp<device::V3_2::ICameraDevice> 605CameraProviderManager::ProviderInfo::getDeviceInterface 606 <device::V3_2::ICameraDevice>(const std::string &name) const { 607 Status status; 608 sp<device::V3_2::ICameraDevice> cameraInterface; 609 mInterface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface]( 610 Status s, sp<device::V3_2::ICameraDevice> interface) { 611 status = s; 612 cameraInterface = interface; 613 }); 614 if (status != Status::OK) { 615 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__, 616 name.c_str(), statusToString(status)); 617 return nullptr; 618 } 619 return cameraInterface; 620} 621 622CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {} 623 624template<class InterfaceT> 625status_t CameraProviderManager::ProviderInfo::DeviceInfo::setTorchMode(InterfaceT& interface, 626 bool enabled) { 627 Status s = interface->setTorchMode(enabled ? TorchMode::ON : TorchMode::OFF); 628 return mapToStatusT(s); 629} 630 631CameraProviderManager::ProviderInfo::DeviceInfo1::DeviceInfo1(const std::string& name, 632 const std::string &id, 633 uint16_t minorVersion, 634 const CameraResourceCost& resourceCost, 635 sp<InterfaceT> interface) : 636 DeviceInfo(name, id, hardware::hidl_version{1, minorVersion}, resourceCost), 637 mInterface(interface) { 638 // Get default parameters and initialize flash unit availability 639 // Requires powering on the camera device 640 Status status = mInterface->open(nullptr); 641 if (status != Status::OK) { 642 ALOGE("%s: Unable to open camera device %s to check for a flash unit: %s (%d)", __FUNCTION__, 643 mId.c_str(), CameraProviderManager::statusToString(status), status); 644 return; 645 } 646 mInterface->getParameters([this](const hardware::hidl_string& parms) { 647 mDefaultParameters.unflatten(String8(parms.c_str())); 648 }); 649 650 const char *flashMode = 651 mDefaultParameters.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES); 652 if (flashMode && strstr(flashMode, CameraParameters::FLASH_MODE_TORCH)) { 653 mHasFlashUnit = true; 654 } else { 655 mHasFlashUnit = false; 656 } 657 658 mInterface->close(); 659} 660 661CameraProviderManager::ProviderInfo::DeviceInfo1::~DeviceInfo1() {} 662 663status_t CameraProviderManager::ProviderInfo::DeviceInfo1::setTorchMode(bool enabled) { 664 return DeviceInfo::setTorchMode(mInterface, enabled); 665} 666 667status_t CameraProviderManager::ProviderInfo::DeviceInfo1::getCameraInfo( 668 hardware::CameraInfo *info) const { 669 if (info == nullptr) return BAD_VALUE; 670 671 Status status; 672 device::V1_0::CameraInfo cInfo; 673 mInterface->getCameraInfo([&status, &cInfo](Status s, device::V1_0::CameraInfo camInfo) { 674 status = s; 675 cInfo = camInfo; 676 }); 677 if (status != Status::OK) { 678 return mapToStatusT(status); 679 } 680 681 switch(cInfo.facing) { 682 case device::V1_0::CameraFacing::BACK: 683 info->facing = hardware::CAMERA_FACING_BACK; 684 break; 685 case device::V1_0::CameraFacing::EXTERNAL: 686 // Map external to front for legacy API 687 case device::V1_0::CameraFacing::FRONT: 688 info->facing = hardware::CAMERA_FACING_FRONT; 689 break; 690 default: 691 ALOGW("%s: Unknown camera facing: %d", __FUNCTION__, cInfo.facing); 692 info->facing = hardware::CAMERA_FACING_BACK; 693 } 694 info->orientation = cInfo.orientation; 695 696 return OK; 697} 698 699CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name, 700 const std::string &id, 701 uint16_t minorVersion, 702 const CameraResourceCost& resourceCost, 703 sp<InterfaceT> interface) : 704 DeviceInfo(name, id, hardware::hidl_version{3, minorVersion}, resourceCost), 705 mInterface(interface) { 706 // Get camera characteristics and initialize flash unit availability 707 Status status; 708 mInterface->getCameraCharacteristics([&status, this](Status s, 709 device::V3_2::CameraMetadata metadata) { 710 status = s; 711 if (s == Status::OK) { 712 camera_metadata_t *buffer = 713 reinterpret_cast<camera_metadata_t*>(metadata.data()); 714 mCameraCharacteristics = buffer; 715 } 716 }); 717 if (status != Status::OK) { 718 ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)", 719 __FUNCTION__, mId.c_str(), CameraProviderManager::statusToString(status), status); 720 return; 721 } 722 camera_metadata_entry flashAvailable = 723 mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE); 724 if (flashAvailable.count == 1 && 725 flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) { 726 mHasFlashUnit = true; 727 } else { 728 mHasFlashUnit = false; 729 } 730} 731 732CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {} 733 734status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) { 735 return DeviceInfo::setTorchMode(mInterface, enabled); 736} 737 738status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo( 739 hardware::CameraInfo *info) const { 740 if (info == nullptr) return BAD_VALUE; 741 742 camera_metadata_ro_entry facing = 743 mCameraCharacteristics.find(ANDROID_LENS_FACING); 744 if (facing.count == 1) { 745 switch (facing.data.u8[0]) { 746 case ANDROID_LENS_FACING_BACK: 747 info->facing = hardware::CAMERA_FACING_BACK; 748 break; 749 case ANDROID_LENS_FACING_EXTERNAL: 750 // Map external to front for legacy API 751 case ANDROID_LENS_FACING_FRONT: 752 info->facing = hardware::CAMERA_FACING_FRONT; 753 break; 754 } 755 } else { 756 ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__); 757 return NAME_NOT_FOUND; 758 } 759 760 camera_metadata_ro_entry orientation = 761 mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION); 762 if (orientation.count == 1) { 763 info->orientation = orientation.data.i32[0]; 764 } else { 765 ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__); 766 return NAME_NOT_FOUND; 767 } 768 769 return OK; 770} 771 772status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics( 773 CameraMetadata *characteristics) const { 774 if (characteristics == nullptr) return BAD_VALUE; 775 776 *characteristics = mCameraCharacteristics; 777 return OK; 778} 779 780status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name, 781 std::string *type, uint32_t *id) { 782 // Format must be "<type>/<id>" 783#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \ 784 "Should match '<type>/<id>' - " 785 786 if (!type || !id) return INVALID_OPERATION; 787 788 std::string::size_type slashIdx = name.find('/'); 789 if (slashIdx == std::string::npos || slashIdx == name.size() - 1) { 790 ALOGE(ERROR_MSG_PREFIX 791 "does not have / separator between type and id", 792 __FUNCTION__, name.c_str()); 793 return BAD_VALUE; 794 } 795 796 std::string typeVal = name.substr(0, slashIdx); 797 798 char *endPtr; 799 errno = 0; 800 long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10); 801 if (errno != 0) { 802 ALOGE(ERROR_MSG_PREFIX 803 "cannot parse provider id as an integer: %s (%d)", 804 __FUNCTION__, name.c_str(), strerror(errno), errno); 805 return BAD_VALUE; 806 } 807 if (endPtr != name.c_str() + name.size()) { 808 ALOGE(ERROR_MSG_PREFIX 809 "provider id has unexpected length", 810 __FUNCTION__, name.c_str()); 811 return BAD_VALUE; 812 } 813 if (idVal < 0) { 814 ALOGE(ERROR_MSG_PREFIX 815 "id is negative: %ld", 816 __FUNCTION__, name.c_str(), idVal); 817 return BAD_VALUE; 818 } 819 820#undef ERROR_MSG_PREFIX 821 822 *type = typeVal; 823 *id = static_cast<uint32_t>(idVal); 824 825 return OK; 826} 827 828status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name, 829 uint16_t *major, uint16_t *minor, std::string *type, std::string *id) { 830 831 // Format must be "device@<major>.<minor>/<type>/<id>" 832 833#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \ 834 "Should match 'device@<major>.<minor>/<type>/<id>' - " 835 836 if (!major || !minor || !type || !id) return INVALID_OPERATION; 837 838 // Verify starting prefix 839 const char expectedPrefix[] = "device@"; 840 841 if (name.find(expectedPrefix) != 0) { 842 ALOGE(ERROR_MSG_PREFIX 843 "does not start with '%s'", 844 __FUNCTION__, name.c_str(), expectedPrefix); 845 return BAD_VALUE; 846 } 847 848 // Extract major/minor versions 849 constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2; 850 std::string::size_type dotIdx = name.find('.', atIdx); 851 if (dotIdx == std::string::npos) { 852 ALOGE(ERROR_MSG_PREFIX 853 "does not have @<major>. version section", 854 __FUNCTION__, name.c_str()); 855 return BAD_VALUE; 856 } 857 std::string::size_type typeSlashIdx = name.find('/', dotIdx); 858 if (typeSlashIdx == std::string::npos) { 859 ALOGE(ERROR_MSG_PREFIX 860 "does not have .<minor>/ version section", 861 __FUNCTION__, name.c_str()); 862 return BAD_VALUE; 863 } 864 865 char *endPtr; 866 errno = 0; 867 long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10); 868 if (errno != 0) { 869 ALOGE(ERROR_MSG_PREFIX 870 "cannot parse major version: %s (%d)", 871 __FUNCTION__, name.c_str(), strerror(errno), errno); 872 return BAD_VALUE; 873 } 874 if (endPtr != name.c_str() + dotIdx) { 875 ALOGE(ERROR_MSG_PREFIX 876 "major version has unexpected length", 877 __FUNCTION__, name.c_str()); 878 return BAD_VALUE; 879 } 880 long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10); 881 if (errno != 0) { 882 ALOGE(ERROR_MSG_PREFIX 883 "cannot parse minor version: %s (%d)", 884 __FUNCTION__, name.c_str(), strerror(errno), errno); 885 return BAD_VALUE; 886 } 887 if (endPtr != name.c_str() + typeSlashIdx) { 888 ALOGE(ERROR_MSG_PREFIX 889 "minor version has unexpected length", 890 __FUNCTION__, name.c_str()); 891 return BAD_VALUE; 892 } 893 if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) { 894 ALOGE(ERROR_MSG_PREFIX 895 "major/minor version is out of range of uint16_t: %ld.%ld", 896 __FUNCTION__, name.c_str(), majorVal, minorVal); 897 return BAD_VALUE; 898 } 899 900 // Extract type and id 901 902 std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1); 903 if (instanceSlashIdx == std::string::npos) { 904 ALOGE(ERROR_MSG_PREFIX 905 "does not have /<type>/ component", 906 __FUNCTION__, name.c_str()); 907 return BAD_VALUE; 908 } 909 std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1); 910 911 if (instanceSlashIdx == name.size() - 1) { 912 ALOGE(ERROR_MSG_PREFIX 913 "does not have an /<id> component", 914 __FUNCTION__, name.c_str()); 915 return BAD_VALUE; 916 } 917 std::string idVal = name.substr(instanceSlashIdx + 1); 918 919#undef ERROR_MSG_PREFIX 920 921 *major = static_cast<uint16_t>(majorVal); 922 *minor = static_cast<uint16_t>(minorVal); 923 *type = typeVal; 924 *id = idVal; 925 926 return OK; 927} 928 929 930 931CameraProviderManager::ProviderInfo::~ProviderInfo() { 932 // Destruction of ProviderInfo is only supposed to happen when the respective 933 // CameraProvider interface dies, so do not unregister callbacks. 934 935} 936 937status_t CameraProviderManager::mapToStatusT(const Status& s) { 938 switch(s) { 939 case Status::OK: 940 return OK; 941 case Status::ILLEGAL_ARGUMENT: 942 return BAD_VALUE; 943 case Status::CAMERA_IN_USE: 944 return -EBUSY; 945 case Status::MAX_CAMERAS_IN_USE: 946 return -EUSERS; 947 case Status::METHOD_NOT_SUPPORTED: 948 return UNKNOWN_TRANSACTION; 949 case Status::OPERATION_NOT_SUPPORTED: 950 return INVALID_OPERATION; 951 case Status::CAMERA_DISCONNECTED: 952 return DEAD_OBJECT; 953 case Status::INTERNAL_ERROR: 954 return INVALID_OPERATION; 955 } 956 ALOGW("Unexpected HAL status code %d", s); 957 return INVALID_OPERATION; 958} 959 960const char* CameraProviderManager::statusToString(const Status& s) { 961 switch(s) { 962 case Status::OK: 963 return "OK"; 964 case Status::ILLEGAL_ARGUMENT: 965 return "ILLEGAL_ARGUMENT"; 966 case Status::CAMERA_IN_USE: 967 return "CAMERA_IN_USE"; 968 case Status::MAX_CAMERAS_IN_USE: 969 return "MAX_CAMERAS_IN_USE"; 970 case Status::METHOD_NOT_SUPPORTED: 971 return "METHOD_NOT_SUPPORTED"; 972 case Status::OPERATION_NOT_SUPPORTED: 973 return "OPERATION_NOT_SUPPORTED"; 974 case Status::CAMERA_DISCONNECTED: 975 return "CAMERA_DISCONNECTED"; 976 case Status::INTERNAL_ERROR: 977 return "INTERNAL_ERROR"; 978 } 979 ALOGW("Unexpected HAL status code %d", s); 980 return "UNKNOWN_ERROR"; 981} 982 983const char* CameraProviderManager::deviceStatusToString(const CameraDeviceStatus& s) { 984 switch(s) { 985 case CameraDeviceStatus::NOT_PRESENT: 986 return "NOT_PRESENT"; 987 case CameraDeviceStatus::PRESENT: 988 return "PRESENT"; 989 case CameraDeviceStatus::ENUMERATING: 990 return "ENUMERATING"; 991 } 992 ALOGW("Unexpected HAL device status code %d", s); 993 return "UNKNOWN_STATUS"; 994} 995 996const char* CameraProviderManager::torchStatusToString(const TorchModeStatus& s) { 997 switch(s) { 998 case TorchModeStatus::NOT_AVAILABLE: 999 return "NOT_AVAILABLE"; 1000 case TorchModeStatus::AVAILABLE_OFF: 1001 return "AVAILABLE_OFF"; 1002 case TorchModeStatus::AVAILABLE_ON: 1003 return "AVAILABLE_ON"; 1004 } 1005 ALOGW("Unexpected HAL torch mode status code %d", s); 1006 return "UNKNOWN_STATUS"; 1007} 1008 1009 1010status_t HidlVendorTagDescriptor::createDescriptorFromHidl( 1011 const hardware::hidl_vec<hardware::camera::common::V1_0::VendorTagSection>& vts, 1012 /*out*/ 1013 sp<VendorTagDescriptor>& descriptor) { 1014 1015 int tagCount = 0; 1016 1017 for (size_t s = 0; s < vts.size(); s++) { 1018 tagCount += vts[s].tags.size(); 1019 } 1020 1021 if (tagCount < 0 || tagCount > INT32_MAX) { 1022 ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount); 1023 return BAD_VALUE; 1024 } 1025 1026 Vector<uint32_t> tagArray; 1027 LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount, 1028 "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount); 1029 1030 1031 sp<HidlVendorTagDescriptor> desc = new HidlVendorTagDescriptor(); 1032 desc->mTagCount = tagCount; 1033 1034 SortedVector<String8> sections; 1035 KeyedVector<uint32_t, String8> tagToSectionMap; 1036 1037 int idx = 0; 1038 for (size_t s = 0; s < vts.size(); s++) { 1039 const hardware::camera::common::V1_0::VendorTagSection& section = vts[s]; 1040 const char *sectionName = section.sectionName.c_str(); 1041 if (sectionName == NULL) { 1042 ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s); 1043 return BAD_VALUE; 1044 } 1045 String8 sectionString(sectionName); 1046 sections.add(sectionString); 1047 1048 for (size_t j = 0; j < section.tags.size(); j++) { 1049 uint32_t tag = section.tags[j].tagId; 1050 if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) { 1051 ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag); 1052 return BAD_VALUE; 1053 } 1054 1055 tagArray.editItemAt(idx++) = section.tags[j].tagId; 1056 1057 const char *tagName = section.tags[j].tagName.c_str(); 1058 if (tagName == NULL) { 1059 ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag); 1060 return BAD_VALUE; 1061 } 1062 desc->mTagToNameMap.add(tag, String8(tagName)); 1063 tagToSectionMap.add(tag, sectionString); 1064 1065 int tagType = (int) section.tags[j].tagType; 1066 if (tagType < 0 || tagType >= NUM_TYPES) { 1067 ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType); 1068 return BAD_VALUE; 1069 } 1070 desc->mTagToTypeMap.add(tag, tagType); 1071 } 1072 } 1073 1074 desc->mSections = sections; 1075 1076 for (size_t i = 0; i < tagArray.size(); ++i) { 1077 uint32_t tag = tagArray[i]; 1078 String8 sectionString = tagToSectionMap.valueFor(tag); 1079 1080 // Set up tag to section index map 1081 ssize_t index = sections.indexOf(sectionString); 1082 LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index); 1083 desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index)); 1084 1085 // Set up reverse mapping 1086 ssize_t reverseIndex = -1; 1087 if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) { 1088 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>(); 1089 reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper); 1090 } 1091 desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag); 1092 } 1093 1094 descriptor = desc; 1095 return OK; 1096} 1097 1098 1099} // namespace android 1100