/*
**
** Copyright 2008, 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_TAG "BpCameraService"
#include <utils/Log.h>
#include <utils/Errors.h>
#include <utils/String16.h>
#include <inttypes.h>
#include <stdint.h>
#include <sys/types.h>
#include <binder/Parcel.h>
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <camera/ICameraService.h>
#include <camera/ICameraServiceListener.h>
#include <camera/ICamera.h>
#include <camera/ICameraClient.h>
#include <camera/camera2/ICameraDeviceUser.h>
#include <camera/camera2/ICameraDeviceCallbacks.h>
#include <camera/CameraMetadata.h>
#include <camera/VendorTagDescriptor.h>
namespace android {
namespace {
enum {
EX_SECURITY = -1,
EX_BAD_PARCELABLE = -2,
EX_ILLEGAL_ARGUMENT = -3,
EX_NULL_POINTER = -4,
EX_ILLEGAL_STATE = -5,
EX_HAS_REPLY_HEADER = -128, // special; see below
};
static bool readExceptionCode(Parcel& reply) {
int32_t exceptionCode = reply.readExceptionCode();
if (exceptionCode != 0) {
const char* errorMsg;
switch(exceptionCode) {
case EX_SECURITY:
errorMsg = "Security";
break;
case EX_BAD_PARCELABLE:
errorMsg = "BadParcelable";
break;
case EX_NULL_POINTER:
errorMsg = "NullPointer";
break;
case EX_ILLEGAL_STATE:
errorMsg = "IllegalState";
break;
// Binder should be handling this code inside Parcel::readException
// but lets have a to-string here anyway just in case.
case EX_HAS_REPLY_HEADER:
errorMsg = "HasReplyHeader";
break;
default:
errorMsg = "Unknown";
}
ALOGE("Binder transmission error %s (%d)", errorMsg, exceptionCode);
return true;
}
return false;
}
};
class BpCameraService: public BpInterface<ICameraService>
{
public:
BpCameraService(const sp<IBinder>& impl)
: BpInterface<ICameraService>(impl)
{
}
// get number of cameras available that support standard camera operations
virtual int32_t getNumberOfCameras()
{
return getNumberOfCameras(CAMERA_TYPE_BACKWARD_COMPATIBLE);
}
// get number of cameras available of a given type
virtual int32_t getNumberOfCameras(int type)
{
Parcel data, reply;
data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
data.writeInt32(type);
remote()->transact(BnCameraService::GET_NUMBER_OF_CAMERAS, data, &reply);
if (readExceptionCode(reply)) return 0;
return reply.readInt32();
}
// get information about a camera
virtual status_t getCameraInfo(int cameraId,
struct CameraInfo* cameraInfo) {
Parcel data, reply;
data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
data.writeInt32(cameraId);
remote()->transact(BnCameraService::GET_CAMERA_INFO, data, &reply);
if (readExceptionCode(reply)) return -EPROTO;
status_t result = reply.readInt32();
if (reply.readInt32() != 0) {
cameraInfo->facing = reply.readInt32();
cameraInfo->orientation = reply.readInt32();
}
return result;
}
// get camera characteristics (static metadata)
virtual status_t getCameraCharacteristics(int cameraId,
CameraMetadata* cameraInfo) {
Parcel data, reply;
data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
data.writeInt32(cameraId);
remote()->transact(BnCameraService::GET_CAMERA_CHARACTERISTICS, data, &reply);
if (readExceptionCode(reply)) return -EPROTO;
status_t result = reply.readInt32();
CameraMetadata out;
if (reply.readInt32() != 0) {
out.readFromParcel(&reply);
}
if (cameraInfo != NULL) {
cameraInfo->swap(out);
}
return result;
}
// Get enumeration and description of vendor tags for camera
virtual status_t getCameraVendorTagDescriptor(/*out*/sp<VendorTagDescriptor>& desc) {
Parcel data, reply;
data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
remote()->transact(BnCameraService::GET_CAMERA_VENDOR_TAG_DESCRIPTOR, data, &reply);
if (readExceptionCode(reply)) return -EPROTO;
status_t result = reply.readInt32();
if (reply.readInt32() != 0) {
sp<VendorTagDescriptor> d;
if (VendorTagDescriptor::createFromParcel(&reply, /*out*/d) == OK) {
desc = d;
}
}
return result;
}
// connect to camera service (android.hardware.Camera)
virtual status_t connect(const sp<ICameraClient>& cameraClient, int cameraId,
const String16 &clientPackageName, int clientUid,
/*out*/
sp<ICamera>& device)
{
Parcel data, reply;
data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
data.writeStrongBinder(IInterface::asBinder(cameraClient));
data.writeInt32(cameraId);
data.writeString16(clientPackageName);
data.writeInt32(clientUid);
status_t status;
status = remote()->transact(BnCameraService::CONNECT, data, &reply);
if (status != OK) return status;
if (readExceptionCode(reply)) return -EPROTO;
status = reply.readInt32();
if (reply.readInt32() != 0) {
device = interface_cast<ICamera>(reply.readStrongBinder());
}
return status;
}
// connect to camera service (android.hardware.Camera)
virtual status_t connectLegacy(const sp<ICameraClient>& cameraClient, int cameraId,
int halVersion,
const String16 &clientPackageName, int clientUid,
/*out*/sp<ICamera>& device)
{
Parcel data, reply;
data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
data.writeStrongBinder(IInterface::asBinder(cameraClient));
data.writeInt32(cameraId);
data.writeInt32(halVersion);
data.writeString16(clientPackageName);
data.writeInt32(clientUid);
status_t status;
status = remote()->transact(BnCameraService::CONNECT_LEGACY, data, &reply);
if (status != OK) return status;
if (readExceptionCode(reply)) return -EPROTO;
status = reply.readInt32();
if (reply.readInt32() != 0) {
device = interface_cast<ICamera>(reply.readStrongBinder());
}
return status;
}
virtual status_t setTorchMode(const String16& cameraId, bool enabled,
const sp<IBinder>& clientBinder)
{
Parcel data, reply;
data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
data.writeString16(cameraId);
data.writeInt32(enabled ? 1 : 0);
data.writeStrongBinder(clientBinder);
remote()->transact(BnCameraService::SET_TORCH_MODE, data, &reply);
if (readExceptionCode(reply)) return -EPROTO;
return reply.readInt32();
}
// connect to camera service (android.hardware.camera2.CameraDevice)
virtual status_t connectDevice(
const sp<ICameraDeviceCallbacks>& cameraCb,
int cameraId,
const String16& clientPackageName,
int clientUid,
/*out*/
sp<ICameraDeviceUser>& device)
{
Parcel data, reply;
data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
data.writeStrongBinder(IInterface::asBinder(cameraCb));
data.writeInt32(cameraId);
data.writeString16(clientPackageName);
data.writeInt32(clientUid);
status_t status;
status = remote()->transact(BnCameraService::CONNECT_DEVICE, data, &reply);
if (status != OK) return status;
if (readExceptionCode(reply)) return -EPROTO;
status = reply.readInt32();
if (reply.readInt32() != 0) {
device = interface_cast<ICameraDeviceUser>(reply.readStrongBinder());
}
return status;
}
virtual status_t addListener(const sp<ICameraServiceListener>& listener)
{
Parcel data, reply;
data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
data.writeStrongBinder(IInterface::asBinder(listener));
remote()->transact(BnCameraService::ADD_LISTENER, data, &reply);
if (readExceptionCode(reply)) return -EPROTO;
return reply.readInt32();
}
virtual status_t removeListener(const sp<ICameraServiceListener>& listener)
{
Parcel data, reply;
data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
data.writeStrongBinder(IInterface::asBinder(listener));
remote()->transact(BnCameraService::REMOVE_LISTENER, data, &reply);
if (readExceptionCode(reply)) return -EPROTO;
return reply.readInt32();
}
virtual status_t getLegacyParameters(int cameraId, String16* parameters) {
if (parameters == NULL) {
ALOGE("%s: parameters must not be null", __FUNCTION__);
return BAD_VALUE;
}
Parcel data, reply;
data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
data.writeInt32(cameraId);
remote()->transact(BnCameraService::GET_LEGACY_PARAMETERS, data, &reply);
if (readExceptionCode(reply)) return -EPROTO;
status_t res = data.readInt32();
int32_t length = data.readInt32(); // -1 means null
if (length > 0) {
*parameters = data.readString16();
} else {
*parameters = String16();
}
return res;
}
virtual status_t supportsCameraApi(int cameraId, int apiVersion) {
Parcel data, reply;
data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
data.writeInt32(cameraId);
data.writeInt32(apiVersion);
remote()->transact(BnCameraService::SUPPORTS_CAMERA_API, data, &reply);
if (readExceptionCode(reply)) return -EPROTO;
status_t res = data.readInt32();
return res;
}
virtual void notifySystemEvent(int32_t eventId, const int32_t* args, size_t len) {
Parcel data, reply;
data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
data.writeInt32(eventId);
data.writeInt32Array(len, args);
remote()->transact(BnCameraService::NOTIFY_SYSTEM_EVENT, data, &reply,
IBinder::FLAG_ONEWAY);
}
};
IMPLEMENT_META_INTERFACE(CameraService, "android.hardware.ICameraService");
// ----------------------------------------------------------------------
status_t BnCameraService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case GET_NUMBER_OF_CAMERAS: {
CHECK_INTERFACE(ICameraService, data, reply);
reply->writeNoException();
reply->writeInt32(getNumberOfCameras(data.readInt32()));
return NO_ERROR;
} break;
case GET_CAMERA_INFO: {
CHECK_INTERFACE(ICameraService, data, reply);
CameraInfo cameraInfo = CameraInfo();
memset(&cameraInfo, 0, sizeof(cameraInfo));
status_t result = getCameraInfo(data.readInt32(), &cameraInfo);
reply->writeNoException();
reply->writeInt32(result);
// Fake a parcelable object here
reply->writeInt32(1); // means the parcelable is included
reply->writeInt32(cameraInfo.facing);
reply->writeInt32(cameraInfo.orientation);
return NO_ERROR;
} break;
case GET_CAMERA_CHARACTERISTICS: {
CHECK_INTERFACE(ICameraService, data, reply);
CameraMetadata info;
status_t result = getCameraCharacteristics(data.readInt32(), &info);
reply->writeNoException();
reply->writeInt32(result);
// out-variables are after exception and return value
reply->writeInt32(1); // means the parcelable is included
info.writeToParcel(reply);
return NO_ERROR;
} break;
case GET_CAMERA_VENDOR_TAG_DESCRIPTOR: {
CHECK_INTERFACE(ICameraService, data, reply);
sp<VendorTagDescriptor> d;
status_t result = getCameraVendorTagDescriptor(d);
reply->writeNoException();
reply->writeInt32(result);
// out-variables are after exception and return value
if (d == NULL) {
reply->writeInt32(0);
} else {
reply->writeInt32(1); // means the parcelable is included
d->writeToParcel(reply);
}
return NO_ERROR;
} break;
case CONNECT: {
CHECK_INTERFACE(ICameraService, data, reply);
sp<ICameraClient> cameraClient =
interface_cast<ICameraClient>(data.readStrongBinder());
int32_t cameraId = data.readInt32();
const String16 clientName = data.readString16();
int32_t clientUid = data.readInt32();
sp<ICamera> camera;
status_t status = connect(cameraClient, cameraId,
clientName, clientUid, /*out*/camera);
reply->writeNoException();
reply->writeInt32(status);
if (camera != NULL) {
reply->writeInt32(1);
reply->writeStrongBinder(IInterface::asBinder(camera));
} else {
reply->writeInt32(0);
}
return NO_ERROR;
} break;
case CONNECT_DEVICE: {
CHECK_INTERFACE(ICameraService, data, reply);
sp<ICameraDeviceCallbacks> cameraClient =
interface_cast<ICameraDeviceCallbacks>(data.readStrongBinder());
int32_t cameraId = data.readInt32();
const String16 clientName = data.readString16();
int32_t clientUid = data.readInt32();
sp<ICameraDeviceUser> camera;
status_t status = connectDevice(cameraClient, cameraId,
clientName, clientUid, /*out*/camera);
reply->writeNoException();
reply->writeInt32(status);
if (camera != NULL) {
reply->writeInt32(1);
reply->writeStrongBinder(IInterface::asBinder(camera));
} else {
reply->writeInt32(0);
}
return NO_ERROR;
} break;
case ADD_LISTENER: {
CHECK_INTERFACE(ICameraService, data, reply);
sp<ICameraServiceListener> listener =
interface_cast<ICameraServiceListener>(data.readStrongBinder());
reply->writeNoException();
reply->writeInt32(addListener(listener));
return NO_ERROR;
} break;
case REMOVE_LISTENER: {
CHECK_INTERFACE(ICameraService, data, reply);
sp<ICameraServiceListener> listener =
interface_cast<ICameraServiceListener>(data.readStrongBinder());
reply->writeNoException();
reply->writeInt32(removeListener(listener));
return NO_ERROR;
} break;
case GET_LEGACY_PARAMETERS: {
CHECK_INTERFACE(ICameraService, data, reply);
int cameraId = data.readInt32();
String16 parameters;
reply->writeNoException();
// return value
reply->writeInt32(getLegacyParameters(cameraId, ¶meters));
// out parameters
reply->writeInt32(1); // parameters is always available
reply->writeString16(parameters);
return NO_ERROR;
} break;
case SUPPORTS_CAMERA_API: {
CHECK_INTERFACE(ICameraService, data, reply);
int cameraId = data.readInt32();
int apiVersion = data.readInt32();
reply->writeNoException();
// return value
reply->writeInt32(supportsCameraApi(cameraId, apiVersion));
return NO_ERROR;
} break;
case CONNECT_LEGACY: {
CHECK_INTERFACE(ICameraService, data, reply);
sp<ICameraClient> cameraClient =
interface_cast<ICameraClient>(data.readStrongBinder());
int32_t cameraId = data.readInt32();
int32_t halVersion = data.readInt32();
const String16 clientName = data.readString16();
int32_t clientUid = data.readInt32();
sp<ICamera> camera;
status_t status = connectLegacy(cameraClient, cameraId, halVersion,
clientName, clientUid, /*out*/camera);
reply->writeNoException();
reply->writeInt32(status);
if (camera != NULL) {
reply->writeInt32(1);
reply->writeStrongBinder(IInterface::asBinder(camera));
} else {
reply->writeInt32(0);
}
return NO_ERROR;
} break;
case SET_TORCH_MODE: {
CHECK_INTERFACE(ICameraService, data, reply);
String16 cameraId = data.readString16();
bool enabled = data.readInt32() != 0 ? true : false;
const sp<IBinder> clientBinder = data.readStrongBinder();
status_t status = setTorchMode(cameraId, enabled, clientBinder);
reply->writeNoException();
reply->writeInt32(status);
return NO_ERROR;
} break;
case NOTIFY_SYSTEM_EVENT: {
CHECK_INTERFACE(ICameraService, data, reply);
int32_t eventId = data.readInt32();
int32_t len = data.readInt32();
if (len < 0) {
ALOGE("%s: Received poorly formatted length in binder request: notifySystemEvent.",
__FUNCTION__);
return FAILED_TRANSACTION;
}
if (len > 512) {
ALOGE("%s: Length %" PRIi32 " too long in binder request: notifySystemEvent.",
__FUNCTION__, len);
return FAILED_TRANSACTION;
}
int32_t events[len];
memset(events, 0, sizeof(int32_t) * len);
status_t status = data.read(events, sizeof(int32_t) * len);
if (status != NO_ERROR) {
ALOGE("%s: Received poorly formatted binder request: notifySystemEvent.",
__FUNCTION__);
return FAILED_TRANSACTION;
}
notifySystemEvent(eventId, events, len);
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
// ----------------------------------------------------------------------------
}; // namespace android