Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge change 1239 into donut

Browse Source 
* changes:
  Modify camera framework to use new streamlined binder interface. This is the second half of bug 1837832. Modifies the camera client and camera service to use the new binder interface. Removes the old binder interface. There will be one more part to this change to surface the undefined callbacks to the Java layer so that partners can implement new features without having to touch the stack.
This commit is contained in:
Android (Google) Code Review
2009-05-11 10:00:42 -07:00
parent 82e61c947b d6289b1b03
commit 3022a11c4c
5 changed files with 81 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
camera/libcameraservice/CameraService.cpp
View File

@@ -915,24 +915,24 @@ String8 CameraService::Client::getParameters() const
void CameraService::Client::postAutoFocus(bool focused)
{
LOGV("postAutoFocus");
mCameraClient->autoFocusCallback(focused);
mCameraClient->notifyCallback(CAMERA_MSG_FOCUS, (int32_t)focused, 0);
}
void CameraService::Client::postShutter()
{
mCameraClient->shutterCallback();
mCameraClient->notifyCallback(CAMERA_MSG_SHUTTER, 0, 0);
}
void CameraService::Client::postRaw(const sp<IMemory>& mem)
{
LOGD("postRaw");
mCameraClient->rawCallback(mem);
mCameraClient->dataCallback(CAMERA_MSG_RAW_IMAGE, mem);
}
void CameraService::Client::postJpeg(const sp<IMemory>& mem)
{
LOGD("postJpeg");
mCameraClient->jpegCallback(mem);
mCameraClient->dataCallback(CAMERA_MSG_COMPRESSED_IMAGE, mem);
}
void CameraService::Client::copyFrameAndPostCopiedFrame(sp<IMemoryHeap> heap, size_t offset, size_t size)
@@ -960,7 +960,7 @@ void CameraService::Client::copyFrameAndPostCopiedFrame(sp<IMemoryHeap> heap, si
LOGE("failed to allocate space for frame callback");
return;
}
mCameraClient->previewCallback(frame);
mCameraClient->dataCallback(CAMERA_MSG_PREVIEW_FRAME, frame);
}
void CameraService::Client::postRecordingFrame(const sp<IMemory>& frame)
@@ -970,7 +970,7 @@ void CameraService::Client::postRecordingFrame(const sp<IMemory>& frame)
LOGW("frame is a null pointer");
return;
}
mCameraClient->recordingCallback(frame);
mCameraClient->dataCallback(CAMERA_MSG_VIDEO_FRAME, frame);
}
void CameraService::Client::postPreviewFrame(const sp<IMemory>& mem)
@@ -1004,7 +1004,7 @@ void CameraService::Client::postPreviewFrame(const sp<IMemory>& mem)
copyFrameAndPostCopiedFrame(heap, offset, size);
} else {
LOGV("frame is directly sent out without copying");
mCameraClient->previewCallback(mem);
mCameraClient->dataCallback(CAMERA_MSG_PREVIEW_FRAME, mem);
}
// Is this is one-shot only?
@@ -1018,7 +1018,7 @@ void CameraService::Client::postPreviewFrame(const sp<IMemory>& mem)
void CameraService::Client::postError(status_t error)
{
mCameraClient->errorCallback(error);
mCameraClient->notifyCallback(CAMERA_MSG_ERROR, error, 0);
}
status_t CameraService::dump(int fd, const Vector<String16>& args)

26
include/ui/Camera.h
View File

@@ -63,6 +63,23 @@ namespace android {
#define FRAME_CALLBACK_FLAG_CAMERA 0x05
#define FRAME_CALLBACK_FLAG_BARCODE_SCANNER 0x07
// msgType in notifyCallback function
enum {
CAMERA_MSG_ERROR,
CAMERA_MSG_SHUTTER,
CAMERA_MSG_FOCUS,
CAMERA_MSG_ZOOM
};
// msgType in dataCallback function
enum {
CAMERA_MSG_PREVIEW_FRAME,
CAMERA_MSG_VIDEO_FRAME,
CAMERA_MSG_POSTVIEW_FRAME,
CAMERA_MSG_RAW_IMAGE,
CAMERA_MSG_COMPRESSED_IMAGE
};
class ICameraService;
class ICamera;
class Surface;
@@ -136,15 +153,8 @@ public:
void setAutoFocusCallback(autofocus_callback cb, void *cookie);
// ICameraClient interface
virtual void shutterCallback();
virtual void rawCallback(const sp<IMemory>& picture);
virtual void jpegCallback(const sp<IMemory>& picture);
virtual void previewCallback(const sp<IMemory>& frame);
virtual void errorCallback(status_t error);
virtual void autoFocusCallback(bool focused);
virtual void recordingCallback(const sp<IMemory>& frame);
virtual void notifyCallback(int32_t msgType, int32_t ext, int32_t ext2);
virtual void dataCallback(int32_t msgType, const sp<IMemory>& frame);
virtual void dataCallback(int32_t msgType, const sp<IMemory>& dataPtr);
sp<ICamera> remote();

24
include/ui/ICameraClient.h
View File

@@ -29,30 +29,6 @@ class ICameraClient: public IInterface
public:
DECLARE_META_INTERFACE(CameraClient);
// msgType in notifyCallback function
enum {
ERROR,
SHUTTER,
FOCUSED,
ZOOM
} notify_callback_message_type;
// msgType in dataCallback function
enum {
PREVIEW,
RECORD,
POSTVIEW,
RAW,
COMPRESSED
} data_callback_message_type;
virtual void shutterCallback() = 0;
virtual void rawCallback(const sp<IMemory>& picture) = 0;
virtual void jpegCallback(const sp<IMemory>& picture) = 0;
virtual void previewCallback(const sp<IMemory>& frame) = 0;
virtual void errorCallback(status_t error) = 0;
virtual void autoFocusCallback(bool focused) = 0;
virtual void recordingCallback(const sp<IMemory>& frame) = 0;
virtual void notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2) = 0;
virtual void dataCallback(int32_t msgType, const sp<IMemory>& data) = 0;

