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