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