cameraservice: Migrate all internal String8/String16s to std::string
String8 and String16 are deprecated classes. It is recommended to use
std::string or std::u16string wherever possible. String16 is the native
string class for aidl, but Strings marked @utf8InCpp can use std::string
directly.
This patch standardizes libcameraservice's use of strings to
std::string, which is capable of storing utf-8 strings. This makes the
code more readable and potentially reduces the number of string copies
to a minimum.
A new set of string utils is added to frameworks/av/camera to aid this
migration.
Change-Id: I59330ac03c8a52b6c21a2388bba0c143e68af4cf
Bug: 265487852
Test: Presubmit, ran CtsCameraTestCases on Cuttlefish, adb shell dumpsys media camera and observed output
diff --git a/services/camera/libcameraservice/CameraService.h b/services/camera/libcameraservice/CameraService.h
index 38336ee..b1ff6a5 100644
--- a/services/camera/libcameraservice/CameraService.h
+++ b/services/camera/libcameraservice/CameraService.h
@@ -120,19 +120,19 @@
/////////////////////////////////////////////////////////////////////
// HAL Callbacks - implements CameraProviderManager::StatusListener
- virtual void onDeviceStatusChanged(const String8 &cameraId,
+ virtual void onDeviceStatusChanged(const std::string &cameraId,
CameraDeviceStatus newHalStatus) override;
- virtual void onDeviceStatusChanged(const String8 &cameraId,
- const String8 &physicalCameraId,
+ virtual void onDeviceStatusChanged(const std::string &cameraId,
+ const std::string &physicalCameraId,
CameraDeviceStatus newHalStatus) override;
// This method may hold CameraProviderManager::mInterfaceMutex as a part
// of calling getSystemCameraKind() internally. Care should be taken not to
// directly / indirectly call this from callers who also hold
// mInterfaceMutex.
- virtual void onTorchStatusChanged(const String8& cameraId,
+ virtual void onTorchStatusChanged(const std::string& cameraId,
TorchModeStatus newStatus) override;
// Does not hold CameraProviderManager::mInterfaceMutex.
- virtual void onTorchStatusChanged(const String8& cameraId,
+ virtual void onTorchStatusChanged(const std::string& cameraId,
TorchModeStatus newStatus,
SystemCameraKind kind) override;
virtual void onNewProviderRegistered() override;
@@ -143,7 +143,7 @@
virtual binder::Status getCameraInfo(int cameraId, bool overrideToPortrait,
hardware::CameraInfo* cameraInfo) override;
- virtual binder::Status getCameraCharacteristics(const String16& cameraId,
+ virtual binder::Status getCameraCharacteristics(const std::string& cameraId,
int targetSdkVersion, bool overrideToPortrait, CameraMetadata* cameraInfo) override;
virtual binder::Status getCameraVendorTagDescriptor(
/*out*/
@@ -153,15 +153,16 @@
hardware::camera2::params::VendorTagDescriptorCache* cache);
virtual binder::Status connect(const sp<hardware::ICameraClient>& cameraClient,
- int32_t cameraId, const String16& clientPackageName,
+ int32_t cameraId, const std::string& clientPackageName,
int32_t clientUid, int clientPid, int targetSdkVersion,
bool overrideToPortrait, bool forceSlowJpegMode,
/*out*/
sp<hardware::ICamera>* device) override;
virtual binder::Status connectDevice(
- const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb, const String16& cameraId,
- const String16& clientPackageName, const std::optional<String16>& clientFeatureId,
+ const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb,
+ const std::string& cameraId,
+ const std::string& clientPackageName, const std::optional<std::string>& clientFeatureId,
int32_t clientUid, int scoreOffset, int targetSdkVersion, bool overrideToPortrait,
/*out*/
sp<hardware::camera2::ICameraDeviceUser>* device);
@@ -183,15 +184,15 @@
virtual binder::Status getLegacyParameters(
int32_t cameraId,
/*out*/
- String16* parameters);
+ std::string* parameters);
- virtual binder::Status setTorchMode(const String16& cameraId, bool enabled,
+ virtual binder::Status setTorchMode(const std::string& cameraId, bool enabled,
const sp<IBinder>& clientBinder);
- virtual binder::Status turnOnTorchWithStrengthLevel(const String16& cameraId,
+ virtual binder::Status turnOnTorchWithStrengthLevel(const std::string& cameraId,
int32_t torchStrength, const sp<IBinder>& clientBinder);
- virtual binder::Status getTorchStrengthLevel(const String16& cameraId,
+ virtual binder::Status getTorchStrengthLevel(const std::string& cameraId,
int32_t* torchStrength);
virtual binder::Status notifySystemEvent(int32_t eventId,
@@ -203,24 +204,24 @@
// OK = supports api of that version, -EOPNOTSUPP = does not support
virtual binder::Status supportsCameraApi(
- const String16& cameraId, int32_t apiVersion,
+ const std::string& cameraId, int32_t apiVersion,
/*out*/
bool *isSupported);
virtual binder::Status isHiddenPhysicalCamera(
- const String16& cameraId,
+ const std::string& cameraId,
/*out*/
bool *isSupported);
virtual binder::Status injectCamera(
- const String16& packageName, const String16& internalCamId,
- const String16& externalCamId,
+ const std::string& packageName, const std::string& internalCamId,
+ const std::string& externalCamId,
const sp<hardware::camera2::ICameraInjectionCallback>& callback,
/*out*/
sp<hardware::camera2::ICameraInjectionSession>* cameraInjectionSession);
virtual binder::Status reportExtensionSessionStats(
- const hardware::CameraExtensionSessionStats& stats, String16* sessionKey /*out*/);
+ const hardware::CameraExtensionSessionStats& stats, std::string* sessionKey /*out*/);
// Extra permissions checks
virtual status_t onTransact(uint32_t code, const Parcel& data,
@@ -243,7 +244,7 @@
void cacheDump();
// Register an offline client for a given active camera id
- status_t addOfflineClient(String8 cameraId, sp<BasicClient> offlineClient);
+ status_t addOfflineClient(const std::string &cameraId, sp<BasicClient> offlineClient);
/////////////////////////////////////////////////////////////////////
// Client functionality
@@ -262,7 +263,7 @@
/////////////////////////////////////////////////////////////////////
// CameraDeviceFactory functionality
- std::pair<int, IPCTransport> getDeviceVersion(const String8& cameraId,
+ std::pair<int, IPCTransport> getDeviceVersion(const std::string& cameraId,
bool overrideToPortrait, int* portraitRotation,
int* facing = nullptr, int* orientation = nullptr);
@@ -290,7 +291,7 @@
friend class CameraService;
public:
virtual status_t initialize(sp<CameraProviderManager> manager,
- const String8& monitorTags) = 0;
+ const std::string& monitorTags) = 0;
virtual binder::Status disconnect();
// because we can't virtually inherit IInterface, which breaks
@@ -311,12 +312,12 @@
// Internal dump method to be called by CameraService
virtual status_t dumpClient(int fd, const Vector<String16>& args) = 0;
- virtual status_t startWatchingTags(const String8 &tags, int outFd);
+ virtual status_t startWatchingTags(const std::string &tags, int outFd);
virtual status_t stopWatchingTags(int outFd);
virtual status_t dumpWatchedEventsToVector(std::vector<std::string> &out);
// Return the package name for this client
- virtual String16 getPackageName() const;
+ virtual std::string getPackageName() const;
// Return the camera facing for this client
virtual int getCameraFacing() const;
@@ -384,7 +385,7 @@
// The injection camera session to replace the internal camera
// session.
- virtual status_t injectCamera(const String8& injectedCamId,
+ virtual status_t injectCamera(const std::string& injectedCamId,
sp<CameraProviderManager> manager) = 0;
// Stop the injection camera and restore to internal camera session.
@@ -393,10 +394,10 @@
protected:
BasicClient(const sp<CameraService>& cameraService,
const sp<IBinder>& remoteCallback,
- const String16& clientPackageName,
+ const std::string& clientPackageName,
bool nativeClient,
- const std::optional<String16>& clientFeatureId,
- const String8& cameraIdStr,
+ const std::optional<std::string>& clientFeatureId,
+ const std::string& cameraIdStr,
int cameraFacing,
int sensorOrientation,
int clientPid,
@@ -414,12 +415,12 @@
// these are initialized in the constructor.
static sp<CameraService> sCameraService;
- const String8 mCameraIdStr;
+ const std::string mCameraIdStr;
const int mCameraFacing;
const int mOrientation;
- String16 mClientPackageName;
+ std::string mClientPackageName;
bool mSystemNativeClient;
- std::optional<String16> mClientFeatureId;
+ std::optional<std::string> mClientFeatureId;
pid_t mClientPid;
const uid_t mClientUid;
const pid_t mServicePid;
@@ -506,10 +507,10 @@
// Interface used by CameraService
Client(const sp<CameraService>& cameraService,
const sp<hardware::ICameraClient>& cameraClient,
- const String16& clientPackageName,
+ const std::string& clientPackageName,
bool systemNativeClient,
- const std::optional<String16>& clientFeatureId,
- const String8& cameraIdStr,
+ const std::optional<std::string>& clientFeatureId,
+ const std::string& cameraIdStr,
int api1CameraId,
int cameraFacing,
int sensorOrientation,
@@ -553,13 +554,13 @@
*/
class ClientEventListener {
public:
- void onClientAdded(const resource_policy::ClientDescriptor<String8,
+ void onClientAdded(const resource_policy::ClientDescriptor<std::string,
sp<CameraService::BasicClient>>& descriptor);
- void onClientRemoved(const resource_policy::ClientDescriptor<String8,
+ void onClientRemoved(const resource_policy::ClientDescriptor<std::string,
sp<CameraService::BasicClient>>& descriptor);
}; // class ClientEventListener
- typedef std::shared_ptr<resource_policy::ClientDescriptor<String8,
+ typedef std::shared_ptr<resource_policy::ClientDescriptor<std::string,
sp<CameraService::BasicClient>>> DescriptorPtr;
/**
@@ -570,7 +571,7 @@
* 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<String8,
+ class CameraClientManager : public resource_policy::ClientManager<std::string,
sp<CameraService::BasicClient>, ClientEventListener> {
public:
CameraClientManager();
@@ -580,18 +581,19 @@
* Return a strong pointer to the active BasicClient for this camera ID, or an empty
* if none exists.
*/
- sp<CameraService::BasicClient> getCameraClient(const String8& id) const;
+ sp<CameraService::BasicClient> getCameraClient(const std::string& id) const;
/**
* Return a string describing the current state.
*/
- String8 toString() const;
+ std::string toString() const;
/**
* Make a ClientDescriptor object wrapping the given BasicClient strong pointer.
*/
- static DescriptorPtr makeClientDescriptor(const String8& key, const sp<BasicClient>& value,
- int32_t cost, const std::set<String8>& conflictingKeys, int32_t score,
+ static DescriptorPtr makeClientDescriptor(const std::string& key,
+ const sp<BasicClient>& value, int32_t cost,
+ const std::set<std::string>& conflictingKeys, int32_t score,
int32_t ownerId, int32_t state, int oomScoreOffset, bool systemNativeClient);
/**
@@ -614,7 +616,7 @@
* AUTOMOTIVE_LOCATION_EXTERIOR_LEFT,AUTOMOTIVE_LOCATION_EXTERIOR_RIGHT,
* AUTOMOTIVE_LOCATION_EXTERIOR_FRONT or AUTOMOTIVE_LOCATION_EXTERIOR_REAR.
*/
- bool isAutomotiveExteriorSystemCamera(const String8& cameraId) const;
+ bool isAutomotiveExteriorSystemCamera(const std::string& cameraId) const;
// TODO: b/263304156 update this to make use of a death callback for more
// robust/fault tolerant logging
@@ -639,11 +641,11 @@
* which is located outside of the vehicle body frame because camera located inside the vehicle
* cabin would need user permission.
*/
- bool checkPermission(const String8& cameraId, const String16& permission,
- const content::AttributionSourceState& attributionSource,const String16& message,
+ bool checkPermission(const std::string& cameraId, const std::string& permission,
+ const content::AttributionSourceState& attributionSource, const std::string& message,
int32_t attributedOpCode) const;
- bool hasPermissionsForSystemCamera(const String8& cameraId, int callingPid, int callingUid)
+ bool hasPermissionsForSystemCamera(const std::string& cameraId, int callingPid, int callingUid)
const;
/**
@@ -674,7 +676,7 @@
* 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<String8>& conflicting,
+ CameraState(const std::string& id, int cost, const std::set<std::string>& conflicting,
SystemCameraKind deviceKind, const std::vector<std::string>& physicalCameras);
virtual ~CameraState();
@@ -688,7 +690,7 @@
/**
* 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)
+ * with a signature onStatusUpdateLocked(const std::string&, int32_t)
* if the status has changed.
*
* This method is idempotent, and will not result in the function passed to
@@ -697,7 +699,7 @@
*/
template<class Func>
void updateStatus(StatusInternal status,
- const String8& cameraId,
+ const std::string& cameraId,
std::initializer_list<StatusInternal> rejectSourceStates,
Func onStatusUpdatedLocked);
@@ -720,12 +722,7 @@
/**
* Return a set of the IDs of conflicting devices advertised by the HAL for this device.
*/
- std::set<String8> getConflicting() const;
-
- /**
- * Return the ID of this camera device.
- */
- String8 getId() const;
+ std::set<std::string> getConflicting() const;
/**
* Return the kind (SystemCameraKind) of this camera device.
@@ -741,28 +738,28 @@
/**
* Add/Remove the unavailable physical camera ID.
*/
- bool addUnavailablePhysicalId(const String8& physicalId);
- bool removeUnavailablePhysicalId(const String8& physicalId);
+ bool addUnavailablePhysicalId(const std::string& physicalId);
+ bool removeUnavailablePhysicalId(const std::string& physicalId);
/**
* Set and get client package name.
*/
- void setClientPackage(const String8& clientPackage);
- String8 getClientPackage() const;
+ void setClientPackage(const std::string& clientPackage);
+ std::string getClientPackage() const;
/**
* Return the unavailable physical ids for this device.
*
* This method acquires mStatusLock.
*/
- std::vector<String8> getUnavailablePhysicalIds() const;
+ std::vector<std::string> getUnavailablePhysicalIds() const;
private:
- const String8 mId;
+ const std::string mId;
StatusInternal mStatus; // protected by mStatusLock
const int mCost;
- std::set<String8> mConflicting;
- std::set<String8> mUnavailablePhysicalIds;
- String8 mClientPackage;
+ std::set<std::string> mConflicting;
+ std::set<std::string> mUnavailablePhysicalIds;
+ std::string mClientPackage;
mutable Mutex mStatusLock;
CameraParameters mShimParams;
const SystemCameraKind mSystemCameraKind;
@@ -782,7 +779,7 @@
void registerSelf();
void unregisterSelf();
- bool isUidActive(uid_t uid, String16 callingPackage);
+ bool isUidActive(uid_t uid, const std::string &callingPackage);
int32_t getProcState(uid_t uid);
// IUidObserver
@@ -793,8 +790,8 @@
int32_t capability) override;
void onUidProcAdjChanged(uid_t uid, int adj) override;
- void addOverrideUid(uid_t uid, String16 callingPackage, bool active);
- void removeOverrideUid(uid_t uid, String16 callingPackage);
+ void addOverrideUid(uid_t uid, const std::string &callingPackage, bool active);
+ void removeOverrideUid(uid_t uid, const std::string &callingPackage);
void registerMonitorUid(uid_t uid, bool openCamera);
void unregisterMonitorUid(uid_t uid, bool closeCamera);
@@ -805,9 +802,10 @@
// IBinder::DeathRecipient implementation
virtual void binderDied(const wp<IBinder> &who);
private:
- bool isUidActiveLocked(uid_t uid, String16 callingPackage);
+ bool isUidActiveLocked(uid_t uid, const std::string &callingPackage);
int32_t getProcStateLocked(uid_t uid);
- void updateOverrideUid(uid_t uid, String16 callingPackage, bool active, bool insert);
+ void updateOverrideUid(uid_t uid, const std::string &callingPackage, bool active,
+ bool insert);
void registerWithActivityManager();
struct MonitoredUid {
@@ -877,8 +875,8 @@
// 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);
+ void addStates(const std::string& id);
+ void removeStates(const std::string& 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
@@ -887,24 +885,25 @@
// 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,
+ binder::Status validateConnectLocked(const std::string& cameraId, const std::string& clientName,
/*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;
+ binder::Status validateClientPermissionsLocked(const std::string& cameraId,
+ const std::string& clientName, /*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<IBinder>& remoteCallback, const String8& packageName,
- int scoreOffset, bool systemNativeClient,
+ status_t handleEvictionsLocked(const std::string& cameraId, int clientPid,
+ apiLevel effectiveApiLevel, const sp<IBinder>& remoteCallback,
+ const std::string& packageName, int scoreOffset, bool systemNativeClient,
/*out*/
sp<BasicClient>* client,
- std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial);
+ std::shared_ptr<resource_policy::ClientDescriptor<std::string, sp<BasicClient>>>* partial);
// Should an operation attempt on a cameraId be rejected ? (this can happen
// under various conditions. For example if a camera device is advertised as
// system only or hidden secure camera, amongst possible others.
- bool shouldRejectSystemCameraConnection(const String8 & cameraId) const;
+ bool shouldRejectSystemCameraConnection(const std::string& cameraId) const;
// Should a device status update be skipped for a particular camera device ? (this can happen
// under various conditions. For example if a camera device is advertised as
@@ -916,7 +915,7 @@
// getSystemCameraKind() needs mInterfaceMutex which might lead to deadlocks
// if held along with mStatusListenerLock (depending on lock ordering, b/141756275), it is
// recommended that we don't call this function with mStatusListenerLock held.
- status_t getSystemCameraKind(const String8& cameraId, SystemCameraKind *kind) const;
+ status_t getSystemCameraKind(const std::string& cameraId, SystemCameraKind *kind) const;
// Update the set of API1Compatible camera devices without including system
// cameras and secure cameras. This is used for hiding system only cameras
@@ -932,13 +931,13 @@
// as for legacy apps we will toggle the app op for all packages in the UID.
// The caveat is that the operation may be attributed to the wrong package and
// stats based on app ops may be slightly off.
- String16 getPackageNameFromUid(int clientUid);
+ std::string getPackageNameFromUid(int clientUid);
// Single implementation shared between the various connect calls
template<class CALLBACK, class CLIENT>
- binder::Status connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
- int api1CameraId, const String16& clientPackageNameMaybe, bool systemNativeClient,
- const std::optional<String16>& clientFeatureId, int clientUid, int clientPid,
+ binder::Status connectHelper(const sp<CALLBACK>& cameraCb, const std::string& cameraId,
+ int api1CameraId, const std::string& clientPackageNameMaybe, bool systemNativeClient,
+ const std::optional<std::string>& clientFeatureId, int clientUid, int clientPid,
apiLevel effectiveApiLevel, bool shimUpdateOnly, int scoreOffset, int targetSdkVersion,
bool overrideToPortrait, bool forceSlowJpegMode,
/*out*/sp<CLIENT>& device);
@@ -950,37 +949,38 @@
std::shared_ptr<WaitableMutexWrapper> mServiceLockWrapper;
// Return NO_ERROR if the device with a give ID can be connected to
- status_t checkIfDeviceIsUsable(const String8& cameraId) const;
+ status_t checkIfDeviceIsUsable(const std::string& cameraId) const;
// Container for managing currently active application-layer clients
CameraClientManager mActiveClientManager;
// Adds client logs during open session to the file pointed by fd.
- void dumpOpenSessionClientLogs(int fd, const Vector<String16>& args, const String8& cameraId);
+ void dumpOpenSessionClientLogs(int fd, const Vector<String16>& args,
+ const std::string& cameraId);
// Adds client logs during closed session to the file pointed by fd.
- void dumpClosedSessionClientLogs(int fd, const String8& cameraId);
+ void dumpClosedSessionClientLogs(int fd, const std::string& cameraId);
// Mapping from camera ID -> state for each device, map is protected by mCameraStatesLock
- std::map<String8, std::shared_ptr<CameraState>> mCameraStates;
+ std::map<std::string, std::shared_ptr<CameraState>> mCameraStates;
// Mutex guarding mCameraStates map
mutable Mutex mCameraStatesLock;
// Circular buffer for storing event logging for dumps
- RingBuffer<String8> mEventLog;
+ RingBuffer<std::string> mEventLog;
Mutex mLogLock;
// set of client package names to watch. if this set contains 'all', then all clients will
// be watched. Access should be guarded by mLogLock
- std::set<String16> mWatchedClientPackages;
+ std::set<std::string> mWatchedClientPackages;
// cache of last monitored tags dump immediately before the client disconnects. If a client
// re-connects, its entry is not updated until it disconnects again. Access should be guarded
// by mLogLock
- std::map<String16, std::string> mWatchedClientsDumpCache;
+ std::map<std::string, std::string> mWatchedClientsDumpCache;
// The last monitored tags set by client
- String8 mMonitorTags;
+ std::string mMonitorTags;
// Currently allowed user IDs
std::set<userid_t> mAllowedUsers;
@@ -990,7 +990,7 @@
*
* This acquires mCameraStatesLock.
*/
- std::shared_ptr<CameraService::CameraState> getCameraState(const String8& cameraId) const;
+ std::shared_ptr<CameraService::CameraState> getCameraState(const std::string& cameraId) const;
/**
* Evict client who's remote binder has died. Returns true if this client was in the active
@@ -1021,7 +1021,7 @@
* 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);
+ std::string cameraIdIntToStr(int cameraIdInt);
/**
* Returns the underlying camera Id string mapped to a camera id int
@@ -1035,7 +1035,7 @@
*
* This method must be called with mServiceLock held.
*/
- sp<CameraService::BasicClient> removeClientLocked(const String8& cameraId);
+ sp<CameraService::BasicClient> removeClientLocked(const std::string& cameraId);
/**
* Handle a notification that the current device user has changed.
@@ -1045,39 +1045,41 @@
/**
* Add an event log message.
*/
- void logEvent(const char* event);
+ void logEvent(const std::string &event);
/**
* Add an event log message that a client has been disconnected.
*/
- void logDisconnected(const char* cameraId, int clientPid, const char* clientPackage);
+ void logDisconnected(const std::string &cameraId, int clientPid,
+ const std::string &clientPackage);
/**
* Add an event log message that a client has been disconnected from offline device.
*/
- void logDisconnectedOffline(const char* cameraId, int clientPid, const char* clientPackage);
+ void logDisconnectedOffline(const std::string &cameraId, int clientPid,
+ const std::string &clientPackage);
/**
* Add an event log message that an offline client has been connected.
*/
- void logConnectedOffline(const char* cameraId, int clientPid,
- const char* clientPackage);
+ void logConnectedOffline(const std::string &cameraId, int clientPid,
+ const std::string &clientPackage);
/**
* Add an event log message that a client has been connected.
*/
- void logConnected(const char* cameraId, int clientPid, const char* clientPackage);
+ void logConnected(const std::string &cameraId, int clientPid, const std::string &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);
+ void logRejected(const std::string &cameraId, int clientPid, const std::string &clientPackage,
+ const std::string &reason);
/**
* Add an event log message when a client calls setTorchMode succesfully.
*/
- void logTorchEvent(const char* cameraId, const char *torchState, int clientPid);
+ void logTorchEvent(const std::string &cameraId, const std::string &torchState, int clientPid);
/**
* Add an event log message that the current device user has been switched.
@@ -1088,30 +1090,30 @@
/**
* Add an event log message that a device has been removed by the HAL
*/
- void logDeviceRemoved(const char* cameraId, const char* reason);
+ void logDeviceRemoved(const std::string &cameraId, const std::string &reason);
/**
* Add an event log message that a device has been added by the HAL
*/
- void logDeviceAdded(const char* cameraId, const char* reason);
+ void logDeviceAdded(const std::string &cameraId, const std::string &reason);
/**
* Add an event log message that a client has unexpectedly died.
*/
- void logClientDied(int clientPid, const char* reason);
+ void logClientDied(int clientPid, const std::string &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);
+ void logServiceError(const std::string &msg, int errorCode);
/**
* Dump the event log to an FD
*/
void dumpEventLog(int fd);
- void cacheClientTagDumpIfNeeded(const char *cameraId, BasicClient *client);
+ void cacheClientTagDumpIfNeeded(const std::string &cameraId, BasicClient *client);
/**
* This method will acquire mServiceLock
@@ -1227,18 +1229,19 @@
* This method acquires mStatusLock and mStatusListenerLock.
*/
void updateStatus(StatusInternal status,
- const String8& cameraId,
+ const std::string& cameraId,
std::initializer_list<StatusInternal>
rejectedSourceStates);
void updateStatus(StatusInternal status,
- const String8& cameraId);
+ const std::string& cameraId);
/**
* Update the opened/closed status of the given camera id.
*
* This method acqiures mStatusListenerLock.
*/
- void updateOpenCloseStatus(const String8& cameraId, bool open, const String16& packageName);
+ void updateOpenCloseStatus(const std::string& cameraId, bool open,
+ const std::string& packageName);
// flashlight control
sp<CameraFlashlight> mFlashlight;
@@ -1249,38 +1252,38 @@
// guard mTorchUidMap
Mutex mTorchUidMapMutex;
// camera id -> torch status
- KeyedVector<String8, TorchModeStatus>
+ KeyedVector<std::string, TorchModeStatus>
mTorchStatusMap;
// camera id -> torch client binder
// only store the last client that turns on each camera's torch mode
- KeyedVector<String8, sp<IBinder>> mTorchClientMap;
+ KeyedVector<std::string, sp<IBinder>> mTorchClientMap;
// camera id -> [incoming uid, current uid] pair
- std::map<String8, std::pair<int, int>> mTorchUidMap;
+ std::map<std::string, std::pair<int, int>> mTorchUidMap;
// check and handle if torch client's process has died
void handleTorchClientBinderDied(const wp<IBinder> &who);
// handle torch mode status change and invoke callbacks. mTorchStatusMutex
// should be locked.
- void onTorchStatusChangedLocked(const String8& cameraId,
+ void onTorchStatusChangedLocked(const std::string& cameraId,
TorchModeStatus newStatus,
SystemCameraKind systemCameraKind);
// get a camera's torch status. mTorchStatusMutex should be locked.
- status_t getTorchStatusLocked(const String8 &cameraId,
+ status_t getTorchStatusLocked(const std::string &cameraId,
TorchModeStatus *status) const;
// set a camera's torch status. mTorchStatusMutex should be locked.
- status_t setTorchStatusLocked(const String8 &cameraId,
+ status_t setTorchStatusLocked(const std::string &cameraId,
TorchModeStatus status);
// notify physical camera status when the physical camera is public.
// Expects mStatusListenerLock to be locked.
- void notifyPhysicalCameraStatusLocked(int32_t status, const String16& physicalCameraId,
- const std::list<String16>& logicalCameraIds, SystemCameraKind deviceKind);
+ void notifyPhysicalCameraStatusLocked(int32_t status, const std::string& physicalCameraId,
+ const std::list<std::string>& logicalCameraIds, SystemCameraKind deviceKind);
// get list of logical cameras which are backed by physicalCameraId
- std::list<String16> getLogicalCameras(const String8& physicalCameraId);
+ std::list<std::string> getLogicalCameras(const std::string& physicalCameraId);
// IBinder::DeathRecipient implementation
@@ -1372,7 +1375,7 @@
// Parses comma separated clients list and adds them to mWatchedClientPackages.
// Does not acquire mLogLock before modifying mWatchedClientPackages. It is the caller's
// responsibility to acquire mLogLock before calling this function.
- void parseClientsToWatchLocked(String8 clients);
+ void parseClientsToWatchLocked(const std::string &clients);
// Prints the shell command help
status_t printHelp(int out);
@@ -1389,39 +1392,37 @@
/**
* Get the current system time as a formatted string.
*/
- static String8 getFormattedCurrentTime();
+ static std::string getFormattedCurrentTime();
static binder::Status makeClient(const sp<CameraService>& cameraService,
- const sp<IInterface>& cameraCb, const String16& packageName,
- bool systemNativeClient, const std::optional<String16>& featureId,
- const String8& cameraId, int api1CameraId, int facing, int sensorOrientation,
+ const sp<IInterface>& cameraCb, const std::string& packageName,
+ bool systemNativeClient, const std::optional<std::string>& featureId,
+ const std::string& cameraId, int api1CameraId, int facing, int sensorOrientation,
int clientPid, uid_t clientUid, int servicePid,
std::pair<int, IPCTransport> deviceVersionAndIPCTransport, apiLevel effectiveApiLevel,
bool overrideForPerfClass, bool overrideToPortrait, bool forceSlowJpegMode,
/*out*/sp<BasicClient>* client);
- status_t checkCameraAccess(const String16& opPackageName);
-
- static String8 toString(std::set<userid_t> intSet);
+ static std::string toString(std::set<userid_t> intSet);
static int32_t mapToInterface(TorchModeStatus status);
static StatusInternal mapToInternal(CameraDeviceStatus status);
static int32_t mapToInterface(StatusInternal status);
- void broadcastTorchModeStatus(const String8& cameraId,
+ void broadcastTorchModeStatus(const std::string& cameraId,
TorchModeStatus status, SystemCameraKind systemCameraKind);
- void broadcastTorchStrengthLevel(const String8& cameraId, int32_t newTorchStrengthLevel);
+ void broadcastTorchStrengthLevel(const std::string& cameraId, int32_t newTorchStrengthLevel);
- void disconnectClient(const String8& id, sp<BasicClient> clientToDisconnect);
+ void disconnectClient(const std::string& id, sp<BasicClient> clientToDisconnect);
// Regular online and offline devices must not be in conflict at camera service layer.
// Use separate keys for offline devices.
- static const String8 kOfflineDevice;
+ static const std::string kOfflineDevice;
// Sentinel value to be stored in `mWatchedClientsPackages` to indicate that all clients should
// be watched.
- static const String16 kWatchAllClientsFlag;
+ static const std::string kWatchAllClientsFlag;
// TODO: right now each BasicClient holds one AppOpsManager instance.
// We can refactor the code so all of clients share this instance
@@ -1462,7 +1463,7 @@
void addListener(const sp<hardware::camera2::ICameraInjectionCallback>& callback);
void removeListener();
- void notifyInjectionError(String8 injectedCamId, status_t err);
+ void notifyInjectionError(const std::string &injectedCamId, status_t err);
// IBinder::DeathRecipient implementation
virtual void binderDied(const wp<IBinder>& who);
@@ -1491,15 +1492,15 @@
// When injecting the camera, it will check whether the injecting camera status is unavailable.
// If it is, the disconnect function will be called to to prevent camera access on the device.
- status_t checkIfInjectionCameraIsPresent(const String8& externalCamId,
+ status_t checkIfInjectionCameraIsPresent(const std::string& externalCamId,
sp<BasicClient> clientSp);
void clearInjectionParameters();
// This is the existing camera id being replaced.
- String8 mInjectionInternalCamId;
+ std::string mInjectionInternalCamId;
// This is the external camera Id replacing the internalId.
- String8 mInjectionExternalCamId;
+ std::string mInjectionExternalCamId;
bool mInjectionInitPending = false;
// Guard mInjectionInternalCamId and mInjectionInitPending.
Mutex mInjectionParametersLock;
@@ -1507,7 +1508,7 @@
// Track the folded/unfoled device state. 0 == UNFOLDED, 4 == FOLDED
int64_t mDeviceState;
- void updateTorchUidMapLocked(const String16& cameraId, int uid);
+ void updateTorchUidMapLocked(const std::string& cameraId, int uid);
};
} // namespace android