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/BnSensorPrivacyListener.h> 22 #include <android/hardware/ICameraServiceListener.h> 23 #include <android/hardware/ICameraServiceProxy.h> 24 25 #include <cutils/multiuser.h> 26 #include <utils/Vector.h> 27 #include <utils/KeyedVector.h> 28 #include <binder/ActivityManager.h> 29 #include <binder/AppOpsManager.h> 30 #include <binder/BinderService.h> 31 #include <binder/IAppOpsCallback.h> 32 #include <binder/IUidObserver.h> 33 #include <hardware/camera.h> 34 #include <sensorprivacy/SensorPrivacyManager.h> 35 36 #include <android/hardware/camera/common/1.0/types.h> 37 38 #include <camera/VendorTagDescriptor.h> 39 #include <camera/CaptureResult.h> 40 #include <camera/CameraParameters.h> 41 #include <camera/camera2/ConcurrentCamera.h> 42 43 #include "CameraFlashlight.h" 44 45 #include "common/CameraProviderManager.h" 46 #include "media/RingBuffer.h" 47 #include "utils/AutoConditionLock.h" 48 #include "utils/ClientManager.h" 49 50 #include <set> 51 #include <string> 52 #include <map> 53 #include <memory> 54 #include <utility> 55 #include <unordered_map> 56 #include <unordered_set> 57 58 namespace android { 59 60 extern volatile int32_t gLogLevel; 61 62 class MemoryHeapBase; 63 class MediaPlayer; 64 65 class CameraService : 66 public BinderService<CameraService>, 67 public virtual ::android::hardware::BnCameraService, 68 public virtual IBinder::DeathRecipient, 69 public virtual CameraProviderManager::StatusListener 70 { 71 friend class BinderService<CameraService>; 72 friend class CameraClient; 73 friend class CameraOfflineSessionClient; 74 public: 75 class Client; 76 class BasicClient; 77 class OfflineClient; 78 79 // The effective API level. The Camera2 API running in LEGACY mode counts as API_1. 80 enum apiLevel { 81 API_1 = 1, 82 API_2 = 2 83 }; 84 85 // 3 second busy timeout when other clients are connecting 86 static const nsecs_t DEFAULT_CONNECT_TIMEOUT_NS = 3000000000; 87 88 // 1 second busy timeout when other clients are disconnecting 89 static const nsecs_t DEFAULT_DISCONNECT_TIMEOUT_NS = 1000000000; 90 91 // Default number of messages to store in eviction log 92 static const size_t DEFAULT_EVENT_LOG_LENGTH = 100; 93 94 // Event log ID 95 static const int SN_EVENT_LOG_ID = 0x534e4554; 96 97 // Implementation of BinderService<T> getServiceName()98 static char const* getServiceName() { return "media.camera"; } 99 100 CameraService(); 101 virtual ~CameraService(); 102 103 ///////////////////////////////////////////////////////////////////// 104 // HAL Callbacks - implements CameraProviderManager::StatusListener 105 106 virtual void onDeviceStatusChanged(const String8 &cameraId, 107 hardware::camera::common::V1_0::CameraDeviceStatus newHalStatus) override; 108 virtual void onDeviceStatusChanged(const String8 &cameraId, 109 const String8 &physicalCameraId, 110 hardware::camera::common::V1_0::CameraDeviceStatus newHalStatus) override; 111 virtual void onTorchStatusChanged(const String8& cameraId, 112 hardware::camera::common::V1_0::TorchModeStatus newStatus) override; 113 virtual void onNewProviderRegistered() override; 114 115 ///////////////////////////////////////////////////////////////////// 116 // ICameraService 117 virtual binder::Status getNumberOfCameras(int32_t type, int32_t* numCameras); 118 119 virtual binder::Status getCameraInfo(int cameraId, 120 hardware::CameraInfo* cameraInfo); 121 virtual binder::Status getCameraCharacteristics(const String16& cameraId, 122 CameraMetadata* cameraInfo); 123 virtual binder::Status getCameraVendorTagDescriptor( 124 /*out*/ 125 hardware::camera2::params::VendorTagDescriptor* desc); 126 virtual binder::Status getCameraVendorTagCache( 127 /*out*/ 128 hardware::camera2::params::VendorTagDescriptorCache* cache); 129 130 virtual binder::Status connect(const sp<hardware::ICameraClient>& cameraClient, 131 int32_t cameraId, const String16& clientPackageName, 132 int32_t clientUid, int clientPid, 133 /*out*/ 134 sp<hardware::ICamera>* device); 135 136 virtual binder::Status connectLegacy(const sp<hardware::ICameraClient>& cameraClient, 137 int32_t cameraId, int32_t halVersion, 138 const String16& clientPackageName, int32_t clientUid, 139 /*out*/ 140 sp<hardware::ICamera>* device); 141 142 virtual binder::Status connectDevice( 143 const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb, const String16& cameraId, 144 const String16& clientPackageName, const std::unique_ptr<String16>& clientFeatureId, 145 int32_t clientUid, 146 /*out*/ 147 sp<hardware::camera2::ICameraDeviceUser>* device); 148 149 virtual binder::Status addListener(const sp<hardware::ICameraServiceListener>& listener, 150 /*out*/ 151 std::vector<hardware::CameraStatus>* cameraStatuses); 152 virtual binder::Status removeListener( 153 const sp<hardware::ICameraServiceListener>& listener); 154 155 virtual binder::Status getConcurrentCameraIds( 156 /*out*/ 157 std::vector<hardware::camera2::utils::ConcurrentCameraIdCombination>* concurrentCameraIds); 158 159 virtual binder::Status isConcurrentSessionConfigurationSupported( 160 const std::vector<hardware::camera2::utils::CameraIdAndSessionConfiguration>& sessions, 161 /*out*/bool* supported); 162 163 virtual binder::Status getLegacyParameters( 164 int32_t cameraId, 165 /*out*/ 166 String16* parameters); 167 168 virtual binder::Status setTorchMode(const String16& cameraId, bool enabled, 169 const sp<IBinder>& clientBinder); 170 171 virtual binder::Status notifySystemEvent(int32_t eventId, 172 const std::vector<int32_t>& args); 173 174 virtual binder::Status notifyDeviceStateChange(int64_t newState); 175 176 // OK = supports api of that version, -EOPNOTSUPP = does not support 177 virtual binder::Status supportsCameraApi( 178 const String16& cameraId, int32_t apiVersion, 179 /*out*/ 180 bool *isSupported); 181 182 virtual binder::Status isHiddenPhysicalCamera( 183 const String16& cameraId, 184 /*out*/ 185 bool *isSupported); 186 187 // Extra permissions checks 188 virtual status_t onTransact(uint32_t code, const Parcel& data, 189 Parcel* reply, uint32_t flags); 190 191 virtual status_t dump(int fd, const Vector<String16>& args); 192 193 virtual status_t shellCommand(int in, int out, int err, const Vector<String16>& args); 194 195 binder::Status addListenerHelper(const sp<hardware::ICameraServiceListener>& listener, 196 /*out*/ 197 std::vector<hardware::CameraStatus>* cameraStatuses, bool isVendor = false); 198 199 // Monitored UIDs availability notification 200 void notifyMonitoredUids(); 201 202 // Register an offline client for a given active camera id 203 status_t addOfflineClient(String8 cameraId, sp<BasicClient> offlineClient); 204 205 ///////////////////////////////////////////////////////////////////// 206 // Client functionality 207 208 enum sound_kind { 209 SOUND_SHUTTER = 0, 210 SOUND_RECORDING_START = 1, 211 SOUND_RECORDING_STOP = 2, 212 NUM_SOUNDS 213 }; 214 215 void playSound(sound_kind kind); 216 void loadSoundLocked(sound_kind kind); 217 void decreaseSoundRef(); 218 void increaseSoundRef(); 219 /** 220 * Update the state of a given camera device (open/close/active/idle) with 221 * the camera proxy service in the system service 222 */ 223 static void updateProxyDeviceState( 224 int newState, 225 const String8& cameraId, 226 int facing, 227 const String16& clientName, 228 int apiLevel); 229 230 ///////////////////////////////////////////////////////////////////// 231 // CameraDeviceFactory functionality 232 int getDeviceVersion(const String8& cameraId, int* facing = NULL); 233 234 ///////////////////////////////////////////////////////////////////// 235 // Shared utilities 236 static binder::Status filterGetInfoErrorCode(status_t err); 237 238 ///////////////////////////////////////////////////////////////////// 239 // CameraClient functionality 240 241 class BasicClient : public virtual RefBase { 242 public: 243 virtual status_t initialize(sp<CameraProviderManager> manager, 244 const String8& monitorTags) = 0; 245 virtual binder::Status disconnect(); 246 247 // because we can't virtually inherit IInterface, which breaks 248 // virtual inheritance 249 virtual sp<IBinder> asBinderWrapper() = 0; 250 251 // Return the remote callback binder object (e.g. ICameraDeviceCallbacks) getRemote()252 sp<IBinder> getRemote() { 253 return mRemoteBinder; 254 } 255 256 // Disallows dumping over binder interface 257 virtual status_t dump(int fd, const Vector<String16>& args); 258 // Internal dump method to be called by CameraService 259 virtual status_t dumpClient(int fd, const Vector<String16>& args) = 0; 260 261 // Return the package name for this client 262 virtual String16 getPackageName() const; 263 264 // Notify client about a fatal error 265 virtual void notifyError(int32_t errorCode, 266 const CaptureResultExtras& resultExtras) = 0; 267 268 // Get the UID of the application client using this 269 virtual uid_t getClientUid() const; 270 271 // Get the PID of the application client using this 272 virtual int getClientPid() const; 273 274 // Check what API level is used for this client. This is used to determine which 275 // superclass this can be cast to. 276 virtual bool canCastToApiClient(apiLevel level) const; 277 278 // Block the client form using the camera 279 virtual void block(); 280 281 // set audio restriction from client 282 // Will call into camera service and hold mServiceLock 283 virtual status_t setAudioRestriction(int32_t mode); 284 285 // Get current global audio restriction setting 286 // Will call into camera service and hold mServiceLock 287 virtual int32_t getServiceAudioRestriction() const; 288 289 // Get current audio restriction setting for this client 290 virtual int32_t getAudioRestriction() const; 291 292 static bool isValidAudioRestriction(int32_t mode); 293 294 // Override rotate-and-crop AUTO behavior 295 virtual status_t setRotateAndCropOverride(uint8_t rotateAndCrop) = 0; 296 297 protected: 298 BasicClient(const sp<CameraService>& cameraService, 299 const sp<IBinder>& remoteCallback, 300 const String16& clientPackageName, 301 const std::unique_ptr<String16>& clientFeatureId, 302 const String8& cameraIdStr, 303 int cameraFacing, 304 int clientPid, 305 uid_t clientUid, 306 int servicePid); 307 308 virtual ~BasicClient(); 309 310 // the instance is in the middle of destruction. When this is set, 311 // the instance should not be accessed from callback. 312 // CameraService's mClientLock should be acquired to access this. 313 // - subclasses should set this to true in their destructors. 314 bool mDestructionStarted; 315 316 // these are initialized in the constructor. 317 static sp<CameraService> sCameraService; 318 const String8 mCameraIdStr; 319 const int mCameraFacing; 320 String16 mClientPackageName; 321 std::unique_ptr<String16> mClientFeatureId; 322 pid_t mClientPid; 323 const uid_t mClientUid; 324 const pid_t mServicePid; 325 bool mDisconnected; 326 bool mUidIsTrusted; 327 328 mutable Mutex mAudioRestrictionLock; 329 int32_t mAudioRestriction; 330 331 // - The app-side Binder interface to receive callbacks from us 332 sp<IBinder> mRemoteBinder; // immutable after constructor 333 334 // permissions management 335 virtual status_t startCameraOps(); 336 virtual status_t finishCameraOps(); 337 338 std::unique_ptr<AppOpsManager> mAppOpsManager = nullptr; 339 340 class OpsCallback : public BnAppOpsCallback { 341 public: 342 explicit OpsCallback(wp<BasicClient> client); 343 virtual void opChanged(int32_t op, const String16& packageName); 344 345 private: 346 wp<BasicClient> mClient; 347 348 }; // class OpsCallback 349 350 sp<OpsCallback> mOpsCallback; 351 // Track whether startCameraOps was called successfully, to avoid 352 // finishing what we didn't start. 353 bool mOpsActive; 354 355 // IAppOpsCallback interface, indirected through opListener 356 virtual void opChanged(int32_t op, const String16& packageName); 357 }; // class BasicClient 358 359 class Client : public hardware::BnCamera, public BasicClient 360 { 361 public: 362 typedef hardware::ICameraClient TCamCallbacks; 363 364 // ICamera interface (see ICamera for details) 365 virtual binder::Status disconnect(); 366 virtual status_t connect(const sp<hardware::ICameraClient>& client) = 0; 367 virtual status_t lock() = 0; 368 virtual status_t unlock() = 0; 369 virtual status_t setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer)=0; 370 virtual void setPreviewCallbackFlag(int flag) = 0; 371 virtual status_t setPreviewCallbackTarget( 372 const sp<IGraphicBufferProducer>& callbackProducer) = 0; 373 virtual status_t startPreview() = 0; 374 virtual void stopPreview() = 0; 375 virtual bool previewEnabled() = 0; 376 virtual status_t setVideoBufferMode(int32_t videoBufferMode) = 0; 377 virtual status_t startRecording() = 0; 378 virtual void stopRecording() = 0; 379 virtual bool recordingEnabled() = 0; 380 virtual void releaseRecordingFrame(const sp<IMemory>& mem) = 0; 381 virtual status_t autoFocus() = 0; 382 virtual status_t cancelAutoFocus() = 0; 383 virtual status_t takePicture(int msgType) = 0; 384 virtual status_t setParameters(const String8& params) = 0; 385 virtual String8 getParameters() const = 0; 386 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) = 0; 387 virtual status_t setVideoTarget(const sp<IGraphicBufferProducer>& bufferProducer) = 0; 388 389 // Interface used by CameraService 390 Client(const sp<CameraService>& cameraService, 391 const sp<hardware::ICameraClient>& cameraClient, 392 const String16& clientPackageName, 393 const std::unique_ptr<String16>& clientFeatureId, 394 const String8& cameraIdStr, 395 int api1CameraId, 396 int cameraFacing, 397 int clientPid, 398 uid_t clientUid, 399 int servicePid); 400 ~Client(); 401 402 // return our camera client getRemoteCallback()403 const sp<hardware::ICameraClient>& getRemoteCallback() { 404 return mRemoteCallback; 405 } 406 asBinderWrapper()407 virtual sp<IBinder> asBinderWrapper() { 408 return asBinder(this); 409 } 410 411 virtual void notifyError(int32_t errorCode, 412 const CaptureResultExtras& resultExtras); 413 414 // Check what API level is used for this client. This is used to determine which 415 // superclass this can be cast to. 416 virtual bool canCastToApiClient(apiLevel level) const; 417 protected: 418 // Initialized in constructor 419 420 // - The app-side Binder interface to receive callbacks from us 421 sp<hardware::ICameraClient> mRemoteCallback; 422 423 int mCameraId; // All API1 clients use integer camera IDs 424 }; // class Client 425 426 /** 427 * A listener class that implements the LISTENER interface for use with a ClientManager, and 428 * implements the following methods: 429 * void onClientRemoved(const ClientDescriptor<KEY, VALUE>& descriptor); 430 * void onClientAdded(const ClientDescriptor<KEY, VALUE>& descriptor); 431 */ 432 class ClientEventListener { 433 public: 434 void onClientAdded(const resource_policy::ClientDescriptor<String8, 435 sp<CameraService::BasicClient>>& descriptor); 436 void onClientRemoved(const resource_policy::ClientDescriptor<String8, 437 sp<CameraService::BasicClient>>& descriptor); 438 }; // class ClientEventListener 439 440 typedef std::shared_ptr<resource_policy::ClientDescriptor<String8, 441 sp<CameraService::BasicClient>>> DescriptorPtr; 442 443 /** 444 * A container class for managing active camera clients that are using HAL devices. Active 445 * clients are represented by ClientDescriptor objects that contain strong pointers to the 446 * actual BasicClient subclass binder interface implementation. 447 * 448 * This class manages the eviction behavior for the camera clients. See the parent class 449 * implementation in utils/ClientManager for the specifics of this behavior. 450 */ 451 class CameraClientManager : public resource_policy::ClientManager<String8, 452 sp<CameraService::BasicClient>, ClientEventListener> { 453 public: 454 CameraClientManager(); 455 virtual ~CameraClientManager(); 456 457 /** 458 * Return a strong pointer to the active BasicClient for this camera ID, or an empty 459 * if none exists. 460 */ 461 sp<CameraService::BasicClient> getCameraClient(const String8& id) const; 462 463 /** 464 * Return a string describing the current state. 465 */ 466 String8 toString() const; 467 468 /** 469 * Make a ClientDescriptor object wrapping the given BasicClient strong pointer. 470 */ 471 static DescriptorPtr makeClientDescriptor(const String8& key, const sp<BasicClient>& value, 472 int32_t cost, const std::set<String8>& conflictingKeys, int32_t score, 473 int32_t ownerId, int32_t state); 474 475 /** 476 * Make a ClientDescriptor object wrapping the given BasicClient strong pointer with 477 * values intialized from a prior ClientDescriptor. 478 */ 479 static DescriptorPtr makeClientDescriptor(const sp<BasicClient>& value, 480 const CameraService::DescriptorPtr& partial); 481 482 }; // class CameraClientManager 483 484 int32_t updateAudioRestriction(); 485 int32_t updateAudioRestrictionLocked(); 486 487 private: 488 489 typedef hardware::camera::common::V1_0::CameraDeviceStatus CameraDeviceStatus; 490 491 /** 492 * Typesafe version of device status, containing both the HAL-layer and the service interface- 493 * layer values. 494 */ 495 enum class StatusInternal : int32_t { 496 NOT_PRESENT = static_cast<int32_t>(CameraDeviceStatus::NOT_PRESENT), 497 PRESENT = static_cast<int32_t>(CameraDeviceStatus::PRESENT), 498 ENUMERATING = static_cast<int32_t>(CameraDeviceStatus::ENUMERATING), 499 NOT_AVAILABLE = static_cast<int32_t>(hardware::ICameraServiceListener::STATUS_NOT_AVAILABLE), 500 UNKNOWN = static_cast<int32_t>(hardware::ICameraServiceListener::STATUS_UNKNOWN) 501 }; 502 503 /** 504 * Container class for the state of each logical camera device, including: ID, status, and 505 * dependencies on other devices. The mapping of camera ID -> state saved in mCameraStates 506 * represents the camera devices advertised by the HAL (and any USB devices, when we add 507 * those). 508 * 509 * This container does NOT represent an active camera client. These are represented using 510 * the ClientDescriptors stored in mActiveClientManager. 511 */ 512 class CameraState { 513 public: 514 515 /** 516 * Make a new CameraState and set the ID, cost, and conflicting devices using the values 517 * returned in the HAL's camera_info struct for each device. 518 */ 519 CameraState(const String8& id, int cost, const std::set<String8>& conflicting, 520 SystemCameraKind deviceKind); 521 virtual ~CameraState(); 522 523 /** 524 * Return the status for this device. 525 * 526 * This method acquires mStatusLock. 527 */ 528 StatusInternal getStatus() const; 529 530 /** 531 * This function updates the status for this camera device, unless the given status 532 * is in the given list of rejected status states, and execute the function passed in 533 * with a signature onStatusUpdateLocked(const String8&, int32_t) 534 * if the status has changed. 535 * 536 * This method is idempotent, and will not result in the function passed to 537 * onStatusUpdateLocked being called more than once for the same arguments. 538 * This method aquires mStatusLock. 539 */ 540 template<class Func> 541 void updateStatus(StatusInternal status, 542 const String8& cameraId, 543 std::initializer_list<StatusInternal> rejectSourceStates, 544 Func onStatusUpdatedLocked); 545 546 /** 547 * Return the last set CameraParameters object generated from the information returned by 548 * the HAL for this device (or an empty CameraParameters object if none has been set). 549 */ 550 CameraParameters getShimParams() const; 551 552 /** 553 * Set the CameraParameters for this device. 554 */ 555 void setShimParams(const CameraParameters& params); 556 557 /** 558 * Return the resource_cost advertised by the HAL for this device. 559 */ 560 int getCost() const; 561 562 /** 563 * Return a set of the IDs of conflicting devices advertised by the HAL for this device. 564 */ 565 std::set<String8> getConflicting() const; 566 567 /** 568 * Return the ID of this camera device. 569 */ 570 String8 getId() const; 571 572 /** 573 * Return the kind (SystemCameraKind) of this camera device. 574 */ 575 SystemCameraKind getSystemCameraKind() const; 576 577 /** 578 * Add/Remove the unavailable physical camera ID. 579 */ 580 bool addUnavailablePhysicalId(const String8& physicalId); 581 bool removeUnavailablePhysicalId(const String8& physicalId); 582 583 /** 584 * Return the unavailable physical ids for this device. 585 * 586 * This method acquires mStatusLock. 587 */ 588 std::vector<String8> getUnavailablePhysicalIds() const; 589 private: 590 const String8 mId; 591 StatusInternal mStatus; // protected by mStatusLock 592 const int mCost; 593 std::set<String8> mConflicting; 594 std::set<String8> mUnavailablePhysicalIds; 595 mutable Mutex mStatusLock; 596 CameraParameters mShimParams; 597 const SystemCameraKind mSystemCameraKind; 598 }; // class CameraState 599 600 // Observer for UID lifecycle enforcing that UIDs in idle 601 // state cannot use the camera to protect user privacy. 602 class UidPolicy : public BnUidObserver, public virtual IBinder::DeathRecipient { 603 public: UidPolicy(sp<CameraService> service)604 explicit UidPolicy(sp<CameraService> service) 605 : mRegistered(false), mService(service) {} 606 607 void registerSelf(); 608 void unregisterSelf(); 609 610 bool isUidActive(uid_t uid, String16 callingPackage); 611 int32_t getProcState(uid_t uid); 612 613 void onUidGone(uid_t uid, bool disabled); 614 void onUidActive(uid_t uid); 615 void onUidIdle(uid_t uid, bool disabled); 616 void onUidStateChanged(uid_t uid, int32_t procState, int64_t procStateSeq, 617 int32_t capability); 618 619 void addOverrideUid(uid_t uid, String16 callingPackage, bool active); 620 void removeOverrideUid(uid_t uid, String16 callingPackage); 621 622 void registerMonitorUid(uid_t uid); 623 void unregisterMonitorUid(uid_t uid); 624 625 // IBinder::DeathRecipient implementation 626 virtual void binderDied(const wp<IBinder> &who); 627 private: 628 bool isUidActiveLocked(uid_t uid, String16 callingPackage); 629 int32_t getProcStateLocked(uid_t uid); 630 void updateOverrideUid(uid_t uid, String16 callingPackage, bool active, bool insert); 631 632 Mutex mUidLock; 633 bool mRegistered; 634 ActivityManager mAm; 635 wp<CameraService> mService; 636 std::unordered_set<uid_t> mActiveUids; 637 // Monitored uid map to cached procState and refCount pair 638 std::unordered_map<uid_t, std::pair<int32_t, size_t>> mMonitoredUids; 639 std::unordered_map<uid_t, bool> mOverrideUids; 640 }; // class UidPolicy 641 642 // If sensor privacy is enabled then all apps, including those that are active, should be 643 // prevented from accessing the camera. 644 class SensorPrivacyPolicy : public hardware::BnSensorPrivacyListener, 645 public virtual IBinder::DeathRecipient { 646 public: SensorPrivacyPolicy(wp<CameraService> service)647 explicit SensorPrivacyPolicy(wp<CameraService> service) 648 : mService(service), mSensorPrivacyEnabled(false), mRegistered(false) {} 649 650 void registerSelf(); 651 void unregisterSelf(); 652 653 bool isSensorPrivacyEnabled(); 654 655 binder::Status onSensorPrivacyChanged(bool enabled); 656 657 // IBinder::DeathRecipient implementation 658 virtual void binderDied(const wp<IBinder> &who); 659 660 private: 661 SensorPrivacyManager mSpm; 662 wp<CameraService> mService; 663 Mutex mSensorPrivacyLock; 664 bool mSensorPrivacyEnabled; 665 bool mRegistered; 666 }; 667 668 sp<UidPolicy> mUidPolicy; 669 670 sp<SensorPrivacyPolicy> mSensorPrivacyPolicy; 671 672 // Delay-load the Camera HAL module 673 virtual void onFirstRef(); 674 675 // Eumerate all camera providers in the system 676 status_t enumerateProviders(); 677 678 // Add/remove a new camera to camera and torch state lists or remove an unplugged one 679 // Caller must not hold mServiceLock 680 void addStates(const String8 id); 681 void removeStates(const String8 id); 682 683 // Check if we can connect, before we acquire the service lock. 684 // The returned originalClientPid is the PID of the original process that wants to connect to 685 // camera. 686 // The returned clientPid is the PID of the client that directly connects to camera. 687 // originalClientPid and clientPid are usually the same except when the application uses 688 // mediaserver to connect to camera (using MediaRecorder to connect to camera). In that case, 689 // clientPid is the PID of mediaserver and originalClientPid is the PID of the application. 690 binder::Status validateConnectLocked(const String8& cameraId, const String8& clientName8, 691 /*inout*/int& clientUid, /*inout*/int& clientPid, /*out*/int& originalClientPid) const; 692 binder::Status validateClientPermissionsLocked(const String8& cameraId, const String8& clientName8, 693 /*inout*/int& clientUid, /*inout*/int& clientPid, /*out*/int& originalClientPid) const; 694 695 // Handle active client evictions, and update service state. 696 // Only call with with mServiceLock held. 697 status_t handleEvictionsLocked(const String8& cameraId, int clientPid, 698 apiLevel effectiveApiLevel, const sp<IBinder>& remoteCallback, const String8& packageName, 699 /*out*/ 700 sp<BasicClient>* client, 701 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial); 702 703 // Should an operation attempt on a cameraId be rejected ? (this can happen 704 // under various conditions. For example if a camera device is advertised as 705 // system only or hidden secure camera, amongst possible others. 706 bool shouldRejectSystemCameraConnection(const String8 & cameraId) const; 707 708 // Should a device status update be skipped for a particular camera device ? (this can happen 709 // under various conditions. For example if a camera device is advertised as 710 // system only or hidden secure camera, amongst possible others. 711 static bool shouldSkipStatusUpdates(SystemCameraKind systemCameraKind, bool isVendorListener, 712 int clientPid, int clientUid); 713 714 // Gets the kind of camera device (i.e public, hidden secure or system only) 715 // getSystemCameraKind() needs mInterfaceMutex which might lead to deadlocks 716 // if held along with mStatusListenerLock (depending on lock ordering, b/141756275), it is 717 // recommended that we don't call this function with mStatusListenerLock held. 718 status_t getSystemCameraKind(const String8& cameraId, SystemCameraKind *kind) const; 719 720 // Update the set of API1Compatible camera devices without including system 721 // cameras and secure cameras. This is used for hiding system only cameras 722 // from clients using camera1 api and not having android.permission.SYSTEM_CAMERA. 723 // This function expects @param normalDeviceIds, to have normalDeviceIds 724 // sorted in alpha-numeric order. 725 void filterAPI1SystemCameraLocked(const std::vector<std::string> &normalDeviceIds); 726 727 // Single implementation shared between the various connect calls 728 template<class CALLBACK, class CLIENT> 729 binder::Status connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId, 730 int api1CameraId, int halVersion, const String16& clientPackageName, 731 const std::unique_ptr<String16>& clientFeatureId, int clientUid, int clientPid, 732 apiLevel effectiveApiLevel, bool shimUpdateOnly, /*out*/sp<CLIENT>& device); 733 734 // Lock guarding camera service state 735 Mutex mServiceLock; 736 737 // Condition to use with mServiceLock, used to handle simultaneous connect calls from clients 738 std::shared_ptr<WaitableMutexWrapper> mServiceLockWrapper; 739 740 // Return NO_ERROR if the device with a give ID can be connected to 741 status_t checkIfDeviceIsUsable(const String8& cameraId) const; 742 743 // Container for managing currently active application-layer clients 744 CameraClientManager mActiveClientManager; 745 746 // Mapping from camera ID -> state for each device, map is protected by mCameraStatesLock 747 std::map<String8, std::shared_ptr<CameraState>> mCameraStates; 748 749 // Mutex guarding mCameraStates map 750 mutable Mutex mCameraStatesLock; 751 752 // Circular buffer for storing event logging for dumps 753 RingBuffer<String8> mEventLog; 754 Mutex mLogLock; 755 756 // The last monitored tags set by client 757 String8 mMonitorTags; 758 759 // Currently allowed user IDs 760 std::set<userid_t> mAllowedUsers; 761 762 /** 763 * Get the camera state for a given camera id. 764 * 765 * This acquires mCameraStatesLock. 766 */ 767 std::shared_ptr<CameraService::CameraState> getCameraState(const String8& cameraId) const; 768 769 /** 770 * Evict client who's remote binder has died. Returns true if this client was in the active 771 * list and was disconnected. 772 * 773 * This method acquires mServiceLock. 774 */ 775 bool evictClientIdByRemote(const wp<IBinder>& cameraClient); 776 777 /** 778 * Remove the given client from the active clients list; does not disconnect the client. 779 * 780 * This method acquires mServiceLock. 781 */ 782 void removeByClient(const BasicClient* client); 783 784 /** 785 * Add new client to active clients list after conflicting clients have disconnected using the 786 * values set in the partial descriptor passed in to construct the actual client descriptor. 787 * This is typically called at the end of a connect call. 788 * 789 * This method must be called with mServiceLock held. 790 */ 791 void finishConnectLocked(const sp<BasicClient>& client, const DescriptorPtr& desc); 792 793 /** 794 * Returns the underlying camera Id string mapped to a camera id int 795 * Empty string is returned when the cameraIdInt is invalid. 796 */ 797 String8 cameraIdIntToStr(int cameraIdInt); 798 799 /** 800 * Returns the underlying camera Id string mapped to a camera id int 801 * Empty string is returned when the cameraIdInt is invalid. 802 */ 803 std::string cameraIdIntToStrLocked(int cameraIdInt); 804 805 /** 806 * Remove a single client corresponding to the given camera id from the list of active clients. 807 * If none exists, return an empty strongpointer. 808 * 809 * This method must be called with mServiceLock held. 810 */ 811 sp<CameraService::BasicClient> removeClientLocked(const String8& cameraId); 812 813 /** 814 * Handle a notification that the current device user has changed. 815 */ 816 void doUserSwitch(const std::vector<int32_t>& newUserIds); 817 818 /** 819 * Add an event log message. 820 */ 821 void logEvent(const char* event); 822 823 /** 824 * Add an event log message that a client has been disconnected. 825 */ 826 void logDisconnected(const char* cameraId, int clientPid, const char* clientPackage); 827 828 /** 829 * Add an event log message that a client has been disconnected from offline device. 830 */ 831 void logDisconnectedOffline(const char* cameraId, int clientPid, const char* clientPackage); 832 833 /** 834 * Add an event log message that an offline client has been connected. 835 */ 836 void logConnectedOffline(const char* cameraId, int clientPid, 837 const char* clientPackage); 838 839 /** 840 * Add an event log message that a client has been connected. 841 */ 842 void logConnected(const char* cameraId, int clientPid, const char* clientPackage); 843 844 /** 845 * Add an event log message that a client's connect attempt has been rejected. 846 */ 847 void logRejected(const char* cameraId, int clientPid, const char* clientPackage, 848 const char* reason); 849 850 /** 851 * Add an event log message when a client calls setTorchMode succesfully. 852 */ 853 void logTorchEvent(const char* cameraId, const char *torchState, int clientPid); 854 855 /** 856 * Add an event log message that the current device user has been switched. 857 */ 858 void logUserSwitch(const std::set<userid_t>& oldUserIds, 859 const std::set<userid_t>& newUserIds); 860 861 /** 862 * Add an event log message that a device has been removed by the HAL 863 */ 864 void logDeviceRemoved(const char* cameraId, const char* reason); 865 866 /** 867 * Add an event log message that a device has been added by the HAL 868 */ 869 void logDeviceAdded(const char* cameraId, const char* reason); 870 871 /** 872 * Add an event log message that a client has unexpectedly died. 873 */ 874 void logClientDied(int clientPid, const char* reason); 875 876 /** 877 * Add a event log message that a serious service-level error has occured 878 * The errorCode should be one of the Android Errors 879 */ 880 void logServiceError(const char* msg, int errorCode); 881 882 /** 883 * Dump the event log to an FD 884 */ 885 void dumpEventLog(int fd); 886 887 /** 888 * This method will acquire mServiceLock 889 */ 890 void updateCameraNumAndIds(); 891 892 // Number of camera devices (excluding hidden secure cameras) 893 int mNumberOfCameras; 894 // Number of camera devices (excluding hidden secure cameras and 895 // system cameras) 896 int mNumberOfCamerasWithoutSystemCamera; 897 898 std::vector<std::string> mNormalDeviceIds; 899 std::vector<std::string> mNormalDeviceIdsWithoutSystemCamera; 900 901 // sounds 902 sp<MediaPlayer> newMediaPlayer(const char *file); 903 904 Mutex mSoundLock; 905 sp<MediaPlayer> mSoundPlayer[NUM_SOUNDS]; 906 int mSoundRef; // reference count (release all MediaPlayer when 0) 907 908 // Basic flag on whether the camera subsystem is in a usable state 909 bool mInitialized; 910 911 sp<CameraProviderManager> mCameraProviderManager; 912 913 class ServiceListener : public virtual IBinder::DeathRecipient { 914 public: ServiceListener(sp<CameraService> parent,sp<hardware::ICameraServiceListener> listener,int uid,int pid,bool isVendorClient,bool openCloseCallbackAllowed)915 ServiceListener(sp<CameraService> parent, sp<hardware::ICameraServiceListener> listener, 916 int uid, int pid, bool isVendorClient, bool openCloseCallbackAllowed) 917 : mParent(parent), mListener(listener), mListenerUid(uid), mListenerPid(pid), 918 mIsVendorListener(isVendorClient), 919 mOpenCloseCallbackAllowed(openCloseCallbackAllowed) { } 920 initialize()921 status_t initialize() { 922 return IInterface::asBinder(mListener)->linkToDeath(this); 923 } 924 binderDied(const wp<IBinder> &)925 virtual void binderDied(const wp<IBinder> &/*who*/) { 926 auto parent = mParent.promote(); 927 if (parent.get() != nullptr) { 928 parent->removeListener(mListener); 929 } 930 } 931 getListenerUid()932 int getListenerUid() { return mListenerUid; } getListenerPid()933 int getListenerPid() { return mListenerPid; } getListener()934 sp<hardware::ICameraServiceListener> getListener() { return mListener; } isVendorListener()935 bool isVendorListener() { return mIsVendorListener; } isOpenCloseCallbackAllowed()936 bool isOpenCloseCallbackAllowed() { return mOpenCloseCallbackAllowed; } 937 938 private: 939 wp<CameraService> mParent; 940 sp<hardware::ICameraServiceListener> mListener; 941 int mListenerUid = -1; 942 int mListenerPid = -1; 943 bool mIsVendorListener = false; 944 bool mOpenCloseCallbackAllowed = false; 945 }; 946 947 // Guarded by mStatusListenerMutex 948 std::vector<sp<ServiceListener>> mListenerList; 949 950 Mutex mStatusListenerLock; 951 952 /** 953 * Update the status for the given camera id (if that device exists), and broadcast the 954 * status update to all current ICameraServiceListeners if the status has changed. Any 955 * statuses in rejectedSourceStates will be ignored. 956 * 957 * This method must be idempotent. 958 * This method acquires mStatusLock and mStatusListenerLock. 959 */ 960 void updateStatus(StatusInternal status, 961 const String8& cameraId, 962 std::initializer_list<StatusInternal> 963 rejectedSourceStates); 964 void updateStatus(StatusInternal status, 965 const String8& cameraId); 966 967 /** 968 * Update the opened/closed status of the given camera id. 969 * 970 * This method acqiures mStatusListenerLock. 971 */ 972 void updateOpenCloseStatus(const String8& cameraId, bool open, const String16& packageName); 973 974 // flashlight control 975 sp<CameraFlashlight> mFlashlight; 976 // guard mTorchStatusMap 977 Mutex mTorchStatusMutex; 978 // guard mTorchClientMap 979 Mutex mTorchClientMapMutex; 980 // guard mTorchUidMap 981 Mutex mTorchUidMapMutex; 982 // camera id -> torch status 983 KeyedVector<String8, hardware::camera::common::V1_0::TorchModeStatus> 984 mTorchStatusMap; 985 // camera id -> torch client binder 986 // only store the last client that turns on each camera's torch mode 987 KeyedVector<String8, sp<IBinder>> mTorchClientMap; 988 // camera id -> [incoming uid, current uid] pair 989 std::map<String8, std::pair<int, int>> mTorchUidMap; 990 991 // check and handle if torch client's process has died 992 void handleTorchClientBinderDied(const wp<IBinder> &who); 993 994 // handle torch mode status change and invoke callbacks. mTorchStatusMutex 995 // should be locked. 996 void onTorchStatusChangedLocked(const String8& cameraId, 997 hardware::camera::common::V1_0::TorchModeStatus newStatus); 998 999 // get a camera's torch status. mTorchStatusMutex should be locked. 1000 status_t getTorchStatusLocked(const String8 &cameraId, 1001 hardware::camera::common::V1_0::TorchModeStatus *status) const; 1002 1003 // set a camera's torch status. mTorchStatusMutex should be locked. 1004 status_t setTorchStatusLocked(const String8 &cameraId, 1005 hardware::camera::common::V1_0::TorchModeStatus status); 1006 1007 // notify physical camera status when the physical camera is public. 1008 void notifyPhysicalCameraStatusLocked(int32_t status, const String8& cameraId, 1009 SystemCameraKind deviceKind); 1010 1011 // IBinder::DeathRecipient implementation 1012 virtual void binderDied(const wp<IBinder> &who); 1013 1014 /** 1015 * Initialize and cache the metadata used by the HAL1 shim for a given cameraId. 1016 * 1017 * Sets Status to a service-specific error on failure 1018 */ 1019 binder::Status initializeShimMetadata(int cameraId); 1020 1021 /** 1022 * Get the cached CameraParameters for the camera. If they haven't been 1023 * cached yet, then initialize them for the first time. 1024 * 1025 * Sets Status to a service-specific error on failure 1026 */ 1027 binder::Status getLegacyParametersLazy(int cameraId, /*out*/CameraParameters* parameters); 1028 1029 // Blocks all clients from the UID 1030 void blockClientsForUid(uid_t uid); 1031 1032 // Blocks all active clients. 1033 void blockAllClients(); 1034 1035 // Overrides the UID state as if it is idle 1036 status_t handleSetUidState(const Vector<String16>& args, int err); 1037 1038 // Clears the override for the UID state 1039 status_t handleResetUidState(const Vector<String16>& args, int err); 1040 1041 // Gets the UID state 1042 status_t handleGetUidState(const Vector<String16>& args, int out, int err); 1043 1044 // Set the rotate-and-crop AUTO override behavior 1045 status_t handleSetRotateAndCrop(const Vector<String16>& args); 1046 1047 // Get the rotate-and-crop AUTO override behavior 1048 status_t handleGetRotateAndCrop(int out); 1049 1050 // Prints the shell command help 1051 status_t printHelp(int out); 1052 1053 /** 1054 * Get the current system time as a formatted string. 1055 */ 1056 static String8 getFormattedCurrentTime(); 1057 1058 static binder::Status makeClient(const sp<CameraService>& cameraService, 1059 const sp<IInterface>& cameraCb, const String16& packageName, 1060 const std::unique_ptr<String16>& featureId, const String8& cameraId, int api1CameraId, 1061 int facing, int clientPid, uid_t clientUid, int servicePid, int halVersion, 1062 int deviceVersion, apiLevel effectiveApiLevel, 1063 /*out*/sp<BasicClient>* client); 1064 1065 status_t checkCameraAccess(const String16& opPackageName); 1066 1067 static String8 toString(std::set<userid_t> intSet); 1068 static int32_t mapToInterface(hardware::camera::common::V1_0::TorchModeStatus status); 1069 static StatusInternal mapToInternal(hardware::camera::common::V1_0::CameraDeviceStatus status); 1070 static int32_t mapToInterface(StatusInternal status); 1071 1072 // Guard mCameraServiceProxy 1073 static Mutex sProxyMutex; 1074 // Cached interface to the camera service proxy in system service 1075 static sp<hardware::ICameraServiceProxy> sCameraServiceProxy; 1076 1077 static sp<hardware::ICameraServiceProxy> getCameraServiceProxy(); 1078 static void pingCameraServiceProxy(); 1079 1080 void broadcastTorchModeStatus(const String8& cameraId, 1081 hardware::camera::common::V1_0::TorchModeStatus status); 1082 1083 void disconnectClient(const String8& id, sp<BasicClient> clientToDisconnect); 1084 1085 // Regular online and offline devices must not be in conflict at camera service layer. 1086 // Use separate keys for offline devices. 1087 static const String8 kOfflineDevice; 1088 1089 // TODO: right now each BasicClient holds one AppOpsManager instance. 1090 // We can refactor the code so all of clients share this instance 1091 AppOpsManager mAppOps; 1092 1093 // Aggreated audio restriction mode for all camera clients 1094 int32_t mAudioRestriction; 1095 1096 // Current override rotate-and-crop mode 1097 uint8_t mOverrideRotateAndCropMode = ANDROID_SCALER_ROTATE_AND_CROP_AUTO; 1098 }; 1099 1100 } // namespace android 1101 1102 #endif 1103