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