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