Initial implementation of android.hardware.photography.CameraDevice (service)
* Verified preview streaming requests
* Other things *should* work but unverified / unimplemented in client side
Missing:
* CameraService needs to return static camera info metadata
Bug: 9213377
Change-Id: I71568560fcf18d0e2b408ed1c4d0066647314868
diff --git a/camera/photography/CaptureRequest.cpp b/camera/photography/CaptureRequest.cpp
new file mode 100644
index 0000000..b822fc9
--- /dev/null
+++ b/camera/photography/CaptureRequest.cpp
@@ -0,0 +1,124 @@
+/*
+**
+** Copyright 2013, The Android Open Source Project
+**
+** 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.
+*/
+
+// #define LOG_NDEBUG 0
+#define LOG_TAG "CameraRequest"
+#include <utils/Log.h>
+
+#include <camera/photography/CaptureRequest.h>
+
+#include <binder/Parcel.h>
+#include <gui/Surface.h>
+
+namespace android {
+
+status_t CaptureRequest::readFromParcel(Parcel* parcel) {
+ if (parcel == NULL) {
+ ALOGE("%s: Null parcel", __FUNCTION__);
+ return BAD_VALUE;
+ }
+
+ mMetadata.clear();
+ mSurfaceList.clear();
+
+ status_t err;
+
+ if ((err = mMetadata.readFromParcel(parcel)) != OK) {
+ ALOGE("%s: Failed to read metadata from parcel", __FUNCTION__);
+ return err;
+ }
+ ALOGV("%s: Read metadata from parcel", __FUNCTION__);
+
+ int32_t size;
+ if ((err = parcel->readInt32(&size)) != OK) {
+ ALOGE("%s: Failed to read surface list size from parcel", __FUNCTION__);
+ return err;
+ }
+ ALOGV("%s: Read surface list size = %d", __FUNCTION__, size);
+
+ // Do not distinguish null arrays from 0-sized arrays.
+ for (int i = 0; i < size; ++i) {
+ // Parcel.writeParcelableArray
+ size_t len;
+ const char16_t* className = parcel->readString16Inplace(&len);
+ ALOGV("%s: Read surface class = %s", __FUNCTION__,
+ className != NULL ? String8(className).string() : "<null>");
+
+ if (className == NULL) {
+ continue;
+ }
+
+ // Surface.writeToParcel
+ String16 name = parcel->readString16();
+ ALOGV("%s: Read surface name = %s",
+ __FUNCTION__, String8(name).string());
+ sp<IBinder> binder(parcel->readStrongBinder());
+ ALOGV("%s: Read surface binder = %p",
+ __FUNCTION__, binder.get());
+
+ sp<Surface> surface;
+
+ if (binder != NULL) {
+ sp<IGraphicBufferProducer> gbp =
+ interface_cast<IGraphicBufferProducer>(binder);
+ surface = new Surface(gbp);
+ }
+
+ mSurfaceList.push_back(surface);
+ }
+
+ return OK;
+}
+
+status_t CaptureRequest::writeToParcel(Parcel* parcel) const {
+ if (parcel == NULL) {
+ ALOGE("%s: Null parcel", __FUNCTION__);
+ return BAD_VALUE;
+ }
+
+ status_t err;
+
+ if ((err = mMetadata.writeToParcel(parcel)) != OK) {
+ return err;
+ }
+
+ int32_t size = static_cast<int32_t>(mSurfaceList.size());
+
+ // Send 0-sized arrays when it's empty. Do not send null arrays.
+ parcel->writeInt32(size);
+
+ for (int32_t i = 0; i < size; ++i) {
+ sp<Surface> surface = mSurfaceList[i];
+
+ sp<IBinder> binder;
+ if (surface != 0) {
+ binder = surface->getIGraphicBufferProducer()->asBinder();
+ }
+
+ // not sure if readParcelableArray does this, hard to tell from source
+ parcel->writeString16(String16("android.view.Surface"));
+
+ // Surface.writeToParcel
+ parcel->writeString16(String16("unknown_name"));
+ // Surface.nativeWriteToParcel
+ parcel->writeStrongBinder(binder);
+ }
+
+ return OK;
+}
+
+}; // namespace android
diff --git a/camera/photography/ICameraDeviceCallbacks.cpp b/camera/photography/ICameraDeviceCallbacks.cpp
new file mode 100644
index 0000000..19763d7
--- /dev/null
+++ b/camera/photography/ICameraDeviceCallbacks.cpp
@@ -0,0 +1,110 @@
+/*
+**
+** Copyright 2013, The Android Open Source Project
+**
+** 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.
+*/
+
+//#define LOG_NDEBUG 0
+#define LOG_TAG "ICameraDeviceCallbacks"
+#include <utils/Log.h>
+#include <stdint.h>
+#include <sys/types.h>
+
+#include <binder/Parcel.h>
+#include <gui/IGraphicBufferProducer.h>
+#include <gui/Surface.h>
+#include <utils/Mutex.h>
+
+#include <camera/photography/ICameraDeviceCallbacks.h>
+#include "camera/CameraMetadata.h"
+
+namespace android {
+
+enum {
+ NOTIFY_CALLBACK = IBinder::FIRST_CALL_TRANSACTION,
+ RESULT_RECEIVED,
+};
+
+class BpCameraDeviceCallbacks: public BpInterface<ICameraDeviceCallbacks>
+{
+public:
+ BpCameraDeviceCallbacks(const sp<IBinder>& impl)
+ : BpInterface<ICameraDeviceCallbacks>(impl)
+ {
+ }
+
+ // generic callback from camera service to app
+ void notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2)
+ {
+ ALOGV("notifyCallback");
+ Parcel data, reply;
+ data.writeInterfaceToken(ICameraDeviceCallbacks::getInterfaceDescriptor());
+ data.writeInt32(msgType);
+ data.writeInt32(ext1);
+ data.writeInt32(ext2);
+ remote()->transact(NOTIFY_CALLBACK, data, &reply, IBinder::FLAG_ONEWAY);
+ data.writeNoException();
+ }
+
+ void onResultReceived(int32_t frameId, const CameraMetadata& result) {
+ ALOGV("onResultReceived");
+ Parcel data, reply;
+ data.writeInterfaceToken(ICameraDeviceCallbacks::getInterfaceDescriptor());
+ data.writeInt32(frameId);
+ result.writeToParcel(&data);
+ remote()->transact(RESULT_RECEIVED, data, &reply, IBinder::FLAG_ONEWAY);
+ data.writeNoException();
+ }
+};
+
+IMPLEMENT_META_INTERFACE(CameraDeviceCallbacks,
+ "android.hardware.photography.ICameraDeviceCallbacks");
+
+// ----------------------------------------------------------------------
+
+status_t BnCameraDeviceCallbacks::onTransact(
+ uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
+{
+ ALOGV("onTransact - code = %d", code);
+ switch(code) {
+ case NOTIFY_CALLBACK: {
+ ALOGV("NOTIFY_CALLBACK");
+ CHECK_INTERFACE(ICameraDeviceCallbacks, data, reply);
+ int32_t msgType = data.readInt32();
+ int32_t ext1 = data.readInt32();
+ int32_t ext2 = data.readInt32();
+ notifyCallback(msgType, ext1, ext2);
+ data.readExceptionCode();
+ return NO_ERROR;
+ } break;
+ case RESULT_RECEIVED: {
+ ALOGV("RESULT_RECEIVED");
+ CHECK_INTERFACE(ICameraDeviceCallbacks, data, reply);
+ int32_t frameId = data.readInt32();
+ CameraMetadata result;
+ result.readFromParcel(const_cast<Parcel*>(&data));
+ onResultReceived(frameId, result);
+ data.readExceptionCode();
+ return NO_ERROR;
+ break;
+ }
+ default:
+ return BBinder::onTransact(code, data, reply, flags);
+ }
+}
+
+// ----------------------------------------------------------------------------
+
+}; // namespace android
+
diff --git a/camera/photography/ICameraDeviceUser.cpp b/camera/photography/ICameraDeviceUser.cpp
new file mode 100644
index 0000000..0515bd7
--- /dev/null
+++ b/camera/photography/ICameraDeviceUser.cpp
@@ -0,0 +1,307 @@
+/*
+**
+** Copyright 2013, The Android Open Source Project
+**
+** 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.
+*/
+
+// #define LOG_NDEBUG 0
+#define LOG_TAG "ICameraDeviceUser"
+#include <utils/Log.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <binder/Parcel.h>
+#include <camera/photography/ICameraDeviceUser.h>
+#include <gui/IGraphicBufferProducer.h>
+#include <gui/Surface.h>
+#include <camera/CameraMetadata.h>
+#include <camera/photography/CaptureRequest.h>
+
+namespace android {
+
+typedef Parcel::WritableBlob WritableBlob;
+typedef Parcel::ReadableBlob ReadableBlob;
+
+enum {
+ DISCONNECT = IBinder::FIRST_CALL_TRANSACTION,
+ SUBMIT_REQUEST,
+ CANCEL_REQUEST,
+ DELETE_STREAM,
+ CREATE_STREAM,
+ CREATE_DEFAULT_REQUEST,
+ GET_CAMERA_INFO,
+};
+
+class BpCameraDeviceUser : public BpInterface<ICameraDeviceUser>
+{
+public:
+ BpCameraDeviceUser(const sp<IBinder>& impl)
+ : BpInterface<ICameraDeviceUser>(impl)
+ {
+ }
+
+ // disconnect from camera service
+ void disconnect()
+ {
+ ALOGV("disconnect");
+ Parcel data, reply;
+ data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
+ remote()->transact(DISCONNECT, data, &reply);
+ reply.readExceptionCode();
+ }
+
+ virtual int submitRequest(sp<CaptureRequest> request, bool streaming)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
+
+ // arg0 = CaptureRequest
+ if (request != 0) {
+ data.writeInt32(1);
+ request->writeToParcel(&data);
+ } else {
+ data.writeInt32(0);
+ }
+
+ // arg1 = streaming (bool)
+ data.writeInt32(streaming);
+
+ remote()->transact(SUBMIT_REQUEST, data, &reply);
+
+ reply.readExceptionCode();
+ return reply.readInt32();
+ }
+
+ virtual status_t cancelRequest(int requestId)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
+ data.writeInt32(requestId);
+
+ remote()->transact(CANCEL_REQUEST, data, &reply);
+
+ reply.readExceptionCode();
+ return reply.readInt32();
+ }
+
+ virtual status_t deleteStream(int streamId)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
+ data.writeInt32(streamId);
+
+ remote()->transact(DELETE_STREAM, data, &reply);
+
+ reply.readExceptionCode();
+ return reply.readInt32();
+ }
+
+ virtual status_t createStream(int width, int height, int format,
+ const sp<IGraphicBufferProducer>& bufferProducer)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
+ data.writeInt32(width);
+ data.writeInt32(height);
+ data.writeInt32(format);
+
+ data.writeInt32(1); // marker that bufferProducer is not null
+ data.writeString16(String16("unknown_name")); // name of surface
+ sp<IBinder> b(bufferProducer->asBinder());
+ data.writeStrongBinder(b);
+
+ remote()->transact(CREATE_STREAM, data, &reply);
+
+ reply.readExceptionCode();
+ return reply.readInt32();
+ }
+
+ // Create a request object from a template.
+ virtual status_t createDefaultRequest(int templateId,
+ /*out*/
+ CameraMetadata* request)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
+ data.writeInt32(templateId);
+ remote()->transact(CREATE_DEFAULT_REQUEST, data, &reply);
+
+ reply.readExceptionCode();
+ status_t result = reply.readInt32();
+
+ CameraMetadata out;
+ if (reply.readInt32() != 0) {
+ out.readFromParcel(&reply);
+ }
+
+ if (request != NULL) {
+ request->swap(out);
+ }
+ return result;
+ }
+
+
+ virtual status_t getCameraInfo(int cameraId, camera_metadata** info)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
+ data.writeInt32(cameraId);
+ remote()->transact(GET_CAMERA_INFO, data, &reply);
+
+
+ reply.readExceptionCode();
+ status_t result = reply.readInt32();
+
+ if (reply.readInt32() != 0) {
+ CameraMetadata::readFromParcel(reply, /*out*/info);
+ } else if (info) {
+ *info = NULL;
+ }
+
+ return result;
+ }
+
+
+private:
+
+
+};
+
+IMPLEMENT_META_INTERFACE(CameraDeviceUser,
+ "android.hardware.photography.ICameraDeviceUser");
+
+// ----------------------------------------------------------------------
+
+status_t BnCameraDeviceUser::onTransact(
+ uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
+{
+ switch(code) {
+ case DISCONNECT: {
+ ALOGV("DISCONNECT");
+ CHECK_INTERFACE(ICameraDeviceUser, data, reply);
+ disconnect();
+ reply->writeNoException();
+ return NO_ERROR;
+ } break;
+ case SUBMIT_REQUEST: {
+ CHECK_INTERFACE(ICameraDeviceUser, data, reply);
+
+ // arg0 = request
+ sp<CaptureRequest> request;
+ if (data.readInt32() != 0) {
+ request = new CaptureRequest();
+ request->readFromParcel(const_cast<Parcel*>(&data));
+ }
+
+ // arg1 = streaming (bool)
+ bool streaming = data.readInt32();
+
+ // return code: requestId (int32)
+ reply->writeNoException();
+ reply->writeInt32(submitRequest(request, streaming));
+
+ return NO_ERROR;
+ } break;
+ case CANCEL_REQUEST: {
+ CHECK_INTERFACE(ICameraDeviceUser, data, reply);
+ int requestId = data.readInt32();
+ reply->writeNoException();
+ reply->writeInt32(cancelRequest(requestId));
+ return NO_ERROR;
+ } break;
+ case DELETE_STREAM: {
+ CHECK_INTERFACE(ICameraDeviceUser, data, reply);
+ int streamId = data.readInt32();
+ reply->writeNoException();
+ reply->writeInt32(deleteStream(streamId));
+ return NO_ERROR;
+ } break;
+ case CREATE_STREAM: {
+ CHECK_INTERFACE(ICameraDeviceUser, data, reply);
+ int width, height, format;
+
+ width = data.readInt32();
+ ALOGV("%s: CREATE_STREAM: width = %d", __FUNCTION__, width);
+ height = data.readInt32();
+ ALOGV("%s: CREATE_STREAM: height = %d", __FUNCTION__, height);
+ format = data.readInt32();
+ ALOGV("%s: CREATE_STREAM: format = %d", __FUNCTION__, format);
+
+ sp<IGraphicBufferProducer> bp;
+ if (data.readInt32() != 0) {
+ String16 name = data.readString16();
+ bp = interface_cast<IGraphicBufferProducer>(
+ data.readStrongBinder());
+
+ ALOGV("%s: CREATE_STREAM: bp = %p, name = %s", __FUNCTION__,
+ bp.get(), String8(name).string());
+ } else {
+ ALOGV("%s: CREATE_STREAM: bp = unset, name = unset",
+ __FUNCTION__);
+ }
+
+ status_t ret;
+ ret = createStream(width, height, format, bp);
+
+ reply->writeNoException();
+ ALOGV("%s: CREATE_STREAM: write noException", __FUNCTION__);
+ reply->writeInt32(ret);
+ ALOGV("%s: CREATE_STREAM: write ret = %d", __FUNCTION__, ret);
+
+ return NO_ERROR;
+ } break;
+
+ case CREATE_DEFAULT_REQUEST: {
+ CHECK_INTERFACE(ICameraDeviceUser, data, reply);
+
+ int templateId = data.readInt32();
+
+ CameraMetadata request;
+ status_t ret;
+ ret = createDefaultRequest(templateId, &request);
+
+ reply->writeNoException();
+ reply->writeInt32(ret);
+
+ reply->writeInt32(1); // to mark presence of metadata object
+ request.writeToParcel(const_cast<Parcel*>(reply));
+
+ return NO_ERROR;
+ } break;
+ case GET_CAMERA_INFO: {
+ CHECK_INTERFACE(ICameraDeviceUser, data, reply);
+
+ int cameraId = data.readInt32();
+
+ camera_metadata_t* info = NULL;
+ status_t ret;
+ ret = getCameraInfo(cameraId, &info);
+
+ reply->writeInt32(1); // to mark presence of metadata object
+ CameraMetadata::writeToParcel(*reply, info);
+
+ reply->writeNoException();
+ reply->writeInt32(ret);
+
+ free_camera_metadata(info);
+
+ return NO_ERROR;
+ } break;
+ default:
+ return BBinder::onTransact(code, data, reply, flags);
+ }
+}
+
+// ----------------------------------------------------------------------------
+
+}; // namespace android