/*
* 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 <android/hardware/BnCameraService.h>
#include <android/hardware/ICameraServiceListener.h>
#include <cutils/multiuser.h>
#include <utils/Vector.h>
#include <utils/KeyedVector.h>
#include <binder/AppOpsManager.h>
#include <binder/BinderService.h>
#include <binder/IAppOpsCallback.h>
#include <camera/ICameraServiceProxy.h>
#include <hardware/camera.h>
#include <camera/VendorTagDescriptor.h>
#include <camera/CaptureResult.h>
#include <camera/CameraParameters.h>
#include "CameraFlashlight.h"
#include "common/CameraModule.h"
#include "media/RingBuffer.h"
#include "utils/AutoConditionLock.h"
#include "utils/ClientManager.h"
#include <set>
#include <string>
#include <map>
#include <memory>
#include <utility>
namespace android {
extern volatile int32_t gLogLevel;
class MemoryHeapBase;
class MediaPlayer;
class CameraService :
public BinderService<CameraService>,
public ::android::hardware::BnCameraService,
public IBinder::DeathRecipient,
public camera_module_callbacks_t
{
friend class BinderService<CameraService>;
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
};
// Process state (mirrors frameworks/base/core/java/android/app/ActivityManager.java)
static const int PROCESS_STATE_NONEXISTENT = -1;
static const int PROCESS_STATE_TOP = 2;
static const int PROCESS_STATE_TOP_SLEEPING = 5;
// 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<T>
static char const* getServiceName() { return "media.camera"; }
CameraService();
virtual ~CameraService();
/////////////////////////////////////////////////////////////////////
// HAL Callbacks
virtual void onDeviceStatusChanged(camera_device_status_t cameraId,
camera_device_status_t newStatus);
virtual void onTorchStatusChanged(const String8& cameraId,
int32_t newStatus);
/////////////////////////////////////////////////////////////////////
// ICameraService
virtual binder::Status getNumberOfCameras(int32_t type, int32_t* numCameras);
virtual binder::Status getCameraInfo(int cameraId,
hardware::CameraInfo* cameraInfo);
virtual binder::Status getCameraCharacteristics(int cameraId,
CameraMetadata* cameraInfo);
virtual binder::Status getCameraVendorTagDescriptor(
/*out*/
hardware::camera2::params::VendorTagDescriptor* desc);
virtual binder::Status connect(const sp<hardware::ICameraClient>& cameraClient,
int32_t cameraId, const String16& clientPackageName,
int32_t clientUid, int clientPid,
/*out*/
sp<hardware::ICamera>* device);
virtual binder::Status connectLegacy(const sp<hardware::ICameraClient>& cameraClient,
int32_t cameraId, int32_t halVersion,
const String16& clientPackageName, int32_t clientUid,
/*out*/
sp<hardware::ICamera>* device);
virtual binder::Status connectDevice(
const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb, int32_t cameraId,
const String16& clientPackageName, int32_t clientUid,
/*out*/
sp<hardware::camera2::ICameraDeviceUser>* device);
virtual binder::Status addListener(const sp<hardware::ICameraServiceListener>& listener);
virtual binder::Status removeListener(
const sp<hardware::ICameraServiceListener>& listener);
virtual binder::Status getLegacyParameters(
int32_t cameraId,
/*out*/
String16* parameters);
virtual binder::Status setTorchMode(const String16& cameraId, bool enabled,
const sp<IBinder>& clientBinder);
virtual binder::Status notifySystemEvent(int32_t eventId,
const std::vector<int32_t>& args);
// OK = supports api of that version, -EOPNOTSUPP = does not support
virtual binder::Status supportsCameraApi(
int32_t cameraId, int32_t apiVersion,
/*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<String16>& args);
/////////////////////////////////////////////////////////////////////
// Client functionality
enum sound_kind {
SOUND_SHUTTER = 0,
SOUND_RECORDING_START = 1,
SOUND_RECORDING_STOP = 2,
NUM_SOUNDS
};
void loadSound();
void playSound(sound_kind kind);
void releaseSound();
/**
* Update the state of a given camera device (open/close/active/idle) with
* the camera proxy service in the system service
*/
static void updateProxyDeviceState(
ICameraServiceProxy::CameraState newState,
const String8& cameraId);
/////////////////////////////////////////////////////////////////////
// CameraDeviceFactory functionality
int getDeviceVersion(int 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(CameraModule *module) = 0;
virtual binder::Status disconnect();
// because we can't virtually inherit IInterface, which breaks
// virtual inheritance
virtual sp<IBinder> asBinderWrapper() = 0;
// Return the remote callback binder object (e.g. ICameraDeviceCallbacks)
sp<IBinder> getRemote() {
return mRemoteBinder;
}
// Disallows dumping over binder interface
virtual status_t dump(int fd, const Vector<String16>& args);
// Internal dump method to be called by CameraService
virtual status_t dumpClient(int fd, const Vector<String16>& 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;
protected:
BasicClient(const sp<CameraService>& cameraService,
const sp<IBinder>& remoteCallback,
const String16& clientPackageName,
int cameraId,
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.
sp<CameraService> mCameraService; // immutable after constructor
int mCameraId; // immutable after constructor
int mCameraFacing; // immutable after constructor
String16 mClientPackageName; // immutable after constructor
pid_t mClientPid;
uid_t mClientUid; // immutable after constructor
pid_t mServicePid; // immutable after constructor
bool mDisconnected;
// - The app-side Binder interface to receive callbacks from us
sp<IBinder> mRemoteBinder; // immutable after constructor
// permissions management
status_t startCameraOps();
status_t finishCameraOps();
private:
AppOpsManager mAppOpsManager;
class OpsCallback : public BnAppOpsCallback {
public:
OpsCallback(wp<BasicClient> client);
virtual void opChanged(int32_t op, const String16& packageName);
private:
wp<BasicClient> mClient;
}; // class OpsCallback
sp<OpsCallback> 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<hardware::ICameraClient>& client) = 0;
virtual status_t lock() = 0;
virtual status_t unlock() = 0;
virtual status_t setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer)=0;
virtual void setPreviewCallbackFlag(int flag) = 0;
virtual status_t setPreviewCallbackTarget(
const sp<IGraphicBufferProducer>& 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<IMemory>& 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<IGraphicBufferProducer>& bufferProducer) = 0;
// Interface used by CameraService
Client(const sp<CameraService>& cameraService,
const sp<hardware::ICameraClient>& cameraClient,
const String16& clientPackageName,
int cameraId,
int cameraFacing,
int clientPid,
uid_t clientUid,
int servicePid);
~Client();
// return our camera client
const sp<hardware::ICameraClient>& getRemoteCallback() {
return mRemoteCallback;
}
virtual sp<IBinder> 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:
// Convert client from cookie.
static sp<CameraService::Client> getClientFromCookie(void* user);
// Initialized in constructor
// - The app-side Binder interface to receive callbacks from us
sp<hardware::ICameraClient> mRemoteCallback;
}; // class Client
/**
* A listener class that implements the LISTENER interface for use with a ClientManager, and
* implements the following methods:
* void onClientRemoved(const ClientDescriptor<KEY, VALUE>& descriptor);
* void onClientAdded(const ClientDescriptor<KEY, VALUE>& descriptor);
*/
class ClientEventListener {
public:
void onClientAdded(const resource_policy::ClientDescriptor<String8,
sp<CameraService::BasicClient>>& descriptor);
void onClientRemoved(const resource_policy::ClientDescriptor<String8,
sp<CameraService::BasicClient>>& descriptor);
}; // class ClientEventListener
typedef std::shared_ptr<resource_policy::ClientDescriptor<String8,
sp<CameraService::BasicClient>>> 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<String8,
sp<CameraService::BasicClient>, ClientEventListener> {
public:
CameraClientManager();
virtual ~CameraClientManager();
/**
* 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;
/**
* 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<BasicClient>& value,
int32_t cost, const std::set<String8>& conflictingKeys, int32_t priority,
int32_t ownerId);
/**
* Make a ClientDescriptor object wrapping the given BasicClient strong pointer with
* values intialized from a prior ClientDescriptor.
*/
static DescriptorPtr makeClientDescriptor(const sp<BasicClient>& value,
const CameraService::DescriptorPtr& partial);
}; // class CameraClientManager
private:
/**
* 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<String8>& conflicting);
virtual ~CameraState();
/**
* Return the status for this device.
*
* This method acquires mStatusLock.
*/
int32_t 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<class Func>
void updateStatus(int32_t status, const String8& cameraId,
std::initializer_list<int32_t> 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<String8> getConflicting() const;
/**
* Return the ID of this camera device.
*/
String8 getId() const;
private:
const String8 mId;
int32_t mStatus; // protected by mStatusLock
const int mCost;
std::set<String8> mConflicting;
mutable Mutex mStatusLock;
CameraParameters mShimParams;
}; // class CameraState
// Delay-load the Camera HAL module
virtual void onFirstRef();
// 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;
// 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,
/*out*/
sp<BasicClient>* client,
std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial);
// Single implementation shared between the various connect calls
template<class CALLBACK, class CLIENT>
binder::Status connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
int halVersion, const String16& clientPackageName,
int clientUid, int clientPid,
apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,
/*out*/sp<CLIENT>& device);
// Lock guarding camera service state
Mutex mServiceLock;
// Condition to use with mServiceLock, used to handle simultaneous connect calls from clients
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;
// 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<String8, std::shared_ptr<CameraState>> mCameraStates;
// Mutex guarding mCameraStates map
mutable Mutex mCameraStatesLock;
// Circular buffer for storing event logging for dumps
RingBuffer<String8> mEventLog;
Mutex mLogLock;
// Currently allowed user IDs
std::set<userid_t> mAllowedUsers;
/**
* Check camera capabilities, such as support for basic color operation
*/
int checkCameraCapabilities(int id, camera_info info, int *latestStrangeCameraId);
/**
* Get the camera state for a given camera id.
*
* This acquires mCameraStatesLock.
*/
std::shared_ptr<CameraService::CameraState> 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<IBinder>& 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<BasicClient>& client, const DescriptorPtr& desc);
/**
* Returns the integer corresponding to the given camera ID string, or -1 on failure.
*/
static int cameraIdToInt(const String8& cameraId);
/**
* 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<CameraService::BasicClient> removeClientLocked(const String8& cameraId);
/**
* Handle a notification that the current device user has changed.
*/
void doUserSwitch(const std::vector<int32_t>& 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 that the current device user has been switched.
*/
void logUserSwitch(const std::set<userid_t>& oldUserIds,
const std::set<userid_t>& 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);
int mNumberOfCameras;
int mNumberOfNormalCameras;
// sounds
MediaPlayer* newMediaPlayer(const char *file);
Mutex mSoundLock;
sp<MediaPlayer> mSoundPlayer[NUM_SOUNDS];
int mSoundRef; // reference count (release all MediaPlayer when 0)
CameraModule* mModule;
// Guarded by mStatusListenerMutex
std::vector<sp<hardware::ICameraServiceListener>> 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(int32_t status, const String8& cameraId,
std::initializer_list<int32_t> rejectedSourceStates);
void updateStatus(int32_t status, const String8& cameraId);
// flashlight control
sp<CameraFlashlight> mFlashlight;
// guard mTorchStatusMap
Mutex mTorchStatusMutex;
// guard mTorchClientMap
Mutex mTorchClientMapMutex;
// guard mTorchUidMap
Mutex mTorchUidMapMutex;
// camera id -> torch status
KeyedVector<String8, int32_t> mTorchStatusMap;
// camera id -> torch client binder
// only store the last client that turns on each camera's torch mode
KeyedVector<String8, sp<IBinder>> mTorchClientMap;
// camera id -> [incoming uid, current uid] pair
std::map<String8, 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,
int32_t newStatus);
// get a camera's torch status. mTorchStatusMutex should be locked.
status_t getTorchStatusLocked(const String8 &cameraId,
int32_t *status) const;
// set a camera's torch status. mTorchStatusMutex should be locked.
status_t setTorchStatusLocked(const String8 &cameraId,
int32_t status);
// IBinder::DeathRecipient implementation
virtual void binderDied(const wp<IBinder> &who);
// Helpers
bool setUpVendorTags();
/**
* 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);
/**
* Generate the CameraCharacteristics metadata required by the Camera2 API
* from the available HAL1 CameraParameters and CameraInfo.
*
* Sets Status to a service-specific error on failure
*/
binder::Status generateShimMetadata(int cameraId, /*out*/CameraMetadata* cameraInfo);
static int getCallingPid();
static int getCallingUid();
/**
* Get the current system time as a formatted string.
*/
static String8 getFormattedCurrentTime();
/**
* Get the camera eviction priority from the current process state given by ActivityManager.
*/
static int getCameraPriorityFromProcState(int procState);
static binder::Status makeClient(const sp<CameraService>& cameraService,
const sp<IInterface>& cameraCb, const String16& packageName, int cameraId,
int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,
int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
/*out*/sp<BasicClient>* client);
status_t checkCameraAccess(const String16& opPackageName);
static String8 toString(std::set<userid_t> intSet);
static sp<ICameraServiceProxy> getCameraServiceProxy();
static void pingCameraServiceProxy();
};
template<class Func>
void CameraService::CameraState::updateStatus(int32_t status,
const String8& cameraId,
std::initializer_list<int32_t> rejectSourceStates,
Func onStatusUpdatedLocked) {
Mutex::Autolock lock(mStatusLock);
int32_t oldStatus = mStatus;
mStatus = status;
if (oldStatus == status) {
return;
}
ALOGV("%s: Status has changed for camera ID %s from %#x to %#x", __FUNCTION__,
cameraId.string(), oldStatus, status);
if (oldStatus == hardware::ICameraServiceListener::STATUS_NOT_PRESENT &&
(status != hardware::ICameraServiceListener::STATUS_PRESENT &&
status != hardware::ICameraServiceListener::STATUS_ENUMERATING)) {
ALOGW("%s: From NOT_PRESENT can only transition into PRESENT or ENUMERATING",
__FUNCTION__);
mStatus = oldStatus;
return;
}
/**
* Sometimes we want to conditionally do a transition.
* For example if a client disconnects, we want to go to PRESENT
* only if we weren't already in NOT_PRESENT or ENUMERATING.
*/
for (auto& rejectStatus : rejectSourceStates) {
if (oldStatus == rejectStatus) {
ALOGV("%s: Rejecting status transition for Camera ID %s, since the source "
"state was was in one of the bad states.", __FUNCTION__, cameraId.string());
mStatus = oldStatus;
return;
}
}
onStatusUpdatedLocked(cameraId, status);
}
#define STATUS_ERROR(errorCode, errorString) \
binder::Status::fromServiceSpecificError(errorCode, \
String8::format("%s:%d: %s", __FUNCTION__, __LINE__, errorString))
#define STATUS_ERROR_FMT(errorCode, errorString, ...) \
binder::Status::fromServiceSpecificError(errorCode, \
String8::format("%s:%d: " errorString, __FUNCTION__, __LINE__, __VA_ARGS__))
template<class CALLBACK, class CLIENT>
binder::Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
int halVersion, const String16& clientPackageName, int clientUid, int clientPid,
apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,
/*out*/sp<CLIENT>& device) {
binder::Status ret = binder::Status::ok();
String8 clientName8(clientPackageName);
int originalClientPid = 0;
ALOGI("CameraService::connect call (PID %d \"%s\", camera ID %s) for HAL version %s and "
"Camera API version %d", clientPid, clientName8.string(), cameraId.string(),
(halVersion == -1) ? "default" : std::to_string(halVersion).c_str(),
static_cast<int>(effectiveApiLevel));
sp<CLIENT> client = nullptr;
{
// Acquire mServiceLock and prevent other clients from connecting
std::unique_ptr<AutoConditionLock> lock =
AutoConditionLock::waitAndAcquire(mServiceLockWrapper, DEFAULT_CONNECT_TIMEOUT_NS);
if (lock == nullptr) {
ALOGE("CameraService::connect (PID %d) rejected (too many other clients connecting)."
, clientPid);
return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
"Cannot open camera %s for \"%s\" (PID %d): Too many other clients connecting",
cameraId.string(), clientName8.string(), clientPid);
}
// Enforce client permissions and do basic sanity checks
if(!(ret = validateConnectLocked(cameraId, clientName8,
/*inout*/clientUid, /*inout*/clientPid, /*out*/originalClientPid)).isOk()) {
return ret;
}
// Check the shim parameters after acquiring lock, if they have already been updated and
// we were doing a shim update, return immediately
if (shimUpdateOnly) {
auto cameraState = getCameraState(cameraId);
if (cameraState != nullptr) {
if (!cameraState->getShimParams().isEmpty()) return ret;
}
}
status_t err;
sp<BasicClient> clientTmp = nullptr;
std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>> partial;
if ((err = handleEvictionsLocked(cameraId, originalClientPid, effectiveApiLevel,
IInterface::asBinder(cameraCb), clientName8, /*out*/&clientTmp,
/*out*/&partial)) != NO_ERROR) {
switch (err) {
case -ENODEV:
return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
"No camera device with ID \"%s\" currently available",
cameraId.string());
case -EBUSY:
return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
"Higher-priority client using camera, ID \"%s\" currently unavailable",
cameraId.string());
default:
return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
"Unexpected error %s (%d) opening camera \"%s\"",
strerror(-err), err, cameraId.string());
}
}
if (clientTmp.get() != nullptr) {
// Handle special case for API1 MediaRecorder where the existing client is returned
device = static_cast<CLIENT*>(clientTmp.get());
return ret;
}
// give flashlight a chance to close devices if necessary.
mFlashlight->prepareDeviceOpen(cameraId);
// TODO: Update getDeviceVersion + HAL interface to use strings for Camera IDs
int id = cameraIdToInt(cameraId);
if (id == -1) {
ALOGE("%s: Invalid camera ID %s, cannot get device version from HAL.", __FUNCTION__,
cameraId.string());
return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
"Bad camera ID \"%s\" passed to camera open", cameraId.string());
}
int facing = -1;
int deviceVersion = getDeviceVersion(id, /*out*/&facing);
sp<BasicClient> tmp = nullptr;
if(!(ret = makeClient(this, cameraCb, clientPackageName, id, facing, clientPid,
clientUid, getpid(), legacyMode, halVersion, deviceVersion, effectiveApiLevel,
/*out*/&tmp)).isOk()) {
return ret;
}
client = static_cast<CLIENT*>(tmp.get());
LOG_ALWAYS_FATAL_IF(client.get() == nullptr, "%s: CameraService in invalid state",
__FUNCTION__);
if ((err = client->initialize(mModule)) != OK) {
ALOGE("%s: Could not initialize client from HAL module.", __FUNCTION__);
// Errors could be from the HAL module open call or from AppOpsManager
switch(err) {
case BAD_VALUE:
return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
"Illegal argument to HAL module for camera \"%s\"", cameraId.string());
case -EBUSY:
return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
"Camera \"%s\" is already open", cameraId.string());
case -EUSERS:
return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
"Too many cameras already open, cannot open camera \"%s\"",
cameraId.string());
case PERMISSION_DENIED:
return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
"No permission to open camera \"%s\"", cameraId.string());
case -EACCES:
return STATUS_ERROR_FMT(ERROR_DISABLED,
"Camera \"%s\" disabled by policy", cameraId.string());
case -ENODEV:
default:
return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
"Failed to initialize camera \"%s\": %s (%d)", cameraId.string(),
strerror(-err), err);
}
}
// Update shim paremeters for legacy clients
if (effectiveApiLevel == API_1) {
// Assume we have always received a Client subclass for API1
sp<Client> shimClient = reinterpret_cast<Client*>(client.get());
String8 rawParams = shimClient->getParameters();
CameraParameters params(rawParams);
auto cameraState = getCameraState(cameraId);
if (cameraState != nullptr) {
cameraState->setShimParams(params);
} else {
ALOGE("%s: Cannot update shim parameters for camera %s, no such device exists.",
__FUNCTION__, cameraId.string());
}
}
if (shimUpdateOnly) {
// If only updating legacy shim parameters, immediately disconnect client
mServiceLock.unlock();
client->disconnect();
mServiceLock.lock();
} else {
// Otherwise, add client to active clients list
finishConnectLocked(client, partial);
}
} // lock is destroyed, allow further connect calls
// Important: release the mutex here so the client can call back into the service from its
// destructor (can be at the end of the call)
device = client;
return ret;
}
#undef STATUS_ERROR_FMT
#undef STATUS_ERROR
} // namespace android
#endif