Home | History | Annotate | Download | only in libcameraservice
      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>
     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)
    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
    333         const sp<hardware::ICameraClient>&    getRemoteCallback() {
    334             return mRemoteCallback;
    335         }
    336 
    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