393eb7967f
We weren't checking to see if there was a valid camera client when calling the notify callback function. Now we grab a strong pointer before the callback to guarantee that the client is not destroyed before we complete the callback. This change also fixes other places in the code where we weren't holding a local strong pointer.
225 lines
8.6 KiB
C++
225 lines
8.6 KiB
C++
/*
|
|
**
|
|
** 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>
|
|
|
|
namespace android {
|
|
|
|
class MemoryHeapBase;
|
|
class MediaPlayer;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#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);
|
|
|
|
virtual status_t onTransact(
|
|
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
|
|
|
|
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();
|
|
|
|
// cancel auto focus
|
|
virtual status_t cancelAutoFocus();
|
|
|
|
// 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;
|
|
|
|
// send command to camera driver
|
|
virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
|
|
|
|
// 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 notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2, void* user);
|
|
static void dataCallback(int32_t msgType, const sp<IMemory>& dataPtr, void* user);
|
|
static void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType,
|
|
const sp<IMemory>& dataPtr, void* user);
|
|
|
|
static sp<Client> getClientFromCookie(void* user);
|
|
|
|
void handlePreviewData(const sp<IMemory>&);
|
|
void handleShutter();
|
|
void handlePostview(const sp<IMemory>&);
|
|
void handleRawPicture(const sp<IMemory>&);
|
|
void handleCompressedPicture(const sp<IMemory>&);
|
|
|
|
void copyFrameAndPostCopiedFrame(const sp<ICameraClient>& client,
|
|
const sp<IMemoryHeap>& heap, size_t offset, size_t size);
|
|
|
|
// 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();
|
|
status_t setOverlay();
|
|
status_t registerPreviewBuffers();
|
|
|
|
// 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;
|
|
|
|
sp<MediaPlayer> mMediaPlayerClick;
|
|
sp<MediaPlayer> mMediaPlayerBeep;
|
|
|
|
// 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;
|
|
|
|
sp<OverlayRef> mOverlayRef;
|
|
int mOverlayW;
|
|
int mOverlayH;
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
CameraService();
|
|
virtual ~CameraService();
|
|
|
|
// We use a count for number of clients (shoule only be 0 or 1).
|
|
volatile int32_t mUsers;
|
|
virtual void incUsers();
|
|
virtual void decUsers();
|
|
|
|
mutable Mutex mServiceLock;
|
|
wp<Client> mClient;
|
|
|
|
#if DEBUG_HEAP_LEAKS
|
|
wp<IMemoryHeap> gWeakHeap;
|
|
#endif
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
}; // namespace android
|
|
|
|
#endif
|