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