CameraService.cpp revision d231fd61ca94441183abda9766ce6906a5b4c3cf
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 LOG_NDEBUG 0 19 20#include <stdio.h> 21#include <string.h> 22#include <sys/types.h> 23#include <pthread.h> 24 25#include <binder/AppOpsManager.h> 26#include <binder/IPCThreadState.h> 27#include <binder/IServiceManager.h> 28#include <binder/MemoryBase.h> 29#include <binder/MemoryHeapBase.h> 30#include <cutils/atomic.h> 31#include <cutils/properties.h> 32#include <cutils/multiuser.h> 33#include <gui/Surface.h> 34#include <hardware/hardware.h> 35#include <media/AudioSystem.h> 36#include <media/IMediaHTTPService.h> 37#include <media/mediaplayer.h> 38#include <utils/Errors.h> 39#include <utils/Log.h> 40#include <utils/String16.h> 41#include <utils/Trace.h> 42#include <system/camera_vendor_tags.h> 43#include <system/camera_metadata.h> 44#include <system/camera.h> 45 46#include "CameraService.h" 47#include "api1/CameraClient.h" 48#include "api1/Camera2Client.h" 49#include "api_pro/ProCamera2Client.h" 50#include "api2/CameraDeviceClient.h" 51#include "utils/CameraTraces.h" 52#include "CameraDeviceFactory.h" 53 54namespace android { 55 56// ---------------------------------------------------------------------------- 57// Logging support -- this is for debugging only 58// Use "adb shell dumpsys media.camera -v 1" to change it. 59volatile int32_t gLogLevel = 0; 60 61#define LOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__); 62#define LOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__); 63 64static void setLogLevel(int level) { 65 android_atomic_write(level, &gLogLevel); 66} 67 68// ---------------------------------------------------------------------------- 69 70static int getCallingPid() { 71 return IPCThreadState::self()->getCallingPid(); 72} 73 74static int getCallingUid() { 75 return IPCThreadState::self()->getCallingUid(); 76} 77 78extern "C" { 79static void camera_device_status_change( 80 const struct camera_module_callbacks* callbacks, 81 int camera_id, 82 int new_status) { 83 sp<CameraService> cs = const_cast<CameraService*>( 84 static_cast<const CameraService*>(callbacks)); 85 86 cs->onDeviceStatusChanged( 87 camera_id, 88 new_status); 89} 90 91static void torch_mode_status_change( 92 const struct camera_module_callbacks* callbacks, 93 const char* camera_id, 94 int new_status) { 95 if (!callbacks || !camera_id) { 96 ALOGE("%s invalid parameters. callbacks %p, camera_id %p", __FUNCTION__, 97 callbacks, camera_id); 98 } 99 sp<CameraService> cs = const_cast<CameraService*>( 100 static_cast<const CameraService*>(callbacks)); 101 102 ICameraServiceListener::TorchStatus status; 103 switch (new_status) { 104 case TORCH_MODE_STATUS_NOT_AVAILABLE: 105 status = ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE; 106 break; 107 case TORCH_MODE_STATUS_AVAILABLE_OFF: 108 status = ICameraServiceListener::TORCH_STATUS_AVAILABLE_OFF; 109 break; 110 case TORCH_MODE_STATUS_AVAILABLE_ON: 111 status = ICameraServiceListener::TORCH_STATUS_AVAILABLE_ON; 112 break; 113 default: 114 ALOGE("Unknown torch status %d", new_status); 115 return; 116 } 117 118 cs->onTorchStatusChanged( 119 String8(camera_id), 120 status); 121} 122} // extern "C" 123 124// ---------------------------------------------------------------------------- 125 126// This is ugly and only safe if we never re-create the CameraService, but 127// should be ok for now. 128static CameraService *gCameraService; 129 130CameraService::CameraService() 131 :mSoundRef(0), mModule(0), mFlashlight(0) 132{ 133 ALOGI("CameraService started (pid=%d)", getpid()); 134 gCameraService = this; 135 136 for (size_t i = 0; i < MAX_CAMERAS; ++i) { 137 mStatusList[i] = ICameraServiceListener::STATUS_PRESENT; 138 } 139 140 this->camera_device_status_change = android::camera_device_status_change; 141 this->torch_mode_status_change = android::torch_mode_status_change; 142 143} 144 145void CameraService::onFirstRef() 146{ 147 LOG1("CameraService::onFirstRef"); 148 149 BnCameraService::onFirstRef(); 150 151 camera_module_t *rawModule; 152 if (hw_get_module(CAMERA_HARDWARE_MODULE_ID, 153 (const hw_module_t **)&rawModule) < 0) { 154 ALOGE("Could not load camera HAL module"); 155 mNumberOfCameras = 0; 156 } 157 else { 158 mModule = new CameraModule(rawModule); 159 const hw_module_t *common = mModule->getRawModule(); 160 ALOGI("Loaded \"%s\" cameraCa module", common->name); 161 mNumberOfCameras = mModule->getNumberOfCameras(); 162 if (mNumberOfCameras > MAX_CAMERAS) { 163 ALOGE("Number of cameras(%d) > MAX_CAMERAS(%d).", 164 mNumberOfCameras, MAX_CAMERAS); 165 mNumberOfCameras = MAX_CAMERAS; 166 } 167 168 mFlashlight = new CameraFlashlight(*mModule, *this); 169 status_t res = mFlashlight->findFlashUnits(); 170 if (res) { 171 // impossible because we haven't open any camera devices. 172 ALOGE("failed to find flash units."); 173 } 174 175 for (int i = 0; i < mNumberOfCameras; i++) { 176 setCameraFree(i); 177 178 String8 cameraName = String8::format("%d", i); 179 if (mFlashlight->hasFlashUnit(cameraName)) { 180 mTorchStatusMap.add(cameraName, 181 ICameraServiceListener::TORCH_STATUS_AVAILABLE_OFF); 182 } 183 } 184 185 if (common->module_api_version >= CAMERA_MODULE_API_VERSION_2_1) { 186 mModule->setCallbacks(this); 187 } 188 189 VendorTagDescriptor::clearGlobalVendorTagDescriptor(); 190 191 if (common->module_api_version >= CAMERA_MODULE_API_VERSION_2_2) { 192 setUpVendorTags(); 193 } 194 195 CameraDeviceFactory::registerService(this); 196 } 197} 198 199CameraService::~CameraService() { 200 for (int i = 0; i < mNumberOfCameras; i++) { 201 if (mBusy[i]) { 202 ALOGE("camera %d is still in use in destructor!", i); 203 } 204 } 205 206 if (mModule) { 207 delete mModule; 208 } 209 VendorTagDescriptor::clearGlobalVendorTagDescriptor(); 210 gCameraService = NULL; 211} 212 213void CameraService::onDeviceStatusChanged(int cameraId, 214 int newStatus) 215{ 216 ALOGV("%s: Status changed for cameraId=%d, newStatus=%d", __FUNCTION__, 217 cameraId, newStatus); 218 219 if (cameraId < 0 || cameraId >= MAX_CAMERAS) { 220 ALOGE("%s: Bad camera ID %d", __FUNCTION__, cameraId); 221 return; 222 } 223 224 if ((int)getStatus(cameraId) == newStatus) { 225 ALOGE("%s: State transition to the same status 0x%x not allowed", 226 __FUNCTION__, (uint32_t)newStatus); 227 return; 228 } 229 230 /* don't do this in updateStatus 231 since it is also called from connect and we could get into a deadlock */ 232 if (newStatus == CAMERA_DEVICE_STATUS_NOT_PRESENT) { 233 Vector<sp<BasicClient> > clientsToDisconnect; 234 { 235 Mutex::Autolock al(mServiceLock); 236 237 /* Remove cached parameters from shim cache */ 238 mShimParams.removeItem(cameraId); 239 240 /* Find all clients that we need to disconnect */ 241 sp<BasicClient> client = mClient[cameraId].promote(); 242 if (client.get() != NULL) { 243 clientsToDisconnect.push_back(client); 244 } 245 246 int i = cameraId; 247 for (size_t j = 0; j < mProClientList[i].size(); ++j) { 248 sp<ProClient> cl = mProClientList[i][j].promote(); 249 if (cl != NULL) { 250 clientsToDisconnect.push_back(cl); 251 } 252 } 253 } 254 255 /* now disconnect them. don't hold the lock 256 or we can get into a deadlock */ 257 258 for (size_t i = 0; i < clientsToDisconnect.size(); ++i) { 259 sp<BasicClient> client = clientsToDisconnect[i]; 260 261 client->disconnect(); 262 /** 263 * The remote app will no longer be able to call methods on the 264 * client since the client PID will be reset to 0 265 */ 266 } 267 268 ALOGV("%s: After unplug, disconnected %zu clients", 269 __FUNCTION__, clientsToDisconnect.size()); 270 } 271 272 updateStatus( 273 static_cast<ICameraServiceListener::Status>(newStatus), cameraId); 274 275} 276 277void CameraService::onTorchStatusChanged(const String8& cameraId, 278 ICameraServiceListener::TorchStatus newStatus) { 279 Mutex::Autolock al(mTorchStatusMutex); 280 onTorchStatusChangedLocked(cameraId, newStatus); 281} 282 283void CameraService::onTorchStatusChangedLocked(const String8& cameraId, 284 ICameraServiceListener::TorchStatus newStatus) { 285 ALOGI("%s: Torch status changed for cameraId=%s, newStatus=%d", 286 __FUNCTION__, cameraId.string(), newStatus); 287 288 ICameraServiceListener::TorchStatus status; 289 status_t res = getTorchStatusLocked(cameraId, &status); 290 if (res) { 291 ALOGE("%s: cannot get torch status of camera %s", cameraId.string()); 292 return; 293 } 294 if (status == newStatus) { 295 ALOGE("%s: Torch state transition to the same status 0x%x not allowed", 296 __FUNCTION__, (uint32_t)newStatus); 297 return; 298 } 299 300 res = setTorchStatusLocked(cameraId, newStatus); 301 if (res) { 302 ALOGE("%s: Failed to set the torch status", __FUNCTION__, 303 (uint32_t)newStatus); 304 return; 305 } 306 307 Vector<sp<ICameraServiceListener> >::const_iterator it; 308 for (it = mListenerList.begin(); it != mListenerList.end(); ++it) { 309 (*it)->onTorchStatusChanged(newStatus, String16(cameraId.string())); 310 } 311} 312 313 314int32_t CameraService::getNumberOfCameras() { 315 return mNumberOfCameras; 316} 317 318status_t CameraService::getCameraInfo(int cameraId, 319 struct CameraInfo* cameraInfo) { 320 if (!mModule) { 321 return -ENODEV; 322 } 323 324 if (cameraId < 0 || cameraId >= mNumberOfCameras) { 325 return BAD_VALUE; 326 } 327 328 struct camera_info info; 329 status_t rc = filterGetInfoErrorCode( 330 mModule->getCameraInfo(cameraId, &info)); 331 cameraInfo->facing = info.facing; 332 cameraInfo->orientation = info.orientation; 333 return rc; 334} 335 336 337status_t CameraService::generateShimMetadata(int cameraId, /*out*/CameraMetadata* cameraInfo) { 338 status_t ret = OK; 339 struct CameraInfo info; 340 if ((ret = getCameraInfo(cameraId, &info)) != OK) { 341 return ret; 342 } 343 344 CameraMetadata shimInfo; 345 int32_t orientation = static_cast<int32_t>(info.orientation); 346 if ((ret = shimInfo.update(ANDROID_SENSOR_ORIENTATION, &orientation, 1)) != OK) { 347 return ret; 348 } 349 350 uint8_t facing = (info.facing == CAMERA_FACING_FRONT) ? 351 ANDROID_LENS_FACING_FRONT : ANDROID_LENS_FACING_BACK; 352 if ((ret = shimInfo.update(ANDROID_LENS_FACING, &facing, 1)) != OK) { 353 return ret; 354 } 355 356 CameraParameters shimParams; 357 if ((ret = getLegacyParametersLazy(cameraId, /*out*/&shimParams)) != OK) { 358 // Error logged by callee 359 return ret; 360 } 361 362 Vector<Size> sizes; 363 Vector<Size> jpegSizes; 364 Vector<int32_t> formats; 365 const char* supportedPreviewFormats; 366 { 367 shimParams.getSupportedPreviewSizes(/*out*/sizes); 368 shimParams.getSupportedPreviewFormats(/*out*/formats); 369 shimParams.getSupportedPictureSizes(/*out*/jpegSizes); 370 } 371 372 // Always include IMPLEMENTATION_DEFINED 373 formats.add(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED); 374 375 const size_t INTS_PER_CONFIG = 4; 376 377 // Build available stream configurations metadata 378 size_t streamConfigSize = (sizes.size() * formats.size() + jpegSizes.size()) * INTS_PER_CONFIG; 379 380 Vector<int32_t> streamConfigs; 381 streamConfigs.setCapacity(streamConfigSize); 382 383 for (size_t i = 0; i < formats.size(); ++i) { 384 for (size_t j = 0; j < sizes.size(); ++j) { 385 streamConfigs.add(formats[i]); 386 streamConfigs.add(sizes[j].width); 387 streamConfigs.add(sizes[j].height); 388 streamConfigs.add(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT); 389 } 390 } 391 392 for (size_t i = 0; i < jpegSizes.size(); ++i) { 393 streamConfigs.add(HAL_PIXEL_FORMAT_BLOB); 394 streamConfigs.add(jpegSizes[i].width); 395 streamConfigs.add(jpegSizes[i].height); 396 streamConfigs.add(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT); 397 } 398 399 if ((ret = shimInfo.update(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, 400 streamConfigs.array(), streamConfigSize)) != OK) { 401 return ret; 402 } 403 404 int64_t fakeMinFrames[0]; 405 // TODO: Fixme, don't fake min frame durations. 406 if ((ret = shimInfo.update(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, 407 fakeMinFrames, 0)) != OK) { 408 return ret; 409 } 410 411 int64_t fakeStalls[0]; 412 // TODO: Fixme, don't fake stall durations. 413 if ((ret = shimInfo.update(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, 414 fakeStalls, 0)) != OK) { 415 return ret; 416 } 417 418 *cameraInfo = shimInfo; 419 return OK; 420} 421 422status_t CameraService::getCameraCharacteristics(int cameraId, 423 CameraMetadata* cameraInfo) { 424 if (!cameraInfo) { 425 ALOGE("%s: cameraInfo is NULL", __FUNCTION__); 426 return BAD_VALUE; 427 } 428 429 if (!mModule) { 430 ALOGE("%s: camera hardware module doesn't exist", __FUNCTION__); 431 return -ENODEV; 432 } 433 434 if (cameraId < 0 || cameraId >= mNumberOfCameras) { 435 ALOGE("%s: Invalid camera id: %d", __FUNCTION__, cameraId); 436 return BAD_VALUE; 437 } 438 439 int facing; 440 status_t ret = OK; 441 if (mModule->getRawModule()->module_api_version < CAMERA_MODULE_API_VERSION_2_0 || 442 getDeviceVersion(cameraId, &facing) <= CAMERA_DEVICE_API_VERSION_2_1 ) { 443 /** 444 * Backwards compatibility mode for old HALs: 445 * - Convert CameraInfo into static CameraMetadata properties. 446 * - Retrieve cached CameraParameters for this camera. If none exist, 447 * attempt to open CameraClient and retrieve the CameraParameters. 448 * - Convert cached CameraParameters into static CameraMetadata 449 * properties. 450 */ 451 ALOGI("%s: Switching to HAL1 shim implementation...", __FUNCTION__); 452 453 if ((ret = generateShimMetadata(cameraId, cameraInfo)) != OK) { 454 return ret; 455 } 456 457 } else { 458 /** 459 * Normal HAL 2.1+ codepath. 460 */ 461 struct camera_info info; 462 ret = filterGetInfoErrorCode(mModule->getCameraInfo(cameraId, &info)); 463 *cameraInfo = info.static_camera_characteristics; 464 } 465 466 return ret; 467} 468 469status_t CameraService::getCameraVendorTagDescriptor(/*out*/sp<VendorTagDescriptor>& desc) { 470 if (!mModule) { 471 ALOGE("%s: camera hardware module doesn't exist", __FUNCTION__); 472 return -ENODEV; 473 } 474 475 desc = VendorTagDescriptor::getGlobalVendorTagDescriptor(); 476 return OK; 477} 478 479int CameraService::getDeviceVersion(int cameraId, int* facing) { 480 struct camera_info info; 481 if (mModule->getCameraInfo(cameraId, &info) != OK) { 482 return -1; 483 } 484 485 int deviceVersion; 486 if (mModule->getRawModule()->module_api_version >= CAMERA_MODULE_API_VERSION_2_0) { 487 deviceVersion = info.device_version; 488 } else { 489 deviceVersion = CAMERA_DEVICE_API_VERSION_1_0; 490 } 491 492 if (facing) { 493 *facing = info.facing; 494 } 495 496 return deviceVersion; 497} 498 499status_t CameraService::filterGetInfoErrorCode(status_t err) { 500 switch(err) { 501 case NO_ERROR: 502 case -EINVAL: 503 return err; 504 default: 505 break; 506 } 507 return -ENODEV; 508} 509 510bool CameraService::setUpVendorTags() { 511 vendor_tag_ops_t vOps = vendor_tag_ops_t(); 512 513 // Check if vendor operations have been implemented 514 if (!mModule->isVendorTagDefined()) { 515 ALOGI("%s: No vendor tags defined for this device.", __FUNCTION__); 516 return false; 517 } 518 519 ATRACE_BEGIN("camera3->get_metadata_vendor_tag_ops"); 520 mModule->getVendorTagOps(&vOps); 521 ATRACE_END(); 522 523 // Ensure all vendor operations are present 524 if (vOps.get_tag_count == NULL || vOps.get_all_tags == NULL || 525 vOps.get_section_name == NULL || vOps.get_tag_name == NULL || 526 vOps.get_tag_type == NULL) { 527 ALOGE("%s: Vendor tag operations not fully defined. Ignoring definitions." 528 , __FUNCTION__); 529 return false; 530 } 531 532 // Read all vendor tag definitions into a descriptor 533 sp<VendorTagDescriptor> desc; 534 status_t res; 535 if ((res = VendorTagDescriptor::createDescriptorFromOps(&vOps, /*out*/desc)) 536 != OK) { 537 ALOGE("%s: Could not generate descriptor from vendor tag operations," 538 "received error %s (%d). Camera clients will not be able to use" 539 "vendor tags", __FUNCTION__, strerror(res), res); 540 return false; 541 } 542 543 // Set the global descriptor to use with camera metadata 544 VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc); 545 return true; 546} 547 548status_t CameraService::initializeShimMetadata(int cameraId) { 549 int pid = getCallingPid(); 550 int uid = getCallingUid(); 551 status_t ret = validateConnect(cameraId, uid); 552 if (ret != OK) { 553 // Error already logged by callee 554 return ret; 555 } 556 557 bool needsNewClient = false; 558 sp<Client> client; 559 560 String16 internalPackageName("media"); 561 { // Scope for service lock 562 Mutex::Autolock lock(mServiceLock); 563 if (mClient[cameraId] != NULL) { 564 client = static_cast<Client*>(mClient[cameraId].promote().get()); 565 } 566 if (client == NULL) { 567 needsNewClient = true; 568 ret = connectHelperLocked(/*out*/client, 569 /*cameraClient*/NULL, // Empty binder callbacks 570 cameraId, 571 internalPackageName, 572 uid, 573 pid); 574 575 if (ret != OK) { 576 // Error already logged by callee 577 return ret; 578 } 579 } 580 581 if (client == NULL) { 582 ALOGE("%s: Could not connect to client camera device.", __FUNCTION__); 583 return BAD_VALUE; 584 } 585 586 String8 rawParams = client->getParameters(); 587 CameraParameters params(rawParams); 588 mShimParams.add(cameraId, params); 589 } 590 591 // Close client if one was opened solely for this call 592 if (needsNewClient) { 593 client->disconnect(); 594 } 595 return OK; 596} 597 598status_t CameraService::getLegacyParametersLazy(int cameraId, 599 /*out*/ 600 CameraParameters* parameters) { 601 602 ALOGV("%s: for cameraId: %d", __FUNCTION__, cameraId); 603 604 status_t ret = 0; 605 606 if (parameters == NULL) { 607 ALOGE("%s: parameters must not be null", __FUNCTION__); 608 return BAD_VALUE; 609 } 610 611 ssize_t index = -1; 612 { // Scope for service lock 613 Mutex::Autolock lock(mServiceLock); 614 index = mShimParams.indexOfKey(cameraId); 615 // Release service lock so initializeShimMetadata can be called correctly. 616 617 if (index >= 0) { 618 *parameters = mShimParams[index]; 619 } 620 } 621 622 if (index < 0) { 623 int64_t token = IPCThreadState::self()->clearCallingIdentity(); 624 ret = initializeShimMetadata(cameraId); 625 IPCThreadState::self()->restoreCallingIdentity(token); 626 if (ret != OK) { 627 // Error already logged by callee 628 return ret; 629 } 630 631 { // Scope for service lock 632 Mutex::Autolock lock(mServiceLock); 633 index = mShimParams.indexOfKey(cameraId); 634 635 LOG_ALWAYS_FATAL_IF(index < 0, "index should have been initialized"); 636 637 *parameters = mShimParams[index]; 638 } 639 } 640 641 return OK; 642} 643 644status_t CameraService::validateConnect(int cameraId, 645 /*inout*/ 646 int& clientUid) const { 647 648 int callingPid = getCallingPid(); 649 650 if (clientUid == USE_CALLING_UID) { 651 clientUid = getCallingUid(); 652 } else { 653 // We only trust our own process to forward client UIDs 654 if (callingPid != getpid()) { 655 ALOGE("CameraService::connect X (pid %d) rejected (don't trust clientUid)", 656 callingPid); 657 return PERMISSION_DENIED; 658 } 659 } 660 661 if (!mModule) { 662 ALOGE("Camera HAL module not loaded"); 663 return -ENODEV; 664 } 665 666 if (cameraId < 0 || cameraId >= mNumberOfCameras) { 667 ALOGE("CameraService::connect X (pid %d) rejected (invalid cameraId %d).", 668 callingPid, cameraId); 669 return -ENODEV; 670 } 671 672 char value[PROPERTY_VALUE_MAX]; 673 char key[PROPERTY_KEY_MAX]; 674 int clientUserId = multiuser_get_user_id(clientUid); 675 snprintf(key, PROPERTY_KEY_MAX, "sys.secpolicy.camera.off_%d", clientUserId); 676 property_get(key, value, "0"); 677 if (strcmp(value, "1") == 0) { 678 // Camera is disabled by DevicePolicyManager. 679 ALOGI("Camera is disabled. connect X (pid %d) rejected", callingPid); 680 return -EACCES; 681 } 682 683 ICameraServiceListener::Status currentStatus = getStatus(cameraId); 684 if (currentStatus == ICameraServiceListener::STATUS_NOT_PRESENT) { 685 ALOGI("Camera is not plugged in," 686 " connect X (pid %d) rejected", callingPid); 687 return -ENODEV; 688 } else if (currentStatus == ICameraServiceListener::STATUS_ENUMERATING) { 689 ALOGI("Camera is enumerating," 690 " connect X (pid %d) rejected", callingPid); 691 return -EBUSY; 692 } 693 // Else don't check for STATUS_NOT_AVAILABLE. 694 // -- It's done implicitly in canConnectUnsafe /w the mBusy array 695 696 return OK; 697} 698 699bool CameraService::canConnectUnsafe(int cameraId, 700 const String16& clientPackageName, 701 const sp<IBinder>& remoteCallback, 702 sp<BasicClient> &client) { 703 String8 clientName8(clientPackageName); 704 int callingPid = getCallingPid(); 705 706 if (mClient[cameraId] != 0) { 707 client = mClient[cameraId].promote(); 708 if (client != 0) { 709 if (remoteCallback == client->getRemote()) { 710 LOG1("CameraService::connect X (pid %d) (the same client)", 711 callingPid); 712 return true; 713 } else { 714 // TODOSC: need to support 1 regular client, 715 // multiple shared clients here 716 ALOGW("CameraService::connect X (pid %d) rejected" 717 " (existing client).", callingPid); 718 return false; 719 } 720 } 721 mClient[cameraId].clear(); 722 } 723 724 /* 725 mBusy is set to false as the last step of the Client destructor, 726 after which it is guaranteed that the Client destructor has finished ( 727 including any inherited destructors) 728 729 We only need this for a Client subclasses since we don't allow 730 multiple Clents to be opened concurrently, but multiple BasicClient 731 would be fine 732 */ 733 if (mBusy[cameraId]) { 734 ALOGW("CameraService::connect X (pid %d, \"%s\") rejected" 735 " (camera %d is still busy).", callingPid, 736 clientName8.string(), cameraId); 737 return false; 738 } 739 740 return true; 741} 742 743status_t CameraService::connectHelperLocked( 744 /*out*/ 745 sp<Client>& client, 746 /*in*/ 747 const sp<ICameraClient>& cameraClient, 748 int cameraId, 749 const String16& clientPackageName, 750 int clientUid, 751 int callingPid, 752 int halVersion, 753 bool legacyMode) { 754 755 // give flashlight a chance to close devices if necessary. 756 mFlashlight->prepareDeviceOpen(String8::format("%d", cameraId)); 757 758 int facing = -1; 759 int deviceVersion = getDeviceVersion(cameraId, &facing); 760 761 if (halVersion < 0 || halVersion == deviceVersion) { 762 // Default path: HAL version is unspecified by caller, create CameraClient 763 // based on device version reported by the HAL. 764 switch(deviceVersion) { 765 case CAMERA_DEVICE_API_VERSION_1_0: 766 client = new CameraClient(this, cameraClient, 767 clientPackageName, cameraId, 768 facing, callingPid, clientUid, getpid(), legacyMode); 769 break; 770 case CAMERA_DEVICE_API_VERSION_2_0: 771 case CAMERA_DEVICE_API_VERSION_2_1: 772 case CAMERA_DEVICE_API_VERSION_3_0: 773 case CAMERA_DEVICE_API_VERSION_3_1: 774 case CAMERA_DEVICE_API_VERSION_3_2: 775 client = new Camera2Client(this, cameraClient, 776 clientPackageName, cameraId, 777 facing, callingPid, clientUid, getpid(), legacyMode); 778 break; 779 case -1: 780 ALOGE("Invalid camera id %d", cameraId); 781 return BAD_VALUE; 782 default: 783 ALOGE("Unknown camera device HAL version: %d", deviceVersion); 784 return INVALID_OPERATION; 785 } 786 } else { 787 // A particular HAL version is requested by caller. Create CameraClient 788 // based on the requested HAL version. 789 if (deviceVersion > CAMERA_DEVICE_API_VERSION_1_0 && 790 halVersion == CAMERA_DEVICE_API_VERSION_1_0) { 791 // Only support higher HAL version device opened as HAL1.0 device. 792 client = new CameraClient(this, cameraClient, 793 clientPackageName, cameraId, 794 facing, callingPid, clientUid, getpid(), legacyMode); 795 } else { 796 // Other combinations (e.g. HAL3.x open as HAL2.x) are not supported yet. 797 ALOGE("Invalid camera HAL version %x: HAL %x device can only be" 798 " opened as HAL %x device", halVersion, deviceVersion, 799 CAMERA_DEVICE_API_VERSION_1_0); 800 return INVALID_OPERATION; 801 } 802 } 803 804 status_t status = connectFinishUnsafe(client, client->getRemote()); 805 if (status != OK) { 806 // this is probably not recoverable.. maybe the client can try again 807 return status; 808 } 809 810 mClient[cameraId] = client; 811 LOG1("CameraService::connect X (id %d, this pid is %d)", cameraId, 812 getpid()); 813 814 return OK; 815} 816 817status_t CameraService::connect( 818 const sp<ICameraClient>& cameraClient, 819 int cameraId, 820 const String16& clientPackageName, 821 int clientUid, 822 /*out*/ 823 sp<ICamera>& device) { 824 825 String8 clientName8(clientPackageName); 826 int callingPid = getCallingPid(); 827 828 LOG1("CameraService::connect E (pid %d \"%s\", id %d)", callingPid, 829 clientName8.string(), cameraId); 830 831 status_t status = validateConnect(cameraId, /*inout*/clientUid); 832 if (status != OK) { 833 return status; 834 } 835 836 837 sp<Client> client; 838 { 839 Mutex::Autolock lock(mServiceLock); 840 sp<BasicClient> clientTmp; 841 if (!canConnectUnsafe(cameraId, clientPackageName, 842 IInterface::asBinder(cameraClient), 843 /*out*/clientTmp)) { 844 return -EBUSY; 845 } else if (client.get() != NULL) { 846 device = static_cast<Client*>(clientTmp.get()); 847 return OK; 848 } 849 850 status = connectHelperLocked(/*out*/client, 851 cameraClient, 852 cameraId, 853 clientPackageName, 854 clientUid, 855 callingPid); 856 if (status != OK) { 857 return status; 858 } 859 860 } 861 // important: release the mutex here so the client can call back 862 // into the service from its destructor (can be at the end of the call) 863 864 device = client; 865 return OK; 866} 867 868status_t CameraService::connectLegacy( 869 const sp<ICameraClient>& cameraClient, 870 int cameraId, int halVersion, 871 const String16& clientPackageName, 872 int clientUid, 873 /*out*/ 874 sp<ICamera>& device) { 875 876 int apiVersion = mModule->getRawModule()->module_api_version; 877 if (halVersion != CAMERA_HAL_API_VERSION_UNSPECIFIED && 878 apiVersion < CAMERA_MODULE_API_VERSION_2_3) { 879 /* 880 * Either the HAL version is unspecified in which case this just creates 881 * a camera client selected by the latest device version, or 882 * it's a particular version in which case the HAL must supported 883 * the open_legacy call 884 */ 885 ALOGE("%s: camera HAL module version %x doesn't support connecting to legacy HAL devices!", 886 __FUNCTION__, apiVersion); 887 return INVALID_OPERATION; 888 } 889 890 String8 clientName8(clientPackageName); 891 int callingPid = getCallingPid(); 892 893 LOG1("CameraService::connect legacy E (pid %d \"%s\", id %d)", callingPid, 894 clientName8.string(), cameraId); 895 896 status_t status = validateConnect(cameraId, /*inout*/clientUid); 897 if (status != OK) { 898 return status; 899 } 900 901 sp<Client> client; 902 { 903 Mutex::Autolock lock(mServiceLock); 904 sp<BasicClient> clientTmp; 905 if (!canConnectUnsafe(cameraId, clientPackageName, 906 IInterface::asBinder(cameraClient), 907 /*out*/clientTmp)) { 908 return -EBUSY; 909 } else if (client.get() != NULL) { 910 device = static_cast<Client*>(clientTmp.get()); 911 return OK; 912 } 913 914 status = connectHelperLocked(/*out*/client, 915 cameraClient, 916 cameraId, 917 clientPackageName, 918 clientUid, 919 callingPid, 920 halVersion, 921 /*legacyMode*/true); 922 if (status != OK) { 923 return status; 924 } 925 926 } 927 // important: release the mutex here so the client can call back 928 // into the service from its destructor (can be at the end of the call) 929 930 device = client; 931 return OK; 932} 933 934bool CameraService::validCameraIdForSetTorchMode(const String8& cameraId) { 935 // invalid string for int 936 if (cameraId.string() == NULL) { 937 return false; 938 } 939 errno = 0; 940 char *endptr; 941 long id = strtol(cameraId.string(), &endptr, 10); // base 10 942 if (errno || id > INT_MAX || id < INT_MIN || *endptr != 0) { 943 return false; 944 } 945 946 // id matches one of the plugged-in devices? 947 ICameraServiceListener::Status deviceStatus = getStatus(id); 948 if (deviceStatus != ICameraServiceListener::STATUS_PRESENT && 949 deviceStatus != ICameraServiceListener::STATUS_NOT_AVAILABLE) { 950 return false; 951 } 952 953 return true; 954} 955 956status_t CameraService::setTorchMode(const String16& cameraId, bool enabled, 957 const sp<IBinder>& clientBinder) { 958 if (enabled && clientBinder == NULL) { 959 ALOGE("%s: torch client binder is NULL", __FUNCTION__); 960 return -EINVAL; 961 } 962 963 String8 id = String8(cameraId.string()); 964 965 // verify id is valid. 966 if (validCameraIdForSetTorchMode(id) == false) { 967 ALOGE("%s: camera id is invalid %s", id.string()); 968 return -EINVAL; 969 } 970 971 { 972 Mutex::Autolock al(mTorchStatusMutex); 973 ICameraServiceListener::TorchStatus status; 974 status_t res = getTorchStatusLocked(id, &status); 975 if (res) { 976 ALOGE("%s: getting current torch status failed for camera %s", 977 __FUNCTION__, id.string()); 978 return -EINVAL; 979 } 980 981 if (status == ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE) { 982 if (getStatus(atoi(id.string())) == 983 ICameraServiceListener::STATUS_NOT_AVAILABLE) { 984 ALOGE("%s: torch mode of camera %s is not available because " 985 "camera is in use", __FUNCTION__, id.string()); 986 return -EBUSY; 987 } else { 988 ALOGE("%s: torch mode of camera %s is not available due to " 989 "insufficient resources", __FUNCTION__, id.string()); 990 return -EUSERS; 991 } 992 } 993 } 994 995 status_t res = mFlashlight->setTorchMode(id, enabled); 996 if (res) { 997 ALOGE("%s: setting torch mode of camera %s to %d failed. %s (%d)", 998 __FUNCTION__, id.string(), enabled, strerror(-res), res); 999 return res; 1000 } 1001 1002 { 1003 // update the link to client's death 1004 Mutex::Autolock al(mTorchClientMapMutex); 1005 ssize_t index = mTorchClientMap.indexOfKey(id); 1006 if (enabled) { 1007 if (index == NAME_NOT_FOUND) { 1008 mTorchClientMap.add(id, clientBinder); 1009 } else { 1010 const sp<IBinder> oldBinder = mTorchClientMap.valueAt(index); 1011 oldBinder->unlinkToDeath(this); 1012 1013 mTorchClientMap.replaceValueAt(index, clientBinder); 1014 } 1015 clientBinder->linkToDeath(this); 1016 } else if (index != NAME_NOT_FOUND) { 1017 sp<IBinder> oldBinder = mTorchClientMap.valueAt(index); 1018 oldBinder->unlinkToDeath(this); 1019 } 1020 } 1021 1022 return OK; 1023} 1024 1025status_t CameraService::connectFinishUnsafe(const sp<BasicClient>& client, 1026 const sp<IBinder>& remoteCallback) { 1027 status_t status = client->initialize(mModule); 1028 if (status != OK) { 1029 ALOGE("%s: Could not initialize client from HAL module.", __FUNCTION__); 1030 return status; 1031 } 1032 if (remoteCallback != NULL) { 1033 remoteCallback->linkToDeath(this); 1034 } 1035 1036 return OK; 1037} 1038 1039status_t CameraService::connectPro( 1040 const sp<IProCameraCallbacks>& cameraCb, 1041 int cameraId, 1042 const String16& clientPackageName, 1043 int clientUid, 1044 /*out*/ 1045 sp<IProCameraUser>& device) 1046{ 1047 if (cameraCb == 0) { 1048 ALOGE("%s: Callback must not be null", __FUNCTION__); 1049 return BAD_VALUE; 1050 } 1051 1052 String8 clientName8(clientPackageName); 1053 int callingPid = getCallingPid(); 1054 1055 LOG1("CameraService::connectPro E (pid %d \"%s\", id %d)", callingPid, 1056 clientName8.string(), cameraId); 1057 status_t status = validateConnect(cameraId, /*inout*/clientUid); 1058 if (status != OK) { 1059 return status; 1060 } 1061 1062 sp<ProClient> client; 1063 { 1064 Mutex::Autolock lock(mServiceLock); 1065 { 1066 sp<BasicClient> client; 1067 if (!canConnectUnsafe(cameraId, clientPackageName, 1068 IInterface::asBinder(cameraCb), 1069 /*out*/client)) { 1070 return -EBUSY; 1071 } 1072 } 1073 1074 int facing = -1; 1075 int deviceVersion = getDeviceVersion(cameraId, &facing); 1076 1077 switch(deviceVersion) { 1078 case CAMERA_DEVICE_API_VERSION_1_0: 1079 ALOGE("Camera id %d uses HALv1, doesn't support ProCamera", 1080 cameraId); 1081 return -EOPNOTSUPP; 1082 break; 1083 case CAMERA_DEVICE_API_VERSION_2_0: 1084 case CAMERA_DEVICE_API_VERSION_2_1: 1085 case CAMERA_DEVICE_API_VERSION_3_0: 1086 case CAMERA_DEVICE_API_VERSION_3_1: 1087 case CAMERA_DEVICE_API_VERSION_3_2: 1088 client = new ProCamera2Client(this, cameraCb, clientPackageName, 1089 cameraId, facing, callingPid, clientUid, getpid()); 1090 break; 1091 case -1: 1092 ALOGE("Invalid camera id %d", cameraId); 1093 return BAD_VALUE; 1094 default: 1095 ALOGE("Unknown camera device HAL version: %d", deviceVersion); 1096 return INVALID_OPERATION; 1097 } 1098 1099 status_t status = connectFinishUnsafe(client, client->getRemote()); 1100 if (status != OK) { 1101 return status; 1102 } 1103 1104 mProClientList[cameraId].push(client); 1105 1106 LOG1("CameraService::connectPro X (id %d, this pid is %d)", cameraId, 1107 getpid()); 1108 } 1109 // important: release the mutex here so the client can call back 1110 // into the service from its destructor (can be at the end of the call) 1111 device = client; 1112 return OK; 1113} 1114 1115status_t CameraService::connectDevice( 1116 const sp<ICameraDeviceCallbacks>& cameraCb, 1117 int cameraId, 1118 const String16& clientPackageName, 1119 int clientUid, 1120 /*out*/ 1121 sp<ICameraDeviceUser>& device) 1122{ 1123 1124 String8 clientName8(clientPackageName); 1125 int callingPid = getCallingPid(); 1126 1127 LOG1("CameraService::connectDevice E (pid %d \"%s\", id %d)", callingPid, 1128 clientName8.string(), cameraId); 1129 1130 status_t status = validateConnect(cameraId, /*inout*/clientUid); 1131 if (status != OK) { 1132 return status; 1133 } 1134 1135 sp<CameraDeviceClient> client; 1136 { 1137 Mutex::Autolock lock(mServiceLock); 1138 { 1139 sp<BasicClient> client; 1140 if (!canConnectUnsafe(cameraId, clientPackageName, 1141 IInterface::asBinder(cameraCb), 1142 /*out*/client)) { 1143 return -EBUSY; 1144 } 1145 } 1146 1147 int facing = -1; 1148 int deviceVersion = getDeviceVersion(cameraId, &facing); 1149 1150 // give flashlight a chance to close devices if necessary. 1151 mFlashlight->prepareDeviceOpen(String8::format("%d", cameraId)); 1152 1153 switch(deviceVersion) { 1154 case CAMERA_DEVICE_API_VERSION_1_0: 1155 ALOGW("Camera using old HAL version: %d", deviceVersion); 1156 return -EOPNOTSUPP; 1157 // TODO: don't allow 2.0 Only allow 2.1 and higher 1158 case CAMERA_DEVICE_API_VERSION_2_0: 1159 case CAMERA_DEVICE_API_VERSION_2_1: 1160 case CAMERA_DEVICE_API_VERSION_3_0: 1161 case CAMERA_DEVICE_API_VERSION_3_1: 1162 case CAMERA_DEVICE_API_VERSION_3_2: 1163 client = new CameraDeviceClient(this, cameraCb, clientPackageName, 1164 cameraId, facing, callingPid, clientUid, getpid()); 1165 break; 1166 case -1: 1167 ALOGE("Invalid camera id %d", cameraId); 1168 return BAD_VALUE; 1169 default: 1170 ALOGE("Unknown camera device HAL version: %d", deviceVersion); 1171 return INVALID_OPERATION; 1172 } 1173 1174 status_t status = connectFinishUnsafe(client, client->getRemote()); 1175 if (status != OK) { 1176 // this is probably not recoverable.. maybe the client can try again 1177 return status; 1178 } 1179 1180 LOG1("CameraService::connectDevice X (id %d, this pid is %d)", cameraId, 1181 getpid()); 1182 1183 mClient[cameraId] = client; 1184 } 1185 // important: release the mutex here so the client can call back 1186 // into the service from its destructor (can be at the end of the call) 1187 1188 device = client; 1189 return OK; 1190} 1191 1192 1193status_t CameraService::addListener( 1194 const sp<ICameraServiceListener>& listener) { 1195 ALOGV("%s: Add listener %p", __FUNCTION__, listener.get()); 1196 1197 if (listener == 0) { 1198 ALOGE("%s: Listener must not be null", __FUNCTION__); 1199 return BAD_VALUE; 1200 } 1201 1202 Mutex::Autolock lock(mServiceLock); 1203 1204 Vector<sp<ICameraServiceListener> >::iterator it, end; 1205 for (it = mListenerList.begin(); it != mListenerList.end(); ++it) { 1206 if (IInterface::asBinder(*it) == IInterface::asBinder(listener)) { 1207 ALOGW("%s: Tried to add listener %p which was already subscribed", 1208 __FUNCTION__, listener.get()); 1209 return ALREADY_EXISTS; 1210 } 1211 } 1212 1213 mListenerList.push_back(listener); 1214 1215 /* Immediately signal current status to this listener only */ 1216 { 1217 Mutex::Autolock m(mStatusMutex) ; 1218 int numCams = getNumberOfCameras(); 1219 for (int i = 0; i < numCams; ++i) { 1220 listener->onStatusChanged(mStatusList[i], i); 1221 } 1222 } 1223 1224 /* Immediately signal current torch status to this listener only */ 1225 { 1226 Mutex::Autolock al(mTorchStatusMutex); 1227 for (size_t i = 0; i < mTorchStatusMap.size(); i++ ) { 1228 String16 id = String16(mTorchStatusMap.keyAt(i).string()); 1229 listener->onTorchStatusChanged(mTorchStatusMap.valueAt(i), id); 1230 } 1231 1232 } 1233 1234 return OK; 1235} 1236status_t CameraService::removeListener( 1237 const sp<ICameraServiceListener>& listener) { 1238 ALOGV("%s: Remove listener %p", __FUNCTION__, listener.get()); 1239 1240 if (listener == 0) { 1241 ALOGE("%s: Listener must not be null", __FUNCTION__); 1242 return BAD_VALUE; 1243 } 1244 1245 Mutex::Autolock lock(mServiceLock); 1246 1247 Vector<sp<ICameraServiceListener> >::iterator it; 1248 for (it = mListenerList.begin(); it != mListenerList.end(); ++it) { 1249 if (IInterface::asBinder(*it) == IInterface::asBinder(listener)) { 1250 mListenerList.erase(it); 1251 return OK; 1252 } 1253 } 1254 1255 ALOGW("%s: Tried to remove a listener %p which was not subscribed", 1256 __FUNCTION__, listener.get()); 1257 1258 return BAD_VALUE; 1259} 1260 1261status_t CameraService::getLegacyParameters( 1262 int cameraId, 1263 /*out*/ 1264 String16* parameters) { 1265 ALOGV("%s: for camera ID = %d", __FUNCTION__, cameraId); 1266 1267 if (parameters == NULL) { 1268 ALOGE("%s: parameters must not be null", __FUNCTION__); 1269 return BAD_VALUE; 1270 } 1271 1272 status_t ret = 0; 1273 1274 CameraParameters shimParams; 1275 if ((ret = getLegacyParametersLazy(cameraId, /*out*/&shimParams)) != OK) { 1276 // Error logged by caller 1277 return ret; 1278 } 1279 1280 String8 shimParamsString8 = shimParams.flatten(); 1281 String16 shimParamsString16 = String16(shimParamsString8); 1282 1283 *parameters = shimParamsString16; 1284 1285 return OK; 1286} 1287 1288status_t CameraService::supportsCameraApi(int cameraId, int apiVersion) { 1289 ALOGV("%s: for camera ID = %d", __FUNCTION__, cameraId); 1290 1291 switch (apiVersion) { 1292 case API_VERSION_1: 1293 case API_VERSION_2: 1294 break; 1295 default: 1296 ALOGE("%s: Bad API version %d", __FUNCTION__, apiVersion); 1297 return BAD_VALUE; 1298 } 1299 1300 int facing = -1; 1301 int deviceVersion = getDeviceVersion(cameraId, &facing); 1302 1303 switch(deviceVersion) { 1304 case CAMERA_DEVICE_API_VERSION_1_0: 1305 case CAMERA_DEVICE_API_VERSION_2_0: 1306 case CAMERA_DEVICE_API_VERSION_2_1: 1307 case CAMERA_DEVICE_API_VERSION_3_0: 1308 case CAMERA_DEVICE_API_VERSION_3_1: 1309 if (apiVersion == API_VERSION_2) { 1310 ALOGV("%s: Camera id %d uses HAL prior to HAL3.2, doesn't support api2 without shim", 1311 __FUNCTION__, cameraId); 1312 return -EOPNOTSUPP; 1313 } else { // if (apiVersion == API_VERSION_1) { 1314 ALOGV("%s: Camera id %d uses older HAL before 3.2, but api1 is always supported", 1315 __FUNCTION__, cameraId); 1316 return OK; 1317 } 1318 case CAMERA_DEVICE_API_VERSION_3_2: 1319 ALOGV("%s: Camera id %d uses HAL3.2 or newer, supports api1/api2 directly", 1320 __FUNCTION__, cameraId); 1321 return OK; 1322 case -1: 1323 ALOGE("%s: Invalid camera id %d", __FUNCTION__, cameraId); 1324 return BAD_VALUE; 1325 default: 1326 ALOGE("%s: Unknown camera device HAL version: %d", __FUNCTION__, deviceVersion); 1327 return INVALID_OPERATION; 1328 } 1329 1330 return OK; 1331} 1332 1333void CameraService::removeClientByRemote(const wp<IBinder>& remoteBinder) { 1334 int callingPid = getCallingPid(); 1335 LOG1("CameraService::removeClientByRemote E (pid %d)", callingPid); 1336 1337 // Declare this before the lock to make absolutely sure the 1338 // destructor won't be called with the lock held. 1339 Mutex::Autolock lock(mServiceLock); 1340 1341 int outIndex; 1342 sp<BasicClient> client = findClientUnsafe(remoteBinder, outIndex); 1343 1344 if (client != 0) { 1345 // Found our camera, clear and leave. 1346 LOG1("removeClient: clear camera %d", outIndex); 1347 1348 sp<IBinder> remote = client->getRemote(); 1349 if (remote != NULL) { 1350 remote->unlinkToDeath(this); 1351 } 1352 1353 mClient[outIndex].clear(); 1354 } else { 1355 1356 sp<ProClient> clientPro = findProClientUnsafe(remoteBinder); 1357 1358 if (clientPro != NULL) { 1359 // Found our camera, clear and leave. 1360 LOG1("removeClient: clear pro %p", clientPro.get()); 1361 1362 IInterface::asBinder(clientPro->getRemoteCallback())->unlinkToDeath(this); 1363 } 1364 } 1365 1366 LOG1("CameraService::removeClientByRemote X (pid %d)", callingPid); 1367} 1368 1369sp<CameraService::ProClient> CameraService::findProClientUnsafe( 1370 const wp<IBinder>& cameraCallbacksRemote) 1371{ 1372 sp<ProClient> clientPro; 1373 1374 for (int i = 0; i < mNumberOfCameras; ++i) { 1375 Vector<size_t> removeIdx; 1376 1377 for (size_t j = 0; j < mProClientList[i].size(); ++j) { 1378 wp<ProClient> cl = mProClientList[i][j]; 1379 1380 sp<ProClient> clStrong = cl.promote(); 1381 if (clStrong != NULL && clStrong->getRemote() == cameraCallbacksRemote) { 1382 clientPro = clStrong; 1383 break; 1384 } else if (clStrong == NULL) { 1385 // mark to clean up dead ptr 1386 removeIdx.push(j); 1387 } 1388 } 1389 1390 // remove stale ptrs (in reverse so the indices dont change) 1391 for (ssize_t j = (ssize_t)removeIdx.size() - 1; j >= 0; --j) { 1392 mProClientList[i].removeAt(removeIdx[j]); 1393 } 1394 1395 } 1396 1397 return clientPro; 1398} 1399 1400sp<CameraService::BasicClient> CameraService::findClientUnsafe( 1401 const wp<IBinder>& cameraClient, int& outIndex) { 1402 sp<BasicClient> client; 1403 1404 for (int i = 0; i < mNumberOfCameras; i++) { 1405 1406 // This happens when we have already disconnected (or this is 1407 // just another unused camera). 1408 if (mClient[i] == 0) continue; 1409 1410 // Promote mClient. It can fail if we are called from this path: 1411 // Client::~Client() -> disconnect() -> removeClientByRemote(). 1412 client = mClient[i].promote(); 1413 1414 // Clean up stale client entry 1415 if (client == NULL) { 1416 mClient[i].clear(); 1417 continue; 1418 } 1419 1420 if (cameraClient == client->getRemote()) { 1421 // Found our camera 1422 outIndex = i; 1423 return client; 1424 } 1425 } 1426 1427 outIndex = -1; 1428 return NULL; 1429} 1430 1431CameraService::BasicClient* CameraService::getClientByIdUnsafe(int cameraId) { 1432 if (cameraId < 0 || cameraId >= mNumberOfCameras) return NULL; 1433 return mClient[cameraId].unsafe_get(); 1434} 1435 1436Mutex* CameraService::getClientLockById(int cameraId) { 1437 if (cameraId < 0 || cameraId >= mNumberOfCameras) return NULL; 1438 return &mClientLock[cameraId]; 1439} 1440 1441sp<CameraService::BasicClient> CameraService::getClientByRemote( 1442 const wp<IBinder>& cameraClient) { 1443 1444 // Declare this before the lock to make absolutely sure the 1445 // destructor won't be called with the lock held. 1446 sp<BasicClient> client; 1447 1448 Mutex::Autolock lock(mServiceLock); 1449 1450 int outIndex; 1451 client = findClientUnsafe(cameraClient, outIndex); 1452 1453 return client; 1454} 1455 1456status_t CameraService::onTransact( 1457 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { 1458 // Permission checks 1459 switch (code) { 1460 case BnCameraService::CONNECT: 1461 case BnCameraService::CONNECT_PRO: 1462 case BnCameraService::CONNECT_DEVICE: 1463 case BnCameraService::CONNECT_LEGACY: 1464 const int pid = getCallingPid(); 1465 const int self_pid = getpid(); 1466 if (pid != self_pid) { 1467 // we're called from a different process, do the real check 1468 if (!checkCallingPermission( 1469 String16("android.permission.CAMERA"))) { 1470 const int uid = getCallingUid(); 1471 ALOGE("Permission Denial: " 1472 "can't use the camera pid=%d, uid=%d", pid, uid); 1473 return PERMISSION_DENIED; 1474 } 1475 } 1476 break; 1477 } 1478 1479 return BnCameraService::onTransact(code, data, reply, flags); 1480} 1481 1482// The reason we need this busy bit is a new CameraService::connect() request 1483// may come in while the previous Client's destructor has not been run or is 1484// still running. If the last strong reference of the previous Client is gone 1485// but the destructor has not been finished, we should not allow the new Client 1486// to be created because we need to wait for the previous Client to tear down 1487// the hardware first. 1488void CameraService::setCameraBusy(int cameraId) { 1489 android_atomic_write(1, &mBusy[cameraId]); 1490 1491 ALOGV("setCameraBusy cameraId=%d", cameraId); 1492} 1493 1494void CameraService::setCameraFree(int cameraId) { 1495 android_atomic_write(0, &mBusy[cameraId]); 1496 1497 ALOGV("setCameraFree cameraId=%d", cameraId); 1498} 1499 1500// We share the media players for shutter and recording sound for all clients. 1501// A reference count is kept to determine when we will actually release the 1502// media players. 1503 1504MediaPlayer* CameraService::newMediaPlayer(const char *file) { 1505 MediaPlayer* mp = new MediaPlayer(); 1506 if (mp->setDataSource(NULL /* httpService */, file, NULL) == NO_ERROR) { 1507 mp->setAudioStreamType(AUDIO_STREAM_ENFORCED_AUDIBLE); 1508 mp->prepare(); 1509 } else { 1510 ALOGE("Failed to load CameraService sounds: %s", file); 1511 return NULL; 1512 } 1513 return mp; 1514} 1515 1516void CameraService::loadSound() { 1517 Mutex::Autolock lock(mSoundLock); 1518 LOG1("CameraService::loadSound ref=%d", mSoundRef); 1519 if (mSoundRef++) return; 1520 1521 mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/system/media/audio/ui/camera_click.ogg"); 1522 mSoundPlayer[SOUND_RECORDING] = newMediaPlayer("/system/media/audio/ui/VideoRecord.ogg"); 1523} 1524 1525void CameraService::releaseSound() { 1526 Mutex::Autolock lock(mSoundLock); 1527 LOG1("CameraService::releaseSound ref=%d", mSoundRef); 1528 if (--mSoundRef) return; 1529 1530 for (int i = 0; i < NUM_SOUNDS; i++) { 1531 if (mSoundPlayer[i] != 0) { 1532 mSoundPlayer[i]->disconnect(); 1533 mSoundPlayer[i].clear(); 1534 } 1535 } 1536} 1537 1538void CameraService::playSound(sound_kind kind) { 1539 LOG1("playSound(%d)", kind); 1540 Mutex::Autolock lock(mSoundLock); 1541 sp<MediaPlayer> player = mSoundPlayer[kind]; 1542 if (player != 0) { 1543 player->seekTo(0); 1544 player->start(); 1545 } 1546} 1547 1548// ---------------------------------------------------------------------------- 1549 1550CameraService::Client::Client(const sp<CameraService>& cameraService, 1551 const sp<ICameraClient>& cameraClient, 1552 const String16& clientPackageName, 1553 int cameraId, int cameraFacing, 1554 int clientPid, uid_t clientUid, 1555 int servicePid) : 1556 CameraService::BasicClient(cameraService, 1557 IInterface::asBinder(cameraClient), 1558 clientPackageName, 1559 cameraId, cameraFacing, 1560 clientPid, clientUid, 1561 servicePid) 1562{ 1563 int callingPid = getCallingPid(); 1564 LOG1("Client::Client E (pid %d, id %d)", callingPid, cameraId); 1565 1566 mRemoteCallback = cameraClient; 1567 1568 cameraService->setCameraBusy(cameraId); 1569 cameraService->loadSound(); 1570 1571 LOG1("Client::Client X (pid %d, id %d)", callingPid, cameraId); 1572} 1573 1574// tear down the client 1575CameraService::Client::~Client() { 1576 ALOGV("~Client"); 1577 mDestructionStarted = true; 1578 1579 mCameraService->releaseSound(); 1580 // unconditionally disconnect. function is idempotent 1581 Client::disconnect(); 1582} 1583 1584CameraService::BasicClient::BasicClient(const sp<CameraService>& cameraService, 1585 const sp<IBinder>& remoteCallback, 1586 const String16& clientPackageName, 1587 int cameraId, int cameraFacing, 1588 int clientPid, uid_t clientUid, 1589 int servicePid): 1590 mClientPackageName(clientPackageName) 1591{ 1592 mCameraService = cameraService; 1593 mRemoteBinder = remoteCallback; 1594 mCameraId = cameraId; 1595 mCameraFacing = cameraFacing; 1596 mClientPid = clientPid; 1597 mClientUid = clientUid; 1598 mServicePid = servicePid; 1599 mOpsActive = false; 1600 mDestructionStarted = false; 1601} 1602 1603CameraService::BasicClient::~BasicClient() { 1604 ALOGV("~BasicClient"); 1605 mDestructionStarted = true; 1606} 1607 1608void CameraService::BasicClient::disconnect() { 1609 ALOGV("BasicClient::disconnect"); 1610 mCameraService->removeClientByRemote(mRemoteBinder); 1611 1612 finishCameraOps(); 1613 // client shouldn't be able to call into us anymore 1614 mClientPid = 0; 1615} 1616 1617status_t CameraService::BasicClient::startCameraOps() { 1618 int32_t res; 1619 // Notify app ops that the camera is not available 1620 mOpsCallback = new OpsCallback(this); 1621 1622 { 1623 ALOGV("%s: Start camera ops, package name = %s, client UID = %d", 1624 __FUNCTION__, String8(mClientPackageName).string(), mClientUid); 1625 } 1626 1627 mAppOpsManager.startWatchingMode(AppOpsManager::OP_CAMERA, 1628 mClientPackageName, mOpsCallback); 1629 res = mAppOpsManager.startOp(AppOpsManager::OP_CAMERA, 1630 mClientUid, mClientPackageName); 1631 1632 if (res != AppOpsManager::MODE_ALLOWED) { 1633 ALOGI("Camera %d: Access for \"%s\" has been revoked", 1634 mCameraId, String8(mClientPackageName).string()); 1635 return PERMISSION_DENIED; 1636 } 1637 1638 mOpsActive = true; 1639 1640 // Transition device availability listeners from PRESENT -> NOT_AVAILABLE 1641 mCameraService->updateStatus(ICameraServiceListener::STATUS_NOT_AVAILABLE, 1642 mCameraId); 1643 1644 return OK; 1645} 1646 1647status_t CameraService::BasicClient::finishCameraOps() { 1648 // Check if startCameraOps succeeded, and if so, finish the camera op 1649 if (mOpsActive) { 1650 // Notify app ops that the camera is available again 1651 mAppOpsManager.finishOp(AppOpsManager::OP_CAMERA, mClientUid, 1652 mClientPackageName); 1653 mOpsActive = false; 1654 1655 // Notify device availability listeners that this camera is available 1656 // again 1657 1658 StatusVector rejectSourceStates; 1659 rejectSourceStates.push_back(ICameraServiceListener::STATUS_NOT_PRESENT); 1660 rejectSourceStates.push_back(ICameraServiceListener::STATUS_ENUMERATING); 1661 1662 // Transition to PRESENT if the camera is not in either of above 2 1663 // states 1664 mCameraService->updateStatus(ICameraServiceListener::STATUS_PRESENT, 1665 mCameraId, 1666 &rejectSourceStates); 1667 1668 // Notify flashlight that a camera device is closed. 1669 mCameraService->mFlashlight->deviceClosed( 1670 String8::format("%d", mCameraId)); 1671 } 1672 // Always stop watching, even if no camera op is active 1673 if (mOpsCallback != NULL) { 1674 mAppOpsManager.stopWatchingMode(mOpsCallback); 1675 } 1676 mOpsCallback.clear(); 1677 1678 return OK; 1679} 1680 1681void CameraService::BasicClient::opChanged(int32_t op, const String16& packageName) { 1682 String8 name(packageName); 1683 String8 myName(mClientPackageName); 1684 1685 if (op != AppOpsManager::OP_CAMERA) { 1686 ALOGW("Unexpected app ops notification received: %d", op); 1687 return; 1688 } 1689 1690 int32_t res; 1691 res = mAppOpsManager.checkOp(AppOpsManager::OP_CAMERA, 1692 mClientUid, mClientPackageName); 1693 ALOGV("checkOp returns: %d, %s ", res, 1694 res == AppOpsManager::MODE_ALLOWED ? "ALLOWED" : 1695 res == AppOpsManager::MODE_IGNORED ? "IGNORED" : 1696 res == AppOpsManager::MODE_ERRORED ? "ERRORED" : 1697 "UNKNOWN"); 1698 1699 if (res != AppOpsManager::MODE_ALLOWED) { 1700 ALOGI("Camera %d: Access for \"%s\" revoked", mCameraId, 1701 myName.string()); 1702 // Reset the client PID to allow server-initiated disconnect, 1703 // and to prevent further calls by client. 1704 mClientPid = getCallingPid(); 1705 CaptureResultExtras resultExtras; // a dummy result (invalid) 1706 notifyError(ICameraDeviceCallbacks::ERROR_CAMERA_SERVICE, resultExtras); 1707 disconnect(); 1708 } 1709} 1710 1711// ---------------------------------------------------------------------------- 1712 1713Mutex* CameraService::Client::getClientLockFromCookie(void* user) { 1714 return gCameraService->getClientLockById((int)(intptr_t) user); 1715} 1716 1717// Provide client pointer for callbacks. Client lock returned from getClientLockFromCookie should 1718// be acquired for this to be safe 1719CameraService::Client* CameraService::Client::getClientFromCookie(void* user) { 1720 BasicClient *basicClient = gCameraService->getClientByIdUnsafe((int)(intptr_t) user); 1721 // OK: only CameraClient calls this, and they already cast anyway. 1722 Client* client = static_cast<Client*>(basicClient); 1723 1724 // This could happen if the Client is in the process of shutting down (the 1725 // last strong reference is gone, but the destructor hasn't finished 1726 // stopping the hardware). 1727 if (client == NULL) return NULL; 1728 1729 // destruction already started, so should not be accessed 1730 if (client->mDestructionStarted) return NULL; 1731 1732 return client; 1733} 1734 1735void CameraService::Client::notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode, 1736 const CaptureResultExtras& resultExtras) { 1737 mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, CAMERA_ERROR_RELEASED, 0); 1738} 1739 1740// NOTE: function is idempotent 1741void CameraService::Client::disconnect() { 1742 ALOGV("Client::disconnect"); 1743 BasicClient::disconnect(); 1744 mCameraService->setCameraFree(mCameraId); 1745} 1746 1747CameraService::Client::OpsCallback::OpsCallback(wp<BasicClient> client): 1748 mClient(client) { 1749} 1750 1751void CameraService::Client::OpsCallback::opChanged(int32_t op, 1752 const String16& packageName) { 1753 sp<BasicClient> client = mClient.promote(); 1754 if (client != NULL) { 1755 client->opChanged(op, packageName); 1756 } 1757} 1758 1759// ---------------------------------------------------------------------------- 1760// IProCamera 1761// ---------------------------------------------------------------------------- 1762 1763CameraService::ProClient::ProClient(const sp<CameraService>& cameraService, 1764 const sp<IProCameraCallbacks>& remoteCallback, 1765 const String16& clientPackageName, 1766 int cameraId, 1767 int cameraFacing, 1768 int clientPid, 1769 uid_t clientUid, 1770 int servicePid) 1771 : CameraService::BasicClient(cameraService, IInterface::asBinder(remoteCallback), 1772 clientPackageName, cameraId, cameraFacing, 1773 clientPid, clientUid, servicePid) 1774{ 1775 mRemoteCallback = remoteCallback; 1776} 1777 1778CameraService::ProClient::~ProClient() { 1779} 1780 1781void CameraService::ProClient::notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode, 1782 const CaptureResultExtras& resultExtras) { 1783 mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, CAMERA_ERROR_RELEASED, 0); 1784} 1785 1786// ---------------------------------------------------------------------------- 1787 1788static const int kDumpLockRetries = 50; 1789static const int kDumpLockSleep = 60000; 1790 1791static bool tryLock(Mutex& mutex) 1792{ 1793 bool locked = false; 1794 for (int i = 0; i < kDumpLockRetries; ++i) { 1795 if (mutex.tryLock() == NO_ERROR) { 1796 locked = true; 1797 break; 1798 } 1799 usleep(kDumpLockSleep); 1800 } 1801 return locked; 1802} 1803 1804status_t CameraService::dump(int fd, const Vector<String16>& args) { 1805 String8 result; 1806 if (checkCallingPermission(String16("android.permission.DUMP")) == false) { 1807 result.appendFormat("Permission Denial: " 1808 "can't dump CameraService from pid=%d, uid=%d\n", 1809 getCallingPid(), 1810 getCallingUid()); 1811 write(fd, result.string(), result.size()); 1812 } else { 1813 bool locked = tryLock(mServiceLock); 1814 // failed to lock - CameraService is probably deadlocked 1815 if (!locked) { 1816 result.append("CameraService may be deadlocked\n"); 1817 write(fd, result.string(), result.size()); 1818 } 1819 1820 bool hasClient = false; 1821 if (!mModule) { 1822 result = String8::format("No camera module available!\n"); 1823 write(fd, result.string(), result.size()); 1824 if (locked) mServiceLock.unlock(); 1825 return NO_ERROR; 1826 } 1827 1828 const hw_module_t* common = mModule->getRawModule(); 1829 result = String8::format("Camera module HAL API version: 0x%x\n", common->hal_api_version); 1830 result.appendFormat("Camera module API version: 0x%x\n", common->module_api_version); 1831 result.appendFormat("Camera module name: %s\n", common->name); 1832 result.appendFormat("Camera module author: %s\n", common->author); 1833 result.appendFormat("Number of camera devices: %d\n\n", mNumberOfCameras); 1834 1835 sp<VendorTagDescriptor> desc = VendorTagDescriptor::getGlobalVendorTagDescriptor(); 1836 if (desc == NULL) { 1837 result.appendFormat("Vendor tags left unimplemented.\n"); 1838 } else { 1839 result.appendFormat("Vendor tag definitions:\n"); 1840 } 1841 1842 write(fd, result.string(), result.size()); 1843 1844 if (desc != NULL) { 1845 desc->dump(fd, /*verbosity*/2, /*indentation*/4); 1846 } 1847 1848 for (int i = 0; i < mNumberOfCameras; i++) { 1849 result = String8::format("Camera %d static information:\n", i); 1850 camera_info info; 1851 1852 status_t rc = mModule->getCameraInfo(i, &info); 1853 if (rc != OK) { 1854 result.appendFormat(" Error reading static information!\n"); 1855 write(fd, result.string(), result.size()); 1856 } else { 1857 result.appendFormat(" Facing: %s\n", 1858 info.facing == CAMERA_FACING_BACK ? "BACK" : "FRONT"); 1859 result.appendFormat(" Orientation: %d\n", info.orientation); 1860 int deviceVersion; 1861 if (common->module_api_version < CAMERA_MODULE_API_VERSION_2_0) { 1862 deviceVersion = CAMERA_DEVICE_API_VERSION_1_0; 1863 } else { 1864 deviceVersion = info.device_version; 1865 } 1866 result.appendFormat(" Device version: 0x%x\n", deviceVersion); 1867 if (deviceVersion >= CAMERA_DEVICE_API_VERSION_2_0) { 1868 result.appendFormat(" Device static metadata:\n"); 1869 write(fd, result.string(), result.size()); 1870 dump_indented_camera_metadata(info.static_camera_characteristics, 1871 fd, /*verbosity*/2, /*indentation*/4); 1872 } else { 1873 write(fd, result.string(), result.size()); 1874 } 1875 } 1876 1877 sp<BasicClient> client = mClient[i].promote(); 1878 if (client == 0) { 1879 result = String8::format(" Device is closed, no client instance\n"); 1880 write(fd, result.string(), result.size()); 1881 continue; 1882 } 1883 hasClient = true; 1884 result = String8::format(" Device is open. Client instance dump:\n"); 1885 write(fd, result.string(), result.size()); 1886 client->dump(fd, args); 1887 } 1888 if (!hasClient) { 1889 result = String8::format("\nNo active camera clients yet.\n"); 1890 write(fd, result.string(), result.size()); 1891 } 1892 1893 if (locked) mServiceLock.unlock(); 1894 1895 // Dump camera traces if there were any 1896 write(fd, "\n", 1); 1897 camera3::CameraTraces::dump(fd, args); 1898 1899 // change logging level 1900 int n = args.size(); 1901 for (int i = 0; i + 1 < n; i++) { 1902 String16 verboseOption("-v"); 1903 if (args[i] == verboseOption) { 1904 String8 levelStr(args[i+1]); 1905 int level = atoi(levelStr.string()); 1906 result = String8::format("\nSetting log level to %d.\n", level); 1907 setLogLevel(level); 1908 write(fd, result.string(), result.size()); 1909 } 1910 } 1911 1912 } 1913 return NO_ERROR; 1914} 1915 1916void CameraService::handleTorchClientBinderDied(const wp<IBinder> &who) { 1917 Mutex::Autolock al(mTorchClientMapMutex); 1918 for (size_t i = 0; i < mTorchClientMap.size(); i++) { 1919 if (mTorchClientMap[i] == who) { 1920 // turn off the torch mode that was turned on by dead client 1921 String8 cameraId = mTorchClientMap.keyAt(i); 1922 status_t res = mFlashlight->setTorchMode(cameraId, false); 1923 if (res) { 1924 ALOGE("%s: torch client died but couldn't turn off torch: " 1925 "%s (%d)", __FUNCTION__, strerror(-res), res); 1926 return; 1927 } 1928 mTorchClientMap.removeItemsAt(i); 1929 break; 1930 } 1931 } 1932} 1933 1934/*virtual*/void CameraService::binderDied( 1935 const wp<IBinder> &who) { 1936 1937 /** 1938 * While tempting to promote the wp<IBinder> into a sp, 1939 * it's actually not supported by the binder driver 1940 */ 1941 1942 ALOGV("java clients' binder died"); 1943 1944 // check torch client 1945 handleTorchClientBinderDied(who); 1946 1947 // check camera device client 1948 sp<BasicClient> cameraClient = getClientByRemote(who); 1949 1950 if (cameraClient == 0) { 1951 ALOGV("java clients' binder death already cleaned up (normal case)"); 1952 return; 1953 } 1954 1955 ALOGW("Disconnecting camera client %p since the binder for it " 1956 "died (this pid %d)", cameraClient.get(), getCallingPid()); 1957 1958 cameraClient->disconnect(); 1959 1960} 1961 1962void CameraService::updateStatus(ICameraServiceListener::Status status, 1963 int32_t cameraId, 1964 const StatusVector *rejectSourceStates) { 1965 // do not lock mServiceLock here or can get into a deadlock from 1966 // connect() -> ProClient::disconnect -> updateStatus 1967 Mutex::Autolock lock(mStatusMutex); 1968 1969 ICameraServiceListener::Status oldStatus = mStatusList[cameraId]; 1970 1971 mStatusList[cameraId] = status; 1972 1973 if (oldStatus != status) { 1974 ALOGV("%s: Status has changed for camera ID %d from 0x%x to 0x%x", 1975 __FUNCTION__, cameraId, (uint32_t)oldStatus, (uint32_t)status); 1976 1977 if (oldStatus == ICameraServiceListener::STATUS_NOT_PRESENT && 1978 (status != ICameraServiceListener::STATUS_PRESENT && 1979 status != ICameraServiceListener::STATUS_ENUMERATING)) { 1980 1981 ALOGW("%s: From NOT_PRESENT can only transition into PRESENT" 1982 " or ENUMERATING", __FUNCTION__); 1983 mStatusList[cameraId] = oldStatus; 1984 return; 1985 } 1986 1987 if (rejectSourceStates != NULL) { 1988 const StatusVector &rejectList = *rejectSourceStates; 1989 StatusVector::const_iterator it = rejectList.begin(); 1990 1991 /** 1992 * Sometimes we want to conditionally do a transition. 1993 * For example if a client disconnects, we want to go to PRESENT 1994 * only if we weren't already in NOT_PRESENT or ENUMERATING. 1995 */ 1996 for (; it != rejectList.end(); ++it) { 1997 if (oldStatus == *it) { 1998 ALOGV("%s: Rejecting status transition for Camera ID %d, " 1999 " since the source state was was in one of the bad " 2000 " states.", __FUNCTION__, cameraId); 2001 mStatusList[cameraId] = oldStatus; 2002 return; 2003 } 2004 } 2005 } 2006 2007 /** 2008 * ProClients lose their exclusive lock. 2009 * - Done before the CameraClient can initialize the HAL device, 2010 * since we want to be able to close it before they get to initialize 2011 */ 2012 if (status == ICameraServiceListener::STATUS_NOT_AVAILABLE) { 2013 Vector<wp<ProClient> > proClients(mProClientList[cameraId]); 2014 Vector<wp<ProClient> >::const_iterator it; 2015 2016 for (it = proClients.begin(); it != proClients.end(); ++it) { 2017 sp<ProClient> proCl = it->promote(); 2018 if (proCl.get() != NULL) { 2019 proCl->onExclusiveLockStolen(); 2020 } 2021 } 2022 } 2023 2024 if (status == ICameraServiceListener::STATUS_NOT_PRESENT || 2025 status == ICameraServiceListener::STATUS_NOT_AVAILABLE) { 2026 // update torch status to not available when the camera device 2027 // becomes not present or not available. 2028 onTorchStatusChanged(String8::format("%d", cameraId), 2029 ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE); 2030 } else if (status == ICameraServiceListener::STATUS_PRESENT) { 2031 // update torch status to available when the camera device becomes 2032 // present or available 2033 onTorchStatusChanged(String8::format("%d", cameraId), 2034 ICameraServiceListener::TORCH_STATUS_AVAILABLE_OFF); 2035 } 2036 2037 Vector<sp<ICameraServiceListener> >::const_iterator it; 2038 for (it = mListenerList.begin(); it != mListenerList.end(); ++it) { 2039 (*it)->onStatusChanged(status, cameraId); 2040 } 2041 } 2042} 2043 2044ICameraServiceListener::Status CameraService::getStatus(int cameraId) const { 2045 if (cameraId < 0 || cameraId >= MAX_CAMERAS) { 2046 ALOGE("%s: Invalid camera ID %d", __FUNCTION__, cameraId); 2047 return ICameraServiceListener::STATUS_UNKNOWN; 2048 } 2049 2050 Mutex::Autolock al(mStatusMutex); 2051 return mStatusList[cameraId]; 2052} 2053 2054status_t CameraService::getTorchStatusLocked( 2055 const String8& cameraId, 2056 ICameraServiceListener::TorchStatus *status) const { 2057 if (!status) { 2058 return BAD_VALUE; 2059 } 2060 ssize_t index = mTorchStatusMap.indexOfKey(cameraId); 2061 if (index == NAME_NOT_FOUND) { 2062 // invalid camera ID or the camera doesn't have a flash unit 2063 return NAME_NOT_FOUND; 2064 } 2065 2066 *status = mTorchStatusMap.valueAt(index); 2067 return OK; 2068} 2069 2070status_t CameraService::setTorchStatusLocked(const String8& cameraId, 2071 ICameraServiceListener::TorchStatus status) { 2072 ssize_t index = mTorchStatusMap.indexOfKey(cameraId); 2073 if (index == NAME_NOT_FOUND) { 2074 return BAD_VALUE; 2075 } 2076 ICameraServiceListener::TorchStatus& item = 2077 mTorchStatusMap.editValueAt(index); 2078 item = status; 2079 2080 return OK; 2081} 2082 2083}; // namespace android 2084