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