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