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