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
30extern volatile int32_t gLogLevel;
31
32class MemoryHeapBase;
33class MediaPlayer;
34
35class CameraService :
36    public BinderService<CameraService>,
37    public BnCameraService,
38    public IBinder::DeathRecipient
39{
40    friend class BinderService<CameraService>;
41public:
42    class Client;
43    static char const* getServiceName() { return "media.camera"; }
44
45                        CameraService();
46    virtual             ~CameraService();
47
48    virtual int32_t     getNumberOfCameras();
49    virtual status_t    getCameraInfo(int cameraId,
50                                      struct CameraInfo* cameraInfo);
51    virtual sp<ICamera> connect(const sp<ICameraClient>& cameraClient, int cameraId);
52    virtual void        removeClient(const sp<ICameraClient>& cameraClient);
53    // returns plain pointer of client. Note that mClientLock should be acquired to
54    // prevent the client from destruction. The result can be NULL.
55    virtual Client*     getClientByIdUnsafe(int cameraId);
56    virtual Mutex*      getClientLockById(int cameraId);
57
58    virtual sp<Client>  getClientByRemote(const wp<IBinder>& cameraClient);
59
60    virtual status_t    dump(int fd, const Vector<String16>& args);
61    virtual status_t    onTransact(uint32_t code, const Parcel& data,
62                                   Parcel* reply, uint32_t flags);
63    virtual void onFirstRef();
64
65    enum sound_kind {
66        SOUND_SHUTTER = 0,
67        SOUND_RECORDING = 1,
68        NUM_SOUNDS
69    };
70
71    void                loadSound();
72    void                playSound(sound_kind kind);
73    void                releaseSound();
74
75    class Client : public BnCamera
76    {
77    public:
78        // ICamera interface (see ICamera for details)
79        virtual void          disconnect();
80        virtual status_t      connect(const sp<ICameraClient>& client) = 0;
81        virtual status_t      lock() = 0;
82        virtual status_t      unlock() = 0;
83        virtual status_t      setPreviewDisplay(const sp<Surface>& surface) = 0;
84        virtual status_t      setPreviewTexture(const sp<ISurfaceTexture>& surfaceTexture) = 0;
85        virtual void          setPreviewCallbackFlag(int flag) = 0;
86        virtual status_t      startPreview() = 0;
87        virtual void          stopPreview() = 0;
88        virtual bool          previewEnabled() = 0;
89        virtual status_t      storeMetaDataInBuffers(bool enabled) = 0;
90        virtual status_t      startRecording() = 0;
91        virtual void          stopRecording() = 0;
92        virtual bool          recordingEnabled() = 0;
93        virtual void          releaseRecordingFrame(const sp<IMemory>& mem) = 0;
94        virtual status_t      autoFocus() = 0;
95        virtual status_t      cancelAutoFocus() = 0;
96        virtual status_t      takePicture(int msgType) = 0;
97        virtual status_t      setParameters(const String8& params) = 0;
98        virtual String8       getParameters() const = 0;
99        virtual status_t      sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) = 0;
100
101        // Interface used by CameraService
102        Client(const sp<CameraService>& cameraService,
103                const sp<ICameraClient>& cameraClient,
104                int cameraId,
105                int cameraFacing,
106                int clientPid,
107                int servicePid);
108        ~Client();
109
110        // return our camera client
111        const sp<ICameraClient>&    getCameraClient() {
112            return mCameraClient;
113        }
114
115        virtual status_t initialize(camera_module_t *module) = 0;
116
117        virtual status_t dump(int fd, const Vector<String16>& args) = 0;
118
119    protected:
120        static Mutex*        getClientLockFromCookie(void* user);
121        // convert client from cookie. Client lock should be acquired before getting Client.
122        static Client*       getClientFromCookie(void* user);
123
124        // the instance is in the middle of destruction. When this is set,
125        // the instance should not be accessed from callback.
126        // CameraService's mClientLock should be acquired to access this.
127        bool                            mDestructionStarted;
128
129        // these are initialized in the constructor.
130        sp<CameraService>               mCameraService;  // immutable after constructor
131        sp<ICameraClient>               mCameraClient;
132        int                             mCameraId;       // immutable after constructor
133        int                             mCameraFacing;   // immutable after constructor
134        pid_t                           mClientPid;
135        pid_t                           mServicePid;     // immutable after constructor
136
137    };
138
139private:
140    Mutex               mServiceLock;
141    wp<Client>          mClient[MAX_CAMERAS];  // protected by mServiceLock
142    Mutex               mClientLock[MAX_CAMERAS]; // prevent Client destruction inside callbacks
143    int                 mNumberOfCameras;
144
145    // needs to be called with mServiceLock held
146    sp<Client>          findClientUnsafe(const wp<IBinder>& cameraClient, int& outIndex);
147
148    // atomics to record whether the hardware is allocated to some client.
149    volatile int32_t    mBusy[MAX_CAMERAS];
150    void                setCameraBusy(int cameraId);
151    void                setCameraFree(int cameraId);
152
153    // sounds
154    MediaPlayer*        newMediaPlayer(const char *file);
155
156    Mutex               mSoundLock;
157    sp<MediaPlayer>     mSoundPlayer[NUM_SOUNDS];
158    int                 mSoundRef;  // reference count (release all MediaPlayer when 0)
159
160    camera_module_t *mModule;
161
162    // IBinder::DeathRecipient implementation
163    virtual void binderDied(const wp<IBinder> &who);
164};
165
166} // namespace android
167
168#endif
169