CameraService.h revision b2119af7f4ced0ecfefd4c7388f86b4e3a3ea7d8
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 connectPro(const sp<IProCameraCallbacks>& cameraCb, 87 int cameraId, const String16& clientPackageName, int clientUid, 88 /*out*/ 89 sp<IProCameraUser>& device); 90 91 virtual status_t connectDevice( 92 const sp<ICameraDeviceCallbacks>& cameraCb, 93 int cameraId, 94 const String16& clientPackageName, 95 int clientUid, 96 /*out*/ 97 sp<ICameraDeviceUser>& device); 98 99 virtual status_t addListener(const sp<ICameraServiceListener>& listener); 100 virtual status_t removeListener( 101 const sp<ICameraServiceListener>& listener); 102 103 // Extra permissions checks 104 virtual status_t onTransact(uint32_t code, const Parcel& data, 105 Parcel* reply, uint32_t flags); 106 107 virtual status_t dump(int fd, const Vector<String16>& args); 108 109 ///////////////////////////////////////////////////////////////////// 110 // Client functionality 111 virtual void removeClientByRemote(const wp<IBinder>& remoteBinder); 112 113 enum sound_kind { 114 SOUND_SHUTTER = 0, 115 SOUND_RECORDING = 1, 116 NUM_SOUNDS 117 }; 118 119 void loadSound(); 120 void playSound(sound_kind kind); 121 void releaseSound(); 122 123 ///////////////////////////////////////////////////////////////////// 124 // CameraDeviceFactory functionality 125 int getDeviceVersion(int cameraId, int* facing = NULL); 126 127 128 ///////////////////////////////////////////////////////////////////// 129 // CameraClient functionality 130 131 // returns plain pointer of client. Note that mClientLock should be acquired to 132 // prevent the client from destruction. The result can be NULL. 133 virtual BasicClient* getClientByIdUnsafe(int cameraId); 134 virtual Mutex* getClientLockById(int cameraId); 135 136 class BasicClient : public virtual RefBase { 137 public: 138 virtual status_t initialize(camera_module_t *module) = 0; 139 140 virtual void disconnect() = 0; 141 142 // because we can't virtually inherit IInterface, which breaks 143 // virtual inheritance 144 virtual sp<IBinder> asBinderWrapper() = 0; 145 146 // Return the remote callback binder object (e.g. IProCameraCallbacks) 147 sp<IBinder> getRemote() { 148 return mRemoteBinder; 149 } 150 151 virtual status_t dump(int fd, const Vector<String16>& args) = 0; 152 153 protected: 154 BasicClient(const sp<CameraService>& cameraService, 155 const sp<IBinder>& remoteCallback, 156 const String16& clientPackageName, 157 int cameraId, 158 int cameraFacing, 159 int clientPid, 160 uid_t clientUid, 161 int servicePid); 162 163 virtual ~BasicClient(); 164 165 // the instance is in the middle of destruction. When this is set, 166 // the instance should not be accessed from callback. 167 // CameraService's mClientLock should be acquired to access this. 168 // - subclasses should set this to true in their destructors. 169 bool mDestructionStarted; 170 171 // these are initialized in the constructor. 172 sp<CameraService> mCameraService; // immutable after constructor 173 int mCameraId; // immutable after constructor 174 int mCameraFacing; // immutable after constructor 175 const String16 mClientPackageName; 176 pid_t mClientPid; 177 uid_t mClientUid; // immutable after constructor 178 pid_t mServicePid; // immutable after constructor 179 180 // - The app-side Binder interface to receive callbacks from us 181 sp<IBinder> mRemoteBinder; // immutable after constructor 182 183 // permissions management 184 status_t startCameraOps(); 185 status_t finishCameraOps(); 186 187 // Notify client about a fatal error 188 virtual void notifyError( 189 ICameraDeviceCallbacks::CameraErrorCode errorCode, 190 const CaptureResultExtras& resultExtras) = 0; 191 private: 192 AppOpsManager mAppOpsManager; 193 194 class OpsCallback : public BnAppOpsCallback { 195 public: 196 OpsCallback(wp<BasicClient> client); 197 virtual void opChanged(int32_t op, const String16& packageName); 198 199 private: 200 wp<BasicClient> mClient; 201 202 }; // class OpsCallback 203 204 sp<OpsCallback> mOpsCallback; 205 // Track whether startCameraOps was called successfully, to avoid 206 // finishing what we didn't start. 207 bool mOpsActive; 208 209 // IAppOpsCallback interface, indirected through opListener 210 virtual void opChanged(int32_t op, const String16& packageName); 211 }; // class BasicClient 212 213 class Client : public BnCamera, public BasicClient 214 { 215 public: 216 typedef ICameraClient TCamCallbacks; 217 218 // ICamera interface (see ICamera for details) 219 virtual void disconnect(); 220 virtual status_t connect(const sp<ICameraClient>& client) = 0; 221 virtual status_t lock() = 0; 222 virtual status_t unlock() = 0; 223 virtual status_t setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer)=0; 224 virtual void setPreviewCallbackFlag(int flag) = 0; 225 virtual status_t setPreviewCallbackTarget( 226 const sp<IGraphicBufferProducer>& callbackProducer) = 0; 227 virtual status_t startPreview() = 0; 228 virtual void stopPreview() = 0; 229 virtual bool previewEnabled() = 0; 230 virtual status_t storeMetaDataInBuffers(bool enabled) = 0; 231 virtual status_t startRecording() = 0; 232 virtual void stopRecording() = 0; 233 virtual bool recordingEnabled() = 0; 234 virtual void releaseRecordingFrame(const sp<IMemory>& mem) = 0; 235 virtual status_t autoFocus() = 0; 236 virtual status_t cancelAutoFocus() = 0; 237 virtual status_t takePicture(int msgType) = 0; 238 virtual status_t setParameters(const String8& params) = 0; 239 virtual String8 getParameters() const = 0; 240 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) = 0; 241 242 // Interface used by CameraService 243 Client(const sp<CameraService>& cameraService, 244 const sp<ICameraClient>& cameraClient, 245 const String16& clientPackageName, 246 int cameraId, 247 int cameraFacing, 248 int clientPid, 249 uid_t clientUid, 250 int servicePid); 251 ~Client(); 252 253 // return our camera client 254 const sp<ICameraClient>& getRemoteCallback() { 255 return mRemoteCallback; 256 } 257 258 virtual sp<IBinder> asBinderWrapper() { 259 return asBinder(); 260 } 261 262 protected: 263 static Mutex* getClientLockFromCookie(void* user); 264 // convert client from cookie. Client lock should be acquired before getting Client. 265 static Client* getClientFromCookie(void* user); 266 267 virtual void notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode, 268 const CaptureResultExtras& resultExtras); 269 270 // Initialized in constructor 271 272 // - The app-side Binder interface to receive callbacks from us 273 sp<ICameraClient> mRemoteCallback; 274 275 }; // class Client 276 277 class ProClient : public BnProCameraUser, public BasicClient { 278 public: 279 typedef IProCameraCallbacks TCamCallbacks; 280 281 ProClient(const sp<CameraService>& cameraService, 282 const sp<IProCameraCallbacks>& remoteCallback, 283 const String16& clientPackageName, 284 int cameraId, 285 int cameraFacing, 286 int clientPid, 287 uid_t clientUid, 288 int servicePid); 289 290 virtual ~ProClient(); 291 292 const sp<IProCameraCallbacks>& getRemoteCallback() { 293 return mRemoteCallback; 294 } 295 296 /*** 297 IProCamera implementation 298 ***/ 299 virtual status_t connect(const sp<IProCameraCallbacks>& callbacks) 300 = 0; 301 virtual status_t exclusiveTryLock() = 0; 302 virtual status_t exclusiveLock() = 0; 303 virtual status_t exclusiveUnlock() = 0; 304 305 virtual bool hasExclusiveLock() = 0; 306 307 // Note that the callee gets a copy of the metadata. 308 virtual int submitRequest(camera_metadata_t* metadata, 309 bool streaming = false) = 0; 310 virtual status_t cancelRequest(int requestId) = 0; 311 312 // Callbacks from camera service 313 virtual void onExclusiveLockStolen() = 0; 314 315 protected: 316 virtual void notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode, 317 const CaptureResultExtras& resultExtras); 318 319 sp<IProCameraCallbacks> mRemoteCallback; 320 }; // class ProClient 321 322private: 323 324 // Delay-load the Camera HAL module 325 virtual void onFirstRef(); 326 327 // Step 1. Check if we can connect, before we acquire the service lock. 328 status_t validateConnect(int cameraId, 329 /*inout*/ 330 int& clientUid) const; 331 332 // Step 2. Check if we can connect, after we acquire the service lock. 333 bool canConnectUnsafe(int cameraId, 334 const String16& clientPackageName, 335 const sp<IBinder>& remoteCallback, 336 /*out*/ 337 sp<BasicClient> &client); 338 339 // When connection is successful, initialize client and track its death 340 status_t connectFinishUnsafe(const sp<BasicClient>& client, 341 const sp<IBinder>& remoteCallback); 342 343 virtual sp<BasicClient> getClientByRemote(const wp<IBinder>& cameraClient); 344 345 Mutex mServiceLock; 346 // either a Client or CameraDeviceClient 347 wp<BasicClient> mClient[MAX_CAMERAS]; // protected by mServiceLock 348 Mutex mClientLock[MAX_CAMERAS]; // prevent Client destruction inside callbacks 349 int mNumberOfCameras; 350 351 typedef wp<ProClient> weak_pro_client_ptr; 352 Vector<weak_pro_client_ptr> mProClientList[MAX_CAMERAS]; 353 354 // needs to be called with mServiceLock held 355 sp<BasicClient> findClientUnsafe(const wp<IBinder>& cameraClient, int& outIndex); 356 sp<ProClient> findProClientUnsafe( 357 const wp<IBinder>& cameraCallbacksRemote); 358 359 // atomics to record whether the hardware is allocated to some client. 360 volatile int32_t mBusy[MAX_CAMERAS]; 361 void setCameraBusy(int cameraId); 362 void setCameraFree(int cameraId); 363 364 // sounds 365 MediaPlayer* newMediaPlayer(const char *file); 366 367 Mutex mSoundLock; 368 sp<MediaPlayer> mSoundPlayer[NUM_SOUNDS]; 369 int mSoundRef; // reference count (release all MediaPlayer when 0) 370 371 camera_module_t *mModule; 372 373 Vector<sp<ICameraServiceListener> > 374 mListenerList; 375 376 // guard only mStatusList and the broadcasting of ICameraServiceListener 377 mutable Mutex mStatusMutex; 378 ICameraServiceListener::Status 379 mStatusList[MAX_CAMERAS]; 380 381 // Read the current status (locks mStatusMutex) 382 ICameraServiceListener::Status 383 getStatus(int cameraId) const; 384 385 typedef Vector<ICameraServiceListener::Status> StatusVector; 386 // Broadcast the new status if it changed (locks the service mutex) 387 void updateStatus( 388 ICameraServiceListener::Status status, 389 int32_t cameraId, 390 const StatusVector *rejectSourceStates = NULL); 391 392 // IBinder::DeathRecipient implementation 393 virtual void binderDied(const wp<IBinder> &who); 394 395 // Helpers 396 397 bool isValidCameraId(int cameraId); 398 399 bool setUpVendorTags(); 400 401 /** 402 * A mapping of camera ids to CameraParameters returned by that camera device. 403 * 404 * This cache is used to generate CameraCharacteristic metadata when using 405 * the HAL1 shim. 406 */ 407 KeyedVector<int, CameraParameters> mShimParams; 408 409 /** 410 * Initialize and cache the metadata used by the HAL1 shim for a given cameraId. 411 * 412 * Returns OK on success, or a negative error code. 413 */ 414 status_t initializeShimMetadata(int cameraId); 415 416 /** 417 * Generate the CameraCharacteristics metadata required by the Camera2 API 418 * from the available HAL1 CameraParameters and CameraInfo. 419 * 420 * Returns OK on success, or a negative error code. 421 */ 422 status_t generateShimMetadata(int cameraId, /*out*/CameraMetadata* cameraInfo); 423 424 /** 425 * Connect a new camera client. This should only be used while holding the 426 * mutex for mServiceLock. 427 * 428 * Returns OK on success, or a negative error code. 429 */ 430 status_t connectHelperLocked(const sp<ICameraClient>& cameraClient, 431 int cameraId, 432 const String16& clientPackageName, 433 int clientUid, 434 int callingPid, 435 /*out*/ 436 sp<Client>& client); 437}; 438 439} // namespace android 440 441#endif 442