Camera: Switch camera2 to auto-gen C++ binder interfaces
- Move camera service AIDL files to frameworks/av
- Build C++ interface stubs with AIDL tools
- Add necessary native-side parcelables and update existing ones
- Remove manually-written stubs, rearrange remaining manual stubs
- Adjust implementations to work with auto-generated stubs
- Adjust method signatures for auto-gen differences
- Add rich error messages using binder::Status
Bug: 25091611
Change-Id: I6f69f34b9d1a3f8d1fb7db87357363f8fa8483ff
diff --git a/camera/ndk/Android.mk b/camera/ndk/Android.mk
index 8e84e40..e43bb2c 100644
--- a/camera/ndk/Android.mk
+++ b/camera/ndk/Android.mk
@@ -34,9 +34,8 @@
LOCAL_MODULE:= libcamera2ndk
LOCAL_C_INCLUDES := \
- system/media/camera/include \
frameworks/av/include/camera/ndk \
- frameworks/av/include/ndk \
+ frameworks/av/include/ndk
LOCAL_CFLAGS += -fvisibility=hidden -D EXPORT='__attribute__ ((visibility ("default")))'
diff --git a/camera/ndk/NdkCameraManager.cpp b/camera/ndk/NdkCameraManager.cpp
index 7d9f84b..ff15263 100644
--- a/camera/ndk/NdkCameraManager.cpp
+++ b/camera/ndk/NdkCameraManager.cpp
@@ -24,6 +24,8 @@
#include <NdkCameraManager.h>
#include "impl/ACameraManager.h"
+using namespace android;
+
EXPORT
ACameraManager* ACameraManager_create() {
ATRACE_CALL();
diff --git a/camera/ndk/impl/ACameraDevice.cpp b/camera/ndk/impl/ACameraDevice.cpp
index 5f89fa3..1ab6af8 100644
--- a/camera/ndk/impl/ACameraDevice.cpp
+++ b/camera/ndk/impl/ACameraDevice.cpp
@@ -20,6 +20,8 @@
#include <vector>
#include <utility>
#include <inttypes.h>
+#include <android/hardware/ICameraService.h>
+#include <camera2/SubmitInfo.h>
#include <gui/Surface.h>
#include "ACameraDevice.h"
#include "ACameraMetadata.h"
@@ -117,13 +119,14 @@
return ACAMERA_ERROR_CAMERA_DISCONNECTED;
}
CameraMetadata rawRequest;
- status_t remoteRet = mRemote->createDefaultRequest(templateId, &rawRequest);
- if (remoteRet == BAD_VALUE) {
+ binder::Status remoteRet = mRemote->createDefaultRequest(templateId, &rawRequest);
+ if (remoteRet.serviceSpecificErrorCode() ==
+ hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT) {
ALOGW("Create capture request failed! template %d is not supported on this device",
templateId);
return ACAMERA_ERROR_UNSUPPORTED;
- } else if (remoteRet != OK) {
- ALOGE("Create capture request failed! error %d", remoteRet);
+ } else if (!remoteRet.isOk()) {
+ ALOGE("Create capture request failed: %s", remoteRet.toString8().string());
return ACAMERA_ERROR_UNKNOWN;
}
ACaptureRequest* outReq = new ACaptureRequest();
@@ -201,8 +204,8 @@
return ret;
}
- // Form List/Vector of capture request
- List<sp<CaptureRequest> > requestList;
+ // Form two vectors of capture request, one for internal tracking
+ std::vector<hardware::camera2::CaptureRequest> requestList;
Vector<sp<CaptureRequest> > requestsV;
requestsV.setCapacity(numRequests);
for (int i = 0; i < numRequests; i++) {
@@ -216,7 +219,7 @@
ALOGE("Capture request without output target cannot be submitted!");
return ACAMERA_ERROR_INVALID_PARAMETER;
}
- requestList.push_back(req);
+ requestList.push_back(*(req.get()));
requestsV.push_back(req);
}
@@ -228,10 +231,11 @@
}
}
- int sequenceId;
- int64_t lastFrameNumber;
-
- sequenceId = mRemote->submitRequestList(requestList, isRepeating, &lastFrameNumber);
+ binder::Status remoteRet;
+ hardware::camera2::utils::SubmitInfo info;
+ remoteRet = mRemote->submitRequestList(requestList, isRepeating, &info);
+ int sequenceId = info.mRequestId;
+ int64_t lastFrameNumber = info.mLastFrameNumber;
if (sequenceId < 0) {
ALOGE("Camera %s submit request remote failure: ret %d", getId(), sequenceId);
return ACAMERA_ERROR_UNKNOWN;
@@ -371,9 +375,9 @@
mRepeatingSequenceId = REQUEST_ID_NONE;
int64_t lastFrameNumber;
- status_t remoteRet = mRemote->cancelRequest(repeatingSequenceId, &lastFrameNumber);
- if (remoteRet != OK) {
- ALOGE("Stop repeating request fails in remote! ret %d", remoteRet);
+ binder::Status remoteRet = mRemote->cancelRequest(repeatingSequenceId, &lastFrameNumber);
+ if (!remoteRet.isOk()) {
+ ALOGE("Stop repeating request fails in remote: %s", remoteRet.toString8().string());
return ACAMERA_ERROR_UNKNOWN;
}
checkRepeatingSequenceCompleteLocked(repeatingSequenceId, lastFrameNumber);
@@ -394,9 +398,9 @@
return ACAMERA_ERROR_INVALID_OPERATION;
}
- status_t remoteRet = mRemote->waitUntilIdle();
- if (remoteRet != OK) {
- ALOGE("Camera device %s waitUntilIdle failed! ret %d", getId(), remoteRet);
+ binder::Status remoteRet = mRemote->waitUntilIdle();
+ if (!remoteRet.isOk()) {
+ ALOGE("Camera device %s waitUntilIdle failed: %s", getId(), remoteRet.toString8().string());
// TODO: define a function to convert status_t -> camera_status_t
return ACAMERA_ERROR_UNKNOWN;
}
@@ -508,17 +512,18 @@
}
mIdle = true;
- status_t remoteRet = mRemote->beginConfigure();
- if (remoteRet != ACAMERA_OK) {
- ALOGE("Camera device %s begin configure failed, ret %d", getId(), remoteRet);
+ binder::Status remoteRet = mRemote->beginConfigure();
+ if (!remoteRet.isOk()) {
+ ALOGE("Camera device %s begin configure failed: %s", getId(), remoteRet.toString8().string());
return ACAMERA_ERROR_UNKNOWN;
}
// delete to-be-deleted streams
for (auto streamId : deleteList) {
remoteRet = mRemote->deleteStream(streamId);
- if (remoteRet != ACAMERA_OK) {
- ALOGE("Camera device %s fails to remove stream %d", getId(), streamId);
+ if (!remoteRet.isOk()) {
+ ALOGE("Camera device %s failed to remove stream %d: %s", getId(), streamId,
+ remoteRet.toString8().string());
return ACAMERA_ERROR_UNKNOWN;
}
mConfiguredOutputs.erase(streamId);
@@ -526,21 +531,23 @@
// add new streams
for (auto outConfig : addSet) {
- remoteRet = mRemote->createStream(outConfig);
- if (remoteRet < 0) {
- ALOGE("Camera device %s fails to create stream", getId());
+ int streamId;
+ remoteRet = mRemote->createStream(outConfig, &streamId);
+ if (!remoteRet.isOk()) {
+ ALOGE("Camera device %s failed to create stream: %s", getId(),
+ remoteRet.toString8().string());
return ACAMERA_ERROR_UNKNOWN;
}
- int streamId = remoteRet; // Weird, right?
mConfiguredOutputs.insert(std::make_pair(streamId, outConfig));
}
- remoteRet = mRemote->endConfigure();
- if (remoteRet == BAD_VALUE) {
- ALOGE("Camera device %s cannnot support app output configuration", getId());
+ remoteRet = mRemote->endConfigure(/*isConstrainedHighSpeed*/ false);
+ if (remoteRet.serviceSpecificErrorCode() == hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT) {
+ ALOGE("Camera device %s cannnot support app output configuration: %s", getId(),
+ remoteRet.toString8().string());
return ACAMERA_ERROR_STREAM_CONFIGURE_FAIL;
- } else if (remoteRet != ACAMERA_OK) {
- ALOGE("Camera device %s end configure failed, ret %d", getId(), remoteRet);
+ } else if (!remoteRet.isOk()) {
+ ALOGE("Camera device %s end configure failed: %s", getId(), remoteRet.toString8().string());
return ACAMERA_ERROR_UNKNOWN;
}
@@ -548,7 +555,7 @@
}
void
-CameraDevice::setRemoteDevice(sp<ICameraDeviceUser> remote) {
+CameraDevice::setRemoteDevice(sp<hardware::camera2::ICameraDeviceUser> remote) {
Mutex::Autolock _l(mDeviceLock);
mRemote = remote;
}
@@ -615,14 +622,14 @@
void
CameraDevice::onCaptureErrorLocked(
- ICameraDeviceCallbacks::CameraErrorCode errorCode,
+ int32_t errorCode,
const CaptureResultExtras& resultExtras) {
int sequenceId = resultExtras.requestId;
int64_t frameNumber = resultExtras.frameNumber;
int32_t burstId = resultExtras.burstId;
// No way to report buffer error now
- if (errorCode == ICameraDeviceCallbacks::CameraErrorCode::ERROR_CAMERA_BUFFER) {
+ if (errorCode == hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER) {
ALOGE("Camera %s Lost output buffer for frame %" PRId64,
getId(), frameNumber);
return;
@@ -646,7 +653,7 @@
failure->reason = CAPTURE_FAILURE_REASON_ERROR;
failure->sequenceId = sequenceId;
failure->wasImageCaptured = (errorCode ==
- ICameraDeviceCallbacks::CameraErrorCode::ERROR_CAMERA_RESULT);
+ hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT);
sp<AMessage> msg = new AMessage(kWhatCaptureFail, mHandler);
msg->setPointer(kContextKey, cbh.mCallbacks.context);
@@ -999,21 +1006,21 @@
/**
* Camera service callback implementation
*/
-void
+binder::Status
CameraDevice::ServiceCallback::onDeviceError(
- CameraErrorCode errorCode,
+ int32_t errorCode,
const CaptureResultExtras& resultExtras) {
ALOGD("Device error received, code %d, frame number %" PRId64 ", request ID %d, subseq ID %d",
errorCode, resultExtras.frameNumber, resultExtras.requestId, resultExtras.burstId);
-
+ binder::Status ret = binder::Status::ok();
sp<CameraDevice> dev = mDevice.promote();
if (dev == nullptr) {
- return; // device has been closed
+ return ret; // device has been closed
}
Mutex::Autolock _l(dev->mDeviceLock);
if (dev->mRemote == nullptr) {
- return; // device has been closed
+ return ret; // device has been closed
}
switch (errorCode) {
case ERROR_CAMERA_DISCONNECTED:
@@ -1061,24 +1068,26 @@
dev->onCaptureErrorLocked(errorCode, resultExtras);
break;
}
+ return ret;
}
-void
+binder::Status
CameraDevice::ServiceCallback::onDeviceIdle() {
ALOGV("Camera is now idle");
+ binder::Status ret = binder::Status::ok();
sp<CameraDevice> dev = mDevice.promote();
if (dev == nullptr) {
- return; // device has been closed
+ return ret; // device has been closed
}
Mutex::Autolock _l(dev->mDeviceLock);
if (dev->isClosed() || dev->mRemote == nullptr) {
- return;
+ return ret;
}
if (dev->mIdle) {
// Already in idle state. Possibly other thread did waitUntilIdle
- return;
+ return ret;
}
if (dev->mCurrentSession != nullptr) {
@@ -1086,7 +1095,7 @@
if (dev->mBusySession != dev->mCurrentSession) {
ALOGE("Current session != busy session");
dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE);
- return;
+ return ret;
}
sp<AMessage> msg = new AMessage(kWhatSessionStateCb, dev->mHandler);
msg->setPointer(kContextKey, dev->mBusySession->mUserSessionCallback.context);
@@ -1098,19 +1107,22 @@
msg->post();
}
dev->mIdle = true;
+ return ret;
}
-void
+binder::Status
CameraDevice::ServiceCallback::onCaptureStarted(
const CaptureResultExtras& resultExtras,
int64_t timestamp) {
+ binder::Status ret = binder::Status::ok();
+
sp<CameraDevice> dev = mDevice.promote();
if (dev == nullptr) {
- return; // device has been closed
+ return ret; // device has been closed
}
Mutex::Autolock _l(dev->mDeviceLock);
if (dev->isClosed() || dev->mRemote == nullptr) {
- return;
+ return ret;
}
int sequenceId = resultExtras.requestId;
@@ -1136,15 +1148,18 @@
msg->setInt64(kTimeStampKey, timestamp);
msg->post();
}
+ return ret;
}
-void
+binder::Status
CameraDevice::ServiceCallback::onResultReceived(
const CameraMetadata& metadata,
const CaptureResultExtras& resultExtras) {
+ binder::Status ret = binder::Status::ok();
+
sp<CameraDevice> dev = mDevice.promote();
if (dev == nullptr) {
- return; // device has been closed
+ return ret; // device has been closed
}
int sequenceId = resultExtras.requestId;
int64_t frameNumber = resultExtras.frameNumber;
@@ -1157,7 +1172,7 @@
Mutex::Autolock _l(dev->mDeviceLock);
if (dev->mRemote == nullptr) {
- return; // device has been disconnected
+ return ret; // device has been disconnected
}
if (dev->isClosed()) {
@@ -1165,7 +1180,7 @@
dev->mFrameNumberTracker.updateTracker(frameNumber, /*isError*/false);
}
// early return to avoid callback sent to closed devices
- return;
+ return ret;
}
CameraMetadata metadataCopy = metadata;
@@ -1201,12 +1216,14 @@
dev->mFrameNumberTracker.updateTracker(frameNumber, /*isError*/false);
dev->checkAndFireSequenceCompleteLocked();
}
+
+ return ret;
}
-void
+binder::Status
CameraDevice::ServiceCallback::onPrepared(int) {
// Prepare not yet implemented in NDK
- return;
+ return binder::Status::ok();
}
} // namespace android
diff --git a/camera/ndk/impl/ACameraDevice.h b/camera/ndk/impl/ACameraDevice.h
index b73e621..46243b9 100644
--- a/camera/ndk/impl/ACameraDevice.h
+++ b/camera/ndk/impl/ACameraDevice.h
@@ -26,20 +26,18 @@
#include <utils/List.h>
#include <utils/Vector.h>
+#include <android/hardware/camera2/BnCameraDeviceCallbacks.h>
+#include <android/hardware/camera2/ICameraDeviceUser.h>
#include <media/stagefright/foundation/ALooper.h>
#include <media/stagefright/foundation/AHandler.h>
#include <media/stagefright/foundation/AMessage.h>
#include <camera/CaptureResult.h>
-#include <camera/camera2/ICameraDeviceCallbacks.h>
-#include <camera/camera2/ICameraDeviceUser.h>
#include <camera/camera2/OutputConfiguration.h>
#include <camera/camera2/CaptureRequest.h>
#include <NdkCameraDevice.h>
#include "ACameraMetadata.h"
-using namespace android;
-
namespace android {
// Wrap ACameraCaptureFailure so it can be ref-counter
@@ -64,24 +62,26 @@
/*out*/ACameraCaptureSession** session);
// Callbacks from camera service
- class ServiceCallback : public BnCameraDeviceCallbacks {
+ class ServiceCallback : public hardware::camera2::BnCameraDeviceCallbacks {
public:
ServiceCallback(CameraDevice* device) : mDevice(device) {}
- void onDeviceError(CameraErrorCode errorCode,
+ binder::Status onDeviceError(int32_t errorCode,
const CaptureResultExtras& resultExtras) override;
- void onDeviceIdle() override;
- void onCaptureStarted(const CaptureResultExtras& resultExtras,
+ binder::Status onDeviceIdle() override;
+ binder::Status onCaptureStarted(const CaptureResultExtras& resultExtras,
int64_t timestamp) override;
- void onResultReceived(const CameraMetadata& metadata,
+ binder::Status onResultReceived(const CameraMetadata& metadata,
const CaptureResultExtras& resultExtras) override;
- void onPrepared(int streamId) override;
+ binder::Status onPrepared(int streamId) override;
private:
const wp<CameraDevice> mDevice;
};
- inline sp<ICameraDeviceCallbacks> getServiceCallback() { return mServiceCallback; };
+ inline sp<hardware::camera2::ICameraDeviceCallbacks> getServiceCallback() {
+ return mServiceCallback;
+ };
// Camera device is only functional after remote being set
- void setRemoteDevice(sp<ICameraDeviceUser> remote);
+ void setRemoteDevice(sp<hardware::camera2::ICameraDeviceUser> remote);
inline ACameraDevice* getWrapper() const { return mWrapper; };
@@ -155,14 +155,14 @@
bool mInError;
camera_status_t mError;
void onCaptureErrorLocked(
- ICameraDeviceCallbacks::CameraErrorCode errorCode,
+ int32_t errorCode,
const CaptureResultExtras& resultExtras);
bool mIdle;
// This will avoid a busy session being deleted before it's back to idle state
sp<ACameraCaptureSession> mBusySession;
- sp<ICameraDeviceUser> mRemote;
+ sp<hardware::camera2::ICameraDeviceUser> mRemote;
// Looper thread to handle callback to app
sp<ALooper> mCbLooper;
@@ -294,17 +294,17 @@
/***********************
* Device interal APIs *
***********************/
- inline sp<ICameraDeviceCallbacks> getServiceCallback() {
+ inline android::sp<android::hardware::camera2::ICameraDeviceCallbacks> getServiceCallback() {
return mDevice->getServiceCallback();
};
// Camera device is only functional after remote being set
- inline void setRemoteDevice(sp<ICameraDeviceUser> remote) {
+ inline void setRemoteDevice(android::sp<android::hardware::camera2::ICameraDeviceUser> remote) {
mDevice->setRemoteDevice(remote);
}
private:
- sp<CameraDevice> mDevice;
+ android::sp<android::CameraDevice> mDevice;
};
#endif // _ACAMERA_DEVICE_H
diff --git a/camera/ndk/impl/ACameraManager.cpp b/camera/ndk/impl/ACameraManager.cpp
index ed5c3ba..6fa0864 100644
--- a/camera/ndk/impl/ACameraManager.cpp
+++ b/camera/ndk/impl/ACameraManager.cpp
@@ -71,7 +71,7 @@
mCameraService.clear();
}
-sp<ICameraService> CameraManagerGlobal::getCameraService() {
+sp<hardware::ICameraService> CameraManagerGlobal::getCameraService() {
Mutex::Autolock _l(mLock);
if (mCameraService.get() == nullptr) {
sp<IServiceManager> sm = defaultServiceManager();
@@ -88,7 +88,7 @@
mDeathNotifier = new DeathNotifier(this);
}
binder->linkToDeath(mDeathNotifier);
- mCameraService = interface_cast<ICameraService>(binder);
+ mCameraService = interface_cast<hardware::ICameraService>(binder);
// Setup looper thread to perfrom availiability callbacks
if (mCbLooper == nullptr) {
@@ -111,22 +111,23 @@
mCameraService->addListener(mCameraServiceListener);
// setup vendor tags
- sp<VendorTagDescriptor> desc;
- status_t ret = mCameraService->getCameraVendorTagDescriptor(/*out*/desc);
+ sp<VendorTagDescriptor> desc = new VendorTagDescriptor();
+ binder::Status ret = mCameraService->getCameraVendorTagDescriptor(/*out*/desc.get());
- if (ret == OK) {
- ret = VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc);
- if (ret != OK) {
+ if (ret.isOk()) {
+ status_t err = VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc);
+ if (err != OK) {
ALOGE("%s: Failed to set vendor tag descriptors, received error %s (%d)",
- __FUNCTION__, strerror(-ret), ret);
+ __FUNCTION__, strerror(-err), err);
}
- } else if (ret == -EOPNOTSUPP) {
+ } else if (ret.serviceSpecificErrorCode() ==
+ hardware::ICameraService::ERROR_DEPRECATED_HAL) {
ALOGW("%s: Camera HAL too old; does not support vendor tags",
__FUNCTION__);
VendorTagDescriptor::clearGlobalVendorTagDescriptor();
} else {
- ALOGE("%s: Failed to get vendor tag descriptors, received error %s (%d)",
- __FUNCTION__, strerror(-ret), ret);
+ ALOGE("%s: Failed to get vendor tag descriptors: %s",
+ __FUNCTION__, ret.toString8().string());
}
}
ALOGE_IF(mCameraService == nullptr, "no CameraService!?");
@@ -142,7 +143,7 @@
for (auto pair : cm->mDeviceStatusMap) {
int32_t cameraId = pair.first;
cm->onStatusChangedLocked(
- ICameraServiceListener::STATUS_NOT_PRESENT, cameraId);
+ CameraServiceListener::STATUS_NOT_PRESENT, cameraId);
}
cm->mCameraService.clear();
// TODO: consider adding re-connect call here?
@@ -158,7 +159,7 @@
if (pair.second) {
for (auto pair : mDeviceStatusMap) {
int32_t cameraId = pair.first;
- Status status = pair.second;
+ int32_t status = pair.second;
sp<AMessage> msg = new AMessage(kWhatSendSingleCallback, mHandler);
ACameraManager_AvailabilityCallback cb = isStatusAvailable(status) ?
@@ -178,21 +179,21 @@
mCallbacks.erase(cb);
}
-bool CameraManagerGlobal::validStatus(Status status) {
+bool CameraManagerGlobal::validStatus(int32_t status) {
switch (status) {
- case ICameraServiceListener::STATUS_NOT_PRESENT:
- case ICameraServiceListener::STATUS_PRESENT:
- case ICameraServiceListener::STATUS_ENUMERATING:
- case ICameraServiceListener::STATUS_NOT_AVAILABLE:
+ case hardware::ICameraServiceListener::STATUS_NOT_PRESENT:
+ case hardware::ICameraServiceListener::STATUS_PRESENT:
+ case hardware::ICameraServiceListener::STATUS_ENUMERATING:
+ case hardware::ICameraServiceListener::STATUS_NOT_AVAILABLE:
return true;
default:
return false;
}
}
-bool CameraManagerGlobal::isStatusAvailable(Status status) {
+bool CameraManagerGlobal::isStatusAvailable(int32_t status) {
switch (status) {
- case ICameraServiceListener::STATUS_PRESENT:
+ case hardware::ICameraServiceListener::STATUS_PRESENT:
return true;
default:
return false;
@@ -239,31 +240,32 @@
}
}
-void CameraManagerGlobal::CameraServiceListener::onStatusChanged(
- Status status, int32_t cameraId) {
+binder::Status CameraManagerGlobal::CameraServiceListener::onStatusChanged(
+ int32_t status, int32_t cameraId) {
sp<CameraManagerGlobal> cm = mCameraManager.promote();
- if (cm == nullptr) {
+ if (cm != nullptr) {
+ cm->onStatusChanged(status, cameraId);
+ } else {
ALOGE("Cannot deliver status change. Global camera manager died");
- return;
}
- cm->onStatusChanged(status, cameraId);
+ return binder::Status::ok();
}
void CameraManagerGlobal::onStatusChanged(
- Status status, int32_t cameraId) {
+ int32_t status, int32_t cameraId) {
Mutex::Autolock _l(mLock);
onStatusChangedLocked(status, cameraId);
}
void CameraManagerGlobal::onStatusChangedLocked(
- Status status, int32_t cameraId) {
+ int32_t status, int32_t cameraId) {
if (!validStatus(status)) {
ALOGE("%s: Invalid status %d", __FUNCTION__, status);
return;
}
bool firstStatus = (mDeviceStatusMap.count(cameraId) == 0);
- Status oldStatus = firstStatus ?
+ int32_t oldStatus = firstStatus ?
status : // first status
mDeviceStatusMap[cameraId];
@@ -296,19 +298,28 @@
if (mCachedCameraIdList.numCameras == kCameraIdListNotInit) {
int numCameras = 0;
Vector<char *> cameraIds;
- sp<ICameraService> cs = CameraManagerGlobal::getInstance().getCameraService();
+ sp<hardware::ICameraService> cs = CameraManagerGlobal::getInstance().getCameraService();
if (cs == nullptr) {
ALOGE("%s: Cannot reach camera service!", __FUNCTION__);
return ACAMERA_ERROR_CAMERA_DISCONNECTED;
}
// Get number of cameras
- int numAllCameras = cs->getNumberOfCameras(ICameraService::CAMERA_TYPE_ALL);
+ int numAllCameras = 0;
+ binder::Status serviceRet = cs->getNumberOfCameras(hardware::ICameraService::CAMERA_TYPE_ALL,
+ &numAllCameras);
+ if (!serviceRet.isOk()) {
+ ALOGE("%s: Error getting camera count: %s", __FUNCTION__,
+ serviceRet.toString8().string());
+ numAllCameras = 0;
+ }
// Filter API2 compatible cameras and push to cameraIds
for (int i = 0; i < numAllCameras; i++) {
// TODO: Only suppot HALs that supports API2 directly now
- status_t camera2Support = cs->supportsCameraApi(i, ICameraService::API_VERSION_2);
+ bool camera2Support = false;
+ serviceRet = cs->supportsCameraApi(i, hardware::ICameraService::API_VERSION_2,
+ &camera2Support);
char buf[kMaxCameraIdLen];
- if (camera2Support == OK) {
+ if (camera2Support) {
numCameras++;
mCameraIds.insert(i);
snprintf(buf, sizeof(buf), "%d", i);
@@ -401,15 +412,16 @@
ALOGE("%s: Camera ID %s does not exist!", __FUNCTION__, cameraIdStr);
return ACAMERA_ERROR_INVALID_PARAMETER;
}
- sp<ICameraService> cs = CameraManagerGlobal::getInstance().getCameraService();
+ sp<hardware::ICameraService> cs = CameraManagerGlobal::getInstance().getCameraService();
if (cs == nullptr) {
ALOGE("%s: Cannot reach camera service!", __FUNCTION__);
return ACAMERA_ERROR_CAMERA_DISCONNECTED;
}
CameraMetadata rawMetadata;
- status_t serviceRet = cs->getCameraCharacteristics(cameraId, &rawMetadata);
- if (serviceRet != OK) {
- ALOGE("Get camera characteristics from camera service failed! Err %d", ret);
+ binder::Status serviceRet = cs->getCameraCharacteristics(cameraId, &rawMetadata);
+ if (!serviceRet.isOk()) {
+ ALOGE("Get camera characteristics from camera service failed: %s",
+ serviceRet.toString8().string());
return ACAMERA_ERROR_UNKNOWN; // should not reach here
}
@@ -436,24 +448,23 @@
ACameraDevice* device = new ACameraDevice(cameraId, callback, std::move(chars));
- sp<ICameraService> cs = CameraManagerGlobal::getInstance().getCameraService();
+ sp<hardware::ICameraService> cs = CameraManagerGlobal::getInstance().getCameraService();
if (cs == nullptr) {
ALOGE("%s: Cannot reach camera service!", __FUNCTION__);
return ACAMERA_ERROR_CAMERA_DISCONNECTED;
}
int id = atoi(cameraId);
- sp<ICameraDeviceCallbacks> callbacks = device->getServiceCallback();
- sp<ICameraDeviceUser> deviceRemote;
+ sp<hardware::camera2::ICameraDeviceCallbacks> callbacks = device->getServiceCallback();
+ sp<hardware::camera2::ICameraDeviceUser> deviceRemote;
// No way to get package name from native.
// Send a zero length package name and let camera service figure it out from UID
- status_t serviceRet = cs->connectDevice(
+ binder::Status serviceRet = cs->connectDevice(
callbacks, id, String16(""),
- ICameraService::USE_CALLING_UID, /*out*/deviceRemote);
+ hardware::ICameraService::USE_CALLING_UID, /*out*/&deviceRemote);
- if (serviceRet != OK) {
- ALOGE("%s: connect camera device failed! err %d", __FUNCTION__, serviceRet);
- // TODO: generate better error message here
+ if (!serviceRet.isOk()) {
+ ALOGE("%s: connect camera device failed: %s", __FUNCTION__, serviceRet.toString8().string());
delete device;
return ACAMERA_ERROR_CAMERA_DISCONNECTED;
}
@@ -476,4 +487,3 @@
delete[] mCachedCameraIdList.cameraIds;
}
}
-
diff --git a/camera/ndk/impl/ACameraManager.h b/camera/ndk/impl/ACameraManager.h
index b68685d..3f2262f 100644
--- a/camera/ndk/impl/ACameraManager.h
+++ b/camera/ndk/impl/ACameraManager.h
@@ -19,9 +19,9 @@
#include "NdkCameraManager.h"
+#include <android/hardware/ICameraService.h>
+#include <android/hardware/BnCameraServiceListener.h>
#include <camera/CameraMetadata.h>
-#include <camera/ICameraService.h>
-#include <camera/ICameraServiceListener.h>
#include <binder/IServiceManager.h>
#include <utils/StrongPointer.h>
#include <utils/Mutex.h>
@@ -33,8 +33,6 @@
#include <set>
#include <map>
-using namespace android;
-
namespace android {
/**
@@ -47,7 +45,7 @@
class CameraManagerGlobal final : public RefBase {
public:
static CameraManagerGlobal& getInstance();
- sp<ICameraService> getCameraService();
+ sp<hardware::ICameraService> getCameraService();
void registerAvailabilityCallback(
const ACameraManager_AvailabilityCallbacks *callback);
@@ -55,7 +53,7 @@
const ACameraManager_AvailabilityCallbacks *callback);
private:
- sp<ICameraService> mCameraService;
+ sp<hardware::ICameraService> mCameraService;
const int kCameraServicePollDelay = 500000; // 0.5s
const char* kCameraServiceName = "media.camera";
Mutex mLock;
@@ -71,13 +69,16 @@
};
sp<DeathNotifier> mDeathNotifier;
- class CameraServiceListener final : public BnCameraServiceListener {
+ class CameraServiceListener final : public hardware::BnCameraServiceListener {
public:
CameraServiceListener(CameraManagerGlobal* cm) : mCameraManager(cm) {}
- virtual void onStatusChanged(Status status, int32_t cameraId);
+ virtual binder::Status onStatusChanged(int32_t status, int32_t cameraId);
// Torch API not implemented yet
- virtual void onTorchStatusChanged(TorchStatus, const String16&) {};
+ virtual binder::Status onTorchStatusChanged(int32_t, const String16&) {
+ return binder::Status::ok();
+ }
+
private:
const wp<CameraManagerGlobal> mCameraManager;
};
@@ -132,15 +133,14 @@
sp<CallbackHandler> mHandler;
sp<ALooper> mCbLooper; // Looper thread where callbacks actually happen on
- typedef ICameraServiceListener::Status Status;
- void onStatusChanged(Status status, int32_t cameraId);
- void onStatusChangedLocked(Status status, int32_t cameraId);
+ void onStatusChanged(int32_t status, int32_t cameraId);
+ void onStatusChangedLocked(int32_t status, int32_t cameraId);
// Utils for status
- static bool validStatus(Status status);
- static bool isStatusAvailable(Status status);
+ static bool validStatus(int32_t status);
+ static bool isStatusAvailable(int32_t status);
// Map camera_id -> status
- std::map<int32_t, Status> mDeviceStatusMap;
+ std::map<int32_t, int32_t> mDeviceStatusMap;
// For the singleton instance
static Mutex sLock;
@@ -158,7 +158,7 @@
struct ACameraManager {
ACameraManager() :
mCachedCameraIdList({kCameraIdListNotInit, nullptr}),
- mGlobalManager(&(CameraManagerGlobal::getInstance())) {}
+ mGlobalManager(&(android::CameraManagerGlobal::getInstance())) {}
~ACameraManager();
camera_status_t getCameraIdList(ACameraIdList** cameraIdList);
static void deleteCameraIdList(ACameraIdList* cameraIdList);
@@ -175,10 +175,10 @@
enum {
kCameraIdListNotInit = -1
};
- Mutex mLock;
+ android::Mutex mLock;
std::set<int> mCameraIds; // Init by getOrCreateCameraIdListLocked
ACameraIdList mCachedCameraIdList; // Init by getOrCreateCameraIdListLocked
- sp<CameraManagerGlobal> mGlobalManager;
+ android::sp<android::CameraManagerGlobal> mGlobalManager;
};
#endif //_ACAMERA_MANAGER_H