diff --git a/brillo_camera/main.cpp b/brillo_camera/main.cpp
index 6d5a3f8..081eb4f 100644
--- a/brillo_camera/main.cpp
+++ b/brillo_camera/main.cpp
@@ -25,10 +25,12 @@
 #include <brillo/message_loops/base_message_loop.h>
 #include <brillo/syslog_logging.h>
 #include <camera/CameraMetadata.h>
-#include <camera/ICameraService.h>
+#include <android/hardware/ICameraService.h>
 #include <camera/camera2/CaptureRequest.h>
-#include <camera/camera2/ICameraDeviceCallbacks.h>
-#include <camera/camera2/ICameraDeviceUser.h>
+#include <camera/camera2/SubmitInfo.h>
+#include <android/hardware/camera2/BnCameraDeviceCallbacks.h>
+#include <android/hardware/camera2/ICameraDeviceCallbacks.h>
+#include <android/hardware/camera2/ICameraDeviceUser.h>
 #include <camera/camera2/OutputConfiguration.h>
 #include <gui/BufferQueue.h>
 #include <gui/BufferQueueConsumer.h>
@@ -42,21 +44,23 @@
 #include <utils/String8.h>
 #include <utils/StrongPointer.h>
 
-using android::BnCameraDeviceCallbacks;
+using android::binder::Status;
 using android::BufferQueue;
 using android::CameraMetadata;
-using android::CaptureRequest;
 using android::CaptureResultExtras;
 using android::CpuConsumer;
-using android::ICameraDeviceCallbacks;
-using android::ICameraDeviceUser;
-using android::ICameraService;
+using android::hardware::camera2::BnCameraDeviceCallbacks;
+using android::hardware::camera2::CaptureRequest;
+using android::hardware::camera2::ICameraDeviceCallbacks;
+using android::hardware::camera2::ICameraDeviceUser;
+using android::hardware::camera2::utils::SubmitInfo;
+using android::hardware::ICameraService;
 using android::IGraphicBufferConsumer;
 using android::IGraphicBufferProducer;
 using android::OK;
+using android::sp;
 using android::String16;
 using android::Surface;
