/* * Copyright (C) 2008 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef ANDROID_SERVERS_CAMERA_CAMERASERVICE_H #define ANDROID_SERVERS_CAMERA_CAMERASERVICE_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "CameraFlashlight.h" #include "common/CameraProviderManager.h" #include "media/RingBuffer.h" #include "utils/AutoConditionLock.h" #include "utils/ClientManager.h" #include #include #include #include #include #include #include namespace android { extern volatile int32_t gLogLevel; class MemoryHeapBase; class MediaPlayer; class CameraService : public BinderService, public virtual ::android::hardware::BnCameraService, public virtual IBinder::DeathRecipient, public virtual CameraProviderManager::StatusListener { friend class BinderService; friend class CameraClient; public: class Client; class BasicClient; // The effective API level. The Camera2 API running in LEGACY mode counts as API_1. enum apiLevel { API_1 = 1, API_2 = 2 }; // 3 second busy timeout when other clients are connecting static const nsecs_t DEFAULT_CONNECT_TIMEOUT_NS = 3000000000; // 1 second busy timeout when other clients are disconnecting static const nsecs_t DEFAULT_DISCONNECT_TIMEOUT_NS = 1000000000; // Default number of messages to store in eviction log static const size_t DEFAULT_EVENT_LOG_LENGTH = 100; // Event log ID static const int SN_EVENT_LOG_ID = 0x534e4554; // Implementation of BinderService static char const* getServiceName() { return "media.camera"; } CameraService(); virtual ~CameraService(); ///////////////////////////////////////////////////////////////////// // HAL Callbacks - implements CameraProviderManager::StatusListener virtual void onDeviceStatusChanged(const String8 &cameraId, hardware::camera::common::V1_0::CameraDeviceStatus newHalStatus) override; virtual void onTorchStatusChanged(const String8& cameraId, hardware::camera::common::V1_0::TorchModeStatus newStatus) override; virtual void onNewProviderRegistered() override; ///////////////////////////////////////////////////////////////////// // ICameraService virtual binder::Status getNumberOfCameras(int32_t type, int32_t* numCameras); virtual binder::Status getCameraInfo(int cameraId, hardware::CameraInfo* cameraInfo); virtual binder::Status getCameraCharacteristics(const String16& cameraId, CameraMetadata* cameraInfo); virtual binder::Status getCameraVendorTagDescriptor( /*out*/ hardware::camera2::params::VendorTagDescriptor* desc); virtual binder::Status getCameraVendorTagCache( /*out*/ hardware::camera2::params::VendorTagDescriptorCache* cache); virtual binder::Status connect(const sp& cameraClient, int32_t cameraId, const String16& clientPackageName, int32_t clientUid, int clientPid, /*out*/ sp* device); virtual binder::Status connectLegacy(const sp& cameraClient, int32_t cameraId, int32_t halVersion, const String16& clientPackageName, int32_t clientUid, /*out*/ sp* device); virtual binder::Status connectDevice( const sp& cameraCb, const String16& cameraId, const String16& clientPackageName, int32_t clientUid, /*out*/ sp* device); virtual binder::Status addListener(const sp& listener, /*out*/ std::vector* cameraStatuses); virtual binder::Status removeListener( const sp& listener); virtual binder::Status getLegacyParameters( int32_t cameraId, /*out*/ String16* parameters); virtual binder::Status setTorchMode(const String16& cameraId, bool enabled, const sp& clientBinder); virtual binder::Status notifySystemEvent(int32_t eventId, const std::vector& args); virtual binder::Status notifyDeviceStateChange(int64_t newState); // OK = supports api of that version, -EOPNOTSUPP = does not support virtual binder::Status supportsCameraApi( const String16& cameraId, int32_t apiVersion, /*out*/ bool *isSupported); virtual binder::Status isHiddenPhysicalCamera( const String16& cameraId, /*out*/ bool *isSupported); // Extra permissions checks virtual status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); virtual status_t dump(int fd, const Vector& args); virtual status_t shellCommand(int in, int out, int err, const Vector& args); binder::Status addListenerHelper(const sp& listener, /*out*/ std::vector* cameraStatuses, bool isVendor = false); // Monitored UIDs availability notification void notifyMonitoredUids(); ///////////////////////////////////////////////////////////////////// // Client functionality enum sound_kind { SOUND_SHUTTER = 0, SOUND_RECORDING_START = 1, SOUND_RECORDING_STOP = 2, NUM_SOUNDS }; void playSound(sound_kind kind); void loadSoundLocked(sound_kind kind); void decreaseSoundRef(); void increaseSoundRef(); /** * Update the state of a given camera device (open/close/active/idle) with * the camera proxy service in the system service */ static void updateProxyDeviceState( int newState, const String8& cameraId, int facing, const String16& clientName, int apiLevel); ///////////////////////////////////////////////////////////////////// // CameraDeviceFactory functionality int getDeviceVersion(const String8& cameraId, int* facing = NULL); ///////////////////////////////////////////////////////////////////// // Shared utilities static binder::Status filterGetInfoErrorCode(status_t err); ///////////////////////////////////////////////////////////////////// // CameraClient functionality class BasicClient : public virtual RefBase { public: virtual status_t initialize(sp manager, const String8& monitorTags) = 0; virtual binder::Status disconnect(); // because we can't virtually inherit IInterface, which breaks // virtual inheritance virtual sp asBinderWrapper() = 0; // Return the remote callback binder object (e.g. ICameraDeviceCallbacks) sp getRemote() { return mRemoteBinder; } // Disallows dumping over binder interface virtual status_t dump(int fd, const Vector& args); // Internal dump method to be called by CameraService virtual status_t dumpClient(int fd, const Vector& args) = 0; // Return the package name for this client virtual String16 getPackageName() const; // Notify client about a fatal error virtual void notifyError(int32_t errorCode, const CaptureResultExtras& resultExtras) = 0; // Get the UID of the application client using this virtual uid_t getClientUid() const; // Get the PID of the application client using this virtual int getClientPid() const; // Check what API level is used for this client. This is used to determine which // superclass this can be cast to. virtual bool canCastToApiClient(apiLevel level) const; // Block the client form using the camera virtual void block(); protected: BasicClient(const sp& cameraService, const sp& remoteCallback, const String16& clientPackageName, const String8& cameraIdStr, int cameraFacing, int clientPid, uid_t clientUid, int servicePid); virtual ~BasicClient(); // the instance is in the middle of destruction. When this is set, // the instance should not be accessed from callback. // CameraService's mClientLock should be acquired to access this. // - subclasses should set this to true in their destructors. bool mDestructionStarted; // these are initialized in the constructor. static sp sCameraService; const String8 mCameraIdStr; const int mCameraFacing; String16 mClientPackageName; pid_t mClientPid; const uid_t mClientUid; const pid_t mServicePid; bool mDisconnected; // - The app-side Binder interface to receive callbacks from us sp mRemoteBinder; // immutable after constructor // permissions management status_t startCameraOps(); status_t finishCameraOps(); private: std::unique_ptr mAppOpsManager = nullptr; class OpsCallback : public BnAppOpsCallback { public: explicit OpsCallback(wp client); virtual void opChanged(int32_t op, const String16& packageName); private: wp mClient; }; // class OpsCallback sp mOpsCallback; // Track whether startCameraOps was called successfully, to avoid // finishing what we didn't start. bool mOpsActive; // IAppOpsCallback interface, indirected through opListener virtual void opChanged(int32_t op, const String16& packageName); }; // class BasicClient class Client : public hardware::BnCamera, public BasicClient { public: typedef hardware::ICameraClient TCamCallbacks; // ICamera interface (see ICamera for details) virtual binder::Status disconnect(); virtual status_t connect(const sp& client) = 0; virtual status_t lock() = 0; virtual status_t unlock() = 0; virtual status_t setPreviewTarget(const sp& bufferProducer)=0; virtual void setPreviewCallbackFlag(int flag) = 0; virtual status_t setPreviewCallbackTarget( const sp& callbackProducer) = 0; virtual status_t startPreview() = 0; virtual void stopPreview() = 0; virtual bool previewEnabled() = 0; virtual status_t setVideoBufferMode(int32_t videoBufferMode) = 0; virtual status_t startRecording() = 0; virtual void stopRecording() = 0; virtual bool recordingEnabled() = 0; virtual void releaseRecordingFrame(const sp& mem) = 0; virtual status_t autoFocus() = 0; virtual status_t cancelAutoFocus() = 0; virtual status_t takePicture(int msgType) = 0; virtual status_t setParameters(const String8& params) = 0; virtual String8 getParameters() const = 0; virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) = 0; virtual status_t setVideoTarget(const sp& bufferProducer) = 0; // Interface used by CameraService Client(const sp& cameraService, const sp& cameraClient, const String16& clientPackageName, const String8& cameraIdStr, int api1CameraId, int cameraFacing, int clientPid, uid_t clientUid, int servicePid); ~Client(); // return our camera client const sp& getRemoteCallback() { return mRemoteCallback; } virtual sp asBinderWrapper() { return asBinder(this); } virtual void notifyError(int32_t errorCode, const CaptureResultExtras& resultExtras); // Check what API level is used for this client. This is used to determine which // superclass this can be cast to. virtual bool canCastToApiClient(apiLevel level) const; protected: // Initialized in constructor // - The app-side Binder interface to receive callbacks from us sp mRemoteCallback; int mCameraId; // All API1 clients use integer camera IDs }; // class Client /** * A listener class that implements the LISTENER interface for use with a ClientManager, and * implements the following methods: * void onClientRemoved(const ClientDescriptor& descriptor); * void onClientAdded(const ClientDescriptor& descriptor); */ class ClientEventListener { public: void onClientAdded(const resource_policy::ClientDescriptor>& descriptor); void onClientRemoved(const resource_policy::ClientDescriptor>& descriptor); }; // class ClientEventListener typedef std::shared_ptr>> DescriptorPtr; /** * A container class for managing active camera clients that are using HAL devices. Active * clients are represented by ClientDescriptor objects that contain strong pointers to the * actual BasicClient subclass binder interface implementation. * * This class manages the eviction behavior for the camera clients. See the parent class * implementation in utils/ClientManager for the specifics of this behavior. */ class CameraClientManager : public resource_policy::ClientManager, ClientEventListener> { public: CameraClientManager(); virtual ~CameraClientManager(); /** * Return a strong pointer to the active BasicClient for this camera ID, or an empty * if none exists. */ sp getCameraClient(const String8& id) const; /** * Return a string describing the current state. */ String8 toString() const; /** * Make a ClientDescriptor object wrapping the given BasicClient strong pointer. */ static DescriptorPtr makeClientDescriptor(const String8& key, const sp& value, int32_t cost, const std::set& conflictingKeys, int32_t score, int32_t ownerId, int32_t state); /** * Make a ClientDescriptor object wrapping the given BasicClient strong pointer with * values intialized from a prior ClientDescriptor. */ static DescriptorPtr makeClientDescriptor(const sp& value, const CameraService::DescriptorPtr& partial); }; // class CameraClientManager private: typedef hardware::camera::common::V1_0::CameraDeviceStatus CameraDeviceStatus; /** * Typesafe version of device status, containing both the HAL-layer and the service interface- * layer values. */ enum class StatusInternal : int32_t { NOT_PRESENT = static_cast(CameraDeviceStatus::NOT_PRESENT), PRESENT = static_cast(CameraDeviceStatus::PRESENT), ENUMERATING = static_cast(CameraDeviceStatus::ENUMERATING), NOT_AVAILABLE = static_cast(hardware::ICameraServiceListener::STATUS_NOT_AVAILABLE), UNKNOWN = static_cast(hardware::ICameraServiceListener::STATUS_UNKNOWN) }; /** * Container class for the state of each logical camera device, including: ID, status, and * dependencies on other devices. The mapping of camera ID -> state saved in mCameraStates * represents the camera devices advertised by the HAL (and any USB devices, when we add * those). * * This container does NOT represent an active camera client. These are represented using * the ClientDescriptors stored in mActiveClientManager. */ class CameraState { public: /** * Make a new CameraState and set the ID, cost, and conflicting devices using the values * returned in the HAL's camera_info struct for each device. */ CameraState(const String8& id, int cost, const std::set& conflicting); virtual ~CameraState(); /** * Return the status for this device. * * This method acquires mStatusLock. */ StatusInternal getStatus() const; /** * This function updates the status for this camera device, unless the given status * is in the given list of rejected status states, and execute the function passed in * with a signature onStatusUpdateLocked(const String8&, int32_t) * if the status has changed. * * This method is idempotent, and will not result in the function passed to * onStatusUpdateLocked being called more than once for the same arguments. * This method aquires mStatusLock. */ template void updateStatus(StatusInternal status, const String8& cameraId, std::initializer_list rejectSourceStates, Func onStatusUpdatedLocked); /** * Return the last set CameraParameters object generated from the information returned by * the HAL for this device (or an empty CameraParameters object if none has been set). */ CameraParameters getShimParams() const; /** * Set the CameraParameters for this device. */ void setShimParams(const CameraParameters& params); /** * Return the resource_cost advertised by the HAL for this device. */ int getCost() const; /** * Return a set of the IDs of conflicting devices advertised by the HAL for this device. */ std::set getConflicting() const; /** * Return the ID of this camera device. */ String8 getId() const; private: const String8 mId; StatusInternal mStatus; // protected by mStatusLock const int mCost; std::set mConflicting; mutable Mutex mStatusLock; CameraParameters mShimParams; }; // class CameraState // Observer for UID lifecycle enforcing that UIDs in idle // state cannot use the camera to protect user privacy. class UidPolicy : public BnUidObserver, public virtual IBinder::DeathRecipient { public: explicit UidPolicy(sp service) : mRegistered(false), mService(service) {} void registerSelf(); void unregisterSelf(); bool isUidActive(uid_t uid, String16 callingPackage); int32_t getProcState(uid_t uid); void onUidGone(uid_t uid, bool disabled); void onUidActive(uid_t uid); void onUidIdle(uid_t uid, bool disabled); void onUidStateChanged(uid_t uid, int32_t procState, int64_t procStateSeq); void addOverrideUid(uid_t uid, String16 callingPackage, bool active); void removeOverrideUid(uid_t uid, String16 callingPackage); void registerMonitorUid(uid_t uid); void unregisterMonitorUid(uid_t uid); // IBinder::DeathRecipient implementation virtual void binderDied(const wp &who); private: bool isUidActiveLocked(uid_t uid, String16 callingPackage); int32_t getProcStateLocked(uid_t uid); void updateOverrideUid(uid_t uid, String16 callingPackage, bool active, bool insert); Mutex mUidLock; bool mRegistered; wp mService; std::unordered_set mActiveUids; // Monitored uid map to cached procState and refCount pair std::unordered_map> mMonitoredUids; std::unordered_map mOverrideUids; }; // class UidPolicy // If sensor privacy is enabled then all apps, including those that are active, should be // prevented from accessing the camera. class SensorPrivacyPolicy : public hardware::BnSensorPrivacyListener, public virtual IBinder::DeathRecipient { public: explicit SensorPrivacyPolicy(wp service) : mService(service), mSensorPrivacyEnabled(false), mRegistered(false) {} void registerSelf(); void unregisterSelf(); bool isSensorPrivacyEnabled(); binder::Status onSensorPrivacyChanged(bool enabled); // IBinder::DeathRecipient implementation virtual void binderDied(const wp &who); private: wp mService; Mutex mSensorPrivacyLock; bool mSensorPrivacyEnabled; bool mRegistered; }; sp mUidPolicy; sp mSensorPrivacyPolicy; // Delay-load the Camera HAL module virtual void onFirstRef(); // Eumerate all camera providers in the system status_t enumerateProviders(); // Add/remove a new camera to camera and torch state lists or remove an unplugged one // Caller must not hold mServiceLock void addStates(const String8 id); void removeStates(const String8 id); // Check if we can connect, before we acquire the service lock. // The returned originalClientPid is the PID of the original process that wants to connect to // camera. // The returned clientPid is the PID of the client that directly connects to camera. // originalClientPid and clientPid are usually the same except when the application uses // mediaserver to connect to camera (using MediaRecorder to connect to camera). In that case, // clientPid is the PID of mediaserver and originalClientPid is the PID of the application. binder::Status validateConnectLocked(const String8& cameraId, const String8& clientName8, /*inout*/int& clientUid, /*inout*/int& clientPid, /*out*/int& originalClientPid) const; binder::Status validateClientPermissionsLocked(const String8& cameraId, const String8& clientName8, /*inout*/int& clientUid, /*inout*/int& clientPid, /*out*/int& originalClientPid) const; // Handle active client evictions, and update service state. // Only call with with mServiceLock held. status_t handleEvictionsLocked(const String8& cameraId, int clientPid, apiLevel effectiveApiLevel, const sp& remoteCallback, const String8& packageName, /*out*/ sp* client, std::shared_ptr>>* partial); // Should an operation attempt on a cameraId be rejected, if the camera id is // advertised as a publically hidden secure camera, by the camera HAL ? bool shouldRejectHiddenCameraConnection(const String8 & cameraId); // Single implementation shared between the various connect calls template binder::Status connectHelper(const sp& cameraCb, const String8& cameraId, int api1CameraId, int halVersion, const String16& clientPackageName, int clientUid, int clientPid, apiLevel effectiveApiLevel, bool shimUpdateOnly, /*out*/sp& device); // Lock guarding camera service state Mutex mServiceLock; // Condition to use with mServiceLock, used to handle simultaneous connect calls from clients std::shared_ptr mServiceLockWrapper; // Return NO_ERROR if the device with a give ID can be connected to status_t checkIfDeviceIsUsable(const String8& cameraId) const; // Container for managing currently active application-layer clients CameraClientManager mActiveClientManager; // Mapping from camera ID -> state for each device, map is protected by mCameraStatesLock std::map> mCameraStates; // Mutex guarding mCameraStates map mutable Mutex mCameraStatesLock; // Circular buffer for storing event logging for dumps RingBuffer mEventLog; Mutex mLogLock; // The last monitored tags set by client String8 mMonitorTags; // Currently allowed user IDs std::set mAllowedUsers; /** * Get the camera state for a given camera id. * * This acquires mCameraStatesLock. */ std::shared_ptr getCameraState(const String8& cameraId) const; /** * Evict client who's remote binder has died. Returns true if this client was in the active * list and was disconnected. * * This method acquires mServiceLock. */ bool evictClientIdByRemote(const wp& cameraClient); /** * Remove the given client from the active clients list; does not disconnect the client. * * This method acquires mServiceLock. */ void removeByClient(const BasicClient* client); /** * Add new client to active clients list after conflicting clients have disconnected using the * values set in the partial descriptor passed in to construct the actual client descriptor. * This is typically called at the end of a connect call. * * This method must be called with mServiceLock held. */ void finishConnectLocked(const sp& client, const DescriptorPtr& desc); /** * Returns the underlying camera Id string mapped to a camera id int * Empty string is returned when the cameraIdInt is invalid. */ String8 cameraIdIntToStr(int cameraIdInt); /** * Returns the underlying camera Id string mapped to a camera id int * Empty string is returned when the cameraIdInt is invalid. */ std::string cameraIdIntToStrLocked(int cameraIdInt); /** * Remove a single client corresponding to the given camera id from the list of active clients. * If none exists, return an empty strongpointer. * * This method must be called with mServiceLock held. */ sp removeClientLocked(const String8& cameraId); /** * Handle a notification that the current device user has changed. */ void doUserSwitch(const std::vector& newUserIds); /** * Add an event log message. */ void logEvent(const char* event); /** * Add an event log message that a client has been disconnected. */ void logDisconnected(const char* cameraId, int clientPid, const char* clientPackage); /** * Add an event log message that a client has been connected. */ void logConnected(const char* cameraId, int clientPid, const char* clientPackage); /** * Add an event log message that a client's connect attempt has been rejected. */ void logRejected(const char* cameraId, int clientPid, const char* clientPackage, const char* reason); /** * Add an event log message when a client calls setTorchMode succesfully. */ void logTorchEvent(const char* cameraId, const char *torchState, int clientPid); /** * Add an event log message that the current device user has been switched. */ void logUserSwitch(const std::set& oldUserIds, const std::set& newUserIds); /** * Add an event log message that a device has been removed by the HAL */ void logDeviceRemoved(const char* cameraId, const char* reason); /** * Add an event log message that a device has been added by the HAL */ void logDeviceAdded(const char* cameraId, const char* reason); /** * Add an event log message that a client has unexpectedly died. */ void logClientDied(int clientPid, const char* reason); /** * Add a event log message that a serious service-level error has occured * The errorCode should be one of the Android Errors */ void logServiceError(const char* msg, int errorCode); /** * Dump the event log to an FD */ void dumpEventLog(int fd); /** * This method will acquire mServiceLock */ void updateCameraNumAndIds(); int mNumberOfCameras; std::vector mNormalDeviceIds; // sounds sp newMediaPlayer(const char *file); Mutex mSoundLock; sp mSoundPlayer[NUM_SOUNDS]; int mSoundRef; // reference count (release all MediaPlayer when 0) // Basic flag on whether the camera subsystem is in a usable state bool mInitialized; sp mCameraProviderManager; class ServiceListener : public virtual IBinder::DeathRecipient { public: ServiceListener(sp parent, sp listener, int uid) : mParent(parent), mListener(listener), mListenerUid(uid) {} status_t initialize() { return IInterface::asBinder(mListener)->linkToDeath(this); } virtual void binderDied(const wp &/*who*/) { auto parent = mParent.promote(); if (parent.get() != nullptr) { parent->removeListener(mListener); } } int getListenerUid() { return mListenerUid; } sp getListener() { return mListener; } private: wp mParent; sp mListener; int mListenerUid; }; // Guarded by mStatusListenerMutex std::vector>> mListenerList; Mutex mStatusListenerLock; /** * Update the status for the given camera id (if that device exists), and broadcast the * status update to all current ICameraServiceListeners if the status has changed. Any * statuses in rejectedSourceStates will be ignored. * * This method must be idempotent. * This method acquires mStatusLock and mStatusListenerLock. */ void updateStatus(StatusInternal status, const String8& cameraId, std::initializer_list rejectedSourceStates); void updateStatus(StatusInternal status, const String8& cameraId); // flashlight control sp mFlashlight; // guard mTorchStatusMap Mutex mTorchStatusMutex; // guard mTorchClientMap Mutex mTorchClientMapMutex; // guard mTorchUidMap Mutex mTorchUidMapMutex; // camera id -> torch status KeyedVector mTorchStatusMap; // camera id -> torch client binder // only store the last client that turns on each camera's torch mode KeyedVector> mTorchClientMap; // camera id -> [incoming uid, current uid] pair std::map> mTorchUidMap; // check and handle if torch client's process has died void handleTorchClientBinderDied(const wp &who); // handle torch mode status change and invoke callbacks. mTorchStatusMutex // should be locked. void onTorchStatusChangedLocked(const String8& cameraId, hardware::camera::common::V1_0::TorchModeStatus newStatus); // get a camera's torch status. mTorchStatusMutex should be locked. status_t getTorchStatusLocked(const String8 &cameraId, hardware::camera::common::V1_0::TorchModeStatus *status) const; // set a camera's torch status. mTorchStatusMutex should be locked. status_t setTorchStatusLocked(const String8 &cameraId, hardware::camera::common::V1_0::TorchModeStatus status); // IBinder::DeathRecipient implementation virtual void binderDied(const wp &who); /** * Initialize and cache the metadata used by the HAL1 shim for a given cameraId. * * Sets Status to a service-specific error on failure */ binder::Status initializeShimMetadata(int cameraId); /** * Get the cached CameraParameters for the camera. If they haven't been * cached yet, then initialize them for the first time. * * Sets Status to a service-specific error on failure */ binder::Status getLegacyParametersLazy(int cameraId, /*out*/CameraParameters* parameters); // Blocks all clients from the UID void blockClientsForUid(uid_t uid); // Blocks all active clients. void blockAllClients(); // Overrides the UID state as if it is idle status_t handleSetUidState(const Vector& args, int err); // Clears the override for the UID state status_t handleResetUidState(const Vector& args, int err); // Gets the UID state status_t handleGetUidState(const Vector& args, int out, int err); // Prints the shell command help status_t printHelp(int out); /** * Get the current system time as a formatted string. */ static String8 getFormattedCurrentTime(); static binder::Status makeClient(const sp& cameraService, const sp& cameraCb, const String16& packageName, const String8& cameraId, int api1CameraId, int facing, int clientPid, uid_t clientUid, int servicePid, int halVersion, int deviceVersion, apiLevel effectiveApiLevel, /*out*/sp* client); status_t checkCameraAccess(const String16& opPackageName); static String8 toString(std::set intSet); static int32_t mapToInterface(hardware::camera::common::V1_0::TorchModeStatus status); static StatusInternal mapToInternal(hardware::camera::common::V1_0::CameraDeviceStatus status); static int32_t mapToInterface(StatusInternal status); // Guard mCameraServiceProxy static Mutex sProxyMutex; // Cached interface to the camera service proxy in system service static sp sCameraServiceProxy; static sp getCameraServiceProxy(); static void pingCameraServiceProxy(); void broadcastTorchModeStatus(const String8& cameraId, hardware::camera::common::V1_0::TorchModeStatus status); }; } // namespace android #endif