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