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