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