CameraService.h revision 93747b9c7724f690b3068300514c05629e0b0a3e 
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 <utils/Vector.h>
22#include <binder/AppOpsManager.h>
23#include <binder/BinderService.h>
24#include <binder/IAppOpsCallback.h>
25#include <camera/ICameraService.h>
26#include <hardware/camera.h>
27
28#include <camera/ICamera.h>
29#include <camera/ICameraClient.h>
30#include <camera/IProCameraUser.h>
31#include <camera/IProCameraCallbacks.h>
32
33#include <camera/ICameraServiceListener.h>
34
35/* This needs to be increased if we can have more cameras */
36#define MAX_CAMERAS 2
37
38namespace android {
39
40extern volatile int32_t gLogLevel;
41
42class MemoryHeapBase;
43class MediaPlayer;
44
45class CameraService :
46    public BinderService<CameraService>,
47    public BnCameraService,
48    public IBinder::DeathRecipient,
49    public camera_module_callbacks_t
50{
51    friend class BinderService<CameraService>;
52public:
53    class Client;
54    class BasicClient;
55
56    // Implementation of BinderService<T>
57    static char const* getServiceName() { return "media.camera"; }
58
59                        CameraService();
60    virtual             ~CameraService();
61
62    /////////////////////////////////////////////////////////////////////
63    // HAL Callbacks
64    virtual void        onDeviceStatusChanged(int cameraId,
65                                              int newStatus);
66
67    /////////////////////////////////////////////////////////////////////
68    // ICameraService
69    virtual int32_t     getNumberOfCameras();
70    virtual status_t    getCameraInfo(int cameraId,
71                                      struct CameraInfo* cameraInfo);
72
73    virtual sp<ICamera> connect(const sp<ICameraClient>& cameraClient, int cameraId,
74            const String16& clientPackageName, int clientUid);
75    virtual sp<IProCameraUser> connect(const sp<IProCameraCallbacks>& cameraCb,
76            int cameraId, const String16& clientPackageName, int clientUid);
77
78    virtual status_t    addListener(const sp<ICameraServiceListener>& listener);
79    virtual status_t    removeListener(
80                                    const sp<ICameraServiceListener>& listener);
81
82    // Extra permissions checks
83    virtual status_t    onTransact(uint32_t code, const Parcel& data,
84                                   Parcel* reply, uint32_t flags);
85
86    virtual status_t    dump(int fd, const Vector<String16>& args);
87
88    /////////////////////////////////////////////////////////////////////
89    // Client functionality
90    virtual void        removeClientByRemote(const wp<IBinder>& remoteBinder);
91
92    enum sound_kind {
93        SOUND_SHUTTER = 0,
94        SOUND_RECORDING = 1,
95        NUM_SOUNDS
96    };
97
98    void                loadSound();
99    void                playSound(sound_kind kind);
100    void                releaseSound();
101
102
103    /////////////////////////////////////////////////////////////////////
104    // CameraClient functionality
105
106    // returns plain pointer of client. Note that mClientLock should be acquired to
107    // prevent the client from destruction. The result can be NULL.
108    virtual Client*     getClientByIdUnsafe(int cameraId);
109    virtual Mutex*      getClientLockById(int cameraId);
110
111    class BasicClient : public virtual RefBase {
112    public:
113        virtual status_t initialize(camera_module_t *module) = 0;
114
115        virtual void          disconnect() = 0;
116
117        // Return the remote callback binder object (e.g. IProCameraCallbacks)
118        wp<IBinder>     getRemote() {
119            return mRemoteBinder;
120        }
121
122    protected:
123        BasicClient(const sp<CameraService>& cameraService,
124                const sp<IBinder>& remoteCallback,
125                const String16& clientPackageName,
126                int cameraId,
127                int cameraFacing,
128                int clientPid,
129                uid_t clientUid,
130                int servicePid);
131
132        virtual ~BasicClient();
133
134        // the instance is in the middle of destruction. When this is set,
135        // the instance should not be accessed from callback.
136        // CameraService's mClientLock should be acquired to access this.
137        // - subclasses should set this to true in their destructors.
138        bool                            mDestructionStarted;
139
140        // these are initialized in the constructor.
141        sp<CameraService>               mCameraService;  // immutable after constructor
142        int                             mCameraId;       // immutable after constructor
143        int                             mCameraFacing;   // immutable after constructor
144        const String16                  mClientPackageName;
145        pid_t                           mClientPid;
146        uid_t                           mClientUid;      // immutable after constructor
147        pid_t                           mServicePid;     // immutable after constructor
148
149        // - The app-side Binder interface to receive callbacks from us
150        wp<IBinder>                     mRemoteBinder;   // immutable after constructor
151
152        // permissions management
153        status_t                        startCameraOps();
154        status_t                        finishCameraOps();
155
156        // Notify client about a fatal error
157        virtual void                    notifyError() = 0;
158    private:
159        AppOpsManager                   mAppOpsManager;
160
161        class OpsCallback : public BnAppOpsCallback {
162        public:
163            OpsCallback(wp<BasicClient> client);
164            virtual void opChanged(int32_t op, const String16& packageName);
165
166        private:
167            wp<BasicClient> mClient;
168
169        }; // class OpsCallback
170
171        sp<OpsCallback> mOpsCallback;
172        // Track whether startCameraOps was called successfully, to avoid
173        // finishing what we didn't start.
174        bool            mOpsActive;
175
176        // IAppOpsCallback interface, indirected through opListener
177        virtual void opChanged(int32_t op, const String16& packageName);
178    }; // class BasicClient
179
180    class Client : public BnCamera, public BasicClient
181    {
182    public:
183        typedef ICameraClient TCamCallbacks;
184
185        // ICamera interface (see ICamera for details)
186        virtual void          disconnect();
187        virtual status_t      connect(const sp<ICameraClient>& client) = 0;
188        virtual status_t      lock() = 0;
189        virtual status_t      unlock() = 0;
190        virtual status_t      setPreviewDisplay(const sp<Surface>& surface) = 0;
191        virtual status_t      setPreviewTexture(const sp<IGraphicBufferProducer>& bufferProducer)=0;
192        virtual void          setPreviewCallbackFlag(int flag) = 0;
193        virtual status_t      startPreview() = 0;
194        virtual void          stopPreview() = 0;
195        virtual bool          previewEnabled() = 0;
196        virtual status_t      storeMetaDataInBuffers(bool enabled) = 0;
197        virtual status_t      startRecording() = 0;
198        virtual void          stopRecording() = 0;
199        virtual bool          recordingEnabled() = 0;
200        virtual void          releaseRecordingFrame(const sp<IMemory>& mem) = 0;
201        virtual status_t      autoFocus() = 0;
202        virtual status_t      cancelAutoFocus() = 0;
203        virtual status_t      takePicture(int msgType) = 0;
204        virtual status_t      setParameters(const String8& params) = 0;
205        virtual String8       getParameters() const = 0;
206        virtual status_t      sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) = 0;
207
208        // Interface used by CameraService
209        Client(const sp<CameraService>& cameraService,
210                const sp<ICameraClient>& cameraClient,
211                const String16& clientPackageName,
212                int cameraId,
213                int cameraFacing,
214                int clientPid,
215                uid_t clientUid,
216                int servicePid);
217        ~Client();
218
219        // return our camera client
220        const sp<ICameraClient>&    getRemoteCallback() {
221            return mRemoteCallback;
222        }
223
224    protected:
225        static Mutex*        getClientLockFromCookie(void* user);
226        // convert client from cookie. Client lock should be acquired before getting Client.
227        static Client*       getClientFromCookie(void* user);
228
229        virtual void         notifyError();
230
231        // Initialized in constructor
232
233        // - The app-side Binder interface to receive callbacks from us
234        sp<ICameraClient>               mRemoteCallback;
235
236    }; // class Client
237
238    class ProClient : public BnProCameraUser, public BasicClient {
239    public:
240        typedef IProCameraCallbacks TCamCallbacks;
241
242        ProClient(const sp<CameraService>& cameraService,
243                const sp<IProCameraCallbacks>& remoteCallback,
244                const String16& clientPackageName,
245                int cameraId,
246                int cameraFacing,
247                int clientPid,
248                uid_t clientUid,
249                int servicePid);
250
251        virtual ~ProClient();
252
253        const sp<IProCameraCallbacks>& getRemoteCallback() {
254            return mRemoteCallback;
255        }
256
257        /***
258            IProCamera implementation
259         ***/
260        virtual status_t      connect(const sp<IProCameraCallbacks>& callbacks)
261                                                                            = 0;
262        virtual status_t      exclusiveTryLock() = 0;
263        virtual status_t      exclusiveLock() = 0;
264        virtual status_t      exclusiveUnlock() = 0;
265
266        virtual bool          hasExclusiveLock() = 0;
267
268        // Note that the callee gets a copy of the metadata.
269        virtual int           submitRequest(camera_metadata_t* metadata,
270                                            bool streaming = false) = 0;
271        virtual status_t      cancelRequest(int requestId) = 0;
272
273        // Callbacks from camera service
274        virtual void          onExclusiveLockStolen() = 0;
275
276    protected:
277        virtual void          notifyError();
278
279        sp<IProCameraCallbacks> mRemoteCallback;
280    }; // class ProClient
281
282private:
283
284    // Delay-load the Camera HAL module
285    virtual void onFirstRef();
286
287    // Step 1. Check if we can connect, before we acquire the service lock.
288    bool                validateConnect(int cameraId,
289                                        /*inout*/
290                                        int& clientUid) const;
291
292    // Step 2. Check if we can connect, after we acquire the service lock.
293    bool                canConnectUnsafe(int cameraId,
294                                         const String16& clientPackageName,
295                                         const sp<IBinder>& remoteCallback,
296                                         /*out*/
297                                         sp<Client> &client);
298
299    // When connection is successful, initialize client and track its death
300    bool                connectFinishUnsafe(const sp<BasicClient>& client,
301                                            const sp<IBinder>& clientBinder);
302
303    virtual sp<BasicClient>  getClientByRemote(const wp<IBinder>& cameraClient);
304
305    Mutex               mServiceLock;
306    wp<Client>          mClient[MAX_CAMERAS];  // protected by mServiceLock
307    Mutex               mClientLock[MAX_CAMERAS]; // prevent Client destruction inside callbacks
308    int                 mNumberOfCameras;
309
310    typedef wp<ProClient> weak_pro_client_ptr;
311    Vector<weak_pro_client_ptr> mProClientList[MAX_CAMERAS];
312
313    // needs to be called with mServiceLock held
314    sp<Client>          findClientUnsafe(const wp<IBinder>& cameraClient, int& outIndex);
315    sp<ProClient>       findProClientUnsafe(
316                                     const wp<IBinder>& cameraCallbacksRemote);
317
318    // atomics to record whether the hardware is allocated to some client.
319    volatile int32_t    mBusy[MAX_CAMERAS];
320    void                setCameraBusy(int cameraId);
321    void                setCameraFree(int cameraId);
322
323    // sounds
324    MediaPlayer*        newMediaPlayer(const char *file);
325
326    Mutex               mSoundLock;
327    sp<MediaPlayer>     mSoundPlayer[NUM_SOUNDS];
328    int                 mSoundRef;  // reference count (release all MediaPlayer when 0)
329
330    camera_module_t *mModule;
331
332    Vector<sp<ICameraServiceListener> >
333                        mListenerList;
334
335    // guard only mStatusList and the broadcasting of ICameraServiceListener
336    mutable Mutex       mStatusMutex;
337    ICameraServiceListener::Status
338                        mStatusList[MAX_CAMERAS];
339
340    // Read the current status (locks mStatusMutex)
341    ICameraServiceListener::Status
342                        getStatus(int cameraId) const;
343
344    typedef Vector<ICameraServiceListener::Status> StatusVector;
345    // Broadcast the new status if it changed (locks the service mutex)
346    void                updateStatus(
347                            ICameraServiceListener::Status status,
348                            int32_t cameraId,
349                            const StatusVector *rejectSourceStates = NULL);
350
351    // IBinder::DeathRecipient implementation
352    virtual void        binderDied(const wp<IBinder> &who);
353
354    // Helpers
355    int                 getDeviceVersion(int cameraId, int* facing);
356
357    bool                isValidCameraId(int cameraId);
358};
359
360} // namespace android
361
362#endif
363