CameraService.h revision b10cdadf0fb945e23ca77008d4af76584bd0e39a
1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef ANDROID_SERVERS_CAMERA_CAMERASERVICE_H 18#define ANDROID_SERVERS_CAMERA_CAMERASERVICE_H 19 20#include <utils/Vector.h> 21#include <utils/KeyedVector.h> 22#include <binder/AppOpsManager.h> 23#include <binder/BinderService.h> 24#include <binder/IAppOpsCallback.h> 25#include <camera/ICameraService.h> 26#include <hardware/camera.h> 27 28#include <camera/ICamera.h> 29#include <camera/ICameraClient.h> 30#include <camera/IProCameraUser.h> 31#include <camera/IProCameraCallbacks.h> 32#include <camera/camera2/ICameraDeviceUser.h> 33#include <camera/camera2/ICameraDeviceCallbacks.h> 34#include <camera/VendorTagDescriptor.h> 35#include <camera/CaptureResult.h> 36#include <camera/CameraParameters.h> 37 38#include <camera/ICameraServiceListener.h> 39 40/* This needs to be increased if we can have more cameras */ 41#define MAX_CAMERAS 2 42 43namespace android { 44 45extern volatile int32_t gLogLevel; 46 47class MemoryHeapBase; 48class MediaPlayer; 49 50class CameraService : 51 public BinderService<CameraService>, 52 public BnCameraService, 53 public IBinder::DeathRecipient, 54 public camera_module_callbacks_t 55{ 56 friend class BinderService<CameraService>; 57public: 58 class Client; 59 class BasicClient; 60 61 // Implementation of BinderService<T> 62 static char const* getServiceName() { return "media.camera"; } 63 64 CameraService(); 65 virtual ~CameraService(); 66 67 ///////////////////////////////////////////////////////////////////// 68 // HAL Callbacks 69 virtual void onDeviceStatusChanged(int cameraId, 70 int newStatus); 71 72 ///////////////////////////////////////////////////////////////////// 73 // ICameraService 74 virtual int32_t getNumberOfCameras(); 75 virtual status_t getCameraInfo(int cameraId, 76 struct CameraInfo* cameraInfo); 77 virtual status_t getCameraCharacteristics(int cameraId, 78 CameraMetadata* cameraInfo); 79 virtual status_t getCameraVendorTagDescriptor(/*out*/ sp<VendorTagDescriptor>& desc); 80 81 virtual status_t connect(const sp<ICameraClient>& cameraClient, int cameraId, 82 const String16& clientPackageName, int clientUid, 83 /*out*/ 84 sp<ICamera>& device); 85 86 virtual status_t connectLegacy(const sp<ICameraClient>& cameraClient, int cameraId, 87 int halVersion, const String16& clientPackageName, int clientUid, 88 /*out*/ 89 sp<ICamera>& device); 90 91 virtual status_t connectPro(const sp<IProCameraCallbacks>& cameraCb, 92 int cameraId, const String16& clientPackageName, int clientUid, 93 /*out*/ 94 sp<IProCameraUser>& device); 95 96 virtual status_t connectDevice( 97 const sp<ICameraDeviceCallbacks>& cameraCb, 98 int cameraId, 99 const String16& clientPackageName, 100 int clientUid, 101 /*out*/ 102 sp<ICameraDeviceUser>& device); 103 104 virtual status_t addListener(const sp<ICameraServiceListener>& listener); 105 virtual status_t removeListener( 106 const sp<ICameraServiceListener>& listener); 107 108 virtual status_t getLegacyParameters( 109 int cameraId, 110 /*out*/ 111 String16* parameters); 112 113 // OK = supports api of that version, -EOPNOTSUPP = does not support 114 virtual status_t supportsCameraApi( 115 int cameraId, int apiVersion); 116 117 // Extra permissions checks 118 virtual status_t onTransact(uint32_t code, const Parcel& data, 119 Parcel* reply, uint32_t flags); 120 121 virtual status_t dump(int fd, const Vector<String16>& args); 122 123 ///////////////////////////////////////////////////////////////////// 124 // Client functionality 125 virtual void removeClientByRemote(const wp<IBinder>& remoteBinder); 126 127 enum sound_kind { 128 SOUND_SHUTTER = 0, 129 SOUND_RECORDING = 1, 130 NUM_SOUNDS 131 }; 132 133 void loadSound(); 134 void playSound(sound_kind kind); 135 void releaseSound(); 136 137 ///////////////////////////////////////////////////////////////////// 138 // CameraDeviceFactory functionality 139 int getDeviceVersion(int cameraId, int* facing = NULL); 140 141 142 ///////////////////////////////////////////////////////////////////// 143 // CameraClient functionality 144 145 // returns plain pointer of client. Note that mClientLock should be acquired to 146 // prevent the client from destruction. The result can be NULL. 147 virtual BasicClient* getClientByIdUnsafe(int cameraId); 148 virtual Mutex* getClientLockById(int cameraId); 149 150 class BasicClient : public virtual RefBase { 151 public: 152 virtual status_t initialize(camera_module_t *module) = 0; 153 154 virtual void disconnect() = 0; 155 156 // because we can't virtually inherit IInterface, which breaks 157 // virtual inheritance 158 virtual sp<IBinder> asBinderWrapper() = 0; 159 160 // Return the remote callback binder object (e.g. IProCameraCallbacks) 161 sp<IBinder> getRemote() { 162 return mRemoteBinder; 163 } 164 165 virtual status_t dump(int fd, const Vector<String16>& args) = 0; 166 167 protected: 168 BasicClient(const sp<CameraService>& cameraService, 169 const sp<IBinder>& remoteCallback, 170 const String16& clientPackageName, 171 int cameraId, 172 int cameraFacing, 173 int clientPid, 174 uid_t clientUid, 175 int servicePid); 176 177 virtual ~BasicClient(); 178 179 // the instance is in the middle of destruction. When this is set, 180 // the instance should not be accessed from callback. 181 // CameraService's mClientLock should be acquired to access this. 182 // - subclasses should set this to true in their destructors. 183 bool mDestructionStarted; 184 185 // these are initialized in the constructor. 186 sp<CameraService> mCameraService; // immutable after constructor 187 int mCameraId; // immutable after constructor 188 int mCameraFacing; // immutable after constructor 189 const String16 mClientPackageName; 190 pid_t mClientPid; 191 uid_t mClientUid; // immutable after constructor 192 pid_t mServicePid; // immutable after constructor 193 194 // - The app-side Binder interface to receive callbacks from us 195 sp<IBinder> mRemoteBinder; // immutable after constructor 196 197 // permissions management 198 status_t startCameraOps(); 199 status_t finishCameraOps(); 200 201 // Notify client about a fatal error 202 virtual void notifyError( 203 ICameraDeviceCallbacks::CameraErrorCode errorCode, 204 const CaptureResultExtras& resultExtras) = 0; 205 private: 206 AppOpsManager mAppOpsManager; 207 208 class OpsCallback : public BnAppOpsCallback { 209 public: 210 OpsCallback(wp<BasicClient> client); 211 virtual void opChanged(int32_t op, const String16& packageName); 212 213 private: 214 wp<BasicClient> mClient; 215 216 }; // class OpsCallback 217 218 sp<OpsCallback> mOpsCallback; 219 // Track whether startCameraOps was called successfully, to avoid 220 // finishing what we didn't start. 221 bool mOpsActive; 222 223 // IAppOpsCallback interface, indirected through opListener 224 virtual void opChanged(int32_t op, const String16& packageName); 225 }; // class BasicClient 226 227 class Client : public BnCamera, public BasicClient 228 { 229 public: 230 typedef ICameraClient TCamCallbacks; 231 232 // ICamera interface (see ICamera for details) 233 virtual void disconnect(); 234 virtual status_t connect(const sp<ICameraClient>& client) = 0; 235 virtual status_t lock() = 0; 236 virtual status_t unlock() = 0; 237 virtual status_t setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer)=0; 238 virtual void setPreviewCallbackFlag(int flag) = 0; 239 virtual status_t setPreviewCallbackTarget( 240 const sp<IGraphicBufferProducer>& callbackProducer) = 0; 241 virtual status_t startPreview() = 0; 242 virtual void stopPreview() = 0; 243 virtual bool previewEnabled() = 0; 244 virtual status_t storeMetaDataInBuffers(bool enabled) = 0; 245 virtual status_t startRecording() = 0; 246 virtual void stopRecording() = 0; 247 virtual bool recordingEnabled() = 0; 248 virtual void releaseRecordingFrame(const sp<IMemory>& mem) = 0; 249 virtual status_t autoFocus() = 0; 250 virtual status_t cancelAutoFocus() = 0; 251 virtual status_t takePicture(int msgType) = 0; 252 virtual status_t setParameters(const String8& params) = 0; 253 virtual String8 getParameters() const = 0; 254 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) = 0; 255 256 // Interface used by CameraService 257 Client(const sp<CameraService>& cameraService, 258 const sp<ICameraClient>& cameraClient, 259 const String16& clientPackageName, 260 int cameraId, 261 int cameraFacing, 262 int clientPid, 263 uid_t clientUid, 264 int servicePid); 265 ~Client(); 266 267 // return our camera client 268 const sp<ICameraClient>& getRemoteCallback() { 269 return mRemoteCallback; 270 } 271 272 virtual sp<IBinder> asBinderWrapper() { 273 return asBinder(); 274 } 275 276 protected: 277 static Mutex* getClientLockFromCookie(void* user); 278 // convert client from cookie. Client lock should be acquired before getting Client. 279 static Client* getClientFromCookie(void* user); 280 281 virtual void notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode, 282 const CaptureResultExtras& resultExtras); 283 284 // Initialized in constructor 285 286 // - The app-side Binder interface to receive callbacks from us 287 sp<ICameraClient> mRemoteCallback; 288 289 }; // class Client 290 291 class ProClient : public BnProCameraUser, public BasicClient { 292 public: 293 typedef IProCameraCallbacks TCamCallbacks; 294 295 ProClient(const sp<CameraService>& cameraService, 296 const sp<IProCameraCallbacks>& remoteCallback, 297 const String16& clientPackageName, 298 int cameraId, 299 int cameraFacing, 300 int clientPid, 301 uid_t clientUid, 302 int servicePid); 303 304 virtual ~ProClient(); 305 306 const sp<IProCameraCallbacks>& getRemoteCallback() { 307 return mRemoteCallback; 308 } 309 310 /*** 311 IProCamera implementation 312 ***/ 313 virtual status_t connect(const sp<IProCameraCallbacks>& callbacks) 314 = 0; 315 virtual status_t exclusiveTryLock() = 0; 316 virtual status_t exclusiveLock() = 0; 317 virtual status_t exclusiveUnlock() = 0; 318 319 virtual bool hasExclusiveLock() = 0; 320 321 // Note that the callee gets a copy of the metadata. 322 virtual int submitRequest(camera_metadata_t* metadata, 323 bool streaming = false) = 0; 324 virtual status_t cancelRequest(int requestId) = 0; 325 326 // Callbacks from camera service 327 virtual void onExclusiveLockStolen() = 0; 328 329 protected: 330 virtual void notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode, 331 const CaptureResultExtras& resultExtras); 332 333 sp<IProCameraCallbacks> mRemoteCallback; 334 }; // class ProClient 335 336private: 337 338 // Delay-load the Camera HAL module 339 virtual void onFirstRef(); 340 341 // Step 1. Check if we can connect, before we acquire the service lock. 342 status_t validateConnect(int cameraId, 343 /*inout*/ 344 int& clientUid) const; 345 346 // Step 2. Check if we can connect, after we acquire the service lock. 347 bool canConnectUnsafe(int cameraId, 348 const String16& clientPackageName, 349 const sp<IBinder>& remoteCallback, 350 /*out*/ 351 sp<BasicClient> &client); 352 353 // When connection is successful, initialize client and track its death 354 status_t connectFinishUnsafe(const sp<BasicClient>& client, 355 const sp<IBinder>& remoteCallback); 356 357 virtual sp<BasicClient> getClientByRemote(const wp<IBinder>& cameraClient); 358 359 Mutex mServiceLock; 360 // either a Client or CameraDeviceClient 361 wp<BasicClient> mClient[MAX_CAMERAS]; // protected by mServiceLock 362 Mutex mClientLock[MAX_CAMERAS]; // prevent Client destruction inside callbacks 363 int mNumberOfCameras; 364 365 typedef wp<ProClient> weak_pro_client_ptr; 366 Vector<weak_pro_client_ptr> mProClientList[MAX_CAMERAS]; 367 368 // needs to be called with mServiceLock held 369 sp<BasicClient> findClientUnsafe(const wp<IBinder>& cameraClient, int& outIndex); 370 sp<ProClient> findProClientUnsafe( 371 const wp<IBinder>& cameraCallbacksRemote); 372 373 // atomics to record whether the hardware is allocated to some client. 374 volatile int32_t mBusy[MAX_CAMERAS]; 375 void setCameraBusy(int cameraId); 376 void setCameraFree(int cameraId); 377 378 // sounds 379 MediaPlayer* newMediaPlayer(const char *file); 380 381 Mutex mSoundLock; 382 sp<MediaPlayer> mSoundPlayer[NUM_SOUNDS]; 383 int mSoundRef; // reference count (release all MediaPlayer when 0) 384 385 camera_module_t *mModule; 386 387 Vector<sp<ICameraServiceListener> > 388 mListenerList; 389 390 // guard only mStatusList and the broadcasting of ICameraServiceListener 391 mutable Mutex mStatusMutex; 392 ICameraServiceListener::Status 393 mStatusList[MAX_CAMERAS]; 394 395 // Read the current status (locks mStatusMutex) 396 ICameraServiceListener::Status 397 getStatus(int cameraId) const; 398 399 typedef Vector<ICameraServiceListener::Status> StatusVector; 400 // Broadcast the new status if it changed (locks the service mutex) 401 void updateStatus( 402 ICameraServiceListener::Status status, 403 int32_t cameraId, 404 const StatusVector *rejectSourceStates = NULL); 405 406 // IBinder::DeathRecipient implementation 407 virtual void binderDied(const wp<IBinder> &who); 408 409 // Helpers 410 411 bool isValidCameraId(int cameraId); 412 413 bool setUpVendorTags(); 414 415 /** 416 * A mapping of camera ids to CameraParameters returned by that camera device. 417 * 418 * This cache is used to generate CameraCharacteristic metadata when using 419 * the HAL1 shim. 420 */ 421 KeyedVector<int, CameraParameters> mShimParams; 422 423 /** 424 * Initialize and cache the metadata used by the HAL1 shim for a given cameraId. 425 * 426 * Returns OK on success, or a negative error code. 427 */ 428 status_t initializeShimMetadata(int cameraId); 429 430 /** 431 * Get the cached CameraParameters for the camera. If they haven't been 432 * cached yet, then initialize them for the first time. 433 * 434 * Returns OK on success, or a negative error code. 435 */ 436 status_t getLegacyParametersLazy(int cameraId, /*out*/CameraParameters* parameters); 437 438 /** 439 * Generate the CameraCharacteristics metadata required by the Camera2 API 440 * from the available HAL1 CameraParameters and CameraInfo. 441 * 442 * Returns OK on success, or a negative error code. 443 */ 444 status_t generateShimMetadata(int cameraId, /*out*/CameraMetadata* cameraInfo); 445 446 /** 447 * Connect a new camera client. This should only be used while holding the 448 * mutex for mServiceLock. 449 * 450 * Returns OK on success, or a negative error code. 451 */ 452 status_t connectHelperLocked(const sp<ICameraClient>& cameraClient, 453 int cameraId, 454 const String16& clientPackageName, 455 int clientUid, 456 int callingPid, 457 /*out*/ 458 sp<Client>& client, 459 int halVersion = CAMERA_HAL_API_VERSION_UNSPECIFIED); 460}; 461 462} // namespace android 463 464#endif 465