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 <android/hardware/BnCameraService.h> 21 #include <android/hardware/ICameraServiceListener.h> 22 #include <android/hardware/ICameraServiceProxy.h> 23 24 #include <cutils/multiuser.h> 25 #include <utils/Vector.h> 26 #include <utils/KeyedVector.h> 27 #include <binder/AppOpsManager.h> 28 #include <binder/BinderService.h> 29 #include <binder/IAppOpsCallback.h> 30 #include <hardware/camera.h> 31 32 #include <android/hardware/camera/common/1.0/types.h> 33 34 #include <camera/VendorTagDescriptor.h> 35 #include <camera/CaptureResult.h> 36 #include <camera/CameraParameters.h> 37 38 #include "CameraFlashlight.h" 39 40 #include "common/CameraProviderManager.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 virtual ::android::hardware::BnCameraService, 61 public virtual IBinder::DeathRecipient, 62 public camera_module_callbacks_t, 63 public virtual CameraProviderManager::StatusListener 64 { 65 friend class BinderService<CameraService>; 66 friend class CameraClient; 67 public: 68 class Client; 69 class BasicClient; 70 71 // The effective API level. The Camera2 API running in LEGACY mode counts as API_1. 72 enum apiLevel { 73 API_1 = 1, 74 API_2 = 2 75 }; 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 // Event log ID 87 static const int SN_EVENT_LOG_ID = 0x534e4554; 88 89 // Implementation of BinderService<T> getServiceName()90 static char const* getServiceName() { return "media.camera"; } 91 92 CameraService(); 93 virtual ~CameraService(); 94 95 ///////////////////////////////////////////////////////////////////// 96 // HAL Callbacks - implements CameraProviderManager::StatusListener 97 98 virtual void onDeviceStatusChanged(const String8 &cameraId, 99 hardware::camera::common::V1_0::CameraDeviceStatus newHalStatus) override; 100 virtual void onTorchStatusChanged(const String8& cameraId, 101 hardware::camera::common::V1_0::TorchModeStatus newStatus) override; 102 virtual void onNewProviderRegistered() override; 103 104 ///////////////////////////////////////////////////////////////////// 105 // ICameraService 106 virtual binder::Status getNumberOfCameras(int32_t type, int32_t* numCameras); 107 108 virtual binder::Status getCameraInfo(int cameraId, 109 hardware::CameraInfo* cameraInfo); 110 virtual binder::Status getCameraCharacteristics(const String16& cameraId, 111 CameraMetadata* cameraInfo); 112 virtual binder::Status getCameraVendorTagDescriptor( 113 /*out*/ 114 hardware::camera2::params::VendorTagDescriptor* desc); 115 virtual binder::Status getCameraVendorTagCache( 116 /*out*/ 117 hardware::camera2::params::VendorTagDescriptorCache* cache); 118 119 virtual binder::Status connect(const sp<hardware::ICameraClient>& cameraClient, 120 int32_t cameraId, const String16& clientPackageName, 121 int32_t clientUid, int clientPid, 122 /*out*/ 123 sp<hardware::ICamera>* device); 124 125 virtual binder::Status connectLegacy(const sp<hardware::ICameraClient>& cameraClient, 126 int32_t cameraId, int32_t halVersion, 127 const String16& clientPackageName, int32_t clientUid, 128 /*out*/ 129 sp<hardware::ICamera>* device); 130 131 virtual binder::Status connectDevice( 132 const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb, const String16& cameraId, 133 const String16& clientPackageName, int32_t clientUid, 134 /*out*/ 135 sp<hardware::camera2::ICameraDeviceUser>* device); 136 137 virtual binder::Status addListener(const sp<hardware::ICameraServiceListener>& listener, 138 /*out*/ 139 std::vector<hardware::CameraStatus>* cameraStatuses); 140 virtual binder::Status removeListener( 141 const sp<hardware::ICameraServiceListener>& listener); 142 143 virtual binder::Status getLegacyParameters( 144 int32_t cameraId, 145 /*out*/ 146 String16* parameters); 147 148 virtual binder::Status setTorchMode(const String16& cameraId, bool enabled, 149 const sp<IBinder>& clientBinder); 150 151 virtual binder::Status notifySystemEvent(int32_t eventId, 152 const std::vector<int32_t>& args); 153 154 // OK = supports api of that version, -EOPNOTSUPP = does not support 155 virtual binder::Status supportsCameraApi( 156 const String16& cameraId, int32_t apiVersion, 157 /*out*/ 158 bool *isSupported); 159 160 // Extra permissions checks 161 virtual status_t onTransact(uint32_t code, const Parcel& data, 162 Parcel* reply, uint32_t flags); 163 164 virtual status_t dump(int fd, const Vector<String16>& args); 165 166 ///////////////////////////////////////////////////////////////////// 167 // Client functionality 168 169 enum sound_kind { 170 SOUND_SHUTTER = 0, 171 SOUND_RECORDING_START = 1, 172 SOUND_RECORDING_STOP = 2, 173 NUM_SOUNDS 174 }; 175 176 void loadSound(); 177 void playSound(sound_kind kind); 178 void releaseSound(); 179 180 /** 181 * Update the state of a given camera device (open/close/active/idle) with 182 * the camera proxy service in the system service 183 */ 184 static void updateProxyDeviceState( 185 int newState, 186 const String8& cameraId, 187 int facing, 188 const String16& clientName); 189 190 ///////////////////////////////////////////////////////////////////// 191 // CameraDeviceFactory functionality 192 int getDeviceVersion(const String8& cameraId, int* facing = NULL); 193 194 ///////////////////////////////////////////////////////////////////// 195 // Shared utilities 196 static binder::Status filterGetInfoErrorCode(status_t err); 197 198 ///////////////////////////////////////////////////////////////////// 199 // CameraClient functionality 200 201 class BasicClient : public virtual RefBase { 202 public: 203 virtual status_t initialize(sp<CameraProviderManager> manager) = 0; 204 virtual binder::Status disconnect(); 205 206 // because we can't virtually inherit IInterface, which breaks 207 // virtual inheritance 208 virtual sp<IBinder> asBinderWrapper() = 0; 209 210 // Return the remote callback binder object (e.g. ICameraDeviceCallbacks) getRemote()211 sp<IBinder> getRemote() { 212 return mRemoteBinder; 213 } 214 215 // Disallows dumping over binder interface 216 virtual status_t dump(int fd, const Vector<String16>& args); 217 // Internal dump method to be called by CameraService 218 virtual status_t dumpClient(int fd, const Vector<String16>& args) = 0; 219 220 // Return the package name for this client 221 virtual String16 getPackageName() const; 222 223 // Notify client about a fatal error 224 virtual void notifyError(int32_t errorCode, 225 const CaptureResultExtras& resultExtras) = 0; 226 227 // Get the UID of the application client using this 228 virtual uid_t getClientUid() const; 229 230 // Get the PID of the application client using this 231 virtual int getClientPid() const; 232 233 // Check what API level is used for this client. This is used to determine which 234 // superclass this can be cast to. 235 virtual bool canCastToApiClient(apiLevel level) const; 236 protected: 237 BasicClient(const sp<CameraService>& cameraService, 238 const sp<IBinder>& remoteCallback, 239 const String16& clientPackageName, 240 const String8& cameraIdStr, 241 int cameraFacing, 242 int clientPid, 243 uid_t clientUid, 244 int servicePid); 245 246 virtual ~BasicClient(); 247 248 // the instance is in the middle of destruction. When this is set, 249 // the instance should not be accessed from callback. 250 // CameraService's mClientLock should be acquired to access this. 251 // - subclasses should set this to true in their destructors. 252 bool mDestructionStarted; 253 254 // these are initialized in the constructor. 255 static sp<CameraService> sCameraService; 256 const String8 mCameraIdStr; 257 const int mCameraFacing; 258 String16 mClientPackageName; 259 pid_t mClientPid; 260 const uid_t mClientUid; 261 const pid_t mServicePid; 262 bool mDisconnected; 263 264 // - The app-side Binder interface to receive callbacks from us 265 sp<IBinder> mRemoteBinder; // immutable after constructor 266 267 // permissions management 268 status_t startCameraOps(); 269 status_t finishCameraOps(); 270 271 private: 272 AppOpsManager mAppOpsManager; 273 274 class OpsCallback : public BnAppOpsCallback { 275 public: 276 explicit OpsCallback(wp<BasicClient> client); 277 virtual void opChanged(int32_t op, const String16& packageName); 278 279 private: 280 wp<BasicClient> mClient; 281 282 }; // class OpsCallback 283 284 sp<OpsCallback> mOpsCallback; 285 // Track whether startCameraOps was called successfully, to avoid 286 // finishing what we didn't start. 287 bool mOpsActive; 288 289 // IAppOpsCallback interface, indirected through opListener 290 virtual void opChanged(int32_t op, const String16& packageName); 291 }; // class BasicClient 292 293 class Client : public hardware::BnCamera, public BasicClient 294 { 295 public: 296 typedef hardware::ICameraClient TCamCallbacks; 297 298 // ICamera interface (see ICamera for details) 299 virtual binder::Status disconnect(); 300 virtual status_t connect(const sp<hardware::ICameraClient>& client) = 0; 301 virtual status_t lock() = 0; 302 virtual status_t unlock() = 0; 303 virtual status_t setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer)=0; 304 virtual void setPreviewCallbackFlag(int flag) = 0; 305 virtual status_t setPreviewCallbackTarget( 306 const sp<IGraphicBufferProducer>& callbackProducer) = 0; 307 virtual status_t startPreview() = 0; 308 virtual void stopPreview() = 0; 309 virtual bool previewEnabled() = 0; 310 virtual status_t setVideoBufferMode(int32_t videoBufferMode) = 0; 311 virtual status_t startRecording() = 0; 312 virtual void stopRecording() = 0; 313 virtual bool recordingEnabled() = 0; 314 virtual void releaseRecordingFrame(const sp<IMemory>& mem) = 0; 315 virtual status_t autoFocus() = 0; 316 virtual status_t cancelAutoFocus() = 0; 317 virtual status_t takePicture(int msgType) = 0; 318 virtual status_t setParameters(const String8& params) = 0; 319 virtual String8 getParameters() const = 0; 320 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) = 0; 321 virtual status_t setVideoTarget(const sp<IGraphicBufferProducer>& bufferProducer) = 0; 322 323 // Interface used by CameraService 324 Client(const sp<CameraService>& cameraService, 325 const sp<hardware::ICameraClient>& cameraClient, 326 const String16& clientPackageName, 327 const String8& cameraIdStr, 328 int cameraFacing, 329 int clientPid, 330 uid_t clientUid, 331 int servicePid); 332 ~Client(); 333 334 // return our camera client getRemoteCallback()335 const sp<hardware::ICameraClient>& getRemoteCallback() { 336 return mRemoteCallback; 337 } 338 asBinderWrapper()339 virtual sp<IBinder> asBinderWrapper() { 340 return asBinder(this); 341 } 342 343 virtual void notifyError(int32_t errorCode, 344 const CaptureResultExtras& resultExtras); 345 346 // Check what API level is used for this client. This is used to determine which 347 // superclass this can be cast to. 348 virtual bool canCastToApiClient(apiLevel level) const; 349 protected: 350 // Initialized in constructor 351 352 // - The app-side Binder interface to receive callbacks from us 353 sp<hardware::ICameraClient> mRemoteCallback; 354 355 int mCameraId; // All API1 clients use integer camera IDs 356 }; // class Client 357 358 /** 359 * A listener class that implements the LISTENER interface for use with a ClientManager, and 360 * implements the following methods: 361 * void onClientRemoved(const ClientDescriptor<KEY, VALUE>& descriptor); 362 * void onClientAdded(const ClientDescriptor<KEY, VALUE>& descriptor); 363 */ 364 class ClientEventListener { 365 public: 366 void onClientAdded(const resource_policy::ClientDescriptor<String8, 367 sp<CameraService::BasicClient>>& descriptor); 368 void onClientRemoved(const resource_policy::ClientDescriptor<String8, 369 sp<CameraService::BasicClient>>& descriptor); 370 }; // class ClientEventListener 371 372 typedef std::shared_ptr<resource_policy::ClientDescriptor<String8, 373 sp<CameraService::BasicClient>>> DescriptorPtr; 374 375 /** 376 * A container class for managing active camera clients that are using HAL devices. Active 377 * clients are represented by ClientDescriptor objects that contain strong pointers to the 378 * actual BasicClient subclass binder interface implementation. 379 * 380 * This class manages the eviction behavior for the camera clients. See the parent class 381 * implementation in utils/ClientManager for the specifics of this behavior. 382 */ 383 class CameraClientManager : public resource_policy::ClientManager<String8, 384 sp<CameraService::BasicClient>, ClientEventListener> { 385 public: 386 CameraClientManager(); 387 virtual ~CameraClientManager(); 388 389 /** 390 * Return a strong pointer to the active BasicClient for this camera ID, or an empty 391 * if none exists. 392 */ 393 sp<CameraService::BasicClient> getCameraClient(const String8& id) const; 394 395 /** 396 * Return a string describing the current state. 397 */ 398 String8 toString() const; 399 400 /** 401 * Make a ClientDescriptor object wrapping the given BasicClient strong pointer. 402 */ 403 static DescriptorPtr makeClientDescriptor(const String8& key, const sp<BasicClient>& value, 404 int32_t cost, const std::set<String8>& conflictingKeys, int32_t score, 405 int32_t ownerId, int32_t state); 406 407 /** 408 * Make a ClientDescriptor object wrapping the given BasicClient strong pointer with 409 * values intialized from a prior ClientDescriptor. 410 */ 411 static DescriptorPtr makeClientDescriptor(const sp<BasicClient>& value, 412 const CameraService::DescriptorPtr& partial); 413 414 }; // class CameraClientManager 415 416 private: 417 418 typedef hardware::camera::common::V1_0::CameraDeviceStatus CameraDeviceStatus; 419 420 /** 421 * Typesafe version of device status, containing both the HAL-layer and the service interface- 422 * layer values. 423 */ 424 enum class StatusInternal : int32_t { 425 NOT_PRESENT = static_cast<int32_t>(CameraDeviceStatus::NOT_PRESENT), 426 PRESENT = static_cast<int32_t>(CameraDeviceStatus::PRESENT), 427 ENUMERATING = static_cast<int32_t>(CameraDeviceStatus::ENUMERATING), 428 NOT_AVAILABLE = static_cast<int32_t>(hardware::ICameraServiceListener::STATUS_NOT_AVAILABLE), 429 UNKNOWN = static_cast<int32_t>(hardware::ICameraServiceListener::STATUS_UNKNOWN) 430 }; 431 432 /** 433 * Container class for the state of each logical camera device, including: ID, status, and 434 * dependencies on other devices. The mapping of camera ID -> state saved in mCameraStates 435 * represents the camera devices advertised by the HAL (and any USB devices, when we add 436 * those). 437 * 438 * This container does NOT represent an active camera client. These are represented using 439 * the ClientDescriptors stored in mActiveClientManager. 440 */ 441 class CameraState { 442 public: 443 444 /** 445 * Make a new CameraState and set the ID, cost, and conflicting devices using the values 446 * returned in the HAL's camera_info struct for each device. 447 */ 448 CameraState(const String8& id, int cost, const std::set<String8>& conflicting); 449 virtual ~CameraState(); 450 451 /** 452 * Return the status for this device. 453 * 454 * This method acquires mStatusLock. 455 */ 456 StatusInternal getStatus() const; 457 458 /** 459 * This function updates the status for this camera device, unless the given status 460 * is in the given list of rejected status states, and execute the function passed in 461 * with a signature onStatusUpdateLocked(const String8&, int32_t) 462 * if the status has changed. 463 * 464 * This method is idempotent, and will not result in the function passed to 465 * onStatusUpdateLocked being called more than once for the same arguments. 466 * This method aquires mStatusLock. 467 */ 468 template<class Func> 469 void updateStatus(StatusInternal status, 470 const String8& cameraId, 471 std::initializer_list<StatusInternal> rejectSourceStates, 472 Func onStatusUpdatedLocked); 473 474 /** 475 * Return the last set CameraParameters object generated from the information returned by 476 * the HAL for this device (or an empty CameraParameters object if none has been set). 477 */ 478 CameraParameters getShimParams() const; 479 480 /** 481 * Set the CameraParameters for this device. 482 */ 483 void setShimParams(const CameraParameters& params); 484 485 /** 486 * Return the resource_cost advertised by the HAL for this device. 487 */ 488 int getCost() const; 489 490 /** 491 * Return a set of the IDs of conflicting devices advertised by the HAL for this device. 492 */ 493 std::set<String8> getConflicting() const; 494 495 /** 496 * Return the ID of this camera device. 497 */ 498 String8 getId() const; 499 500 private: 501 const String8 mId; 502 StatusInternal mStatus; // protected by mStatusLock 503 const int mCost; 504 std::set<String8> mConflicting; 505 mutable Mutex mStatusLock; 506 CameraParameters mShimParams; 507 }; // class CameraState 508 509 // Delay-load the Camera HAL module 510 virtual void onFirstRef(); 511 512 // Eumerate all camera providers in the system 513 status_t enumerateProviders(); 514 515 // Check if we can connect, before we acquire the service lock. 516 // The returned originalClientPid is the PID of the original process that wants to connect to 517 // camera. 518 // The returned clientPid is the PID of the client that directly connects to camera. 519 // originalClientPid and clientPid are usually the same except when the application uses 520 // mediaserver to connect to camera (using MediaRecorder to connect to camera). In that case, 521 // clientPid is the PID of mediaserver and originalClientPid is the PID of the application. 522 binder::Status validateConnectLocked(const String8& cameraId, const String8& clientName8, 523 /*inout*/int& clientUid, /*inout*/int& clientPid, /*out*/int& originalClientPid) const; 524 binder::Status validateClientPermissionsLocked(const String8& cameraId, const String8& clientName8, 525 /*inout*/int& clientUid, /*inout*/int& clientPid, /*out*/int& originalClientPid) const; 526 527 // Handle active client evictions, and update service state. 528 // Only call with with mServiceLock held. 529 status_t handleEvictionsLocked(const String8& cameraId, int clientPid, 530 apiLevel effectiveApiLevel, const sp<IBinder>& remoteCallback, const String8& packageName, 531 /*out*/ 532 sp<BasicClient>* client, 533 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial); 534 535 // Single implementation shared between the various connect calls 536 template<class CALLBACK, class CLIENT> 537 binder::Status connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId, 538 int halVersion, const String16& clientPackageName, 539 int clientUid, int clientPid, 540 apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly, 541 /*out*/sp<CLIENT>& device); 542 543 // Lock guarding camera service state 544 Mutex mServiceLock; 545 546 // Condition to use with mServiceLock, used to handle simultaneous connect calls from clients 547 std::shared_ptr<WaitableMutexWrapper> mServiceLockWrapper; 548 549 // Return NO_ERROR if the device with a give ID can be connected to 550 status_t checkIfDeviceIsUsable(const String8& cameraId) const; 551 552 // Container for managing currently active application-layer clients 553 CameraClientManager mActiveClientManager; 554 555 // Mapping from camera ID -> state for each device, map is protected by mCameraStatesLock 556 std::map<String8, std::shared_ptr<CameraState>> mCameraStates; 557 558 // Mutex guarding mCameraStates map 559 mutable Mutex mCameraStatesLock; 560 561 // Circular buffer for storing event logging for dumps 562 RingBuffer<String8> mEventLog; 563 Mutex mLogLock; 564 565 // Currently allowed user IDs 566 std::set<userid_t> mAllowedUsers; 567 568 /** 569 * Get the camera state for a given camera id. 570 * 571 * This acquires mCameraStatesLock. 572 */ 573 std::shared_ptr<CameraService::CameraState> getCameraState(const String8& cameraId) const; 574 575 /** 576 * Evict client who's remote binder has died. Returns true if this client was in the active 577 * list and was disconnected. 578 * 579 * This method acquires mServiceLock. 580 */ 581 bool evictClientIdByRemote(const wp<IBinder>& cameraClient); 582 583 /** 584 * Remove the given client from the active clients list; does not disconnect the client. 585 * 586 * This method acquires mServiceLock. 587 */ 588 void removeByClient(const BasicClient* client); 589 590 /** 591 * Add new client to active clients list after conflicting clients have disconnected using the 592 * values set in the partial descriptor passed in to construct the actual client descriptor. 593 * This is typically called at the end of a connect call. 594 * 595 * This method must be called with mServiceLock held. 596 */ 597 void finishConnectLocked(const sp<BasicClient>& client, const DescriptorPtr& desc); 598 599 /** 600 * Returns the integer corresponding to the given camera ID string, or -1 on failure. 601 */ 602 static int cameraIdToInt(const String8& cameraId); 603 604 /** 605 * Remove a single client corresponding to the given camera id from the list of active clients. 606 * If none exists, return an empty strongpointer. 607 * 608 * This method must be called with mServiceLock held. 609 */ 610 sp<CameraService::BasicClient> removeClientLocked(const String8& cameraId); 611 612 /** 613 * Handle a notification that the current device user has changed. 614 */ 615 void doUserSwitch(const std::vector<int32_t>& newUserIds); 616 617 /** 618 * Add an event log message. 619 */ 620 void logEvent(const char* event); 621 622 /** 623 * Add an event log message that a client has been disconnected. 624 */ 625 void logDisconnected(const char* cameraId, int clientPid, const char* clientPackage); 626 627 /** 628 * Add an event log message that a client has been connected. 629 */ 630 void logConnected(const char* cameraId, int clientPid, const char* clientPackage); 631 632 /** 633 * Add an event log message that a client's connect attempt has been rejected. 634 */ 635 void logRejected(const char* cameraId, int clientPid, const char* clientPackage, 636 const char* reason); 637 638 /** 639 * Add an event log message that the current device user has been switched. 640 */ 641 void logUserSwitch(const std::set<userid_t>& oldUserIds, 642 const std::set<userid_t>& newUserIds); 643 644 /** 645 * Add an event log message that a device has been removed by the HAL 646 */ 647 void logDeviceRemoved(const char* cameraId, const char* reason); 648 649 /** 650 * Add an event log message that a device has been added by the HAL 651 */ 652 void logDeviceAdded(const char* cameraId, const char* reason); 653 654 /** 655 * Add an event log message that a client has unexpectedly died. 656 */ 657 void logClientDied(int clientPid, const char* reason); 658 659 /** 660 * Add a event log message that a serious service-level error has occured 661 * The errorCode should be one of the Android Errors 662 */ 663 void logServiceError(const char* msg, int errorCode); 664 665 /** 666 * Dump the event log to an FD 667 */ 668 void dumpEventLog(int fd); 669 670 int mNumberOfCameras; 671 int mNumberOfNormalCameras; 672 673 // sounds 674 MediaPlayer* newMediaPlayer(const char *file); 675 676 Mutex mSoundLock; 677 sp<MediaPlayer> mSoundPlayer[NUM_SOUNDS]; 678 int mSoundRef; // reference count (release all MediaPlayer when 0) 679 680 // Basic flag on whether the camera subsystem is in a usable state 681 bool mInitialized; 682 683 sp<CameraProviderManager> mCameraProviderManager; 684 685 // Guarded by mStatusListenerMutex 686 std::vector<sp<hardware::ICameraServiceListener>> mListenerList; 687 Mutex mStatusListenerLock; 688 689 /** 690 * Update the status for the given camera id (if that device exists), and broadcast the 691 * status update to all current ICameraServiceListeners if the status has changed. Any 692 * statuses in rejectedSourceStates will be ignored. 693 * 694 * This method must be idempotent. 695 * This method acquires mStatusLock and mStatusListenerLock. 696 */ 697 void updateStatus(StatusInternal status, 698 const String8& cameraId, 699 std::initializer_list<StatusInternal> 700 rejectedSourceStates); 701 void updateStatus(StatusInternal status, 702 const String8& cameraId); 703 704 // flashlight control 705 sp<CameraFlashlight> mFlashlight; 706 // guard mTorchStatusMap 707 Mutex mTorchStatusMutex; 708 // guard mTorchClientMap 709 Mutex mTorchClientMapMutex; 710 // guard mTorchUidMap 711 Mutex mTorchUidMapMutex; 712 // camera id -> torch status 713 KeyedVector<String8, hardware::camera::common::V1_0::TorchModeStatus> 714 mTorchStatusMap; 715 // camera id -> torch client binder 716 // only store the last client that turns on each camera's torch mode 717 KeyedVector<String8, sp<IBinder>> mTorchClientMap; 718 // camera id -> [incoming uid, current uid] pair 719 std::map<String8, std::pair<int, int>> mTorchUidMap; 720 721 // check and handle if torch client's process has died 722 void handleTorchClientBinderDied(const wp<IBinder> &who); 723 724 // handle torch mode status change and invoke callbacks. mTorchStatusMutex 725 // should be locked. 726 void onTorchStatusChangedLocked(const String8& cameraId, 727 hardware::camera::common::V1_0::TorchModeStatus newStatus); 728 729 // get a camera's torch status. mTorchStatusMutex should be locked. 730 status_t getTorchStatusLocked(const String8 &cameraId, 731 hardware::camera::common::V1_0::TorchModeStatus *status) const; 732 733 // set a camera's torch status. mTorchStatusMutex should be locked. 734 status_t setTorchStatusLocked(const String8 &cameraId, 735 hardware::camera::common::V1_0::TorchModeStatus status); 736 737 // IBinder::DeathRecipient implementation 738 virtual void binderDied(const wp<IBinder> &who); 739 740 /** 741 * Initialize and cache the metadata used by the HAL1 shim for a given cameraId. 742 * 743 * Sets Status to a service-specific error on failure 744 */ 745 binder::Status initializeShimMetadata(int cameraId); 746 747 /** 748 * Get the cached CameraParameters for the camera. If they haven't been 749 * cached yet, then initialize them for the first time. 750 * 751 * Sets Status to a service-specific error on failure 752 */ 753 binder::Status getLegacyParametersLazy(int cameraId, /*out*/CameraParameters* parameters); 754 755 static int getCallingPid(); 756 757 static int getCallingUid(); 758 759 /** 760 * Get the current system time as a formatted string. 761 */ 762 static String8 getFormattedCurrentTime(); 763 764 static binder::Status makeClient(const sp<CameraService>& cameraService, 765 const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId, 766 int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode, 767 int halVersion, int deviceVersion, apiLevel effectiveApiLevel, 768 /*out*/sp<BasicClient>* client); 769 770 status_t checkCameraAccess(const String16& opPackageName); 771 772 static String8 toString(std::set<userid_t> intSet); 773 static int32_t mapToInterface(hardware::camera::common::V1_0::TorchModeStatus status); 774 static StatusInternal mapToInternal(hardware::camera::common::V1_0::CameraDeviceStatus status); 775 static int32_t mapToInterface(StatusInternal status); 776 777 static sp<hardware::ICameraServiceProxy> getCameraServiceProxy(); 778 static void pingCameraServiceProxy(); 779 780 }; 781 782 } // namespace android 783 784 #endif 785