diff options
author | The Android Open Source Project <initial-contribution@android.com> | 2009-03-03 19:31:44 -0800 |
---|---|---|
committer | The Android Open Source Project <initial-contribution@android.com> | 2009-03-03 19:31:44 -0800 |
commit | edbf3b6af777b721cd2a1ef461947e51e88241e1 (patch) | |
tree | f09427b843b192cccf8c3b5328cb81dddf6489fa /camera/libcameraservice/CameraService.h | |
parent | d5193d9394c5e58176d7bcdf50ef017f8a3b9e1e (diff) | |
download | frameworks_native-edbf3b6af777b721cd2a1ef461947e51e88241e1.zip frameworks_native-edbf3b6af777b721cd2a1ef461947e51e88241e1.tar.gz frameworks_native-edbf3b6af777b721cd2a1ef461947e51e88241e1.tar.bz2 |
auto import from //depot/cupcake/@135843
Diffstat (limited to 'camera/libcameraservice/CameraService.h')
-rw-r--r-- | camera/libcameraservice/CameraService.h | 206 |
1 files changed, 206 insertions, 0 deletions
diff --git a/camera/libcameraservice/CameraService.h b/camera/libcameraservice/CameraService.h new file mode 100644 index 0000000..d9b7927 --- /dev/null +++ b/camera/libcameraservice/CameraService.h @@ -0,0 +1,206 @@ +/* +** +** 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 <ui/ICameraService.h> +#include <ui/CameraHardwareInterface.h> +#include <ui/Camera.h> + +class android::MemoryHeapBase; + +namespace android { + +// ---------------------------------------------------------------------------- + +#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) +#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) + +// When enabled, this feature allows you to send an event to the CameraService +// so that you can cause all references to the heap object gWeakHeap, defined +// below, to be printed. You will also need to set DEBUG_REFS=1 and +// DEBUG_REFS_ENABLED_BY_DEFAULT=0 in libutils/RefBase.cpp. You just have to +// set gWeakHeap to the appropriate heap you want to track. + +#define DEBUG_HEAP_LEAKS 0 + +// ---------------------------------------------------------------------------- + +class CameraService : public BnCameraService +{ + class Client; + +public: + static void instantiate(); + + // ICameraService interface + virtual sp<ICamera> connect(const sp<ICameraClient>& cameraClient); + + virtual status_t dump(int fd, const Vector<String16>& args); + + void removeClient(const sp<ICameraClient>& cameraClient); + +#if DEBUG_HEAP_LEAKS + virtual status_t onTransact( + uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); +#endif + +private: + +// ---------------------------------------------------------------------------- + + class Client : public BnCamera { + + public: + virtual void disconnect(); + + // connect new client with existing camera remote + virtual status_t connect(const sp<ICameraClient>& client); + + // prevent other processes from using this ICamera interface + virtual status_t lock(); + + // allow other processes to use this ICamera interface + virtual status_t unlock(); + + // pass the buffered ISurface to the camera service + virtual status_t setPreviewDisplay(const sp<ISurface>& surface); + + // set the preview callback flag to affect how the received frames from + // preview are handled. + virtual void setPreviewCallbackFlag(int callback_flag); + + // start preview mode, must call setPreviewDisplay first + virtual status_t startPreview(); + + // stop preview mode + virtual void stopPreview(); + + // get preview state + virtual bool previewEnabled(); + + // start recording mode + virtual status_t startRecording(); + + // stop recording mode + virtual void stopRecording(); + + // get recording state + virtual bool recordingEnabled(); + + // release a recording frame + virtual void releaseRecordingFrame(const sp<IMemory>& mem); + + // auto focus + virtual status_t autoFocus(); + + // take a picture - returns an IMemory (ref-counted mmap) + virtual status_t takePicture(); + + // set preview/capture parameters - key/value pairs + virtual status_t setParameters(const String8& params); + + // get preview/capture parameters - key/value pairs + virtual String8 getParameters() const; + + // our client... + const sp<ICameraClient>& getCameraClient() const { return mCameraClient; } + + private: + friend class CameraService; + Client(const sp<CameraService>& cameraService, + const sp<ICameraClient>& cameraClient, + pid_t clientPid); + Client(); + virtual ~Client(); + + status_t checkPid(); + + static void recordingCallback(const sp<IMemory>& mem, void* user); + static void previewCallback(const sp<IMemory>& mem, void* user); + static void shutterCallback(void *user); + static void yuvPictureCallback(const sp<IMemory>& mem, void* user); + static void jpegPictureCallback(const sp<IMemory>& mem, void* user); + static void autoFocusCallback(bool focused, void* user); + static sp<Client> getClientFromCookie(void* user); + + void postShutter(); + void postRaw(const sp<IMemory>& mem); + void postJpeg(const sp<IMemory>& mem); + void postPreviewFrame(const sp<IMemory>& mem); + void postRecordingFrame(const sp<IMemory>& frame); + void copyFrameAndPostCopiedFrame(sp<IMemoryHeap> heap, size_t offset, size_t size); + void postError(status_t error); + void postAutoFocus(bool focused); + + // 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() + }; + status_t startCameraMode(camera_mode mode); + status_t startPreviewMode(); + status_t startRecordingMode(); + + // Ensures atomicity among the public methods + mutable Mutex mLock; + + // mSurfaceLock synchronizes access to mSurface between + // setPreviewSurface() and postPreviewFrame(). Note that among + // the public methods, all accesses to mSurface are + // syncrhonized by mLock. However, postPreviewFrame() is called + // by the CameraHardwareInterface callback, and needs to + // access mSurface. It cannot hold mLock, however, because + // stopPreview() may be holding that lock while attempting + // to stop preview, and stopPreview itself will block waiting + // for a callback from CameraHardwareInterface. If this + // happens, it will cause a deadlock. + mutable Mutex mSurfaceLock; + mutable Condition mReady; + sp<CameraService> mCameraService; + sp<ISurface> mSurface; + sp<MemoryHeapBase> mPreviewBuffer; + int mPreviewCallbackFlag; + + // these are immutable once the object is created, + // they don't need to be protected by a lock + sp<ICameraClient> mCameraClient; + sp<CameraHardwareInterface> mHardware; + pid_t mClientPid; + bool mUseOverlay; + }; + +// ---------------------------------------------------------------------------- + + CameraService(); + virtual ~CameraService(); + + mutable Mutex mLock; + wp<Client> mClient; + +#if DEBUG_HEAP_LEAKS + wp<IMemoryHeap> gWeakHeap; +#endif +}; + +// ---------------------------------------------------------------------------- + +}; // namespace android + +#endif |