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