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