-using android::sp;
 
 namespace {
 
@@ -72,32 +76,44 @@
  public:
   explicit CameraDeviceCallbacks(brillo::MessageLoop* loop) : loop_(loop) {}
 
-  void onDeviceError(ICameraDeviceCallbacks::CameraErrorCode error_code,
-                     const CaptureResultExtras& /* result_extras */) override {
+  Status  onDeviceError(
+      int error_code,
+      const CaptureResultExtras& /* result_extras */) override {
     LOG(ERROR) << "Received camera error = " << error_code;
     loop_->BreakLoop();
+    return Status::ok();
   }
 
-  void onDeviceIdle() override {
+  Status onDeviceIdle() override {
     LOG(INFO) << "Camera device is idle";
+    return Status::ok();
   }
 
-  void onCaptureStarted(
+  Status onCaptureStarted(
       const CaptureResultExtras& /* result_extras */,
       int64_t /* timestamp */) override {
     LOG(INFO) << "Capture started.";
+    return Status::ok();
   }
 
-  void onResultReceived(
+  Status onResultReceived(
       const CameraMetadata& /* metadata */,
       const CaptureResultExtras& /* result_extras */) override {
     LOG(INFO) << "Capture result received";
     result_received_ = true;
     loop_->BreakLoop();
+    return Status::ok();
   }
 
-  void onPrepared(int stream_id) override {
+  Status onPrepared(int stream_id) override {
     LOG(INFO) << "Camera is prepared for stream " << stream_id;
+    return Status::ok();
+  }
+
+  Status onRepeatingRequestError(int64_t lastFrameNumber) {
+    LOG(INFO) << "Repeating request error, last frame = " << lastFrameNumber;
+    loop_->BreakLoop();
+    return Status::ok();
   }
 
   bool result_received() { return result_received_; }
@@ -115,7 +131,7 @@
   brillo::InitLog(brillo::kLogToStderr);
 
   // Create a message loop.
-  brillo::BaseMessageLoop message_loop;
+  brillo::BaseMessageLoop message_loop(new base::MessageLoopForIO);
 
   // Initialize a binder watcher.
   brillo::BinderWatcher watcher(&message_loop);
@@ -123,35 +139,37 @@
 
   LOG(INFO) << "Retrieving a binder for the camera service.";
   sp<ICameraService> camera_service;
-  android::status_t status = android::getService(
+  android::status_t service_status = android::getService(
       String16(kCameraServiceName), &camera_service);
-  CHECK(status == OK)
+  CHECK(service_status == OK)
       << "Failed to get ICameraService binder from service manager!";
 
   LOG(INFO) << "Asking how many cameras we have.";
-  const int32_t num_cameras = camera_service->getNumberOfCameras(
-      ICameraService::CAMERA_TYPE_ALL);
+  int32_t num_cameras;
+  Status status = camera_service->getNumberOfCameras(
+      ICameraService::CAMERA_TYPE_ALL, &num_cameras);
+  CHECK(status.isOk()) << "Failed to get number of cameras";
   CHECK(num_cameras > 0)
       << "ICameraService reports no cameras available";
 
   const int camera_id = 0;
   LOG(INFO) << "Connecting to camera " << camera_id;
   sp<CameraDeviceCallbacks> camera_cb =
-      new CameraDeviceCallbacks(&message_loop);
+    new CameraDeviceCallbacks(&message_loop);
   sp<ICameraDeviceCallbacks> camera_cb_alias = camera_cb;
   const String16 client_package_name("brillo");
   sp<ICameraDeviceUser> camera_device_user;
   status = camera_service->connectDevice(
       camera_cb_alias, camera_id, client_package_name,
       ICameraService::USE_CALLING_UID,
-      camera_device_user);
-  CHECK(status == OK) << "Failed to connect to camera id=" << camera_id
-                      << " error=" << status;
+      &camera_device_user);
+  CHECK(status.isOk()) << "Failed to connect to camera id="
+                       << camera_id << " error=" << status;
 
   LOG(INFO) << "Obtaining camera info";
   CameraMetadata camera_metadata;
   status = camera_device_user->getCameraInfo(&camera_metadata);
-  CHECK(status == OK) << "Failed to get camera info, error=" << status;
+  CHECK(status.isOk()) << "Failed to get camera info, error=" << status;
 
   LOG(INFO) << "Calculating smallest stream configuration";
   camera_metadata_entry streamConfigs =
@@ -159,12 +177,16 @@
   int32_t width = std::numeric_limits<int32_t>::max();
   int32_t height = 1;
   for (size_t i = 0; i < streamConfigs.count; i += 4) {
+    LOG(INFO) << "Found " << streamConfigs.count << " stream configs.";
     int32_t fmt = streamConfigs.data.i32[i];
+    LOG(INFO) << "Format: " << fmt;
     int32_t inout = streamConfigs.data.i32[i + 3];
+    LOG(INFO) << "inout: " << inout;
     if (fmt == ANDROID_SCALER_AVAILABLE_FORMATS_RAW16 &&
         inout == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT) {
       int32_t w = streamConfigs.data.i32[i + 1];
       int32_t h = streamConfigs.data.i32[i + 2];
+      LOG(INFO) << "w: " << w << " h: " << h;
 
       if (width * height > w * h) {
         width = w;
@@ -190,19 +212,21 @@
 
   LOG(INFO) << "Configuring the camera";
   status = camera_device_user->beginConfigure();
-  CHECK(status == OK) << "Failed calling ICameraDeviceUser::beginConfigure()"
-                      << " error = " << status;
+  CHECK(status.isOk()) << "Failed calling ICameraDeviceUser::beginConfigure()"
+                       << " error = " << status;
   android::OutputConfiguration output_configuration(
       buffer_producer, CAMERA3_STREAM_ROTATION_0);
-  status = camera_device_user->createStream(output_configuration);
-  CHECK(status == OK) << "Failed calling ICameraDeviceUser::createStream()"
-                      << " error = " << status;
+  int32_t stream_id;
+  status = camera_device_user->createStream(output_configuration, &stream_id);
+  CHECK(status.isOk()) << "Failed calling ICameraDeviceUser::createStream()"
+                       << " error = " << status;
   status = camera_device_user->endConfigure(false /* isConstrainedHighSpeed */);
-  CHECK(status == OK) << "Failed calling ICameraDeviceUser::endConfigure()"
-                      << " error = " << status;
+  CHECK(status.isOk()) << "Failed calling ICameraDeviceUser::endConfigure()"
+                       << " error = " << status;
 
   LOG(INFO) << "Creating capture_request";
-  sp<CaptureRequest> capture_request = new CaptureRequest;
+  // CaptureRequest doesn't define incStrong, can't be strong pointer.
+  CaptureRequest* capture_request = new CaptureRequest;
   status = camera_device_user->createDefaultRequest(
       CAMERA3_TEMPLATE_STILL_CAPTURE, &capture_request->mMetadata);
   sp<Surface> surface = new Surface(
@@ -211,11 +235,11 @@
   capture_request->mIsReprocess = false;
 
   LOG(INFO) << "Submitting capture request";
-  int64_t last_frame_number = 0;
+  SubmitInfo submit_info;
   status = camera_device_user->submitRequest(
-      capture_request, false, &last_frame_number);
-  CHECK(status == OK) << "Got error=" << status
-                      << " while submitting capture request.";
+      *capture_request, false, &submit_info);
+  CHECK(status.isOk()) << "Got error=" << status
+                       << " while submitting capture request.";
 
   LOG(INFO) << "Waiting for the camera to take a picture.";
   // If we don't hear back from the camera for long enough, just time out.
@@ -229,5 +253,8 @@
 
   // TODO(wiley) render this image to a file to save somewhere.
 
+  // Cleanup.
+  delete capture_request;
+
   return 0;
 }