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