CameraService.h revision 08ad5efcef90e24db2863c0f85972ed05fe848a2
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 <binder/BinderService.h> 22#include <camera/ICameraService.h> 23#include <hardware/camera.h> 24 25/* This needs to be increased if we can have more cameras */ 26#define MAX_CAMERAS 2 27 28namespace android { 29 30class MemoryHeapBase; 31class MediaPlayer; 32class CameraHardwareInterface; 33 34class CameraService : 35 public BinderService<CameraService>, 36 public BnCameraService 37{ 38 class Client; 39 friend class BinderService<CameraService>; 40public: 41 static char const* getServiceName() { return "media.camera"; } 42 43 CameraService(); 44 virtual ~CameraService(); 45 46 virtual int32_t getNumberOfCameras(); 47 virtual status_t getCameraInfo(int cameraId, 48 struct CameraInfo* cameraInfo); 49 virtual sp<ICamera> connect(const sp<ICameraClient>& cameraClient, int cameraId); 50 virtual void removeClient(const sp<ICameraClient>& cameraClient); 51 // returns plain pointer of client. Note that mClientLock should be acquired to 52 // prevent the client from destruction. The result can be NULL. 53 virtual Client* getClientByIdUnsafe(int cameraId); 54 virtual Mutex* getClientLockById(int cameraId); 55 56 virtual status_t dump(int fd, const Vector<String16>& args); 57 virtual status_t onTransact(uint32_t code, const Parcel& data, 58 Parcel* reply, uint32_t flags); 59 virtual void onFirstRef(); 60 61 enum sound_kind { 62 SOUND_SHUTTER = 0, 63 SOUND_RECORDING = 1, 64 NUM_SOUNDS 65 }; 66 67 void loadSound(); 68 void playSound(sound_kind kind); 69 void releaseSound(); 70 71private: 72 Mutex mServiceLock; 73 wp<Client> mClient[MAX_CAMERAS]; // protected by mServiceLock 74 Mutex mClientLock[MAX_CAMERAS]; // prevent Client destruction inside callbacks 75 int mNumberOfCameras; 76 77 // atomics to record whether the hardware is allocated to some client. 78 volatile int32_t mBusy[MAX_CAMERAS]; 79 void setCameraBusy(int cameraId); 80 void setCameraFree(int cameraId); 81 82 // sounds 83 MediaPlayer* newMediaPlayer(const char *file); 84 85 Mutex mSoundLock; 86 sp<MediaPlayer> mSoundPlayer[NUM_SOUNDS]; 87 int mSoundRef; // reference count (release all MediaPlayer when 0) 88 89 class Client : public BnCamera 90 { 91 public: 92 // ICamera interface (see ICamera for details) 93 virtual void disconnect(); 94 virtual status_t connect(const sp<ICameraClient>& client); 95 virtual status_t lock(); 96 virtual status_t unlock(); 97 virtual status_t setPreviewDisplay(const sp<Surface>& surface); 98 virtual status_t setPreviewTexture(const sp<ISurfaceTexture>& surfaceTexture); 99 virtual void setPreviewCallbackFlag(int flag); 100 virtual status_t startPreview(); 101 virtual void stopPreview(); 102 virtual bool previewEnabled(); 103 virtual status_t storeMetaDataInBuffers(bool enabled); 104 virtual status_t startRecording(); 105 virtual void stopRecording(); 106 virtual bool recordingEnabled(); 107 virtual void releaseRecordingFrame(const sp<IMemory>& mem); 108 virtual status_t autoFocus(); 109 virtual status_t cancelAutoFocus(); 110 virtual status_t takePicture(int msgType); 111 virtual status_t setParameters(const String8& params); 112 virtual String8 getParameters() const; 113 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2); 114 private: 115 friend class CameraService; 116 Client(const sp<CameraService>& cameraService, 117 const sp<ICameraClient>& cameraClient, 118 const sp<CameraHardwareInterface>& hardware, 119 int cameraId, 120 int cameraFacing, 121 int clientPid); 122 ~Client(); 123 124 // return our camera client 125 const sp<ICameraClient>& getCameraClient() { return mCameraClient; } 126 127 // check whether the calling process matches mClientPid. 128 status_t checkPid() const; 129 status_t checkPidAndHardware() const; // also check mHardware != 0 130 131 // these are internal functions used to set up preview buffers 132 status_t registerPreviewBuffers(); 133 134 // camera operation mode 135 enum camera_mode { 136 CAMERA_PREVIEW_MODE = 0, // frame automatically released 137 CAMERA_RECORDING_MODE = 1, // frame has to be explicitly released by releaseRecordingFrame() 138 }; 139 // these are internal functions used for preview/recording 140 status_t startCameraMode(camera_mode mode); 141 status_t startPreviewMode(); 142 status_t startRecordingMode(); 143 144 // internal function used by sendCommand to enable/disable shutter sound. 145 status_t enableShutterSound(bool enable); 146 147 // these are static callback functions 148 static void notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2, void* user); 149 static void dataCallback(int32_t msgType, const sp<IMemory>& dataPtr, 150 camera_frame_metadata_t *metadata, void* user); 151 static void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr, void* user); 152 static Mutex* getClientLockFromCookie(void* user); 153 // convert client from cookie. Client lock should be acquired before getting Client. 154 static Client* getClientFromCookie(void* user); 155 // handlers for messages 156 void handleShutter(void); 157 void handlePreviewData(int32_t msgType, const sp<IMemory>& mem, 158 camera_frame_metadata_t *metadata); 159 void handlePostview(const sp<IMemory>& mem); 160 void handleRawPicture(const sp<IMemory>& mem); 161 void handleCompressedPicture(const sp<IMemory>& mem); 162 void handleGenericNotify(int32_t msgType, int32_t ext1, int32_t ext2); 163 void handleGenericData(int32_t msgType, const sp<IMemory>& dataPtr, 164 camera_frame_metadata_t *metadata); 165 void handleGenericDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr); 166 167 void copyFrameAndPostCopiedFrame( 168 int32_t msgType, 169 const sp<ICameraClient>& client, 170 const sp<IMemoryHeap>& heap, 171 size_t offset, size_t size, 172 camera_frame_metadata_t *metadata); 173 174 int getOrientation(int orientation, bool mirror); 175 176 status_t setPreviewWindow( 177 const sp<IBinder>& binder, 178 const sp<ANativeWindow>& window); 179 180 // these are initialized in the constructor. 181 sp<CameraService> mCameraService; // immutable after constructor 182 sp<ICameraClient> mCameraClient; 183 int mCameraId; // immutable after constructor 184 int mCameraFacing; // immutable after constructor 185 pid_t mClientPid; 186 sp<CameraHardwareInterface> mHardware; // cleared after disconnect() 187 int mPreviewCallbackFlag; 188 int mOrientation; // Current display orientation 189 bool mPlayShutterSound; 190 191 // Ensures atomicity among the public methods 192 mutable Mutex mLock; 193 // This is a binder of Surface or SurfaceTexture. 194 sp<IBinder> mSurface; 195 sp<ANativeWindow> mPreviewWindow; 196 197 // If the user want us to return a copy of the preview frame (instead 198 // of the original one), we allocate mPreviewBuffer and reuse it if possible. 199 sp<MemoryHeapBase> mPreviewBuffer; 200 201 // the instance is in the middle of destruction. When this is set, 202 // the instance should not be accessed from callback. 203 // CameraService's mClientLock should be acquired to access this. 204 bool mDestructionStarted; 205 206 // We need to avoid the deadlock when the incoming command thread and 207 // the CameraHardwareInterface callback thread both want to grab mLock. 208 // An extra flag is used to tell the callback thread that it should stop 209 // trying to deliver the callback messages if the client is not 210 // interested in it anymore. For example, if the client is calling 211 // stopPreview(), the preview frame messages do not need to be delivered 212 // anymore. 213 214 // This function takes the same parameter as the enableMsgType() and 215 // disableMsgType() functions in CameraHardwareInterface. 216 void enableMsgType(int32_t msgType); 217 void disableMsgType(int32_t msgType); 218 volatile int32_t mMsgEnabled; 219 220 // This function keeps trying to grab mLock, or give up if the message 221 // is found to be disabled. It returns true if mLock is grabbed. 222 bool lockIfMessageWanted(int32_t msgType); 223 }; 224 225 camera_module_t *mModule; 226}; 227 228} // namespace android 229 230#endif 231