/* ** ** Copyright (C) 2008, The Android Open Source Project ** Copyright (C) 2008 HTC Inc. ** ** Licensed under the Apache License, Version 2.0 (the "License"); ** you may not use this file except in compliance with the License. ** You may obtain a copy of the License at ** ** http://www.apache.org/licenses/LICENSE-2.0 ** ** Unless required by applicable law or agreed to in writing, software ** distributed under the License is distributed on an "AS IS" BASIS, ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** See the License for the specific language governing permissions and ** limitations under the License. */ #ifndef ANDROID_SERVERS_CAMERA_CAMERASERVICE_H #define ANDROID_SERVERS_CAMERA_CAMERASERVICE_H #include #include /* This needs to be increased if we can have more cameras */ #define MAX_CAMERAS 2 namespace android { class MemoryHeapBase; class MediaPlayer; class CameraService: public BnCameraService { class Client; public: static void instantiate(); CameraService(); virtual ~CameraService(); virtual int32_t getNumberOfCameras(); virtual status_t getCameraInfo(int cameraId, struct CameraInfo* cameraInfo); virtual sp connect(const sp& cameraClient, int cameraId); virtual void removeClient(const sp& cameraClient); virtual sp getClientById(int cameraId); virtual status_t dump(int fd, const Vector& args); virtual status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); enum sound_kind { SOUND_SHUTTER = 0, SOUND_RECORDING = 1, NUM_SOUNDS }; void loadSound(); void playSound(sound_kind kind); void releaseSound(); private: Mutex mServiceLock; wp mClient[MAX_CAMERAS]; // protected by mServiceLock int mNumberOfCameras; // atomics to record whether the hardware is allocated to some client. volatile int32_t mBusy[MAX_CAMERAS]; void setCameraBusy(int cameraId); void setCameraFree(int cameraId); // sounds Mutex mSoundLock; sp mSoundPlayer[NUM_SOUNDS]; int mSoundRef; // reference count (release all MediaPlayer when 0) class Client : public BnCamera { public: // ICamera interface (see ICamera for details) virtual void disconnect(); virtual status_t connect(const sp& client); virtual status_t lock(); virtual status_t unlock(); virtual status_t setPreviewDisplay(const sp& surface); virtual void setPreviewCallbackFlag(int flag); virtual status_t startPreview(); virtual void stopPreview(); virtual bool previewEnabled(); virtual status_t startRecording(); virtual void stopRecording(); virtual bool recordingEnabled(); virtual void releaseRecordingFrame(const sp& mem); virtual status_t autoFocus(); virtual status_t cancelAutoFocus(); virtual status_t takePicture(); virtual status_t setParameters(const String8& params); virtual String8 getParameters() const; virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2); private: friend class CameraService; Client(const sp& cameraService, const sp& cameraClient, int cameraId, int clientPid); ~Client(); // return our camera client const sp& getCameraClient() { return mCameraClient; } // check whether the calling process matches mClientPid. status_t checkPid() const; status_t checkPidAndHardware() const; // also check mHardware != 0 // these are internal functions used to set up preview buffers status_t registerPreviewBuffers(); status_t setOverlay(); // camera operation mode enum camera_mode { CAMERA_PREVIEW_MODE = 0, // frame automatically released CAMERA_RECORDING_MODE = 1, // frame has to be explicitly released by releaseRecordingFrame() }; // these are internal functions used for preview/recording status_t startCameraMode(camera_mode mode); status_t startPreviewMode(); status_t startRecordingMode(); // these are static callback functions static void notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2, void* user); static void dataCallback(int32_t msgType, const sp& dataPtr, void* user); static void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp& dataPtr, void* user); // convert client from cookie static sp getClientFromCookie(void* user); // handlers for messages void handleShutter(image_rect_type *size); void handlePreviewData(const sp& mem); void handlePostview(const sp& mem); void handleRawPicture(const sp& mem); void handleCompressedPicture(const sp& mem); void handleGenericNotify(int32_t msgType, int32_t ext1, int32_t ext2); void handleGenericData(int32_t msgType, const sp& dataPtr); void handleGenericDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp& dataPtr); void copyFrameAndPostCopiedFrame( const sp& client, const sp& heap, size_t offset, size_t size); // these are initialized in the constructor. sp mCameraService; // immutable after constructor sp mCameraClient; int mCameraId; // immutable after constructor pid_t mClientPid; sp mHardware; // cleared after disconnect() bool mUseOverlay; // immutable after constructor sp mOverlayRef; int mOverlayW; int mOverlayH; int mPreviewCallbackFlag; int mOrientation; // Ensures atomicity among the public methods mutable Mutex mLock; sp mSurface; // If the user want us to return a copy of the preview frame (instead // of the original one), we allocate mPreviewBuffer and reuse it if possible. sp mPreviewBuffer; // We need to avoid the deadlock when the incoming command thread and // the CameraHardwareInterface callback thread both want to grab mLock. // An extra flag is used to tell the callback thread that it should stop // trying to deliver the callback messages if the client is not // interested in it anymore. For example, if the client is calling // stopPreview(), the preview frame messages do not need to be delivered // anymore. // This function takes the same parameter as the enableMsgType() and // disableMsgType() functions in CameraHardwareInterface. void enableMsgType(int32_t msgType); void disableMsgType(int32_t msgType); volatile int32_t mMsgEnabled; // This function keeps trying to grab mLock, or give up if the message // is found to be disabled. It returns true if mLock is grabbed. bool lockIfMessageWanted(int32_t msgType); }; }; } // namespace android #endif