CameraService.h revision 2823ce0ce6f9d508a07de20912c93cce9165027f
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#ifndef ANDROID_SERVERS_CAMERA_CAMERASERVICE_H 18#define ANDROID_SERVERS_CAMERA_CAMERASERVICE_H 19 20#include <cutils/multiuser.h> 21#include <utils/Vector.h> 22#include <utils/KeyedVector.h> 23#include <binder/AppOpsManager.h> 24#include <binder/BinderService.h> 25#include <binder/IAppOpsCallback.h> 26#include <camera/ICameraService.h> 27#include <hardware/camera.h> 28 29#include <camera/ICamera.h> 30#include <camera/ICameraClient.h> 31#include <camera/camera2/ICameraDeviceUser.h> 32#include <camera/camera2/ICameraDeviceCallbacks.h> 33#include <camera/VendorTagDescriptor.h> 34#include <camera/CaptureResult.h> 35#include <camera/CameraParameters.h> 36 37#include <camera/ICameraServiceListener.h> 38#include "CameraFlashlight.h" 39 40#include "common/CameraModule.h" 41#include "media/RingBuffer.h" 42#include "utils/AutoConditionLock.h" 43#include "utils/ClientManager.h" 44 45#include <set> 46#include <string> 47#include <map> 48#include <memory> 49 50namespace android { 51 52extern volatile int32_t gLogLevel; 53 54class MemoryHeapBase; 55class MediaPlayer; 56 57class CameraService : 58 public BinderService<CameraService>, 59 public BnCameraService, 60 public IBinder::DeathRecipient, 61 public camera_module_callbacks_t 62{ 63 friend class BinderService<CameraService>; 64public: 65 class Client; 66 class BasicClient; 67 68 // The effective API level. The Camera2 API running in LEGACY mode counts as API_1. 69 enum apiLevel { 70 API_1 = 1, 71 API_2 = 2 72 }; 73 74 // Process state (mirrors frameworks/base/core/java/android/app/ActivityManager.java) 75 static const int PROCESS_STATE_NONEXISTENT = -1; 76 77 // 3 second busy timeout when other clients are connecting 78 static const nsecs_t DEFAULT_CONNECT_TIMEOUT_NS = 3000000000; 79 80 // 1 second busy timeout when other clients are disconnecting 81 static const nsecs_t DEFAULT_DISCONNECT_TIMEOUT_NS = 1000000000; 82 83 // Default number of messages to store in eviction log 84 static const size_t DEFAULT_EVENT_LOG_LENGTH = 100; 85 86 // Implementation of BinderService<T> 87 static char const* getServiceName() { return "media.camera"; } 88 89 CameraService(); 90 virtual ~CameraService(); 91 92 ///////////////////////////////////////////////////////////////////// 93 // HAL Callbacks 94 virtual void onDeviceStatusChanged(camera_device_status_t cameraId, 95 camera_device_status_t newStatus); 96 virtual void onTorchStatusChanged(const String8& cameraId, 97 ICameraServiceListener::TorchStatus 98 newStatus); 99 100 ///////////////////////////////////////////////////////////////////// 101 // ICameraService 102 virtual int32_t getNumberOfCameras(); 103 virtual status_t getCameraInfo(int cameraId, 104 struct CameraInfo* cameraInfo); 105 virtual status_t getCameraCharacteristics(int cameraId, 106 CameraMetadata* cameraInfo); 107 virtual status_t getCameraVendorTagDescriptor(/*out*/ sp<VendorTagDescriptor>& desc); 108 109 virtual status_t connect(const sp<ICameraClient>& cameraClient, int cameraId, 110 const String16& clientPackageName, int clientUid, 111 /*out*/ 112 sp<ICamera>& device); 113 114 virtual status_t connectLegacy(const sp<ICameraClient>& cameraClient, int cameraId, 115 int halVersion, const String16& clientPackageName, int clientUid, 116 /*out*/ 117 sp<ICamera>& device); 118 119 virtual status_t connectDevice( 120 const sp<ICameraDeviceCallbacks>& cameraCb, 121 int cameraId, 122 const String16& clientPackageName, 123 int clientUid, 124 /*out*/ 125 sp<ICameraDeviceUser>& device); 126 127 virtual status_t addListener(const sp<ICameraServiceListener>& listener); 128 virtual status_t removeListener( 129 const sp<ICameraServiceListener>& listener); 130 131 virtual status_t getLegacyParameters( 132 int cameraId, 133 /*out*/ 134 String16* parameters); 135 136 virtual status_t setTorchMode(const String16& cameraId, bool enabled, 137 const sp<IBinder>& clientBinder); 138 139 virtual void notifySystemEvent(int32_t eventId, const int32_t* args, size_t length); 140 141 // OK = supports api of that version, -EOPNOTSUPP = does not support 142 virtual status_t supportsCameraApi( 143 int cameraId, int apiVersion); 144 145 // Extra permissions checks 146 virtual status_t onTransact(uint32_t code, const Parcel& data, 147 Parcel* reply, uint32_t flags); 148 149 virtual status_t dump(int fd, const Vector<String16>& args); 150 151 ///////////////////////////////////////////////////////////////////// 152 // Client functionality 153 154 enum sound_kind { 155 SOUND_SHUTTER = 0, 156 SOUND_RECORDING = 1, 157 NUM_SOUNDS 158 }; 159 160 void loadSound(); 161 void playSound(sound_kind kind); 162 void releaseSound(); 163 164 ///////////////////////////////////////////////////////////////////// 165 // CameraDeviceFactory functionality 166 int getDeviceVersion(int cameraId, int* facing = NULL); 167 168 ///////////////////////////////////////////////////////////////////// 169 // Shared utilities 170 static status_t filterGetInfoErrorCode(status_t err); 171 172 ///////////////////////////////////////////////////////////////////// 173 // CameraClient functionality 174 175 class BasicClient : public virtual RefBase { 176 public: 177 virtual status_t initialize(CameraModule *module) = 0; 178 virtual void disconnect(); 179 180 // because we can't virtually inherit IInterface, which breaks 181 // virtual inheritance 182 virtual sp<IBinder> asBinderWrapper() = 0; 183 184 // Return the remote callback binder object (e.g. ICameraDeviceCallbacks) 185 sp<IBinder> getRemote() { 186 return mRemoteBinder; 187 } 188 189 virtual status_t dump(int fd, const Vector<String16>& args) = 0; 190 191 // Return the package name for this client 192 virtual String16 getPackageName() const; 193 194 // Notify client about a fatal error 195 virtual void notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode, 196 const CaptureResultExtras& resultExtras) = 0; 197 198 // Get the UID of the application client using this 199 virtual uid_t getClientUid() const; 200 201 // Get the PID of the application client using this 202 virtual int getClientPid() const; 203 204 // Check what API level is used for this client. This is used to determine which 205 // superclass this can be cast to. 206 virtual bool canCastToApiClient(apiLevel level) const; 207 protected: 208 BasicClient(const sp<CameraService>& cameraService, 209 const sp<IBinder>& remoteCallback, 210 const String16& clientPackageName, 211 int cameraId, 212 int cameraFacing, 213 int clientPid, 214 uid_t clientUid, 215 int servicePid); 216 217 virtual ~BasicClient(); 218 219 // the instance is in the middle of destruction. When this is set, 220 // the instance should not be accessed from callback. 221 // CameraService's mClientLock should be acquired to access this. 222 // - subclasses should set this to true in their destructors. 223 bool mDestructionStarted; 224 225 // these are initialized in the constructor. 226 sp<CameraService> mCameraService; // immutable after constructor 227 int mCameraId; // immutable after constructor 228 int mCameraFacing; // immutable after constructor 229 const String16 mClientPackageName; 230 pid_t mClientPid; 231 uid_t mClientUid; // immutable after constructor 232 pid_t mServicePid; // immutable after constructor 233 bool mDisconnected; 234 235 // - The app-side Binder interface to receive callbacks from us 236 sp<IBinder> mRemoteBinder; // immutable after constructor 237 238 // permissions management 239 status_t startCameraOps(); 240 status_t finishCameraOps(); 241 242 private: 243 AppOpsManager mAppOpsManager; 244 245 class OpsCallback : public BnAppOpsCallback { 246 public: 247 OpsCallback(wp<BasicClient> client); 248 virtual void opChanged(int32_t op, const String16& packageName); 249 250 private: 251 wp<BasicClient> mClient; 252 253 }; // class OpsCallback 254 255 sp<OpsCallback> mOpsCallback; 256 // Track whether startCameraOps was called successfully, to avoid 257 // finishing what we didn't start. 258 bool mOpsActive; 259 260 // IAppOpsCallback interface, indirected through opListener 261 virtual void opChanged(int32_t op, const String16& packageName); 262 }; // class BasicClient 263 264 class Client : public BnCamera, public BasicClient 265 { 266 public: 267 typedef ICameraClient TCamCallbacks; 268 269 // ICamera interface (see ICamera for details) 270 virtual void disconnect(); 271 virtual status_t connect(const sp<ICameraClient>& client) = 0; 272 virtual status_t lock() = 0; 273 virtual status_t unlock() = 0; 274 virtual status_t setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer)=0; 275 virtual void setPreviewCallbackFlag(int flag) = 0; 276 virtual status_t setPreviewCallbackTarget( 277 const sp<IGraphicBufferProducer>& callbackProducer) = 0; 278 virtual status_t startPreview() = 0; 279 virtual void stopPreview() = 0; 280 virtual bool previewEnabled() = 0; 281 virtual status_t storeMetaDataInBuffers(bool enabled) = 0; 282 virtual status_t startRecording() = 0; 283 virtual void stopRecording() = 0; 284 virtual bool recordingEnabled() = 0; 285 virtual void releaseRecordingFrame(const sp<IMemory>& mem) = 0; 286 virtual status_t autoFocus() = 0; 287 virtual status_t cancelAutoFocus() = 0; 288 virtual status_t takePicture(int msgType) = 0; 289 virtual status_t setParameters(const String8& params) = 0; 290 virtual String8 getParameters() const = 0; 291 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) = 0; 292 293 // Interface used by CameraService 294 Client(const sp<CameraService>& cameraService, 295 const sp<ICameraClient>& cameraClient, 296 const String16& clientPackageName, 297 int cameraId, 298 int cameraFacing, 299 int clientPid, 300 uid_t clientUid, 301 int servicePid); 302 ~Client(); 303 304 // return our camera client 305 const sp<ICameraClient>& getRemoteCallback() { 306 return mRemoteCallback; 307 } 308 309 virtual sp<IBinder> asBinderWrapper() { 310 return asBinder(this); 311 } 312 313 virtual void notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode, 314 const CaptureResultExtras& resultExtras); 315 316 // Check what API level is used for this client. This is used to determine which 317 // superclass this can be cast to. 318 virtual bool canCastToApiClient(apiLevel level) const; 319 protected: 320 // Convert client from cookie. 321 static sp<CameraService::Client> getClientFromCookie(void* user); 322 323 // Initialized in constructor 324 325 // - The app-side Binder interface to receive callbacks from us 326 sp<ICameraClient> mRemoteCallback; 327 328 }; // class Client 329 330 typedef std::shared_ptr<resource_policy::ClientDescriptor<String8, 331 sp<CameraService::BasicClient>>> DescriptorPtr; 332 333 /** 334 * A container class for managing active camera clients that are using HAL devices. Active 335 * clients are represented by ClientDescriptor objects that contain strong pointers to the 336 * actual BasicClient subclass binder interface implementation. 337 * 338 * This class manages the eviction behavior for the camera clients. See the parent class 339 * implementation in utils/ClientManager for the specifics of this behavior. 340 */ 341 class CameraClientManager : 342 public resource_policy::ClientManager<String8, sp<CameraService::BasicClient>> { 343 public: 344 virtual ~CameraClientManager(); 345 346 /** 347 * Return a strong pointer to the active BasicClient for this camera ID, or an empty 348 * if none exists. 349 */ 350 sp<CameraService::BasicClient> getCameraClient(const String8& id) const; 351 352 /** 353 * Return a string describing the current state. 354 */ 355 String8 toString() const; 356 357 /** 358 * Make a ClientDescriptor object wrapping the given BasicClient strong pointer. 359 */ 360 static DescriptorPtr makeClientDescriptor(const String8& key, const sp<BasicClient>& value, 361 int32_t cost, const std::set<String8>& conflictingKeys, int32_t priority, 362 int32_t ownerId); 363 364 /** 365 * Make a ClientDescriptor object wrapping the given BasicClient strong pointer with 366 * values intialized from a prior ClientDescriptor. 367 */ 368 static DescriptorPtr makeClientDescriptor(const sp<BasicClient>& value, 369 const CameraService::DescriptorPtr& partial); 370 371 }; // class CameraClientManager 372 373private: 374 375 /** 376 * Container class for the state of each logical camera device, including: ID, status, and 377 * dependencies on other devices. The mapping of camera ID -> state saved in mCameraStates 378 * represents the camera devices advertised by the HAL (and any USB devices, when we add 379 * those). 380 * 381 * This container does NOT represent an active camera client. These are represented using 382 * the ClientDescriptors stored in mActiveClientManager. 383 */ 384 class CameraState { 385 public: 386 /** 387 * Make a new CameraState and set the ID, cost, and conflicting devices using the values 388 * returned in the HAL's camera_info struct for each device. 389 */ 390 CameraState(const String8& id, int cost, const std::set<String8>& conflicting); 391 virtual ~CameraState(); 392 393 /** 394 * Return the status for this device. 395 * 396 * This method acquires mStatusLock. 397 */ 398 ICameraServiceListener::Status getStatus() const; 399 400 /** 401 * This function updates the status for this camera device, unless the given status 402 * is in the given list of rejected status states, and execute the function passed in 403 * with a signature onStatusUpdateLocked(const String8&, ICameraServiceListener::Status) 404 * if the status has changed. 405 * 406 * This method is idempotent, and will not result in the function passed to 407 * onStatusUpdateLocked being called more than once for the same arguments. 408 * This method aquires mStatusLock. 409 */ 410 template<class Func> 411 void updateStatus(ICameraServiceListener::Status status, const String8& cameraId, 412 std::initializer_list<ICameraServiceListener::Status> rejectSourceStates, 413 Func onStatusUpdatedLocked); 414 415 /** 416 * Return the last set CameraParameters object generated from the information returned by 417 * the HAL for this device (or an empty CameraParameters object if none has been set). 418 */ 419 CameraParameters getShimParams() const; 420 421 /** 422 * Set the CameraParameters for this device. 423 */ 424 void setShimParams(const CameraParameters& params); 425 426 /** 427 * Return the resource_cost advertised by the HAL for this device. 428 */ 429 int getCost() const; 430 431 /** 432 * Return a set of the IDs of conflicting devices advertised by the HAL for this device. 433 */ 434 std::set<String8> getConflicting() const; 435 436 /** 437 * Return the ID of this camera device. 438 */ 439 String8 getId() const; 440 441 private: 442 const String8 mId; 443 ICameraServiceListener::Status mStatus; // protected by mStatusLock 444 const int mCost; 445 std::set<String8> mConflicting; 446 mutable Mutex mStatusLock; 447 CameraParameters mShimParams; 448 }; // class CameraState 449 450 // Delay-load the Camera HAL module 451 virtual void onFirstRef(); 452 453 // Check if we can connect, before we acquire the service lock. 454 status_t validateConnectLocked(const String8& cameraId, /*inout*/int& clientUid) const; 455 456 // Handle active client evictions, and update service state. 457 // Only call with with mServiceLock held. 458 status_t handleEvictionsLocked(const String8& cameraId, int clientPid, 459 apiLevel effectiveApiLevel, const sp<IBinder>& remoteCallback, const String8& packageName, 460 /*out*/ 461 sp<BasicClient>* client, 462 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial); 463 464 // Single implementation shared between the various connect calls 465 template<class CALLBACK, class CLIENT> 466 status_t connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId, int halVersion, 467 const String16& clientPackageName, int clientUid, apiLevel effectiveApiLevel, 468 bool legacyMode, bool shimUpdateOnly, /*out*/sp<CLIENT>& device); 469 470 // Lock guarding camera service state 471 Mutex mServiceLock; 472 473 // Condition to use with mServiceLock, used to handle simultaneous connect calls from clients 474 std::shared_ptr<WaitableMutexWrapper> mServiceLockWrapper; 475 476 // Return NO_ERROR if the device with a give ID can be connected to 477 status_t checkIfDeviceIsUsable(const String8& cameraId) const; 478 479 // Container for managing currently active application-layer clients 480 CameraClientManager mActiveClientManager; 481 482 // Mapping from camera ID -> state for each device, map is protected by mCameraStatesLock 483 std::map<String8, std::shared_ptr<CameraState>> mCameraStates; 484 485 // Mutex guarding mCameraStates map 486 mutable Mutex mCameraStatesLock; 487 488 // Circular buffer for storing event logging for dumps 489 RingBuffer<String8> mEventLog; 490 Mutex mLogLock; 491 492 // Currently allowed user IDs 493 std::set<userid_t> mAllowedUsers; 494 495 /** 496 * Get the camera state for a given camera id. 497 * 498 * This acquires mCameraStatesLock. 499 */ 500 std::shared_ptr<CameraService::CameraState> getCameraState(const String8& cameraId) const; 501 502 /** 503 * Evict client who's remote binder has died. Returns true if this client was in the active 504 * list and was disconnected. 505 * 506 * This method acquires mServiceLock. 507 */ 508 bool evictClientIdByRemote(const wp<IBinder>& cameraClient); 509 510 /** 511 * Remove the given client from the active clients list; does not disconnect the client. 512 * 513 * This method acquires mServiceLock. 514 */ 515 void removeByClient(const BasicClient* client); 516 517 /** 518 * Add new client to active clients list after conflicting clients have disconnected using the 519 * values set in the partial descriptor passed in to construct the actual client descriptor. 520 * This is typically called at the end of a connect call. 521 * 522 * This method must be called with mServiceLock held. 523 */ 524 void finishConnectLocked(const sp<BasicClient>& client, const DescriptorPtr& desc); 525 526 /** 527 * Returns the integer corresponding to the given camera ID string, or -1 on failure. 528 */ 529 static int cameraIdToInt(const String8& cameraId); 530 531 /** 532 * Remove a single client corresponding to the given camera id from the list of active clients. 533 * If none exists, return an empty strongpointer. 534 * 535 * This method must be called with mServiceLock held. 536 */ 537 sp<CameraService::BasicClient> removeClientLocked(const String8& cameraId); 538 539 /** 540 * Handle a notification that the current device user has changed. 541 */ 542 void doUserSwitch(const int32_t* newUserId, size_t length); 543 544 /** 545 * Add an event log message. 546 */ 547 void logEvent(const char* event); 548 549 /** 550 * Add an event log message that a client has been disconnected. 551 */ 552 void logDisconnected(const char* cameraId, int clientPid, const char* clientPackage); 553 554 /** 555 * Add an event log message that a client has been connected. 556 */ 557 void logConnected(const char* cameraId, int clientPid, const char* clientPackage); 558 559 /** 560 * Add an event log message that a client's connect attempt has been rejected. 561 */ 562 void logRejected(const char* cameraId, int clientPid, const char* clientPackage, 563 const char* reason); 564 565 /** 566 * Add an event log message that the current device user has been switched. 567 */ 568 void logUserSwitch(const std::set<userid_t>& oldUserIds, 569 const std::set<userid_t>& newUserIds); 570 571 /** 572 * Add an event log message that a device has been removed by the HAL 573 */ 574 void logDeviceRemoved(const char* cameraId, const char* reason); 575 576 /** 577 * Add an event log message that a device has been added by the HAL 578 */ 579 void logDeviceAdded(const char* cameraId, const char* reason); 580 581 /** 582 * Add an event log message that a client has unexpectedly died. 583 */ 584 void logClientDied(int clientPid, const char* reason); 585 586 /** 587 * Add a event log message that a serious service-level error has occured 588 */ 589 void logServiceError(const char* msg, int errorCode); 590 591 /** 592 * Dump the event log to an FD 593 */ 594 void dumpEventLog(int fd); 595 596 int mNumberOfCameras; 597 598 // sounds 599 MediaPlayer* newMediaPlayer(const char *file); 600 601 Mutex mSoundLock; 602 sp<MediaPlayer> mSoundPlayer[NUM_SOUNDS]; 603 int mSoundRef; // reference count (release all MediaPlayer when 0) 604 605 CameraModule* mModule; 606 607 // Guarded by mStatusListenerMutex 608 std::vector<sp<ICameraServiceListener>> mListenerList; 609 Mutex mStatusListenerLock; 610 611 /** 612 * Update the status for the given camera id (if that device exists), and broadcast the 613 * status update to all current ICameraServiceListeners if the status has changed. Any 614 * statuses in rejectedSourceStates will be ignored. 615 * 616 * This method must be idempotent. 617 * This method acquires mStatusLock and mStatusListenerLock. 618 */ 619 void updateStatus(ICameraServiceListener::Status status, const String8& cameraId, 620 std::initializer_list<ICameraServiceListener::Status> rejectedSourceStates); 621 void updateStatus(ICameraServiceListener::Status status, const String8& cameraId); 622 623 // flashlight control 624 sp<CameraFlashlight> mFlashlight; 625 // guard mTorchStatusMap 626 Mutex mTorchStatusMutex; 627 // guard mTorchClientMap 628 Mutex mTorchClientMapMutex; 629 // camera id -> torch status 630 KeyedVector<String8, ICameraServiceListener::TorchStatus> mTorchStatusMap; 631 // camera id -> torch client binder 632 // only store the last client that turns on each camera's torch mode 633 KeyedVector<String8, sp<IBinder> > mTorchClientMap; 634 635 // check and handle if torch client's process has died 636 void handleTorchClientBinderDied(const wp<IBinder> &who); 637 638 // handle torch mode status change and invoke callbacks. mTorchStatusMutex 639 // should be locked. 640 void onTorchStatusChangedLocked(const String8& cameraId, 641 ICameraServiceListener::TorchStatus newStatus); 642 643 // get a camera's torch status. mTorchStatusMutex should be locked. 644 status_t getTorchStatusLocked(const String8 &cameraId, 645 ICameraServiceListener::TorchStatus *status) const; 646 647 // set a camera's torch status. mTorchStatusMutex should be locked. 648 status_t setTorchStatusLocked(const String8 &cameraId, 649 ICameraServiceListener::TorchStatus status); 650 651 // IBinder::DeathRecipient implementation 652 virtual void binderDied(const wp<IBinder> &who); 653 654 // Helpers 655 656 bool setUpVendorTags(); 657 658 /** 659 * Initialize and cache the metadata used by the HAL1 shim for a given cameraId. 660 * 661 * Returns OK on success, or a negative error code. 662 */ 663 status_t initializeShimMetadata(int cameraId); 664 665 /** 666 * Get the cached CameraParameters for the camera. If they haven't been 667 * cached yet, then initialize them for the first time. 668 * 669 * Returns OK on success, or a negative error code. 670 */ 671 status_t getLegacyParametersLazy(int cameraId, /*out*/CameraParameters* parameters); 672 673 /** 674 * Generate the CameraCharacteristics metadata required by the Camera2 API 675 * from the available HAL1 CameraParameters and CameraInfo. 676 * 677 * Returns OK on success, or a negative error code. 678 */ 679 status_t generateShimMetadata(int cameraId, /*out*/CameraMetadata* cameraInfo); 680 681 static int getCallingPid(); 682 683 static int getCallingUid(); 684 685 /** 686 * Get the current system time as a formatted string. 687 */ 688 static String8 getFormattedCurrentTime(); 689 690 /** 691 * Get the camera eviction priority from the current process state given by ActivityManager. 692 */ 693 static int getCameraPriorityFromProcState(int procState); 694 695 static status_t makeClient(const sp<CameraService>& cameraService, 696 const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId, 697 int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode, 698 int halVersion, int deviceVersion, apiLevel effectiveApiLevel, 699 /*out*/sp<BasicClient>* client); 700 701 status_t checkCameraAccess(const String16& opPackageName); 702 703 static String8 toString(std::set<userid_t> intSet); 704 705 static void pingCameraServiceProxy(); 706 707}; 708 709template<class Func> 710void CameraService::CameraState::updateStatus(ICameraServiceListener::Status status, 711 const String8& cameraId, 712 std::initializer_list<ICameraServiceListener::Status> rejectSourceStates, 713 Func onStatusUpdatedLocked) { 714 Mutex::Autolock lock(mStatusLock); 715 ICameraServiceListener::Status oldStatus = mStatus; 716 mStatus = status; 717 718 if (oldStatus == status) { 719 return; 720 } 721 722 ALOGV("%s: Status has changed for camera ID %s from %#x to %#x", __FUNCTION__, 723 cameraId.string(), oldStatus, status); 724 725 if (oldStatus == ICameraServiceListener::STATUS_NOT_PRESENT && 726 (status != ICameraServiceListener::STATUS_PRESENT && 727 status != ICameraServiceListener::STATUS_ENUMERATING)) { 728 729 ALOGW("%s: From NOT_PRESENT can only transition into PRESENT or ENUMERATING", 730 __FUNCTION__); 731 mStatus = oldStatus; 732 return; 733 } 734 735 /** 736 * Sometimes we want to conditionally do a transition. 737 * For example if a client disconnects, we want to go to PRESENT 738 * only if we weren't already in NOT_PRESENT or ENUMERATING. 739 */ 740 for (auto& rejectStatus : rejectSourceStates) { 741 if (oldStatus == rejectStatus) { 742 ALOGV("%s: Rejecting status transition for Camera ID %s, since the source " 743 "state was was in one of the bad states.", __FUNCTION__, cameraId.string()); 744 mStatus = oldStatus; 745 return; 746 } 747 } 748 749 onStatusUpdatedLocked(cameraId, status); 750} 751 752 753template<class CALLBACK, class CLIENT> 754status_t CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId, 755 int halVersion, const String16& clientPackageName, int clientUid, 756 apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly, 757 /*out*/sp<CLIENT>& device) { 758 status_t ret = NO_ERROR; 759 String8 clientName8(clientPackageName); 760 int clientPid = getCallingPid(); 761 762 ALOGI("CameraService::connect call (PID %d \"%s\", camera ID %s) for HAL version %s and " 763 "Camera API version %d", clientPid, clientName8.string(), cameraId.string(), 764 (halVersion == -1) ? "default" : std::to_string(halVersion).c_str(), 765 static_cast<int>(effectiveApiLevel)); 766 767 sp<CLIENT> client = nullptr; 768 { 769 // Acquire mServiceLock and prevent other clients from connecting 770 std::unique_ptr<AutoConditionLock> lock = 771 AutoConditionLock::waitAndAcquire(mServiceLockWrapper, DEFAULT_CONNECT_TIMEOUT_NS); 772 773 if (lock == nullptr) { 774 ALOGE("CameraService::connect X (PID %d) rejected (too many other clients connecting)." 775 , clientPid); 776 return -EBUSY; 777 } 778 779 // Enforce client permissions and do basic sanity checks 780 if((ret = validateConnectLocked(cameraId, /*inout*/clientUid)) != NO_ERROR) { 781 return ret; 782 } 783 784 // Check the shim parameters after acquiring lock, if they have already been updated and 785 // we were doing a shim update, return immediately 786 if (shimUpdateOnly) { 787 auto cameraState = getCameraState(cameraId); 788 if (cameraState != nullptr) { 789 if (!cameraState->getShimParams().isEmpty()) return NO_ERROR; 790 } 791 } 792 793 sp<BasicClient> clientTmp = nullptr; 794 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>> partial; 795 if ((ret = handleEvictionsLocked(cameraId, clientPid, effectiveApiLevel, 796 IInterface::asBinder(cameraCb), clientName8, /*out*/&clientTmp, 797 /*out*/&partial)) != NO_ERROR) { 798 return ret; 799 } 800 801 if (clientTmp.get() != nullptr) { 802 // Handle special case for API1 MediaRecorder where the existing client is returned 803 device = static_cast<CLIENT*>(clientTmp.get()); 804 return NO_ERROR; 805 } 806 807 // give flashlight a chance to close devices if necessary. 808 mFlashlight->prepareDeviceOpen(cameraId); 809 810 // TODO: Update getDeviceVersion + HAL interface to use strings for Camera IDs 811 int id = cameraIdToInt(cameraId); 812 if (id == -1) { 813 ALOGE("%s: Invalid camera ID %s, cannot get device version from HAL.", __FUNCTION__, 814 cameraId.string()); 815 return BAD_VALUE; 816 } 817 818 int facing = -1; 819 int deviceVersion = getDeviceVersion(id, /*out*/&facing); 820 sp<BasicClient> tmp = nullptr; 821 if((ret = makeClient(this, cameraCb, clientPackageName, cameraId, facing, clientPid, 822 clientUid, getpid(), legacyMode, halVersion, deviceVersion, effectiveApiLevel, 823 /*out*/&tmp)) != NO_ERROR) { 824 return ret; 825 } 826 client = static_cast<CLIENT*>(tmp.get()); 827 828 LOG_ALWAYS_FATAL_IF(client.get() == nullptr, "%s: CameraService in invalid state", 829 __FUNCTION__); 830 831 if ((ret = client->initialize(mModule)) != OK) { 832 ALOGE("%s: Could not initialize client from HAL module.", __FUNCTION__); 833 return ret; 834 } 835 836 sp<IBinder> remoteCallback = client->getRemote(); 837 if (remoteCallback != nullptr) { 838 remoteCallback->linkToDeath(this); 839 } 840 841 // Update shim paremeters for legacy clients 842 if (effectiveApiLevel == API_1) { 843 // Assume we have always received a Client subclass for API1 844 sp<Client> shimClient = reinterpret_cast<Client*>(client.get()); 845 String8 rawParams = shimClient->getParameters(); 846 CameraParameters params(rawParams); 847 848 auto cameraState = getCameraState(cameraId); 849 if (cameraState != nullptr) { 850 cameraState->setShimParams(params); 851 } else { 852 ALOGE("%s: Cannot update shim parameters for camera %s, no such device exists.", 853 __FUNCTION__, cameraId.string()); 854 } 855 } 856 857 if (shimUpdateOnly) { 858 // If only updating legacy shim parameters, immediately disconnect client 859 mServiceLock.unlock(); 860 client->disconnect(); 861 mServiceLock.lock(); 862 } else { 863 // Otherwise, add client to active clients list 864 finishConnectLocked(client, partial); 865 } 866 } // lock is destroyed, allow further connect calls 867 868 // Important: release the mutex here so the client can call back into the service from its 869 // destructor (can be at the end of the call) 870 device = client; 871 return NO_ERROR; 872} 873 874} // namespace android 875 876#endif 877