am 3022a11: Merge change 1239 into donut (70a16b40) · Commits · e / os / android_frameworks_base

camera/libcameraservice/CameraService.cpp

+8 −8

Original line number	Diff line number	Diff line
		@@ -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)

include/ui/Camera.h

+18 −8

Original line number	Diff line number	Diff line
		@@ -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();

include/ui/ICameraClient.h

+0 −24

Original line number	Diff line number	Diff line
		@@ -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;

libs/ui/Camera.cpp

+54 −64

Original line number	Diff line number	Diff line
		@@ -337,76 +337,66 @@ void Camera::setErrorCallback(error_callback cb, void *cookie)
		mErrorCallbackCookie = cookie;
		}

		void Camera::autoFocusCallback(bool focused)
		// callback from camera service
		void Camera::notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2)
		{
		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(focused, mAutoFocusCallbackCookie);
		mAutoFocusCallback((bool)ext1, mAutoFocusCallbackCookie);
		}
		}

		void Camera::shutterCallback()
		{
		break;
		case CAMERA_MSG_SHUTTER:
		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);
		break;
		default:
		LOGV("notifyCallback(%d, %d, %d)", msgType, ext1, ext2);
		break;
		}
		}

		// callback from camera service when preview frame is ready
		void Camera::previewCallback(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("frameCallback");
		switch(msgType) {
		case CAMERA_MSG_PREVIEW_FRAME:
		LOGV("previewCallback");
		if (mPreviewCallback) {
		mPreviewCallback(frame, mPreviewCallbackCookie);
		mPreviewCallback(dataPtr, mPreviewCallbackCookie);
		}
		}

		// callback from camera service when a recording frame is ready
		void Camera::recordingCallback(const sp<IMemory>& frame)
		{
		break;
		case CAMERA_MSG_VIDEO_FRAME:
		LOGV("recordingCallback");
		if (mRecordingCallback) {
		mRecordingCallback(frame, mRecordingCallbackCookie);
		}
		mRecordingCallback(dataPtr, 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);
		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);
		}

		// callback from camera service
		void Camera::notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2)
		{
		LOGV("notifyCallback");
		break;
		default:
		LOGV("dataCallback(%d, %p)", msgType, dataPtr.get());
		break;
		}

		// callback from camera service when image is ready
		void Camera::dataCallback(int32_t msgType, const sp<IMemory>& frame)
		{
		LOGV("dataCallback");
		}

		void Camera::binderDied(const wp<IBinder>& who) {

libs/ui/ICameraClient.cpp

+1 −125

Original line number	Diff line number	Diff line
		@@ -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);