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