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