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