CameraService.cpp revision 5ff9c91a90d7d5fad49de38bc314910251b25774
1/* 2 * Copyright (C) 2008 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 "CameraService" 18#define ATRACE_TAG ATRACE_TAG_CAMERA 19//#define LOG_NDEBUG 0 20 21#include <algorithm> 22#include <climits> 23#include <stdio.h> 24#include <cstring> 25#include <ctime> 26#include <string> 27#include <sys/types.h> 28#include <inttypes.h> 29#include <pthread.h> 30 31#include <android/hardware/ICamera.h> 32#include <android/hardware/ICameraClient.h> 33 34#include <android-base/macros.h> 35#include <android-base/parseint.h> 36#include <binder/AppOpsManager.h> 37#include <binder/IPCThreadState.h> 38#include <binder/IServiceManager.h> 39#include <binder/MemoryBase.h> 40#include <binder/MemoryHeapBase.h> 41#include <binder/ProcessInfoService.h> 42#include <cutils/atomic.h> 43#include <cutils/properties.h> 44#include <gui/Surface.h> 45#include <hardware/hardware.h> 46#include <memunreachable/memunreachable.h> 47#include <media/AudioSystem.h> 48#include <media/IMediaHTTPService.h> 49#include <media/mediaplayer.h> 50#include <mediautils/BatteryNotifier.h> 51#include <utils/Errors.h> 52#include <utils/Log.h> 53#include <utils/String16.h> 54#include <utils/Trace.h> 55#include <private/android_filesystem_config.h> 56#include <system/camera_vendor_tags.h> 57#include <system/camera_metadata.h> 58 59#include <system/camera.h> 60 61#include "CameraService.h" 62#include "api1/CameraClient.h" 63#include "api1/Camera2Client.h" 64#include "api2/CameraDeviceClient.h" 65#include "utils/CameraTraces.h" 66 67namespace { 68 const char* kPermissionServiceName = "permission"; 69}; // namespace anonymous 70 71namespace android { 72 73using binder::Status; 74using hardware::ICamera; 75using hardware::ICameraClient; 76using hardware::ICameraServiceListener; 77using hardware::camera::common::V1_0::CameraDeviceStatus; 78using hardware::camera::common::V1_0::TorchModeStatus; 79 80// ---------------------------------------------------------------------------- 81// Logging support -- this is for debugging only 82// Use "adb shell dumpsys media.camera -v 1" to change it. 83volatile int32_t gLogLevel = 0; 84 85#define LOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__); 86#define LOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__); 87 88static void setLogLevel(int level) { 89 android_atomic_write(level, &gLogLevel); 90} 91 92// Convenience methods for constructing binder::Status objects for error returns 93 94#define STATUS_ERROR(errorCode, errorString) \ 95 binder::Status::fromServiceSpecificError(errorCode, \ 96 String8::format("%s:%d: %s", __FUNCTION__, __LINE__, errorString)) 97 98#define STATUS_ERROR_FMT(errorCode, errorString, ...) \ 99 binder::Status::fromServiceSpecificError(errorCode, \ 100 String8::format("%s:%d: " errorString, __FUNCTION__, __LINE__, \ 101 __VA_ARGS__)) 102 103// ---------------------------------------------------------------------------- 104 105extern "C" { 106static void camera_device_status_change( 107 const struct camera_module_callbacks* callbacks, 108 int camera_id, 109 int new_status) { 110 sp<CameraService> cs = const_cast<CameraService*>( 111 static_cast<const CameraService*>(callbacks)); 112 String8 id = String8::format("%d", camera_id); 113 114 CameraDeviceStatus newStatus{CameraDeviceStatus::NOT_PRESENT}; 115 switch (new_status) { 116 case CAMERA_DEVICE_STATUS_NOT_PRESENT: 117 newStatus = CameraDeviceStatus::NOT_PRESENT; 118 break; 119 case CAMERA_DEVICE_STATUS_PRESENT: 120 newStatus = CameraDeviceStatus::PRESENT; 121 break; 122 case CAMERA_DEVICE_STATUS_ENUMERATING: 123 newStatus = CameraDeviceStatus::ENUMERATING; 124 break; 125 default: 126 ALOGW("Unknown device status change to %d", new_status); 127 break; 128 } 129 cs->onDeviceStatusChanged(id, newStatus); 130} 131 132static void torch_mode_status_change( 133 const struct camera_module_callbacks* callbacks, 134 const char* camera_id, 135 int new_status) { 136 if (!callbacks || !camera_id) { 137 ALOGE("%s invalid parameters. callbacks %p, camera_id %p", __FUNCTION__, 138 callbacks, camera_id); 139 } 140 sp<CameraService> cs = const_cast<CameraService*>( 141 static_cast<const CameraService*>(callbacks)); 142 143 TorchModeStatus status; 144 switch (new_status) { 145 case TORCH_MODE_STATUS_NOT_AVAILABLE: 146 status = TorchModeStatus::NOT_AVAILABLE; 147 break; 148 case TORCH_MODE_STATUS_AVAILABLE_OFF: 149 status = TorchModeStatus::AVAILABLE_OFF; 150 break; 151 case TORCH_MODE_STATUS_AVAILABLE_ON: 152 status = TorchModeStatus::AVAILABLE_ON; 153 break; 154 default: 155 ALOGE("Unknown torch status %d", new_status); 156 return; 157 } 158 159 cs->onTorchStatusChanged( 160 String8(camera_id), 161 status); 162} 163} // extern "C" 164 165// ---------------------------------------------------------------------------- 166 167CameraService::CameraService() : 168 mEventLog(DEFAULT_EVENT_LOG_LENGTH), 169 mNumberOfCameras(0), mNumberOfNormalCameras(0), 170 mSoundRef(0), mInitialized(false), mModule(nullptr) { 171 ALOGI("CameraService started (pid=%d)", getpid()); 172 173 this->camera_device_status_change = android::camera_device_status_change; 174 this->torch_mode_status_change = android::torch_mode_status_change; 175 176 mServiceLockWrapper = std::make_shared<WaitableMutexWrapper>(&mServiceLock); 177} 178 179void CameraService::onFirstRef() 180{ 181 ALOGI("CameraService process starting"); 182 183 BnCameraService::onFirstRef(); 184 185 // Update battery life tracking if service is restarting 186 BatteryNotifier& notifier(BatteryNotifier::getInstance()); 187 notifier.noteResetCamera(); 188 notifier.noteResetFlashlight(); 189 190 status_t res = INVALID_OPERATION; 191 192 bool disableTreble = property_get_bool("camera.disable_treble", false); 193 if (disableTreble) { 194 ALOGI("Treble disabled - using legacy path"); 195 res = loadLegacyHalModule(); 196 } else { 197 res = enumerateProviders(); 198 } 199 if (res == OK) { 200 mInitialized = true; 201 } 202 203 CameraService::pingCameraServiceProxy(); 204} 205 206status_t CameraService::loadLegacyHalModule() { 207 camera_module_t *rawModule; 208 int err = hw_get_module(CAMERA_HARDWARE_MODULE_ID, 209 (const hw_module_t **)&rawModule); 210 if (err < 0) { 211 ALOGE("Could not load camera HAL module: %d (%s)", err, strerror(-err)); 212 logServiceError("Could not load camera HAL module", err); 213 return INVALID_OPERATION; 214 } 215 216 mModule = new CameraModule(rawModule); 217 err = mModule->init(); 218 if (err != OK) { 219 ALOGE("Could not initialize camera HAL module: %d (%s)", err, 220 strerror(-err)); 221 logServiceError("Could not initialize camera HAL module", err); 222 223 delete mModule; 224 mModule = nullptr; 225 return INVALID_OPERATION; 226 } 227 ALOGI("Loaded \"%s\" camera module", mModule->getModuleName()); 228 229 mNumberOfCameras = mModule->getNumberOfCameras(); 230 mNumberOfNormalCameras = mNumberOfCameras; 231 232 // Setup vendor tags before we call get_camera_info the first time 233 // because HAL might need to setup static vendor keys in get_camera_info 234 VendorTagDescriptor::clearGlobalVendorTagDescriptor(); 235 if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_2) { 236 setUpVendorTags(); 237 } 238 239 mFlashlight = new CameraFlashlight(mModule, this); 240 status_t res = mFlashlight->findFlashUnits(); 241 if (res) { 242 // impossible because we haven't open any camera devices. 243 ALOGE("Failed to find flash units."); 244 } 245 246 int latestStrangeCameraId = INT_MAX; 247 for (int i = 0; i < mNumberOfCameras; i++) { 248 String8 cameraId = String8::format("%d", i); 249 250 // Get camera info 251 252 struct camera_info info; 253 bool haveInfo = true; 254 status_t rc = mModule->getCameraInfo(i, &info); 255 if (rc != NO_ERROR) { 256 ALOGE("%s: Received error loading camera info for device %d, cost and" 257 " conflicting devices fields set to defaults for this device.", 258 __FUNCTION__, i); 259 haveInfo = false; 260 } 261 262 // Check for backwards-compatibility support 263 if (haveInfo) { 264 if (checkCameraCapabilities(i, info, &latestStrangeCameraId) != OK) { 265 delete mModule; 266 mModule = nullptr; 267 return INVALID_OPERATION; 268 } 269 } 270 271 // Defaults to use for cost and conflicting devices 272 int cost = 100; 273 char** conflicting_devices = nullptr; 274 size_t conflicting_devices_length = 0; 275 276 // If using post-2.4 module version, query the cost + conflicting devices from the HAL 277 if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4 && haveInfo) { 278 cost = info.resource_cost; 279 conflicting_devices = info.conflicting_devices; 280 conflicting_devices_length = info.conflicting_devices_length; 281 } 282 283 std::set<String8> conflicting; 284 for (size_t i = 0; i < conflicting_devices_length; i++) { 285 conflicting.emplace(String8(conflicting_devices[i])); 286 } 287 288 // Initialize state for each camera device 289 { 290 Mutex::Autolock lock(mCameraStatesLock); 291 mCameraStates.emplace(cameraId, std::make_shared<CameraState>(cameraId, cost, 292 conflicting)); 293 } 294 295 if (mFlashlight->hasFlashUnit(cameraId)) { 296 mTorchStatusMap.add(cameraId, 297 TorchModeStatus::AVAILABLE_OFF); 298 } 299 } 300 301 if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_1) { 302 mModule->setCallbacks(this); 303 } 304 305 return OK; 306} 307 308status_t CameraService::enumerateProviders() { 309 mCameraProviderManager = new CameraProviderManager(); 310 status_t res; 311 res = mCameraProviderManager->initialize(this); 312 if (res != OK) { 313 ALOGE("%s: Unable to initialize camera provider manager: %s (%d)", 314 __FUNCTION__, strerror(-res), res); 315 return res; 316 } 317 318 mNumberOfCameras = mCameraProviderManager->getCameraCount(); 319 mNumberOfNormalCameras = mCameraProviderManager->getStandardCameraCount(); 320 321 // Setup vendor tags before we call get_camera_info the first time 322 // because HAL might need to setup static vendor keys in get_camera_info 323 // TODO: maybe put this into CameraProviderManager::initialize()? 324 mCameraProviderManager->setUpVendorTags(); 325 326 mFlashlight = new CameraFlashlight(mCameraProviderManager, this); 327 res = mFlashlight->findFlashUnits(); 328 if (res != OK) { 329 ALOGE("Failed to enumerate flash units: %s (%d)", strerror(-res), res); 330 } 331 332 // TODO: Verify device versions are in support 333 334 for (auto& cameraId : mCameraProviderManager->getCameraDeviceIds()) { 335 hardware::camera::common::V1_0::CameraResourceCost cost; 336 res = mCameraProviderManager->getResourceCost(cameraId, &cost); 337 if (res != OK) { 338 ALOGE("Failed to query device resource cost: %s (%d)", strerror(-res), res); 339 continue; 340 } 341 std::set<String8> conflicting; 342 for (size_t i = 0; i < cost.conflictingDevices.size(); i++) { 343 conflicting.emplace(String8(cost.conflictingDevices[i].c_str())); 344 } 345 String8 id8 = String8(cameraId.c_str()); 346 347 Mutex::Autolock lock(mCameraStatesLock); 348 mCameraStates.emplace(id8, 349 std::make_shared<CameraState>(id8, cost.resourceCost, conflicting)); 350 351 if (mFlashlight->hasFlashUnit(id8)) { 352 mTorchStatusMap.add(id8, 353 TorchModeStatus::AVAILABLE_OFF); 354 } 355 } 356 357 return OK; 358} 359 360 361sp<ICameraServiceProxy> CameraService::getCameraServiceProxy() { 362 sp<ICameraServiceProxy> proxyBinder = nullptr; 363#ifndef __BRILLO__ 364 sp<IServiceManager> sm = defaultServiceManager(); 365 // Use checkService because cameraserver normally starts before the 366 // system server and the proxy service. So the long timeout that getService 367 // has before giving up is inappropriate. 368 sp<IBinder> binder = sm->checkService(String16("media.camera.proxy")); 369 if (binder != nullptr) { 370 proxyBinder = interface_cast<ICameraServiceProxy>(binder); 371 } 372#endif 373 return proxyBinder; 374} 375 376void CameraService::pingCameraServiceProxy() { 377 sp<ICameraServiceProxy> proxyBinder = getCameraServiceProxy(); 378 if (proxyBinder == nullptr) return; 379 proxyBinder->pingForUserUpdate(); 380} 381 382CameraService::~CameraService() { 383 if (mModule) { 384 delete mModule; 385 mModule = nullptr; 386 } 387 VendorTagDescriptor::clearGlobalVendorTagDescriptor(); 388} 389 390void CameraService::onDeviceStatusChanged(const String8& id, 391 CameraDeviceStatus newHalStatus) { 392 ALOGI("%s: Status changed for cameraId=%s, newStatus=%d", __FUNCTION__, 393 id.string(), newHalStatus); 394 395 StatusInternal newStatus = mapToInternal(newHalStatus); 396 397 std::shared_ptr<CameraState> state = getCameraState(id); 398 399 if (state == nullptr) { 400 ALOGE("%s: Bad camera ID %s", __FUNCTION__, id.string()); 401 return; 402 } 403 404 StatusInternal oldStatus = state->getStatus(); 405 406 if (oldStatus == newStatus) { 407 ALOGE("%s: State transition to the same status %#x not allowed", __FUNCTION__, newStatus); 408 return; 409 } 410 411 if (newStatus == StatusInternal::NOT_PRESENT) { 412 logDeviceRemoved(id, String8::format("Device status changed from %d to %d", oldStatus, 413 newStatus)); 414 sp<BasicClient> clientToDisconnect; 415 { 416 // Don't do this in updateStatus to avoid deadlock over mServiceLock 417 Mutex::Autolock lock(mServiceLock); 418 419 // Set the device status to NOT_PRESENT, clients will no longer be able to connect 420 // to this device until the status changes 421 updateStatus(StatusInternal::NOT_PRESENT, id); 422 423 // Remove cached shim parameters 424 state->setShimParams(CameraParameters()); 425 426 // Remove the client from the list of active clients 427 clientToDisconnect = removeClientLocked(id); 428 429 // Notify the client of disconnection 430 clientToDisconnect->notifyError( 431 hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED, 432 CaptureResultExtras{}); 433 } 434 435 ALOGI("%s: Client for camera ID %s evicted due to device status change from HAL", 436 __FUNCTION__, id.string()); 437 438 // Disconnect client 439 if (clientToDisconnect.get() != nullptr) { 440 // Ensure not in binder RPC so client disconnect PID checks work correctly 441 LOG_ALWAYS_FATAL_IF(getCallingPid() != getpid(), 442 "onDeviceStatusChanged must be called from the camera service process!"); 443 clientToDisconnect->disconnect(); 444 } 445 446 } else { 447 if (oldStatus == StatusInternal::NOT_PRESENT) { 448 logDeviceAdded(id, String8::format("Device status changed from %d to %d", oldStatus, 449 newStatus)); 450 } 451 updateStatus(newStatus, id); 452 } 453 454} 455 456void CameraService::onTorchStatusChanged(const String8& cameraId, 457 TorchModeStatus newStatus) { 458 Mutex::Autolock al(mTorchStatusMutex); 459 onTorchStatusChangedLocked(cameraId, newStatus); 460} 461 462void CameraService::onTorchStatusChangedLocked(const String8& cameraId, 463 TorchModeStatus newStatus) { 464 ALOGI("%s: Torch status changed for cameraId=%s, newStatus=%d", 465 __FUNCTION__, cameraId.string(), newStatus); 466 467 TorchModeStatus status; 468 status_t res = getTorchStatusLocked(cameraId, &status); 469 if (res) { 470 ALOGE("%s: cannot get torch status of camera %s: %s (%d)", 471 __FUNCTION__, cameraId.string(), strerror(-res), res); 472 return; 473 } 474 if (status == newStatus) { 475 return; 476 } 477 478 res = setTorchStatusLocked(cameraId, newStatus); 479 if (res) { 480 ALOGE("%s: Failed to set the torch status to %d: %s (%d)", __FUNCTION__, 481 (uint32_t)newStatus, strerror(-res), res); 482 return; 483 } 484 485 { 486 // Update battery life logging for flashlight 487 Mutex::Autolock al(mTorchUidMapMutex); 488 auto iter = mTorchUidMap.find(cameraId); 489 if (iter != mTorchUidMap.end()) { 490 int oldUid = iter->second.second; 491 int newUid = iter->second.first; 492 BatteryNotifier& notifier(BatteryNotifier::getInstance()); 493 if (oldUid != newUid) { 494 // If the UID has changed, log the status and update current UID in mTorchUidMap 495 if (status == TorchModeStatus::AVAILABLE_ON) { 496 notifier.noteFlashlightOff(cameraId, oldUid); 497 } 498 if (newStatus == TorchModeStatus::AVAILABLE_ON) { 499 notifier.noteFlashlightOn(cameraId, newUid); 500 } 501 iter->second.second = newUid; 502 } else { 503 // If the UID has not changed, log the status 504 if (newStatus == TorchModeStatus::AVAILABLE_ON) { 505 notifier.noteFlashlightOn(cameraId, oldUid); 506 } else { 507 notifier.noteFlashlightOff(cameraId, oldUid); 508 } 509 } 510 } 511 } 512 513 { 514 Mutex::Autolock lock(mStatusListenerLock); 515 for (auto& i : mListenerList) { 516 i->onTorchStatusChanged(mapToInterface(newStatus), String16{cameraId}); 517 } 518 } 519} 520 521Status CameraService::getNumberOfCameras(int32_t type, int32_t* numCameras) { 522 ATRACE_CALL(); 523 switch (type) { 524 case CAMERA_TYPE_BACKWARD_COMPATIBLE: 525 *numCameras = mNumberOfNormalCameras; 526 break; 527 case CAMERA_TYPE_ALL: 528 *numCameras = mNumberOfCameras; 529 break; 530 default: 531 ALOGW("%s: Unknown camera type %d", 532 __FUNCTION__, type); 533 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT, 534 "Unknown camera type %d", type); 535 } 536 return Status::ok(); 537} 538 539Status CameraService::getCameraInfo(int cameraId, 540 CameraInfo* cameraInfo) { 541 ATRACE_CALL(); 542 if (!mInitialized) { 543 return STATUS_ERROR(ERROR_DISCONNECTED, 544 "Camera subsystem is not available"); 545 } 546 547 if (cameraId < 0 || cameraId >= mNumberOfCameras) { 548 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, 549 "CameraId is not valid"); 550 } 551 552 Status ret = Status::ok(); 553 if (mModule != nullptr) { 554 struct camera_info info; 555 ret = filterGetInfoErrorCode(mModule->getCameraInfo(cameraId, &info)); 556 557 if (ret.isOk()) { 558 cameraInfo->facing = info.facing; 559 cameraInfo->orientation = info.orientation; 560 // CameraInfo is for android.hardware.Camera which does not 561 // support external camera facing. The closest approximation would be 562 // front camera. 563 if (cameraInfo->facing == CAMERA_FACING_EXTERNAL) { 564 cameraInfo->facing = hardware::CAMERA_FACING_FRONT; 565 } 566 } 567 } else { 568 status_t err = mCameraProviderManager->getCameraInfo(std::to_string(cameraId), cameraInfo); 569 if (err != OK) { 570 ret = STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, 571 "Error retrieving camera info from device %d: %s (%d)", cameraId, 572 strerror(-err), err); 573 } 574 } 575 return ret; 576} 577 578int CameraService::cameraIdToInt(const String8& cameraId) { 579 int id; 580 bool success = base::ParseInt(cameraId.string(), &id, 0); 581 if (!success) { 582 return -1; 583 } 584 return id; 585} 586 587Status CameraService::getCameraCharacteristics(const String16& cameraId, 588 CameraMetadata* cameraInfo) { 589 ATRACE_CALL(); 590 if (!cameraInfo) { 591 ALOGE("%s: cameraInfo is NULL", __FUNCTION__); 592 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "cameraInfo is NULL"); 593 } 594 595 if (!mInitialized) { 596 ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__); 597 return STATUS_ERROR(ERROR_DISCONNECTED, 598 "Camera subsystem is not available");; 599 } 600 601 Status ret{}; 602 603 if (mModule != nullptr) { 604 int id = cameraIdToInt(String8(cameraId)); 605 606 if (id < 0 || id >= mNumberOfCameras) { 607 ALOGE("%s: Invalid camera id: %d", __FUNCTION__, id); 608 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT, 609 "Invalid camera id: %d", id); 610 } 611 612 int version = getDeviceVersion(String8(cameraId)); 613 if (version < CAMERA_DEVICE_API_VERSION_3_0) { 614 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT, "Can't get camera characteristics" 615 " for devices with HAL version < 3.0, %d is version %x", id, version); 616 } 617 618 struct camera_info info; 619 ret = filterGetInfoErrorCode(mModule->getCameraInfo(id, &info)); 620 if (ret.isOk()) { 621 *cameraInfo = info.static_camera_characteristics; 622 } 623 } else { 624 status_t res = mCameraProviderManager->getCameraCharacteristics( 625 String8(cameraId).string(), cameraInfo); 626 if (res != OK) { 627 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Unable to retrieve camera " 628 "characteristics for device %s: %s (%d)", String8(cameraId).string(), 629 strerror(-res), res); 630 } 631 } 632 633 return ret; 634} 635 636int CameraService::getCallingPid() { 637 return IPCThreadState::self()->getCallingPid(); 638} 639 640int CameraService::getCallingUid() { 641 return IPCThreadState::self()->getCallingUid(); 642} 643 644String8 CameraService::getFormattedCurrentTime() { 645 time_t now = time(nullptr); 646 char formattedTime[64]; 647 strftime(formattedTime, sizeof(formattedTime), "%m-%d %H:%M:%S", localtime(&now)); 648 return String8(formattedTime); 649} 650 651Status CameraService::getCameraVendorTagDescriptor( 652 /*out*/ 653 hardware::camera2::params::VendorTagDescriptor* desc) { 654 ATRACE_CALL(); 655 if (!mInitialized) { 656 ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__); 657 return STATUS_ERROR(ERROR_DISCONNECTED, "Camera subsystem not available"); 658 } 659 sp<VendorTagDescriptor> globalDescriptor = VendorTagDescriptor::getGlobalVendorTagDescriptor(); 660 if (globalDescriptor != nullptr) { 661 *desc = *(globalDescriptor.get()); 662 } 663 return Status::ok(); 664} 665 666int CameraService::getDeviceVersion(const String8& cameraId, int* facing) { 667 ATRACE_CALL(); 668 669 int deviceVersion = 0; 670 671 if (mModule != nullptr) { 672 int id = cameraIdToInt(cameraId); 673 if (id < 0) return -1; 674 675 struct camera_info info; 676 if (mModule->getCameraInfo(id, &info) != OK) { 677 return -1; 678 } 679 680 if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0) { 681 deviceVersion = info.device_version; 682 } else { 683 deviceVersion = CAMERA_DEVICE_API_VERSION_1_0; 684 } 685 686 if (facing) { 687 *facing = info.facing; 688 } 689 } else { 690 status_t res; 691 hardware::hidl_version maxVersion{0,0}; 692 res = mCameraProviderManager->getHighestSupportedVersion(cameraId.string(), 693 &maxVersion); 694 if (res != OK) return -1; 695 deviceVersion = HARDWARE_DEVICE_API_VERSION(maxVersion.get_major(), maxVersion.get_minor()); 696 697 hardware::CameraInfo info; 698 if (facing) { 699 res = mCameraProviderManager->getCameraInfo(cameraId.string(), &info); 700 if (res != OK) return -1; 701 *facing = info.facing; 702 } 703 } 704 return deviceVersion; 705} 706 707Status CameraService::filterGetInfoErrorCode(status_t err) { 708 switch(err) { 709 case NO_ERROR: 710 return Status::ok(); 711 case BAD_VALUE: 712 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, 713 "CameraId is not valid for HAL module"); 714 case NO_INIT: 715 return STATUS_ERROR(ERROR_DISCONNECTED, 716 "Camera device not available"); 717 default: 718 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, 719 "Camera HAL encountered error %d: %s", 720 err, strerror(-err)); 721 } 722} 723 724bool CameraService::setUpVendorTags() { 725 ATRACE_CALL(); 726 if (mModule == nullptr) return false; 727 728 vendor_tag_ops_t vOps = vendor_tag_ops_t(); 729 730 // Check if vendor operations have been implemented 731 if (!mModule->isVendorTagDefined()) { 732 ALOGI("%s: No vendor tags defined for this device.", __FUNCTION__); 733 return false; 734 } 735 736 mModule->getVendorTagOps(&vOps); 737 738 // Ensure all vendor operations are present 739 if (vOps.get_tag_count == NULL || vOps.get_all_tags == NULL || 740 vOps.get_section_name == NULL || vOps.get_tag_name == NULL || 741 vOps.get_tag_type == NULL) { 742 ALOGE("%s: Vendor tag operations not fully defined. Ignoring definitions." 743 , __FUNCTION__); 744 return false; 745 } 746 747 // Read all vendor tag definitions into a descriptor 748 sp<VendorTagDescriptor> desc; 749 status_t res; 750 if ((res = VendorTagDescriptor::createDescriptorFromOps(&vOps, /*out*/desc)) 751 != OK) { 752 ALOGE("%s: Could not generate descriptor from vendor tag operations," 753 "received error %s (%d). Camera clients will not be able to use" 754 "vendor tags", __FUNCTION__, strerror(res), res); 755 return false; 756 } 757 758 // Set the global descriptor to use with camera metadata 759 VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc); 760 return true; 761} 762 763Status CameraService::makeClient(const sp<CameraService>& cameraService, 764 const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId, 765 int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode, 766 int halVersion, int deviceVersion, apiLevel effectiveApiLevel, 767 /*out*/sp<BasicClient>* client) { 768 769 if (halVersion < 0 || halVersion == deviceVersion) { 770 // Default path: HAL version is unspecified by caller, create CameraClient 771 // based on device version reported by the HAL. 772 switch(deviceVersion) { 773 case CAMERA_DEVICE_API_VERSION_1_0: 774 if (effectiveApiLevel == API_1) { // Camera1 API route 775 sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get()); 776 *client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId), 777 facing, clientPid, clientUid, getpid(), legacyMode); 778 } else { // Camera2 API route 779 ALOGW("Camera using old HAL version: %d", deviceVersion); 780 return STATUS_ERROR_FMT(ERROR_DEPRECATED_HAL, 781 "Camera device \"%s\" HAL version %d does not support camera2 API", 782 cameraId.string(), deviceVersion); 783 } 784 break; 785 case CAMERA_DEVICE_API_VERSION_3_0: 786 case CAMERA_DEVICE_API_VERSION_3_1: 787 case CAMERA_DEVICE_API_VERSION_3_2: 788 case CAMERA_DEVICE_API_VERSION_3_3: 789 case CAMERA_DEVICE_API_VERSION_3_4: 790 if (effectiveApiLevel == API_1) { // Camera1 API route 791 sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get()); 792 *client = new Camera2Client(cameraService, tmp, packageName, cameraIdToInt(cameraId), 793 facing, clientPid, clientUid, servicePid, legacyMode); 794 } else { // Camera2 API route 795 sp<hardware::camera2::ICameraDeviceCallbacks> tmp = 796 static_cast<hardware::camera2::ICameraDeviceCallbacks*>(cameraCb.get()); 797 *client = new CameraDeviceClient(cameraService, tmp, packageName, cameraId, 798 facing, clientPid, clientUid, servicePid); 799 } 800 break; 801 default: 802 // Should not be reachable 803 ALOGE("Unknown camera device HAL version: %d", deviceVersion); 804 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, 805 "Camera device \"%s\" has unknown HAL version %d", 806 cameraId.string(), deviceVersion); 807 } 808 } else { 809 // A particular HAL version is requested by caller. Create CameraClient 810 // based on the requested HAL version. 811 if (deviceVersion > CAMERA_DEVICE_API_VERSION_1_0 && 812 halVersion == CAMERA_DEVICE_API_VERSION_1_0) { 813 // Only support higher HAL version device opened as HAL1.0 device. 814 sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get()); 815 *client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId), 816 facing, clientPid, clientUid, servicePid, legacyMode); 817 } else { 818 // Other combinations (e.g. HAL3.x open as HAL2.x) are not supported yet. 819 ALOGE("Invalid camera HAL version %x: HAL %x device can only be" 820 " opened as HAL %x device", halVersion, deviceVersion, 821 CAMERA_DEVICE_API_VERSION_1_0); 822 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT, 823 "Camera device \"%s\" (HAL version %d) cannot be opened as HAL version %d", 824 cameraId.string(), deviceVersion, halVersion); 825 } 826 } 827 return Status::ok(); 828} 829 830String8 CameraService::toString(std::set<userid_t> intSet) { 831 String8 s(""); 832 bool first = true; 833 for (userid_t i : intSet) { 834 if (first) { 835 s.appendFormat("%d", i); 836 first = false; 837 } else { 838 s.appendFormat(", %d", i); 839 } 840 } 841 return s; 842} 843 844int32_t CameraService::mapToInterface(TorchModeStatus status) { 845 int32_t serviceStatus = ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE; 846 switch (status) { 847 case TorchModeStatus::NOT_AVAILABLE: 848 serviceStatus = ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE; 849 break; 850 case TorchModeStatus::AVAILABLE_OFF: 851 serviceStatus = ICameraServiceListener::TORCH_STATUS_AVAILABLE_OFF; 852 break; 853 case TorchModeStatus::AVAILABLE_ON: 854 serviceStatus = ICameraServiceListener::TORCH_STATUS_AVAILABLE_ON; 855 break; 856 default: 857 ALOGW("Unknown new flash status: %d", status); 858 } 859 return serviceStatus; 860} 861 862CameraService::StatusInternal CameraService::mapToInternal(CameraDeviceStatus status) { 863 StatusInternal serviceStatus = StatusInternal::NOT_PRESENT; 864 switch (status) { 865 case CameraDeviceStatus::NOT_PRESENT: 866 serviceStatus = StatusInternal::NOT_PRESENT; 867 break; 868 case CameraDeviceStatus::PRESENT: 869 serviceStatus = StatusInternal::PRESENT; 870 break; 871 case CameraDeviceStatus::ENUMERATING: 872 serviceStatus = StatusInternal::ENUMERATING; 873 break; 874 default: 875 ALOGW("Unknown new HAL device status: %d", status); 876 } 877 return serviceStatus; 878} 879 880int32_t CameraService::mapToInterface(StatusInternal status) { 881 int32_t serviceStatus = ICameraServiceListener::STATUS_NOT_PRESENT; 882 switch (status) { 883 case StatusInternal::NOT_PRESENT: 884 serviceStatus = ICameraServiceListener::STATUS_NOT_PRESENT; 885 break; 886 case StatusInternal::PRESENT: 887 serviceStatus = ICameraServiceListener::STATUS_PRESENT; 888 break; 889 case StatusInternal::ENUMERATING: 890 serviceStatus = ICameraServiceListener::STATUS_ENUMERATING; 891 break; 892 case StatusInternal::NOT_AVAILABLE: 893 serviceStatus = ICameraServiceListener::STATUS_NOT_AVAILABLE; 894 break; 895 case StatusInternal::UNKNOWN: 896 serviceStatus = ICameraServiceListener::STATUS_UNKNOWN; 897 break; 898 default: 899 ALOGW("Unknown new internal device status: %d", status); 900 } 901 return serviceStatus; 902} 903 904Status CameraService::initializeShimMetadata(int cameraId) { 905 int uid = getCallingUid(); 906 907 String16 internalPackageName("cameraserver"); 908 String8 id = String8::format("%d", cameraId); 909 Status ret = Status::ok(); 910 sp<Client> tmp = nullptr; 911 if (!(ret = connectHelper<ICameraClient,Client>( 912 sp<ICameraClient>{nullptr}, id, static_cast<int>(CAMERA_HAL_API_VERSION_UNSPECIFIED), 913 internalPackageName, uid, USE_CALLING_PID, 914 API_1, /*legacyMode*/ false, /*shimUpdateOnly*/ true, 915 /*out*/ tmp) 916 ).isOk()) { 917 ALOGE("%s: Error initializing shim metadata: %s", __FUNCTION__, ret.toString8().string()); 918 } 919 return ret; 920} 921 922Status CameraService::getLegacyParametersLazy(int cameraId, 923 /*out*/ 924 CameraParameters* parameters) { 925 926 ALOGV("%s: for cameraId: %d", __FUNCTION__, cameraId); 927 928 Status ret = Status::ok(); 929 930 if (parameters == NULL) { 931 ALOGE("%s: parameters must not be null", __FUNCTION__); 932 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Parameters must not be null"); 933 } 934 935 String8 id = String8::format("%d", cameraId); 936 937 // Check if we already have parameters 938 { 939 // Scope for service lock 940 Mutex::Autolock lock(mServiceLock); 941 auto cameraState = getCameraState(id); 942 if (cameraState == nullptr) { 943 ALOGE("%s: Invalid camera ID: %s", __FUNCTION__, id.string()); 944 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT, 945 "Invalid camera ID: %s", id.string()); 946 } 947 CameraParameters p = cameraState->getShimParams(); 948 if (!p.isEmpty()) { 949 *parameters = p; 950 return ret; 951 } 952 } 953 954 int64_t token = IPCThreadState::self()->clearCallingIdentity(); 955 ret = initializeShimMetadata(cameraId); 956 IPCThreadState::self()->restoreCallingIdentity(token); 957 if (!ret.isOk()) { 958 // Error already logged by callee 959 return ret; 960 } 961 962 // Check for parameters again 963 { 964 // Scope for service lock 965 Mutex::Autolock lock(mServiceLock); 966 auto cameraState = getCameraState(id); 967 if (cameraState == nullptr) { 968 ALOGE("%s: Invalid camera ID: %s", __FUNCTION__, id.string()); 969 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT, 970 "Invalid camera ID: %s", id.string()); 971 } 972 CameraParameters p = cameraState->getShimParams(); 973 if (!p.isEmpty()) { 974 *parameters = p; 975 return ret; 976 } 977 } 978 979 ALOGE("%s: Parameters were not initialized, or were empty. Device may not be present.", 980 __FUNCTION__); 981 return STATUS_ERROR(ERROR_INVALID_OPERATION, "Unable to initialize legacy parameters"); 982} 983 984// Can camera service trust the caller based on the calling UID? 985static bool isTrustedCallingUid(uid_t uid) { 986 switch (uid) { 987 case AID_MEDIA: // mediaserver 988 case AID_CAMERASERVER: // cameraserver 989 case AID_RADIO: // telephony 990 return true; 991 default: 992 return false; 993 } 994} 995 996Status CameraService::validateConnectLocked(const String8& cameraId, 997 const String8& clientName8, /*inout*/int& clientUid, /*inout*/int& clientPid, 998 /*out*/int& originalClientPid) const { 999 1000#ifdef __BRILLO__ 1001 UNUSED(clientName8); 1002 UNUSED(clientUid); 1003 UNUSED(clientPid); 1004 UNUSED(originalClientPid); 1005#else 1006 Status allowed = validateClientPermissionsLocked(cameraId, clientName8, clientUid, clientPid, 1007 originalClientPid); 1008 if (!allowed.isOk()) { 1009 return allowed; 1010 } 1011#endif // __BRILLO__ 1012 1013 int callingPid = getCallingPid(); 1014 1015 if (!mInitialized) { 1016 ALOGE("CameraService::connect X (PID %d) rejected (camera HAL module not loaded)", 1017 callingPid); 1018 return STATUS_ERROR_FMT(ERROR_DISCONNECTED, 1019 "No camera HAL module available to open camera device \"%s\"", cameraId.string()); 1020 } 1021 1022 if (getCameraState(cameraId) == nullptr) { 1023 ALOGE("CameraService::connect X (PID %d) rejected (invalid camera ID %s)", callingPid, 1024 cameraId.string()); 1025 return STATUS_ERROR_FMT(ERROR_DISCONNECTED, 1026 "No camera device with ID \"%s\" available", cameraId.string()); 1027 } 1028 1029 status_t err = checkIfDeviceIsUsable(cameraId); 1030 if (err != NO_ERROR) { 1031 switch(err) { 1032 case -ENODEV: 1033 case -EBUSY: 1034 return STATUS_ERROR_FMT(ERROR_DISCONNECTED, 1035 "No camera device with ID \"%s\" currently available", cameraId.string()); 1036 default: 1037 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, 1038 "Unknown error connecting to ID \"%s\"", cameraId.string()); 1039 } 1040 } 1041 return Status::ok(); 1042} 1043 1044Status CameraService::validateClientPermissionsLocked(const String8& cameraId, 1045 const String8& clientName8, int& clientUid, int& clientPid, 1046 /*out*/int& originalClientPid) const { 1047 int callingPid = getCallingPid(); 1048 int callingUid = getCallingUid(); 1049 1050 // Check if we can trust clientUid 1051 if (clientUid == USE_CALLING_UID) { 1052 clientUid = callingUid; 1053 } else if (!isTrustedCallingUid(callingUid)) { 1054 ALOGE("CameraService::connect X (calling PID %d, calling UID %d) rejected " 1055 "(don't trust clientUid %d)", callingPid, callingUid, clientUid); 1056 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED, 1057 "Untrusted caller (calling PID %d, UID %d) trying to " 1058 "forward camera access to camera %s for client %s (PID %d, UID %d)", 1059 callingPid, callingUid, cameraId.string(), 1060 clientName8.string(), clientUid, clientPid); 1061 } 1062 1063 // Check if we can trust clientPid 1064 if (clientPid == USE_CALLING_PID) { 1065 clientPid = callingPid; 1066 } else if (!isTrustedCallingUid(callingUid)) { 1067 ALOGE("CameraService::connect X (calling PID %d, calling UID %d) rejected " 1068 "(don't trust clientPid %d)", callingPid, callingUid, clientPid); 1069 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED, 1070 "Untrusted caller (calling PID %d, UID %d) trying to " 1071 "forward camera access to camera %s for client %s (PID %d, UID %d)", 1072 callingPid, callingUid, cameraId.string(), 1073 clientName8.string(), clientUid, clientPid); 1074 } 1075 1076 // If it's not calling from cameraserver, check the permission. 1077 if (callingPid != getpid() && 1078 !checkPermission(String16("android.permission.CAMERA"), clientPid, clientUid)) { 1079 ALOGE("Permission Denial: can't use the camera pid=%d, uid=%d", clientPid, clientUid); 1080 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED, 1081 "Caller \"%s\" (PID %d, UID %d) cannot open camera \"%s\" without camera permission", 1082 clientName8.string(), clientUid, clientPid, cameraId.string()); 1083 } 1084 1085 // Only use passed in clientPid to check permission. Use calling PID as the client PID that's 1086 // connected to camera service directly. 1087 originalClientPid = clientPid; 1088 clientPid = callingPid; 1089 1090 userid_t clientUserId = multiuser_get_user_id(clientUid); 1091 1092 // Only allow clients who are being used by the current foreground device user, unless calling 1093 // from our own process. 1094 if (callingPid != getpid() && (mAllowedUsers.find(clientUserId) == mAllowedUsers.end())) { 1095 ALOGE("CameraService::connect X (PID %d) rejected (cannot connect from " 1096 "device user %d, currently allowed device users: %s)", callingPid, clientUserId, 1097 toString(mAllowedUsers).string()); 1098 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED, 1099 "Callers from device user %d are not currently allowed to connect to camera \"%s\"", 1100 clientUserId, cameraId.string()); 1101 } 1102 1103 return Status::ok(); 1104} 1105 1106status_t CameraService::checkIfDeviceIsUsable(const String8& cameraId) const { 1107 auto cameraState = getCameraState(cameraId); 1108 int callingPid = getCallingPid(); 1109 if (cameraState == nullptr) { 1110 ALOGE("CameraService::connect X (PID %d) rejected (invalid camera ID %s)", callingPid, 1111 cameraId.string()); 1112 return -ENODEV; 1113 } 1114 1115 StatusInternal currentStatus = cameraState->getStatus(); 1116 if (currentStatus == StatusInternal::NOT_PRESENT) { 1117 ALOGE("CameraService::connect X (PID %d) rejected (camera %s is not connected)", 1118 callingPid, cameraId.string()); 1119 return -ENODEV; 1120 } else if (currentStatus == StatusInternal::ENUMERATING) { 1121 ALOGE("CameraService::connect X (PID %d) rejected, (camera %s is initializing)", 1122 callingPid, cameraId.string()); 1123 return -EBUSY; 1124 } 1125 1126 return NO_ERROR; 1127} 1128 1129void CameraService::finishConnectLocked(const sp<BasicClient>& client, 1130 const CameraService::DescriptorPtr& desc) { 1131 1132 // Make a descriptor for the incoming client 1133 auto clientDescriptor = CameraService::CameraClientManager::makeClientDescriptor(client, desc); 1134 auto evicted = mActiveClientManager.addAndEvict(clientDescriptor); 1135 1136 logConnected(desc->getKey(), static_cast<int>(desc->getOwnerId()), 1137 String8(client->getPackageName())); 1138 1139 if (evicted.size() > 0) { 1140 // This should never happen - clients should already have been removed in disconnect 1141 for (auto& i : evicted) { 1142 ALOGE("%s: Invalid state: Client for camera %s was not removed in disconnect", 1143 __FUNCTION__, i->getKey().string()); 1144 } 1145 1146 LOG_ALWAYS_FATAL("%s: Invalid state for CameraService, clients not evicted properly", 1147 __FUNCTION__); 1148 } 1149 1150 // And register a death notification for the client callback. Do 1151 // this last to avoid Binder policy where a nested Binder 1152 // transaction might be pre-empted to service the client death 1153 // notification if the client process dies before linkToDeath is 1154 // invoked. 1155 sp<IBinder> remoteCallback = client->getRemote(); 1156 if (remoteCallback != nullptr) { 1157 remoteCallback->linkToDeath(this); 1158 } 1159} 1160 1161status_t CameraService::handleEvictionsLocked(const String8& cameraId, int clientPid, 1162 apiLevel effectiveApiLevel, const sp<IBinder>& remoteCallback, const String8& packageName, 1163 /*out*/ 1164 sp<BasicClient>* client, 1165 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial) { 1166 ATRACE_CALL(); 1167 status_t ret = NO_ERROR; 1168 std::vector<DescriptorPtr> evictedClients; 1169 DescriptorPtr clientDescriptor; 1170 { 1171 if (effectiveApiLevel == API_1) { 1172 // If we are using API1, any existing client for this camera ID with the same remote 1173 // should be returned rather than evicted to allow MediaRecorder to work properly. 1174 1175 auto current = mActiveClientManager.get(cameraId); 1176 if (current != nullptr) { 1177 auto clientSp = current->getValue(); 1178 if (clientSp.get() != nullptr) { // should never be needed 1179 if (!clientSp->canCastToApiClient(effectiveApiLevel)) { 1180 ALOGW("CameraService connect called from same client, but with a different" 1181 " API level, evicting prior client..."); 1182 } else if (clientSp->getRemote() == remoteCallback) { 1183 ALOGI("CameraService::connect X (PID %d) (second call from same" 1184 " app binder, returning the same client)", clientPid); 1185 *client = clientSp; 1186 return NO_ERROR; 1187 } 1188 } 1189 } 1190 } 1191 1192 // Get current active client PIDs 1193 std::vector<int> ownerPids(mActiveClientManager.getAllOwners()); 1194 ownerPids.push_back(clientPid); 1195 1196 std::vector<int> priorityScores(ownerPids.size()); 1197 std::vector<int> states(ownerPids.size()); 1198 1199 // Get priority scores of all active PIDs 1200 status_t err = ProcessInfoService::getProcessStatesScoresFromPids( 1201 ownerPids.size(), &ownerPids[0], /*out*/&states[0], 1202 /*out*/&priorityScores[0]); 1203 if (err != OK) { 1204 ALOGE("%s: Priority score query failed: %d", 1205 __FUNCTION__, err); 1206 return err; 1207 } 1208 1209 // Update all active clients' priorities 1210 std::map<int,resource_policy::ClientPriority> pidToPriorityMap; 1211 for (size_t i = 0; i < ownerPids.size() - 1; i++) { 1212 pidToPriorityMap.emplace(ownerPids[i], 1213 resource_policy::ClientPriority(priorityScores[i], states[i])); 1214 } 1215 mActiveClientManager.updatePriorities(pidToPriorityMap); 1216 1217 // Get state for the given cameraId 1218 auto state = getCameraState(cameraId); 1219 if (state == nullptr) { 1220 ALOGE("CameraService::connect X (PID %d) rejected (no camera device with ID %s)", 1221 clientPid, cameraId.string()); 1222 // Should never get here because validateConnectLocked should have errored out 1223 return BAD_VALUE; 1224 } 1225 1226 // Make descriptor for incoming client 1227 clientDescriptor = CameraClientManager::makeClientDescriptor(cameraId, 1228 sp<BasicClient>{nullptr}, static_cast<int32_t>(state->getCost()), 1229 state->getConflicting(), 1230 priorityScores[priorityScores.size() - 1], 1231 clientPid, 1232 states[states.size() - 1]); 1233 1234 // Find clients that would be evicted 1235 auto evicted = mActiveClientManager.wouldEvict(clientDescriptor); 1236 1237 // If the incoming client was 'evicted,' higher priority clients have the camera in the 1238 // background, so we cannot do evictions 1239 if (std::find(evicted.begin(), evicted.end(), clientDescriptor) != evicted.end()) { 1240 ALOGE("CameraService::connect X (PID %d) rejected (existing client(s) with higher" 1241 " priority).", clientPid); 1242 1243 sp<BasicClient> clientSp = clientDescriptor->getValue(); 1244 String8 curTime = getFormattedCurrentTime(); 1245 auto incompatibleClients = 1246 mActiveClientManager.getIncompatibleClients(clientDescriptor); 1247 1248 String8 msg = String8::format("%s : DENIED connect device %s client for package %s " 1249 "(PID %d, score %d state %d) due to eviction policy", curTime.string(), 1250 cameraId.string(), packageName.string(), clientPid, 1251 priorityScores[priorityScores.size() - 1], 1252 states[states.size() - 1]); 1253 1254 for (auto& i : incompatibleClients) { 1255 msg.appendFormat("\n - Blocked by existing device %s client for package %s" 1256 "(PID %" PRId32 ", score %" PRId32 ", state %" PRId32 ")", 1257 i->getKey().string(), 1258 String8{i->getValue()->getPackageName()}.string(), 1259 i->getOwnerId(), i->getPriority().getScore(), 1260 i->getPriority().getState()); 1261 ALOGE(" Conflicts with: Device %s, client package %s (PID %" 1262 PRId32 ", score %" PRId32 ", state %" PRId32 ")", i->getKey().string(), 1263 String8{i->getValue()->getPackageName()}.string(), i->getOwnerId(), 1264 i->getPriority().getScore(), i->getPriority().getState()); 1265 } 1266 1267 // Log the client's attempt 1268 Mutex::Autolock l(mLogLock); 1269 mEventLog.add(msg); 1270 1271 return -EBUSY; 1272 } 1273 1274 for (auto& i : evicted) { 1275 sp<BasicClient> clientSp = i->getValue(); 1276 if (clientSp.get() == nullptr) { 1277 ALOGE("%s: Invalid state: Null client in active client list.", __FUNCTION__); 1278 1279 // TODO: Remove this 1280 LOG_ALWAYS_FATAL("%s: Invalid state for CameraService, null client in active list", 1281 __FUNCTION__); 1282 mActiveClientManager.remove(i); 1283 continue; 1284 } 1285 1286 ALOGE("CameraService::connect evicting conflicting client for camera ID %s", 1287 i->getKey().string()); 1288 evictedClients.push_back(i); 1289 1290 // Log the clients evicted 1291 logEvent(String8::format("EVICT device %s client held by package %s (PID" 1292 " %" PRId32 ", score %" PRId32 ", state %" PRId32 ")\n - Evicted by device %s client for" 1293 " package %s (PID %d, score %" PRId32 ", state %" PRId32 ")", 1294 i->getKey().string(), String8{clientSp->getPackageName()}.string(), 1295 i->getOwnerId(), i->getPriority().getScore(), 1296 i->getPriority().getState(), cameraId.string(), 1297 packageName.string(), clientPid, 1298 priorityScores[priorityScores.size() - 1], 1299 states[states.size() - 1])); 1300 1301 // Notify the client of disconnection 1302 clientSp->notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED, 1303 CaptureResultExtras()); 1304 } 1305 } 1306 1307 // Do not hold mServiceLock while disconnecting clients, but retain the condition blocking 1308 // other clients from connecting in mServiceLockWrapper if held 1309 mServiceLock.unlock(); 1310 1311 // Clear caller identity temporarily so client disconnect PID checks work correctly 1312 int64_t token = IPCThreadState::self()->clearCallingIdentity(); 1313 1314 // Destroy evicted clients 1315 for (auto& i : evictedClients) { 1316 // Disconnect is blocking, and should only have returned when HAL has cleaned up 1317 i->getValue()->disconnect(); // Clients will remove themselves from the active client list 1318 } 1319 1320 IPCThreadState::self()->restoreCallingIdentity(token); 1321 1322 for (const auto& i : evictedClients) { 1323 ALOGV("%s: Waiting for disconnect to complete for client for device %s (PID %" PRId32 ")", 1324 __FUNCTION__, i->getKey().string(), i->getOwnerId()); 1325 ret = mActiveClientManager.waitUntilRemoved(i, DEFAULT_DISCONNECT_TIMEOUT_NS); 1326 if (ret == TIMED_OUT) { 1327 ALOGE("%s: Timed out waiting for client for device %s to disconnect, " 1328 "current clients:\n%s", __FUNCTION__, i->getKey().string(), 1329 mActiveClientManager.toString().string()); 1330 return -EBUSY; 1331 } 1332 if (ret != NO_ERROR) { 1333 ALOGE("%s: Received error waiting for client for device %s to disconnect: %s (%d), " 1334 "current clients:\n%s", __FUNCTION__, i->getKey().string(), strerror(-ret), 1335 ret, mActiveClientManager.toString().string()); 1336 return ret; 1337 } 1338 } 1339 1340 evictedClients.clear(); 1341 1342 // Once clients have been disconnected, relock 1343 mServiceLock.lock(); 1344 1345 // Check again if the device was unplugged or something while we weren't holding mServiceLock 1346 if ((ret = checkIfDeviceIsUsable(cameraId)) != NO_ERROR) { 1347 return ret; 1348 } 1349 1350 *partial = clientDescriptor; 1351 return NO_ERROR; 1352} 1353 1354Status CameraService::connect( 1355 const sp<ICameraClient>& cameraClient, 1356 int cameraId, 1357 const String16& clientPackageName, 1358 int clientUid, 1359 int clientPid, 1360 /*out*/ 1361 sp<ICamera>* device) { 1362 1363 ATRACE_CALL(); 1364 Status ret = Status::ok(); 1365 String8 id = String8::format("%d", cameraId); 1366 sp<Client> client = nullptr; 1367 ret = connectHelper<ICameraClient,Client>(cameraClient, id, 1368 CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName, clientUid, clientPid, API_1, 1369 /*legacyMode*/ false, /*shimUpdateOnly*/ false, 1370 /*out*/client); 1371 1372 if(!ret.isOk()) { 1373 logRejected(id, getCallingPid(), String8(clientPackageName), 1374 ret.toString8()); 1375 return ret; 1376 } 1377 1378 *device = client; 1379 return ret; 1380} 1381 1382Status CameraService::connectLegacy( 1383 const sp<ICameraClient>& cameraClient, 1384 int cameraId, int halVersion, 1385 const String16& clientPackageName, 1386 int clientUid, 1387 /*out*/ 1388 sp<ICamera>* device) { 1389 1390 ATRACE_CALL(); 1391 String8 id = String8::format("%d", cameraId); 1392 if (mModule != nullptr) { 1393 int apiVersion = mModule->getModuleApiVersion(); 1394 if (halVersion != CAMERA_HAL_API_VERSION_UNSPECIFIED && 1395 apiVersion < CAMERA_MODULE_API_VERSION_2_3) { 1396 /* 1397 * Either the HAL version is unspecified in which case this just creates 1398 * a camera client selected by the latest device version, or 1399 * it's a particular version in which case the HAL must supported 1400 * the open_legacy call 1401 */ 1402 String8 msg = String8::format("Camera HAL module version %x too old for connectLegacy!", 1403 apiVersion); 1404 ALOGE("%s: %s", 1405 __FUNCTION__, msg.string()); 1406 logRejected(id, getCallingPid(), String8(clientPackageName), 1407 msg); 1408 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string()); 1409 } 1410 } 1411 1412 Status ret = Status::ok(); 1413 sp<Client> client = nullptr; 1414 ret = connectHelper<ICameraClient,Client>(cameraClient, id, halVersion, 1415 clientPackageName, clientUid, USE_CALLING_PID, API_1, 1416 /*legacyMode*/ true, /*shimUpdateOnly*/ false, 1417 /*out*/client); 1418 1419 if(!ret.isOk()) { 1420 logRejected(id, getCallingPid(), String8(clientPackageName), 1421 ret.toString8()); 1422 return ret; 1423 } 1424 1425 *device = client; 1426 return ret; 1427} 1428 1429Status CameraService::connectDevice( 1430 const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb, 1431 const String16& cameraId, 1432 const String16& clientPackageName, 1433 int clientUid, 1434 /*out*/ 1435 sp<hardware::camera2::ICameraDeviceUser>* device) { 1436 1437 ATRACE_CALL(); 1438 Status ret = Status::ok(); 1439 String8 id = String8(cameraId); 1440 sp<CameraDeviceClient> client = nullptr; 1441 ret = connectHelper<hardware::camera2::ICameraDeviceCallbacks,CameraDeviceClient>(cameraCb, id, 1442 CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName, 1443 clientUid, USE_CALLING_PID, API_2, 1444 /*legacyMode*/ false, /*shimUpdateOnly*/ false, 1445 /*out*/client); 1446 1447 if(!ret.isOk()) { 1448 logRejected(id, getCallingPid(), String8(clientPackageName), 1449 ret.toString8()); 1450 return ret; 1451 } 1452 1453 *device = client; 1454 return ret; 1455} 1456 1457template<class CALLBACK, class CLIENT> 1458Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId, 1459 int halVersion, const String16& clientPackageName, int clientUid, int clientPid, 1460 apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly, 1461 /*out*/sp<CLIENT>& device) { 1462 binder::Status ret = binder::Status::ok(); 1463 1464 String8 clientName8(clientPackageName); 1465 1466 int originalClientPid = 0; 1467 1468 ALOGI("CameraService::connect call (PID %d \"%s\", camera ID %s) for HAL version %s and " 1469 "Camera API version %d", clientPid, clientName8.string(), cameraId.string(), 1470 (halVersion == -1) ? "default" : std::to_string(halVersion).c_str(), 1471 static_cast<int>(effectiveApiLevel)); 1472 1473 sp<CLIENT> client = nullptr; 1474 { 1475 // Acquire mServiceLock and prevent other clients from connecting 1476 std::unique_ptr<AutoConditionLock> lock = 1477 AutoConditionLock::waitAndAcquire(mServiceLockWrapper, DEFAULT_CONNECT_TIMEOUT_NS); 1478 1479 if (lock == nullptr) { 1480 ALOGE("CameraService::connect (PID %d) rejected (too many other clients connecting)." 1481 , clientPid); 1482 return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE, 1483 "Cannot open camera %s for \"%s\" (PID %d): Too many other clients connecting", 1484 cameraId.string(), clientName8.string(), clientPid); 1485 } 1486 1487 // Enforce client permissions and do basic sanity checks 1488 if(!(ret = validateConnectLocked(cameraId, clientName8, 1489 /*inout*/clientUid, /*inout*/clientPid, /*out*/originalClientPid)).isOk()) { 1490 return ret; 1491 } 1492 1493 // Check the shim parameters after acquiring lock, if they have already been updated and 1494 // we were doing a shim update, return immediately 1495 if (shimUpdateOnly) { 1496 auto cameraState = getCameraState(cameraId); 1497 if (cameraState != nullptr) { 1498 if (!cameraState->getShimParams().isEmpty()) return ret; 1499 } 1500 } 1501 1502 status_t err; 1503 1504 sp<BasicClient> clientTmp = nullptr; 1505 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>> partial; 1506 if ((err = handleEvictionsLocked(cameraId, originalClientPid, effectiveApiLevel, 1507 IInterface::asBinder(cameraCb), clientName8, /*out*/&clientTmp, 1508 /*out*/&partial)) != NO_ERROR) { 1509 switch (err) { 1510 case -ENODEV: 1511 return STATUS_ERROR_FMT(ERROR_DISCONNECTED, 1512 "No camera device with ID \"%s\" currently available", 1513 cameraId.string()); 1514 case -EBUSY: 1515 return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE, 1516 "Higher-priority client using camera, ID \"%s\" currently unavailable", 1517 cameraId.string()); 1518 default: 1519 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, 1520 "Unexpected error %s (%d) opening camera \"%s\"", 1521 strerror(-err), err, cameraId.string()); 1522 } 1523 } 1524 1525 if (clientTmp.get() != nullptr) { 1526 // Handle special case for API1 MediaRecorder where the existing client is returned 1527 device = static_cast<CLIENT*>(clientTmp.get()); 1528 return ret; 1529 } 1530 1531 // give flashlight a chance to close devices if necessary. 1532 mFlashlight->prepareDeviceOpen(cameraId); 1533 1534 int facing = -1; 1535 int deviceVersion = getDeviceVersion(cameraId, /*out*/&facing); 1536 if (facing == -1) { 1537 ALOGE("%s: Unable to get camera device \"%s\" facing", __FUNCTION__, cameraId.string()); 1538 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, 1539 "Unable to get camera device \"%s\" facing", cameraId.string()); 1540 } 1541 1542 sp<BasicClient> tmp = nullptr; 1543 if(!(ret = makeClient(this, cameraCb, clientPackageName, cameraId, facing, clientPid, 1544 clientUid, getpid(), legacyMode, halVersion, deviceVersion, effectiveApiLevel, 1545 /*out*/&tmp)).isOk()) { 1546 return ret; 1547 } 1548 client = static_cast<CLIENT*>(tmp.get()); 1549 1550 LOG_ALWAYS_FATAL_IF(client.get() == nullptr, "%s: CameraService in invalid state", 1551 __FUNCTION__); 1552 1553 if (mModule != nullptr) { 1554 err = client->initialize(mModule); 1555 } else { 1556 err = client->initialize(mCameraProviderManager); 1557 } 1558 1559 if (err != OK) { 1560 ALOGE("%s: Could not initialize client from HAL.", __FUNCTION__); 1561 // Errors could be from the HAL module open call or from AppOpsManager 1562 switch(err) { 1563 case BAD_VALUE: 1564 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT, 1565 "Illegal argument to HAL module for camera \"%s\"", cameraId.string()); 1566 case -EBUSY: 1567 return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE, 1568 "Camera \"%s\" is already open", cameraId.string()); 1569 case -EUSERS: 1570 return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE, 1571 "Too many cameras already open, cannot open camera \"%s\"", 1572 cameraId.string()); 1573 case PERMISSION_DENIED: 1574 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED, 1575 "No permission to open camera \"%s\"", cameraId.string()); 1576 case -EACCES: 1577 return STATUS_ERROR_FMT(ERROR_DISABLED, 1578 "Camera \"%s\" disabled by policy", cameraId.string()); 1579 case -ENODEV: 1580 default: 1581 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, 1582 "Failed to initialize camera \"%s\": %s (%d)", cameraId.string(), 1583 strerror(-err), err); 1584 } 1585 } 1586 1587 // Update shim paremeters for legacy clients 1588 if (effectiveApiLevel == API_1) { 1589 // Assume we have always received a Client subclass for API1 1590 sp<Client> shimClient = reinterpret_cast<Client*>(client.get()); 1591 String8 rawParams = shimClient->getParameters(); 1592 CameraParameters params(rawParams); 1593 1594 auto cameraState = getCameraState(cameraId); 1595 if (cameraState != nullptr) { 1596 cameraState->setShimParams(params); 1597 } else { 1598 ALOGE("%s: Cannot update shim parameters for camera %s, no such device exists.", 1599 __FUNCTION__, cameraId.string()); 1600 } 1601 } 1602 1603 if (shimUpdateOnly) { 1604 // If only updating legacy shim parameters, immediately disconnect client 1605 mServiceLock.unlock(); 1606 client->disconnect(); 1607 mServiceLock.lock(); 1608 } else { 1609 // Otherwise, add client to active clients list 1610 finishConnectLocked(client, partial); 1611 } 1612 } // lock is destroyed, allow further connect calls 1613 1614 // Important: release the mutex here so the client can call back into the service from its 1615 // destructor (can be at the end of the call) 1616 device = client; 1617 return ret; 1618} 1619 1620Status CameraService::setTorchMode(const String16& cameraId, bool enabled, 1621 const sp<IBinder>& clientBinder) { 1622 Mutex::Autolock lock(mServiceLock); 1623 1624 ATRACE_CALL(); 1625 if (enabled && clientBinder == nullptr) { 1626 ALOGE("%s: torch client binder is NULL", __FUNCTION__); 1627 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, 1628 "Torch client Binder is null"); 1629 } 1630 1631 String8 id = String8(cameraId.string()); 1632 int uid = getCallingUid(); 1633 1634 // verify id is valid. 1635 auto state = getCameraState(id); 1636 if (state == nullptr) { 1637 ALOGE("%s: camera id is invalid %s", __FUNCTION__, id.string()); 1638 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT, 1639 "Camera ID \"%s\" is a not valid camera ID", id.string()); 1640 } 1641 1642 StatusInternal cameraStatus = state->getStatus(); 1643 if (cameraStatus != StatusInternal::PRESENT && 1644 cameraStatus != StatusInternal::NOT_AVAILABLE) { 1645 ALOGE("%s: camera id is invalid %s, status %d", __FUNCTION__, id.string(), (int)cameraStatus); 1646 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT, 1647 "Camera ID \"%s\" is a not valid camera ID", id.string()); 1648 } 1649 1650 { 1651 Mutex::Autolock al(mTorchStatusMutex); 1652 TorchModeStatus status; 1653 status_t err = getTorchStatusLocked(id, &status); 1654 if (err != OK) { 1655 if (err == NAME_NOT_FOUND) { 1656 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT, 1657 "Camera \"%s\" does not have a flash unit", id.string()); 1658 } 1659 ALOGE("%s: getting current torch status failed for camera %s", 1660 __FUNCTION__, id.string()); 1661 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, 1662 "Error updating torch status for camera \"%s\": %s (%d)", id.string(), 1663 strerror(-err), err); 1664 } 1665 1666 if (status == TorchModeStatus::NOT_AVAILABLE) { 1667 if (cameraStatus == StatusInternal::NOT_AVAILABLE) { 1668 ALOGE("%s: torch mode of camera %s is not available because " 1669 "camera is in use", __FUNCTION__, id.string()); 1670 return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE, 1671 "Torch for camera \"%s\" is not available due to an existing camera user", 1672 id.string()); 1673 } else { 1674 ALOGE("%s: torch mode of camera %s is not available due to " 1675 "insufficient resources", __FUNCTION__, id.string()); 1676 return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE, 1677 "Torch for camera \"%s\" is not available due to insufficient resources", 1678 id.string()); 1679 } 1680 } 1681 } 1682 1683 { 1684 // Update UID map - this is used in the torch status changed callbacks, so must be done 1685 // before setTorchMode 1686 Mutex::Autolock al(mTorchUidMapMutex); 1687 if (mTorchUidMap.find(id) == mTorchUidMap.end()) { 1688 mTorchUidMap[id].first = uid; 1689 mTorchUidMap[id].second = uid; 1690 } else { 1691 // Set the pending UID 1692 mTorchUidMap[id].first = uid; 1693 } 1694 } 1695 1696 status_t err = mFlashlight->setTorchMode(id, enabled); 1697 1698 if (err != OK) { 1699 int32_t errorCode; 1700 String8 msg; 1701 switch (err) { 1702 case -ENOSYS: 1703 msg = String8::format("Camera \"%s\" has no flashlight", 1704 id.string()); 1705 errorCode = ERROR_ILLEGAL_ARGUMENT; 1706 break; 1707 default: 1708 msg = String8::format( 1709 "Setting torch mode of camera \"%s\" to %d failed: %s (%d)", 1710 id.string(), enabled, strerror(-err), err); 1711 errorCode = ERROR_INVALID_OPERATION; 1712 } 1713 ALOGE("%s: %s", __FUNCTION__, msg.string()); 1714 return STATUS_ERROR(errorCode, msg.string()); 1715 } 1716 1717 { 1718 // update the link to client's death 1719 Mutex::Autolock al(mTorchClientMapMutex); 1720 ssize_t index = mTorchClientMap.indexOfKey(id); 1721 if (enabled) { 1722 if (index == NAME_NOT_FOUND) { 1723 mTorchClientMap.add(id, clientBinder); 1724 } else { 1725 mTorchClientMap.valueAt(index)->unlinkToDeath(this); 1726 mTorchClientMap.replaceValueAt(index, clientBinder); 1727 } 1728 clientBinder->linkToDeath(this); 1729 } else if (index != NAME_NOT_FOUND) { 1730 mTorchClientMap.valueAt(index)->unlinkToDeath(this); 1731 } 1732 } 1733 1734 return Status::ok(); 1735} 1736 1737Status CameraService::notifySystemEvent(int32_t eventId, 1738 const std::vector<int32_t>& args) { 1739 ATRACE_CALL(); 1740 1741 switch(eventId) { 1742 case ICameraService::EVENT_USER_SWITCHED: { 1743 doUserSwitch(/*newUserIds*/ args); 1744 break; 1745 } 1746 case ICameraService::EVENT_NONE: 1747 default: { 1748 ALOGW("%s: Received invalid system event from system_server: %d", __FUNCTION__, 1749 eventId); 1750 break; 1751 } 1752 } 1753 return Status::ok(); 1754} 1755 1756Status CameraService::addListener(const sp<ICameraServiceListener>& listener, 1757 /*out*/ 1758 std::vector<hardware::CameraStatus> *cameraStatuses) { 1759 ATRACE_CALL(); 1760 1761 ALOGV("%s: Add listener %p", __FUNCTION__, listener.get()); 1762 1763 if (listener == nullptr) { 1764 ALOGE("%s: Listener must not be null", __FUNCTION__); 1765 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Null listener given to addListener"); 1766 } 1767 1768 Mutex::Autolock lock(mServiceLock); 1769 1770 { 1771 Mutex::Autolock lock(mStatusListenerLock); 1772 for (auto& it : mListenerList) { 1773 if (IInterface::asBinder(it) == IInterface::asBinder(listener)) { 1774 ALOGW("%s: Tried to add listener %p which was already subscribed", 1775 __FUNCTION__, listener.get()); 1776 return STATUS_ERROR(ERROR_ALREADY_EXISTS, "Listener already registered"); 1777 } 1778 } 1779 1780 mListenerList.push_back(listener); 1781 } 1782 1783 /* Collect current devices and status */ 1784 { 1785 Mutex::Autolock lock(mCameraStatesLock); 1786 for (auto& i : mCameraStates) { 1787 cameraStatuses->emplace_back(i.first, mapToInterface(i.second->getStatus())); 1788 } 1789 } 1790 1791 /* 1792 * Immediately signal current torch status to this listener only 1793 * This may be a subset of all the devices, so don't include it in the response directly 1794 */ 1795 { 1796 Mutex::Autolock al(mTorchStatusMutex); 1797 for (size_t i = 0; i < mTorchStatusMap.size(); i++ ) { 1798 String16 id = String16(mTorchStatusMap.keyAt(i).string()); 1799 listener->onTorchStatusChanged(mapToInterface(mTorchStatusMap.valueAt(i)), id); 1800 } 1801 } 1802 1803 return Status::ok(); 1804} 1805 1806Status CameraService::removeListener(const sp<ICameraServiceListener>& listener) { 1807 ATRACE_CALL(); 1808 1809 ALOGV("%s: Remove listener %p", __FUNCTION__, listener.get()); 1810 1811 if (listener == 0) { 1812 ALOGE("%s: Listener must not be null", __FUNCTION__); 1813 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Null listener given to removeListener"); 1814 } 1815 1816 Mutex::Autolock lock(mServiceLock); 1817 1818 { 1819 Mutex::Autolock lock(mStatusListenerLock); 1820 for (auto it = mListenerList.begin(); it != mListenerList.end(); it++) { 1821 if (IInterface::asBinder(*it) == IInterface::asBinder(listener)) { 1822 mListenerList.erase(it); 1823 return Status::ok(); 1824 } 1825 } 1826 } 1827 1828 ALOGW("%s: Tried to remove a listener %p which was not subscribed", 1829 __FUNCTION__, listener.get()); 1830 1831 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Unregistered listener given to removeListener"); 1832} 1833 1834Status CameraService::getLegacyParameters(int cameraId, /*out*/String16* parameters) { 1835 1836 ATRACE_CALL(); 1837 ALOGV("%s: for camera ID = %d", __FUNCTION__, cameraId); 1838 1839 if (parameters == NULL) { 1840 ALOGE("%s: parameters must not be null", __FUNCTION__); 1841 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Parameters must not be null"); 1842 } 1843 1844 Status ret = Status::ok(); 1845 1846 CameraParameters shimParams; 1847 if (!(ret = getLegacyParametersLazy(cameraId, /*out*/&shimParams)).isOk()) { 1848 // Error logged by caller 1849 return ret; 1850 } 1851 1852 String8 shimParamsString8 = shimParams.flatten(); 1853 String16 shimParamsString16 = String16(shimParamsString8); 1854 1855 *parameters = shimParamsString16; 1856 1857 return ret; 1858} 1859 1860Status CameraService::supportsCameraApi(const String16& cameraId, int apiVersion, 1861 /*out*/ bool *isSupported) { 1862 ATRACE_CALL(); 1863 1864 const String8 id = String8(cameraId); 1865 1866 ALOGV("%s: for camera ID = %s", __FUNCTION__, id.string()); 1867 1868 switch (apiVersion) { 1869 case API_VERSION_1: 1870 case API_VERSION_2: 1871 break; 1872 default: 1873 String8 msg = String8::format("Unknown API version %d", apiVersion); 1874 ALOGE("%s: %s", __FUNCTION__, msg.string()); 1875 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string()); 1876 } 1877 1878 int deviceVersion = getDeviceVersion(id); 1879 switch(deviceVersion) { 1880 case CAMERA_DEVICE_API_VERSION_1_0: 1881 case CAMERA_DEVICE_API_VERSION_3_0: 1882 case CAMERA_DEVICE_API_VERSION_3_1: 1883 if (apiVersion == API_VERSION_2) { 1884 ALOGV("%s: Camera id %s uses HAL version %d <3.2, doesn't support api2 without shim", 1885 __FUNCTION__, id.string(), deviceVersion); 1886 *isSupported = false; 1887 } else { // if (apiVersion == API_VERSION_1) { 1888 ALOGV("%s: Camera id %s uses older HAL before 3.2, but api1 is always supported", 1889 __FUNCTION__, id.string()); 1890 *isSupported = true; 1891 } 1892 break; 1893 case CAMERA_DEVICE_API_VERSION_3_2: 1894 case CAMERA_DEVICE_API_VERSION_3_3: 1895 case CAMERA_DEVICE_API_VERSION_3_4: 1896 ALOGV("%s: Camera id %s uses HAL3.2 or newer, supports api1/api2 directly", 1897 __FUNCTION__, id.string()); 1898 *isSupported = true; 1899 break; 1900 case -1: { 1901 String8 msg = String8::format("Unknown camera ID %s", id.string()); 1902 ALOGE("%s: %s", __FUNCTION__, msg.string()); 1903 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string()); 1904 } 1905 default: { 1906 String8 msg = String8::format("Unknown device version %x for device %s", 1907 deviceVersion, id.string()); 1908 ALOGE("%s: %s", __FUNCTION__, msg.string()); 1909 return STATUS_ERROR(ERROR_INVALID_OPERATION, msg.string()); 1910 } 1911 } 1912 1913 return Status::ok(); 1914} 1915 1916void CameraService::removeByClient(const BasicClient* client) { 1917 Mutex::Autolock lock(mServiceLock); 1918 for (auto& i : mActiveClientManager.getAll()) { 1919 auto clientSp = i->getValue(); 1920 if (clientSp.get() == client) { 1921 mActiveClientManager.remove(i); 1922 } 1923 } 1924} 1925 1926bool CameraService::evictClientIdByRemote(const wp<IBinder>& remote) { 1927 const int callingPid = getCallingPid(); 1928 const int servicePid = getpid(); 1929 bool ret = false; 1930 { 1931 // Acquire mServiceLock and prevent other clients from connecting 1932 std::unique_ptr<AutoConditionLock> lock = 1933 AutoConditionLock::waitAndAcquire(mServiceLockWrapper); 1934 1935 1936 std::vector<sp<BasicClient>> evicted; 1937 for (auto& i : mActiveClientManager.getAll()) { 1938 auto clientSp = i->getValue(); 1939 if (clientSp.get() == nullptr) { 1940 ALOGE("%s: Dead client still in mActiveClientManager.", __FUNCTION__); 1941 mActiveClientManager.remove(i); 1942 continue; 1943 } 1944 if (remote == clientSp->getRemote() && (callingPid == servicePid || 1945 callingPid == clientSp->getClientPid())) { 1946 mActiveClientManager.remove(i); 1947 evicted.push_back(clientSp); 1948 1949 // Notify the client of disconnection 1950 clientSp->notifyError( 1951 hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED, 1952 CaptureResultExtras()); 1953 } 1954 } 1955 1956 // Do not hold mServiceLock while disconnecting clients, but retain the condition blocking 1957 // other clients from connecting in mServiceLockWrapper if held 1958 mServiceLock.unlock(); 1959 1960 // Do not clear caller identity, remote caller should be client proccess 1961 1962 for (auto& i : evicted) { 1963 if (i.get() != nullptr) { 1964 i->disconnect(); 1965 ret = true; 1966 } 1967 } 1968 1969 // Reacquire mServiceLock 1970 mServiceLock.lock(); 1971 1972 } // lock is destroyed, allow further connect calls 1973 1974 return ret; 1975} 1976 1977 1978/** 1979 * Check camera capabilities, such as support for basic color operation 1980 * Also check that the device HAL version is still in support 1981 */ 1982int CameraService::checkCameraCapabilities(int id, camera_info info, int *latestStrangeCameraId) { 1983 if (mModule == nullptr) return NO_INIT; 1984 1985 // device_version undefined in CAMERA_MODULE_API_VERSION_1_0, 1986 // All CAMERA_MODULE_API_VERSION_1_0 devices are backward-compatible 1987 if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0) { 1988 // Verify the device version is in the supported range 1989 switch (info.device_version) { 1990 case CAMERA_DEVICE_API_VERSION_1_0: 1991 case CAMERA_DEVICE_API_VERSION_3_0: 1992 case CAMERA_DEVICE_API_VERSION_3_1: 1993 case CAMERA_DEVICE_API_VERSION_3_2: 1994 case CAMERA_DEVICE_API_VERSION_3_3: 1995 case CAMERA_DEVICE_API_VERSION_3_4: 1996 // in support 1997 break; 1998 case CAMERA_DEVICE_API_VERSION_2_0: 1999 case CAMERA_DEVICE_API_VERSION_2_1: 2000 // no longer supported 2001 default: 2002 ALOGE("%s: Device %d has HAL version %x, which is not supported", 2003 __FUNCTION__, id, info.device_version); 2004 String8 msg = String8::format( 2005 "Unsupported device HAL version %x for device %d", 2006 info.device_version, id); 2007 logServiceError(msg.string(), NO_INIT); 2008 return NO_INIT; 2009 } 2010 } 2011 2012 // Assume all devices pre-v3.3 are backward-compatible 2013 bool isBackwardCompatible = true; 2014 if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0 2015 && info.device_version >= CAMERA_DEVICE_API_VERSION_3_3) { 2016 isBackwardCompatible = false; 2017 status_t res; 2018 camera_metadata_ro_entry_t caps; 2019 res = find_camera_metadata_ro_entry( 2020 info.static_camera_characteristics, 2021 ANDROID_REQUEST_AVAILABLE_CAPABILITIES, 2022 &caps); 2023 if (res != 0) { 2024 ALOGW("%s: Unable to find camera capabilities for camera device %d", 2025 __FUNCTION__, id); 2026 caps.count = 0; 2027 } 2028 for (size_t i = 0; i < caps.count; i++) { 2029 if (caps.data.u8[i] == 2030 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) { 2031 isBackwardCompatible = true; 2032 break; 2033 } 2034 } 2035 } 2036 2037 if (!isBackwardCompatible) { 2038 mNumberOfNormalCameras--; 2039 *latestStrangeCameraId = id; 2040 } else { 2041 if (id > *latestStrangeCameraId) { 2042 ALOGE("%s: Normal camera ID %d higher than strange camera ID %d. " 2043 "This is not allowed due backward-compatibility requirements", 2044 __FUNCTION__, id, *latestStrangeCameraId); 2045 logServiceError("Invalid order of camera devices", NO_INIT); 2046 mNumberOfCameras = 0; 2047 mNumberOfNormalCameras = 0; 2048 return NO_INIT; 2049 } 2050 } 2051 return OK; 2052} 2053 2054std::shared_ptr<CameraService::CameraState> CameraService::getCameraState( 2055 const String8& cameraId) const { 2056 std::shared_ptr<CameraState> state; 2057 { 2058 Mutex::Autolock lock(mCameraStatesLock); 2059 auto iter = mCameraStates.find(cameraId); 2060 if (iter != mCameraStates.end()) { 2061 state = iter->second; 2062 } 2063 } 2064 return state; 2065} 2066 2067sp<CameraService::BasicClient> CameraService::removeClientLocked(const String8& cameraId) { 2068 // Remove from active clients list 2069 auto clientDescriptorPtr = mActiveClientManager.remove(cameraId); 2070 if (clientDescriptorPtr == nullptr) { 2071 ALOGW("%s: Could not evict client, no client for camera ID %s", __FUNCTION__, 2072 cameraId.string()); 2073 return sp<BasicClient>{nullptr}; 2074 } 2075 2076 return clientDescriptorPtr->getValue(); 2077} 2078 2079void CameraService::doUserSwitch(const std::vector<int32_t>& newUserIds) { 2080 // Acquire mServiceLock and prevent other clients from connecting 2081 std::unique_ptr<AutoConditionLock> lock = 2082 AutoConditionLock::waitAndAcquire(mServiceLockWrapper); 2083 2084 std::set<userid_t> newAllowedUsers; 2085 for (size_t i = 0; i < newUserIds.size(); i++) { 2086 if (newUserIds[i] < 0) { 2087 ALOGE("%s: Bad user ID %d given during user switch, ignoring.", 2088 __FUNCTION__, newUserIds[i]); 2089 return; 2090 } 2091 newAllowedUsers.insert(static_cast<userid_t>(newUserIds[i])); 2092 } 2093 2094 2095 if (newAllowedUsers == mAllowedUsers) { 2096 ALOGW("%s: Received notification of user switch with no updated user IDs.", __FUNCTION__); 2097 return; 2098 } 2099 2100 logUserSwitch(mAllowedUsers, newAllowedUsers); 2101 2102 mAllowedUsers = std::move(newAllowedUsers); 2103 2104 // Current user has switched, evict all current clients. 2105 std::vector<sp<BasicClient>> evicted; 2106 for (auto& i : mActiveClientManager.getAll()) { 2107 auto clientSp = i->getValue(); 2108 2109 if (clientSp.get() == nullptr) { 2110 ALOGE("%s: Dead client still in mActiveClientManager.", __FUNCTION__); 2111 continue; 2112 } 2113 2114 // Don't evict clients that are still allowed. 2115 uid_t clientUid = clientSp->getClientUid(); 2116 userid_t clientUserId = multiuser_get_user_id(clientUid); 2117 if (mAllowedUsers.find(clientUserId) != mAllowedUsers.end()) { 2118 continue; 2119 } 2120 2121 evicted.push_back(clientSp); 2122 2123 String8 curTime = getFormattedCurrentTime(); 2124 2125 ALOGE("Evicting conflicting client for camera ID %s due to user change", 2126 i->getKey().string()); 2127 2128 // Log the clients evicted 2129 logEvent(String8::format("EVICT device %s client held by package %s (PID %" 2130 PRId32 ", score %" PRId32 ", state %" PRId32 ")\n - Evicted due" 2131 " to user switch.", i->getKey().string(), 2132 String8{clientSp->getPackageName()}.string(), 2133 i->getOwnerId(), i->getPriority().getScore(), 2134 i->getPriority().getState())); 2135 2136 } 2137 2138 // Do not hold mServiceLock while disconnecting clients, but retain the condition 2139 // blocking other clients from connecting in mServiceLockWrapper if held. 2140 mServiceLock.unlock(); 2141 2142 // Clear caller identity temporarily so client disconnect PID checks work correctly 2143 int64_t token = IPCThreadState::self()->clearCallingIdentity(); 2144 2145 for (auto& i : evicted) { 2146 i->disconnect(); 2147 } 2148 2149 IPCThreadState::self()->restoreCallingIdentity(token); 2150 2151 // Reacquire mServiceLock 2152 mServiceLock.lock(); 2153} 2154 2155void CameraService::logEvent(const char* event) { 2156 String8 curTime = getFormattedCurrentTime(); 2157 Mutex::Autolock l(mLogLock); 2158 mEventLog.add(String8::format("%s : %s", curTime.string(), event)); 2159} 2160 2161void CameraService::logDisconnected(const char* cameraId, int clientPid, 2162 const char* clientPackage) { 2163 // Log the clients evicted 2164 logEvent(String8::format("DISCONNECT device %s client for package %s (PID %d)", cameraId, 2165 clientPackage, clientPid)); 2166} 2167 2168void CameraService::logConnected(const char* cameraId, int clientPid, 2169 const char* clientPackage) { 2170 // Log the clients evicted 2171 logEvent(String8::format("CONNECT device %s client for package %s (PID %d)", cameraId, 2172 clientPackage, clientPid)); 2173} 2174 2175void CameraService::logRejected(const char* cameraId, int clientPid, 2176 const char* clientPackage, const char* reason) { 2177 // Log the client rejected 2178 logEvent(String8::format("REJECT device %s client for package %s (PID %d), reason: (%s)", 2179 cameraId, clientPackage, clientPid, reason)); 2180} 2181 2182void CameraService::logUserSwitch(const std::set<userid_t>& oldUserIds, 2183 const std::set<userid_t>& newUserIds) { 2184 String8 newUsers = toString(newUserIds); 2185 String8 oldUsers = toString(oldUserIds); 2186 if (oldUsers.size() == 0) { 2187 oldUsers = "<None>"; 2188 } 2189 // Log the new and old users 2190 logEvent(String8::format("USER_SWITCH previous allowed user IDs: %s, current allowed user IDs: %s", 2191 oldUsers.string(), newUsers.string())); 2192} 2193 2194void CameraService::logDeviceRemoved(const char* cameraId, const char* reason) { 2195 // Log the device removal 2196 logEvent(String8::format("REMOVE device %s, reason: (%s)", cameraId, reason)); 2197} 2198 2199void CameraService::logDeviceAdded(const char* cameraId, const char* reason) { 2200 // Log the device removal 2201 logEvent(String8::format("ADD device %s, reason: (%s)", cameraId, reason)); 2202} 2203 2204void CameraService::logClientDied(int clientPid, const char* reason) { 2205 // Log the device removal 2206 logEvent(String8::format("DIED client(s) with PID %d, reason: (%s)", clientPid, reason)); 2207} 2208 2209void CameraService::logServiceError(const char* msg, int errorCode) { 2210 String8 curTime = getFormattedCurrentTime(); 2211 logEvent(String8::format("SERVICE ERROR: %s : %d (%s)", msg, errorCode, strerror(-errorCode))); 2212} 2213 2214status_t CameraService::onTransact(uint32_t code, const Parcel& data, Parcel* reply, 2215 uint32_t flags) { 2216 2217 const int pid = getCallingPid(); 2218 const int selfPid = getpid(); 2219 2220 // Permission checks 2221 switch (code) { 2222 case BnCameraService::NOTIFYSYSTEMEVENT: { 2223 if (pid != selfPid) { 2224 // Ensure we're being called by system_server, or similar process with 2225 // permissions to notify the camera service about system events 2226 if (!checkCallingPermission( 2227 String16("android.permission.CAMERA_SEND_SYSTEM_EVENTS"))) { 2228 const int uid = getCallingUid(); 2229 ALOGE("Permission Denial: cannot send updates to camera service about system" 2230 " events from pid=%d, uid=%d", pid, uid); 2231 return PERMISSION_DENIED; 2232 } 2233 } 2234 break; 2235 } 2236 } 2237 2238 return BnCameraService::onTransact(code, data, reply, flags); 2239} 2240 2241// We share the media players for shutter and recording sound for all clients. 2242// A reference count is kept to determine when we will actually release the 2243// media players. 2244 2245MediaPlayer* CameraService::newMediaPlayer(const char *file) { 2246 MediaPlayer* mp = new MediaPlayer(); 2247 if (mp->setDataSource(NULL /* httpService */, file, NULL) == NO_ERROR) { 2248 mp->setAudioStreamType(AUDIO_STREAM_ENFORCED_AUDIBLE); 2249 mp->prepare(); 2250 } else { 2251 ALOGE("Failed to load CameraService sounds: %s", file); 2252 return NULL; 2253 } 2254 return mp; 2255} 2256 2257void CameraService::loadSound() { 2258 ATRACE_CALL(); 2259 2260 Mutex::Autolock lock(mSoundLock); 2261 LOG1("CameraService::loadSound ref=%d", mSoundRef); 2262 if (mSoundRef++) return; 2263 2264 mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/system/media/audio/ui/camera_click.ogg"); 2265 mSoundPlayer[SOUND_RECORDING_START] = newMediaPlayer("/system/media/audio/ui/VideoRecord.ogg"); 2266 mSoundPlayer[SOUND_RECORDING_STOP] = newMediaPlayer("/system/media/audio/ui/VideoStop.ogg"); 2267} 2268 2269void CameraService::releaseSound() { 2270 Mutex::Autolock lock(mSoundLock); 2271 LOG1("CameraService::releaseSound ref=%d", mSoundRef); 2272 if (--mSoundRef) return; 2273 2274 for (int i = 0; i < NUM_SOUNDS; i++) { 2275 if (mSoundPlayer[i] != 0) { 2276 mSoundPlayer[i]->disconnect(); 2277 mSoundPlayer[i].clear(); 2278 } 2279 } 2280} 2281 2282void CameraService::playSound(sound_kind kind) { 2283 ATRACE_CALL(); 2284 2285 LOG1("playSound(%d)", kind); 2286 Mutex::Autolock lock(mSoundLock); 2287 sp<MediaPlayer> player = mSoundPlayer[kind]; 2288 if (player != 0) { 2289 player->seekTo(0); 2290 player->start(); 2291 } 2292} 2293 2294// ---------------------------------------------------------------------------- 2295 2296CameraService::Client::Client(const sp<CameraService>& cameraService, 2297 const sp<ICameraClient>& cameraClient, 2298 const String16& clientPackageName, 2299 const String8& cameraIdStr, int cameraFacing, 2300 int clientPid, uid_t clientUid, 2301 int servicePid) : 2302 CameraService::BasicClient(cameraService, 2303 IInterface::asBinder(cameraClient), 2304 clientPackageName, 2305 cameraIdStr, cameraFacing, 2306 clientPid, clientUid, 2307 servicePid), 2308 mCameraId(CameraService::cameraIdToInt(cameraIdStr)) 2309{ 2310 int callingPid = getCallingPid(); 2311 LOG1("Client::Client E (pid %d, id %d)", callingPid, mCameraId); 2312 2313 mRemoteCallback = cameraClient; 2314 2315 cameraService->loadSound(); 2316 2317 LOG1("Client::Client X (pid %d, id %d)", callingPid, mCameraId); 2318} 2319 2320// tear down the client 2321CameraService::Client::~Client() { 2322 ALOGV("~Client"); 2323 mDestructionStarted = true; 2324 2325 sCameraService->releaseSound(); 2326 // unconditionally disconnect. function is idempotent 2327 Client::disconnect(); 2328} 2329 2330sp<CameraService> CameraService::BasicClient::BasicClient::sCameraService; 2331 2332CameraService::BasicClient::BasicClient(const sp<CameraService>& cameraService, 2333 const sp<IBinder>& remoteCallback, 2334 const String16& clientPackageName, 2335 const String8& cameraIdStr, int cameraFacing, 2336 int clientPid, uid_t clientUid, 2337 int servicePid): 2338 mCameraIdStr(cameraIdStr), mCameraFacing(cameraFacing), 2339 mClientPackageName(clientPackageName), mClientPid(clientPid), mClientUid(clientUid), 2340 mServicePid(servicePid), 2341 mDisconnected(false), 2342 mRemoteBinder(remoteCallback) 2343{ 2344 if (sCameraService == nullptr) { 2345 sCameraService = cameraService; 2346 } 2347 mOpsActive = false; 2348 mDestructionStarted = false; 2349 2350 // In some cases the calling code has no access to the package it runs under. 2351 // For example, NDK camera API. 2352 // In this case we will get the packages for the calling UID and pick the first one 2353 // for attributing the app op. This will work correctly for runtime permissions 2354 // as for legacy apps we will toggle the app op for all packages in the UID. 2355 // The caveat is that the operation may be attributed to the wrong package and 2356 // stats based on app ops may be slightly off. 2357 if (mClientPackageName.size() <= 0) { 2358 sp<IServiceManager> sm = defaultServiceManager(); 2359 sp<IBinder> binder = sm->getService(String16(kPermissionServiceName)); 2360 if (binder == 0) { 2361 ALOGE("Cannot get permission service"); 2362 // Leave mClientPackageName unchanged (empty) and the further interaction 2363 // with camera will fail in BasicClient::startCameraOps 2364 return; 2365 } 2366 2367 sp<IPermissionController> permCtrl = interface_cast<IPermissionController>(binder); 2368 Vector<String16> packages; 2369 2370 permCtrl->getPackagesForUid(mClientUid, packages); 2371 2372 if (packages.isEmpty()) { 2373 ALOGE("No packages for calling UID"); 2374 // Leave mClientPackageName unchanged (empty) and the further interaction 2375 // with camera will fail in BasicClient::startCameraOps 2376 return; 2377 } 2378 mClientPackageName = packages[0]; 2379 } 2380} 2381 2382CameraService::BasicClient::~BasicClient() { 2383 ALOGV("~BasicClient"); 2384 mDestructionStarted = true; 2385} 2386 2387binder::Status CameraService::BasicClient::disconnect() { 2388 binder::Status res = Status::ok(); 2389 if (mDisconnected) { 2390 return res; 2391 } 2392 mDisconnected = true; 2393 2394 sCameraService->removeByClient(this); 2395 sCameraService->logDisconnected(mCameraIdStr, mClientPid, 2396 String8(mClientPackageName)); 2397 2398 sp<IBinder> remote = getRemote(); 2399 if (remote != nullptr) { 2400 remote->unlinkToDeath(sCameraService); 2401 } 2402 2403 finishCameraOps(); 2404 // Notify flashlight that a camera device is closed. 2405 sCameraService->mFlashlight->deviceClosed(mCameraIdStr); 2406 ALOGI("%s: Disconnected client for camera %s for PID %d", __FUNCTION__, mCameraIdStr.string(), 2407 mClientPid); 2408 2409 // client shouldn't be able to call into us anymore 2410 mClientPid = 0; 2411 2412 return res; 2413} 2414 2415status_t CameraService::BasicClient::dump(int, const Vector<String16>&) { 2416 // No dumping of clients directly over Binder, 2417 // must go through CameraService::dump 2418 android_errorWriteWithInfoLog(SN_EVENT_LOG_ID, "26265403", 2419 IPCThreadState::self()->getCallingUid(), NULL, 0); 2420 return OK; 2421} 2422 2423String16 CameraService::BasicClient::getPackageName() const { 2424 return mClientPackageName; 2425} 2426 2427 2428int CameraService::BasicClient::getClientPid() const { 2429 return mClientPid; 2430} 2431 2432uid_t CameraService::BasicClient::getClientUid() const { 2433 return mClientUid; 2434} 2435 2436bool CameraService::BasicClient::canCastToApiClient(apiLevel level) const { 2437 // Defaults to API2. 2438 return level == API_2; 2439} 2440 2441status_t CameraService::BasicClient::startCameraOps() { 2442 ATRACE_CALL(); 2443 2444 int32_t res; 2445 // Notify app ops that the camera is not available 2446 mOpsCallback = new OpsCallback(this); 2447 2448 { 2449 ALOGV("%s: Start camera ops, package name = %s, client UID = %d", 2450 __FUNCTION__, String8(mClientPackageName).string(), mClientUid); 2451 } 2452 2453 mAppOpsManager.startWatchingMode(AppOpsManager::OP_CAMERA, 2454 mClientPackageName, mOpsCallback); 2455 res = mAppOpsManager.startOp(AppOpsManager::OP_CAMERA, 2456 mClientUid, mClientPackageName); 2457 2458 if (res == AppOpsManager::MODE_ERRORED) { 2459 ALOGI("Camera %s: Access for \"%s\" has been revoked", 2460 mCameraIdStr.string(), String8(mClientPackageName).string()); 2461 return PERMISSION_DENIED; 2462 } 2463 2464 if (res == AppOpsManager::MODE_IGNORED) { 2465 ALOGI("Camera %s: Access for \"%s\" has been restricted", 2466 mCameraIdStr.string(), String8(mClientPackageName).string()); 2467 // Return the same error as for device policy manager rejection 2468 return -EACCES; 2469 } 2470 2471 mOpsActive = true; 2472 2473 // Transition device availability listeners from PRESENT -> NOT_AVAILABLE 2474 sCameraService->updateStatus(StatusInternal::NOT_AVAILABLE, mCameraIdStr); 2475 2476 // Transition device state to OPEN 2477 sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_OPEN, 2478 mCameraIdStr); 2479 2480 return OK; 2481} 2482 2483status_t CameraService::BasicClient::finishCameraOps() { 2484 ATRACE_CALL(); 2485 2486 // Check if startCameraOps succeeded, and if so, finish the camera op 2487 if (mOpsActive) { 2488 // Notify app ops that the camera is available again 2489 mAppOpsManager.finishOp(AppOpsManager::OP_CAMERA, mClientUid, 2490 mClientPackageName); 2491 mOpsActive = false; 2492 2493 std::initializer_list<StatusInternal> rejected = {StatusInternal::PRESENT, 2494 StatusInternal::ENUMERATING}; 2495 2496 // Transition to PRESENT if the camera is not in either of the rejected states 2497 sCameraService->updateStatus(StatusInternal::PRESENT, 2498 mCameraIdStr, rejected); 2499 2500 // Transition device state to CLOSED 2501 sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_CLOSED, 2502 mCameraIdStr); 2503 } 2504 // Always stop watching, even if no camera op is active 2505 if (mOpsCallback != NULL) { 2506 mAppOpsManager.stopWatchingMode(mOpsCallback); 2507 } 2508 mOpsCallback.clear(); 2509 2510 return OK; 2511} 2512 2513void CameraService::BasicClient::opChanged(int32_t op, const String16& packageName) { 2514 ATRACE_CALL(); 2515 2516 String8 name(packageName); 2517 String8 myName(mClientPackageName); 2518 2519 if (op != AppOpsManager::OP_CAMERA) { 2520 ALOGW("Unexpected app ops notification received: %d", op); 2521 return; 2522 } 2523 2524 int32_t res; 2525 res = mAppOpsManager.checkOp(AppOpsManager::OP_CAMERA, 2526 mClientUid, mClientPackageName); 2527 ALOGV("checkOp returns: %d, %s ", res, 2528 res == AppOpsManager::MODE_ALLOWED ? "ALLOWED" : 2529 res == AppOpsManager::MODE_IGNORED ? "IGNORED" : 2530 res == AppOpsManager::MODE_ERRORED ? "ERRORED" : 2531 "UNKNOWN"); 2532 2533 if (res != AppOpsManager::MODE_ALLOWED) { 2534 ALOGI("Camera %s: Access for \"%s\" revoked", mCameraIdStr.string(), 2535 myName.string()); 2536 // Reset the client PID to allow server-initiated disconnect, 2537 // and to prevent further calls by client. 2538 mClientPid = getCallingPid(); 2539 CaptureResultExtras resultExtras; // a dummy result (invalid) 2540 notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_SERVICE, resultExtras); 2541 disconnect(); 2542 } 2543} 2544 2545// ---------------------------------------------------------------------------- 2546 2547void CameraService::Client::notifyError(int32_t errorCode, 2548 const CaptureResultExtras& resultExtras) { 2549 (void) errorCode; 2550 (void) resultExtras; 2551 if (mRemoteCallback != NULL) { 2552 mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, CAMERA_ERROR_RELEASED, 0); 2553 } else { 2554 ALOGE("mRemoteCallback is NULL!!"); 2555 } 2556} 2557 2558// NOTE: function is idempotent 2559binder::Status CameraService::Client::disconnect() { 2560 ALOGV("Client::disconnect"); 2561 return BasicClient::disconnect(); 2562} 2563 2564bool CameraService::Client::canCastToApiClient(apiLevel level) const { 2565 return level == API_1; 2566} 2567 2568CameraService::Client::OpsCallback::OpsCallback(wp<BasicClient> client): 2569 mClient(client) { 2570} 2571 2572void CameraService::Client::OpsCallback::opChanged(int32_t op, 2573 const String16& packageName) { 2574 sp<BasicClient> client = mClient.promote(); 2575 if (client != NULL) { 2576 client->opChanged(op, packageName); 2577 } 2578} 2579 2580// ---------------------------------------------------------------------------- 2581// CameraState 2582// ---------------------------------------------------------------------------- 2583 2584CameraService::CameraState::CameraState(const String8& id, int cost, 2585 const std::set<String8>& conflicting) : mId(id), 2586 mStatus(StatusInternal::PRESENT), mCost(cost), mConflicting(conflicting) {} 2587 2588CameraService::CameraState::~CameraState() {} 2589 2590CameraService::StatusInternal CameraService::CameraState::getStatus() const { 2591 Mutex::Autolock lock(mStatusLock); 2592 return mStatus; 2593} 2594 2595CameraParameters CameraService::CameraState::getShimParams() const { 2596 return mShimParams; 2597} 2598 2599void CameraService::CameraState::setShimParams(const CameraParameters& params) { 2600 mShimParams = params; 2601} 2602 2603int CameraService::CameraState::getCost() const { 2604 return mCost; 2605} 2606 2607std::set<String8> CameraService::CameraState::getConflicting() const { 2608 return mConflicting; 2609} 2610 2611String8 CameraService::CameraState::getId() const { 2612 return mId; 2613} 2614 2615// ---------------------------------------------------------------------------- 2616// ClientEventListener 2617// ---------------------------------------------------------------------------- 2618 2619void CameraService::ClientEventListener::onClientAdded( 2620 const resource_policy::ClientDescriptor<String8, 2621 sp<CameraService::BasicClient>>& descriptor) { 2622 const auto& basicClient = descriptor.getValue(); 2623 if (basicClient.get() != nullptr) { 2624 BatteryNotifier& notifier(BatteryNotifier::getInstance()); 2625 notifier.noteStartCamera(descriptor.getKey(), 2626 static_cast<int>(basicClient->getClientUid())); 2627 } 2628} 2629 2630void CameraService::ClientEventListener::onClientRemoved( 2631 const resource_policy::ClientDescriptor<String8, 2632 sp<CameraService::BasicClient>>& descriptor) { 2633 const auto& basicClient = descriptor.getValue(); 2634 if (basicClient.get() != nullptr) { 2635 BatteryNotifier& notifier(BatteryNotifier::getInstance()); 2636 notifier.noteStopCamera(descriptor.getKey(), 2637 static_cast<int>(basicClient->getClientUid())); 2638 } 2639} 2640 2641 2642// ---------------------------------------------------------------------------- 2643// CameraClientManager 2644// ---------------------------------------------------------------------------- 2645 2646CameraService::CameraClientManager::CameraClientManager() { 2647 setListener(std::make_shared<ClientEventListener>()); 2648} 2649 2650CameraService::CameraClientManager::~CameraClientManager() {} 2651 2652sp<CameraService::BasicClient> CameraService::CameraClientManager::getCameraClient( 2653 const String8& id) const { 2654 auto descriptor = get(id); 2655 if (descriptor == nullptr) { 2656 return sp<BasicClient>{nullptr}; 2657 } 2658 return descriptor->getValue(); 2659} 2660 2661String8 CameraService::CameraClientManager::toString() const { 2662 auto all = getAll(); 2663 String8 ret("["); 2664 bool hasAny = false; 2665 for (auto& i : all) { 2666 hasAny = true; 2667 String8 key = i->getKey(); 2668 int32_t cost = i->getCost(); 2669 int32_t pid = i->getOwnerId(); 2670 int32_t score = i->getPriority().getScore(); 2671 int32_t state = i->getPriority().getState(); 2672 auto conflicting = i->getConflicting(); 2673 auto clientSp = i->getValue(); 2674 String8 packageName; 2675 userid_t clientUserId = 0; 2676 if (clientSp.get() != nullptr) { 2677 packageName = String8{clientSp->getPackageName()}; 2678 uid_t clientUid = clientSp->getClientUid(); 2679 clientUserId = multiuser_get_user_id(clientUid); 2680 } 2681 ret.appendFormat("\n(Camera ID: %s, Cost: %" PRId32 ", PID: %" PRId32 ", Score: %" 2682 PRId32 ", State: %" PRId32, key.string(), cost, pid, score, state); 2683 2684 if (clientSp.get() != nullptr) { 2685 ret.appendFormat("User Id: %d, ", clientUserId); 2686 } 2687 if (packageName.size() != 0) { 2688 ret.appendFormat("Client Package Name: %s", packageName.string()); 2689 } 2690 2691 ret.append(", Conflicting Client Devices: {"); 2692 for (auto& j : conflicting) { 2693 ret.appendFormat("%s, ", j.string()); 2694 } 2695 ret.append("})"); 2696 } 2697 if (hasAny) ret.append("\n"); 2698 ret.append("]\n"); 2699 return ret; 2700} 2701 2702CameraService::DescriptorPtr CameraService::CameraClientManager::makeClientDescriptor( 2703 const String8& key, const sp<BasicClient>& value, int32_t cost, 2704 const std::set<String8>& conflictingKeys, int32_t score, int32_t ownerId, 2705 int32_t state) { 2706 2707 return std::make_shared<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>( 2708 key, value, cost, conflictingKeys, score, ownerId, state); 2709} 2710 2711CameraService::DescriptorPtr CameraService::CameraClientManager::makeClientDescriptor( 2712 const sp<BasicClient>& value, const CameraService::DescriptorPtr& partial) { 2713 return makeClientDescriptor(partial->getKey(), value, partial->getCost(), 2714 partial->getConflicting(), partial->getPriority().getScore(), 2715 partial->getOwnerId(), partial->getPriority().getState()); 2716} 2717 2718// ---------------------------------------------------------------------------- 2719 2720static const int kDumpLockRetries = 50; 2721static const int kDumpLockSleep = 60000; 2722 2723static bool tryLock(Mutex& mutex) 2724{ 2725 bool locked = false; 2726 for (int i = 0; i < kDumpLockRetries; ++i) { 2727 if (mutex.tryLock() == NO_ERROR) { 2728 locked = true; 2729 break; 2730 } 2731 usleep(kDumpLockSleep); 2732 } 2733 return locked; 2734} 2735 2736status_t CameraService::dump(int fd, const Vector<String16>& args) { 2737 ATRACE_CALL(); 2738 2739 if (checkCallingPermission(String16("android.permission.DUMP")) == false) { 2740 dprintf(fd, "Permission Denial: can't dump CameraService from pid=%d, uid=%d\n", 2741 getCallingPid(), 2742 getCallingUid()); 2743 return NO_ERROR; 2744 } 2745 bool locked = tryLock(mServiceLock); 2746 // failed to lock - CameraService is probably deadlocked 2747 if (!locked) { 2748 dprintf(fd, "!! CameraService may be deadlocked !!\n"); 2749 } 2750 2751 if (!mInitialized) { 2752 dprintf(fd, "!! No camera HAL available !!\n"); 2753 2754 // Dump event log for error information 2755 dumpEventLog(fd); 2756 2757 if (locked) mServiceLock.unlock(); 2758 return NO_ERROR; 2759 } 2760 dprintf(fd, "\n== Service global info: ==\n\n"); 2761 dprintf(fd, "Number of camera devices: %d\n", mNumberOfCameras); 2762 dprintf(fd, "Number of normal camera devices: %d\n", mNumberOfNormalCameras); 2763 String8 activeClientString = mActiveClientManager.toString(); 2764 dprintf(fd, "Active Camera Clients:\n%s", activeClientString.string()); 2765 dprintf(fd, "Allowed user IDs: %s\n", toString(mAllowedUsers).string()); 2766 2767 dumpEventLog(fd); 2768 2769 bool stateLocked = tryLock(mCameraStatesLock); 2770 if (!stateLocked) { 2771 dprintf(fd, "CameraStates in use, may be deadlocked\n"); 2772 } 2773 2774 for (auto& state : mCameraStates) { 2775 String8 cameraId = state.first; 2776 2777 dprintf(fd, "== Camera device %s dynamic info: ==\n", cameraId.string()); 2778 2779 CameraParameters p = state.second->getShimParams(); 2780 if (!p.isEmpty()) { 2781 dprintf(fd, " Camera1 API shim is using parameters:\n "); 2782 p.dump(fd, args); 2783 } 2784 2785 auto clientDescriptor = mActiveClientManager.get(cameraId); 2786 if (clientDescriptor != nullptr) { 2787 dprintf(fd, " Device %s is open. Client instance dump:\n", 2788 cameraId.string()); 2789 dprintf(fd, " Client priority score: %d state: %d\n", 2790 clientDescriptor->getPriority().getScore(), 2791 clientDescriptor->getPriority().getState()); 2792 dprintf(fd, " Client PID: %d\n", clientDescriptor->getOwnerId()); 2793 2794 auto client = clientDescriptor->getValue(); 2795 dprintf(fd, " Client package: %s\n", 2796 String8(client->getPackageName()).string()); 2797 2798 client->dumpClient(fd, args); 2799 } else { 2800 dprintf(fd, " Device %s is closed, no client instance\n", 2801 cameraId.string()); 2802 } 2803 2804 if (mModule != nullptr) { 2805 dprintf(fd, "== Camera HAL device %s static information: ==\n", cameraId.string()); 2806 2807 camera_info info; 2808 status_t rc = mModule->getCameraInfo(cameraIdToInt(cameraId), &info); 2809 int deviceVersion = -1; 2810 if (rc != OK) { 2811 dprintf(fd, " Error reading static information!\n"); 2812 } else { 2813 dprintf(fd, " Facing: %s\n", 2814 info.facing == CAMERA_FACING_BACK ? "BACK" : 2815 info.facing == CAMERA_FACING_FRONT ? "FRONT" : "EXTERNAL"); 2816 dprintf(fd, " Orientation: %d\n", info.orientation); 2817 2818 if (mModule->getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_0) { 2819 deviceVersion = CAMERA_DEVICE_API_VERSION_1_0; 2820 } else { 2821 deviceVersion = info.device_version; 2822 } 2823 } 2824 2825 auto conflicting = state.second->getConflicting(); 2826 dprintf(fd, " Resource Cost: %d\n", state.second->getCost()); 2827 dprintf(fd, " Conflicting Devices:"); 2828 for (auto& id : conflicting) { 2829 dprintf(fd, " %s", id.string()); 2830 } 2831 if (conflicting.size() == 0) { 2832 dprintf(fd, " NONE"); 2833 } 2834 dprintf(fd, "\n"); 2835 2836 dprintf(fd, " Device version: %#x\n", deviceVersion); 2837 if (deviceVersion >= CAMERA_DEVICE_API_VERSION_3_0) { 2838 dprintf(fd, " Device static metadata:\n"); 2839 dump_indented_camera_metadata(info.static_camera_characteristics, 2840 fd, /*verbosity*/2, /*indentation*/4); 2841 } 2842 } 2843 2844 } 2845 2846 if (stateLocked) mCameraStatesLock.unlock(); 2847 2848 if (locked) mServiceLock.unlock(); 2849 2850 if (mModule == nullptr) { 2851 mCameraProviderManager->dump(fd, args); 2852 } else { 2853 dprintf(fd, "\n== Camera Module HAL static info: ==\n"); 2854 dprintf(fd, "Camera module HAL API version: 0x%x\n", mModule->getHalApiVersion()); 2855 dprintf(fd, "Camera module API version: 0x%x\n", mModule->getModuleApiVersion()); 2856 dprintf(fd, "Camera module name: %s\n", mModule->getModuleName()); 2857 dprintf(fd, "Camera module author: %s\n", mModule->getModuleAuthor()); 2858 } 2859 2860 dprintf(fd, "\n== Vendor tags: ==\n\n"); 2861 2862 sp<VendorTagDescriptor> desc = VendorTagDescriptor::getGlobalVendorTagDescriptor(); 2863 if (desc == NULL) { 2864 dprintf(fd, "No vendor tags.\n"); 2865 } else { 2866 desc->dump(fd, /*verbosity*/2, /*indentation*/2); 2867 } 2868 2869 // Dump camera traces if there were any 2870 dprintf(fd, "\n"); 2871 camera3::CameraTraces::dump(fd, args); 2872 2873 // Process dump arguments, if any 2874 int n = args.size(); 2875 String16 verboseOption("-v"); 2876 String16 unreachableOption("--unreachable"); 2877 for (int i = 0; i < n; i++) { 2878 if (args[i] == verboseOption) { 2879 // change logging level 2880 if (i + 1 >= n) continue; 2881 String8 levelStr(args[i+1]); 2882 int level = atoi(levelStr.string()); 2883 dprintf(fd, "\nSetting log level to %d.\n", level); 2884 setLogLevel(level); 2885 } else if (args[i] == unreachableOption) { 2886 // Dump memory analysis 2887 // TODO - should limit be an argument parameter? 2888 UnreachableMemoryInfo info; 2889 bool success = GetUnreachableMemory(info, /*limit*/ 10000); 2890 if (!success) { 2891 dprintf(fd, "\n== Unable to dump unreachable memory. " 2892 "Try disabling SELinux enforcement. ==\n"); 2893 } else { 2894 dprintf(fd, "\n== Dumping unreachable memory: ==\n"); 2895 std::string s = info.ToString(/*log_contents*/ true); 2896 write(fd, s.c_str(), s.size()); 2897 } 2898 } 2899 } 2900 return NO_ERROR; 2901} 2902 2903void CameraService::dumpEventLog(int fd) { 2904 dprintf(fd, "\n== Camera service events log (most recent at top): ==\n"); 2905 2906 Mutex::Autolock l(mLogLock); 2907 for (const auto& msg : mEventLog) { 2908 dprintf(fd, " %s\n", msg.string()); 2909 } 2910 2911 if (mEventLog.size() == DEFAULT_EVENT_LOG_LENGTH) { 2912 dprintf(fd, " ...\n"); 2913 } else if (mEventLog.size() == 0) { 2914 dprintf(fd, " [no events yet]\n"); 2915 } 2916 dprintf(fd, "\n"); 2917} 2918 2919void CameraService::handleTorchClientBinderDied(const wp<IBinder> &who) { 2920 Mutex::Autolock al(mTorchClientMapMutex); 2921 for (size_t i = 0; i < mTorchClientMap.size(); i++) { 2922 if (mTorchClientMap[i] == who) { 2923 // turn off the torch mode that was turned on by dead client 2924 String8 cameraId = mTorchClientMap.keyAt(i); 2925 status_t res = mFlashlight->setTorchMode(cameraId, false); 2926 if (res) { 2927 ALOGE("%s: torch client died but couldn't turn off torch: " 2928 "%s (%d)", __FUNCTION__, strerror(-res), res); 2929 return; 2930 } 2931 mTorchClientMap.removeItemsAt(i); 2932 break; 2933 } 2934 } 2935} 2936 2937/*virtual*/void CameraService::binderDied(const wp<IBinder> &who) { 2938 2939 /** 2940 * While tempting to promote the wp<IBinder> into a sp, it's actually not supported by the 2941 * binder driver 2942 */ 2943 2944 logClientDied(getCallingPid(), String8("Binder died unexpectedly")); 2945 2946 // check torch client 2947 handleTorchClientBinderDied(who); 2948 2949 // check camera device client 2950 if(!evictClientIdByRemote(who)) { 2951 ALOGV("%s: Java client's binder death already cleaned up (normal case)", __FUNCTION__); 2952 return; 2953 } 2954 2955 ALOGE("%s: Java client's binder died, removing it from the list of active clients", 2956 __FUNCTION__); 2957} 2958 2959void CameraService::updateStatus(StatusInternal status, const String8& cameraId) { 2960 updateStatus(status, cameraId, {}); 2961} 2962 2963void CameraService::updateStatus(StatusInternal status, const String8& cameraId, 2964 std::initializer_list<StatusInternal> rejectSourceStates) { 2965 // Do not lock mServiceLock here or can get into a deadlock from 2966 // connect() -> disconnect -> updateStatus 2967 2968 auto state = getCameraState(cameraId); 2969 2970 if (state == nullptr) { 2971 ALOGW("%s: Could not update the status for %s, no such device exists", __FUNCTION__, 2972 cameraId.string()); 2973 return; 2974 } 2975 2976 // Update the status for this camera state, then send the onStatusChangedCallbacks to each 2977 // of the listeners with both the mStatusStatus and mStatusListenerLock held 2978 state->updateStatus(status, cameraId, rejectSourceStates, [this] 2979 (const String8& cameraId, StatusInternal status) { 2980 2981 if (status != StatusInternal::ENUMERATING) { 2982 // Update torch status if it has a flash unit. 2983 Mutex::Autolock al(mTorchStatusMutex); 2984 TorchModeStatus torchStatus; 2985 if (getTorchStatusLocked(cameraId, &torchStatus) != 2986 NAME_NOT_FOUND) { 2987 TorchModeStatus newTorchStatus = 2988 status == StatusInternal::PRESENT ? 2989 TorchModeStatus::AVAILABLE_OFF : 2990 TorchModeStatus::NOT_AVAILABLE; 2991 if (torchStatus != newTorchStatus) { 2992 onTorchStatusChangedLocked(cameraId, newTorchStatus); 2993 } 2994 } 2995 } 2996 2997 Mutex::Autolock lock(mStatusListenerLock); 2998 2999 for (auto& listener : mListenerList) { 3000 listener->onStatusChanged(mapToInterface(status), String16(cameraId)); 3001 } 3002 }); 3003} 3004 3005template<class Func> 3006void CameraService::CameraState::updateStatus(StatusInternal status, 3007 const String8& cameraId, 3008 std::initializer_list<StatusInternal> rejectSourceStates, 3009 Func onStatusUpdatedLocked) { 3010 Mutex::Autolock lock(mStatusLock); 3011 StatusInternal oldStatus = mStatus; 3012 mStatus = status; 3013 3014 if (oldStatus == status) { 3015 return; 3016 } 3017 3018 ALOGV("%s: Status has changed for camera ID %s from %#x to %#x", __FUNCTION__, 3019 cameraId.string(), oldStatus, status); 3020 3021 if (oldStatus == StatusInternal::NOT_PRESENT && 3022 (status != StatusInternal::PRESENT && 3023 status != StatusInternal::ENUMERATING)) { 3024 3025 ALOGW("%s: From NOT_PRESENT can only transition into PRESENT or ENUMERATING", 3026 __FUNCTION__); 3027 mStatus = oldStatus; 3028 return; 3029 } 3030 3031 /** 3032 * Sometimes we want to conditionally do a transition. 3033 * For example if a client disconnects, we want to go to PRESENT 3034 * only if we weren't already in NOT_PRESENT or ENUMERATING. 3035 */ 3036 for (auto& rejectStatus : rejectSourceStates) { 3037 if (oldStatus == rejectStatus) { 3038 ALOGV("%s: Rejecting status transition for Camera ID %s, since the source " 3039 "state was was in one of the bad states.", __FUNCTION__, cameraId.string()); 3040 mStatus = oldStatus; 3041 return; 3042 } 3043 } 3044 3045 onStatusUpdatedLocked(cameraId, status); 3046} 3047 3048void CameraService::updateProxyDeviceState(ICameraServiceProxy::CameraState newState, 3049 const String8& cameraId) { 3050 sp<ICameraServiceProxy> proxyBinder = getCameraServiceProxy(); 3051 if (proxyBinder == nullptr) return; 3052 String16 id(cameraId); 3053 proxyBinder->notifyCameraState(id, newState); 3054} 3055 3056status_t CameraService::getTorchStatusLocked( 3057 const String8& cameraId, 3058 TorchModeStatus *status) const { 3059 if (!status) { 3060 return BAD_VALUE; 3061 } 3062 ssize_t index = mTorchStatusMap.indexOfKey(cameraId); 3063 if (index == NAME_NOT_FOUND) { 3064 // invalid camera ID or the camera doesn't have a flash unit 3065 return NAME_NOT_FOUND; 3066 } 3067 3068 *status = mTorchStatusMap.valueAt(index); 3069 return OK; 3070} 3071 3072status_t CameraService::setTorchStatusLocked(const String8& cameraId, 3073 TorchModeStatus status) { 3074 ssize_t index = mTorchStatusMap.indexOfKey(cameraId); 3075 if (index == NAME_NOT_FOUND) { 3076 return BAD_VALUE; 3077 } 3078 mTorchStatusMap.editValueAt(index) = status; 3079 3080 return OK; 3081} 3082 3083}; // namespace android 3084