118
libs/ui/Camera.cpp
View File

@@ -337,76 +337,66 @@ void Camera::setErrorCallback(error_callback cb, void *cookie)
mErrorCallbackCookie = cookie;
}
void Camera::autoFocusCallback(bool focused)
{
LOGV("autoFocusCallback");
if (mAutoFocusCallback) {
mAutoFocusCallback(focused, mAutoFocusCallbackCookie);
}
}
void Camera::shutterCallback()
{
LOGV("shutterCallback");
if (mShutterCallback) {
mShutterCallback(mShutterCallbackCookie);
}
}
void Camera::rawCallback(const sp<IMemory>& picture)
{
LOGV("rawCallback");
if (mRawCallback) {
mRawCallback(picture, mRawCallbackCookie);
}
}
// callback from camera service when image is ready
void Camera::jpegCallback(const sp<IMemory>& picture)
{
LOGV("jpegCallback");
if (mJpegCallback) {
mJpegCallback(picture, mJpegCallbackCookie);
}
}
// callback from camera service when preview frame is ready
void Camera::previewCallback(const sp<IMemory>& frame)
{
LOGV("frameCallback");
if (mPreviewCallback) {
mPreviewCallback(frame, mPreviewCallbackCookie);
}
}
// callback from camera service when a recording frame is ready
void Camera::recordingCallback(const sp<IMemory>& frame)
{
LOGV("recordingCallback");
if (mRecordingCallback) {
mRecordingCallback(frame, mRecordingCallbackCookie);
}
}
// callback from camera service when an error occurs in preview or takePicture
void Camera::errorCallback(status_t error)
{
LOGV("errorCallback");
if (mErrorCallback) {
mErrorCallback(error, mErrorCallbackCookie);
}
}
// callback from camera service
void Camera::notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2)
{
LOGV("notifyCallback");
switch(msgType) {
case CAMERA_MSG_ERROR:
LOGV("errorCallback");
if (mErrorCallback) {
mErrorCallback((status_t)ext1, mErrorCallbackCookie);
}
break;
case CAMERA_MSG_FOCUS:
LOGV("autoFocusCallback");
if (mAutoFocusCallback) {
mAutoFocusCallback((bool)ext1, mAutoFocusCallbackCookie);
}
break;
case CAMERA_MSG_SHUTTER:
LOGV("shutterCallback");
if (mShutterCallback) {
mShutterCallback(mShutterCallbackCookie);
}
break;
default:
LOGV("notifyCallback(%d, %d, %d)", msgType, ext1, ext2);
break;
}
}
// callback from camera service when image is ready
void Camera::dataCallback(int32_t msgType, const sp<IMemory>& frame)
// callback from camera service when frame or image is ready
void Camera::dataCallback(int32_t msgType, const sp<IMemory>& dataPtr)
{
LOGV("dataCallback");
switch(msgType) {
case CAMERA_MSG_PREVIEW_FRAME:
LOGV("previewCallback");
if (mPreviewCallback) {
mPreviewCallback(dataPtr, mPreviewCallbackCookie);
}
break;
case CAMERA_MSG_VIDEO_FRAME:
LOGV("recordingCallback");
if (mRecordingCallback) {
mRecordingCallback(dataPtr, mRecordingCallbackCookie);
}
break;
case CAMERA_MSG_RAW_IMAGE:
LOGV("rawCallback");
if (mRawCallback) {
mRawCallback(dataPtr, mRawCallbackCookie);
}
break;
case CAMERA_MSG_COMPRESSED_IMAGE:
LOGV("jpegCallback");
if (mJpegCallback) {
mJpegCallback(dataPtr, mJpegCallbackCookie);
}
break;
default:
LOGV("dataCallback(%d, %p)", msgType, dataPtr.get());
break;
}
}
void Camera::binderDied(const wp<IBinder>& who) {

126
libs/ui/ICameraClient.cpp
View File

@@ -25,14 +25,7 @@
namespace android {
enum {
SHUTTER_CALLBACK = IBinder::FIRST_CALL_TRANSACTION,
RAW_CALLBACK,
JPEG_CALLBACK,
PREVIEW_CALLBACK,
ERROR_CALLBACK,
AUTOFOCUS_CALLBACK,
RECORDING_CALLBACK,
NOTIFY_CALLBACK,
NOTIFY_CALLBACK = IBinder::FIRST_CALL_TRANSACTION,
DATA_CALLBACK,
};
@@ -44,75 +37,6 @@ public:
{
}
// callback to let the app know the shutter has closed, ideal for playing the shutter sound
void shutterCallback()
{
LOGV("shutterCallback");
Parcel data, reply;
data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
remote()->transact(SHUTTER_CALLBACK, data, &reply, IBinder::FLAG_ONEWAY);
}
// callback from camera service to app with picture data
void rawCallback(const sp<IMemory>& picture)
{
LOGV("rawCallback");
Parcel data, reply;
data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
data.writeStrongBinder(picture->asBinder());
remote()->transact(RAW_CALLBACK, data, &reply, IBinder::FLAG_ONEWAY);
}
// callback from camera service to app with picture data
void jpegCallback(const sp<IMemory>& picture)
{
LOGV("jpegCallback");
Parcel data, reply;
data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
data.writeStrongBinder(picture->asBinder());
remote()->transact(JPEG_CALLBACK, data, &reply, IBinder::FLAG_ONEWAY);
}
// callback from camera service to app with preview frame data
void previewCallback(const sp<IMemory>& frame)
{
LOGV("previewCallback");
Parcel data, reply;
data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
data.writeStrongBinder(frame->asBinder());
remote()->transact(PREVIEW_CALLBACK, data, &reply, IBinder::FLAG_ONEWAY);
}
// callback from camera service to app with recording frame data
void recordingCallback(const sp<IMemory>& frame)
{
LOGV("recordingCallback");
Parcel data, reply;
data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
data.writeStrongBinder(frame->asBinder());
remote()->transact(RECORDING_CALLBACK, data, &reply, IBinder::FLAG_ONEWAY);
}
// callback from camera service to app to report error
void errorCallback(status_t error)
{
LOGV("errorCallback");
Parcel data, reply;
data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
data.writeInt32(error);
remote()->transact(ERROR_CALLBACK, data, &reply, IBinder::FLAG_ONEWAY);
}
// callback from camera service to app to report autofocus completion
void autoFocusCallback(bool focused)
{
LOGV("autoFocusCallback");
Parcel data, reply;
data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
data.writeInt32(focused);
remote()->transact(AUTOFOCUS_CALLBACK, data, &reply, IBinder::FLAG_ONEWAY);
}
// generic callback from camera service to app
void notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2)
{
@@ -152,54 +76,6 @@ status_t BnCameraClient::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case SHUTTER_CALLBACK: {
LOGV("SHUTTER_CALLBACK");
CHECK_INTERFACE(ICameraClient, data, reply);
shutterCallback();
return NO_ERROR;
} break;
case RAW_CALLBACK: {
LOGV("RAW_CALLBACK");
CHECK_INTERFACE(ICameraClient, data, reply);
sp<IMemory> picture = interface_cast<IMemory>(data.readStrongBinder());
rawCallback(picture);
return NO_ERROR;
} break;
case JPEG_CALLBACK: {
LOGV("JPEG_CALLBACK");
CHECK_INTERFACE(ICameraClient, data, reply);
sp<IMemory> picture = interface_cast<IMemory>(data.readStrongBinder());
jpegCallback(picture);
return NO_ERROR;
} break;
case PREVIEW_CALLBACK: {
LOGV("PREVIEW_CALLBACK");
CHECK_INTERFACE(ICameraClient, data, reply);
sp<IMemory> frame = interface_cast<IMemory>(data.readStrongBinder());
previewCallback(frame);
return NO_ERROR;
} break;
case RECORDING_CALLBACK: {
LOGV("RECORDING_CALLBACK");
CHECK_INTERFACE(ICameraClient, data, reply);
sp<IMemory> frame = interface_cast<IMemory>(data.readStrongBinder());
recordingCallback(frame);
return NO_ERROR;
} break;
case ERROR_CALLBACK: {
LOGV("ERROR_CALLBACK");
CHECK_INTERFACE(ICameraClient, data, reply);
status_t error = data.readInt32();
errorCallback(error);
return NO_ERROR;
} break;
case AUTOFOCUS_CALLBACK: {
LOGV("AUTOFOCUS_CALLBACK");
CHECK_INTERFACE(ICameraClient, data, reply);
bool focused = (bool)data.readInt32();
autoFocusCallback(focused);
return NO_ERROR;
} break;
case NOTIFY_CALLBACK: {
LOGV("NOTIFY_CALLBACK");
CHECK_INTERFACE(ICameraClient, data, reply);