diff --git a/src/camera/examples/demo/BUILD.gn b/src/camera/examples/demo/BUILD.gn
index e97db51..fffcfe8 100644
--- a/src/camera/examples/demo/BUILD.gn
+++ b/src/camera/examples/demo/BUILD.gn
@@ -3,7 +3,6 @@
 # found in the LICENSE file.
 
 import("//build/package.gni")
-import("//src/graphics/lib/vulkan/layers.gni")
 
 demo_name = "camera_demo"
 
@@ -15,17 +14,17 @@
   ]
 
   deps = [
+    "./stream_provider",
     "//garnet/public/lib/fsl",
     "//garnet/public/lib/ui/base_view/cpp",
     "//garnet/public/lib/ui/scenic/cpp",
+    "//sdk/fidl/fuchsia.camera2",
     "//sdk/fidl/fuchsia.ui.gfx",
     "//sdk/lib/fidl/cpp",
     "//src/lib/fxl",
     "//src/lib/ui/scenic/cpp",
     "//src/ui/lib/glm_workaround",
     "//zircon/public/lib/async-loop-cpp",
-    "//zircon/system/fidl/fuchsia-camera-common",
-    "//zircon/system/fidl/fuchsia-camera-test:fuchsia-camera-test_c",
   ]
 }
 
diff --git a/src/camera/examples/demo/main.cc b/src/camera/examples/demo/main.cc
index fab0fcc..69c090f 100644
--- a/src/camera/examples/demo/main.cc
+++ b/src/camera/examples/demo/main.cc
@@ -8,8 +8,6 @@
 
 #include <dirent.h>
 #include <fcntl.h>
-#include <fuchsia/camera/common/cpp/fidl.h>
-#include <fuchsia/camera/test/c/fidl.h>
 #include <lib/async-loop/cpp/loop.h>
 #include <lib/component/cpp/startup_context.h>
 #include <lib/fdio/fdio.h>
@@ -18,6 +16,7 @@
 #include <lib/ui/scenic/cpp/commands.h>
 #include <lib/ui/scenic/cpp/resources.h>
 #include <lib/zx/time.h>
+#include <stream_provider.h>
 #include <sys/types.h>
 
 #include <queue>
@@ -34,23 +33,21 @@
 #include <glm/gtc/type_ptr.hpp>
 #include <glm/gtx/quaternion.hpp>
 
-static constexpr const char* kDevicePath = "/dev/class/isp-device-test/000";
-
 static const uint32_t kChaosMaxSleepMsec = 2000;
 static const uint32_t kChaosMeanSleepMsec = 50;
 
-static fuchsia::images::PixelFormat convertFormat(fuchsia_sysmem_PixelFormatType type) {
+static fuchsia::images::PixelFormat convertFormat(fuchsia::sysmem::PixelFormatType type) {
   switch (type) {
-    case fuchsia_sysmem_PixelFormatType_BGRA32:
+    case fuchsia::sysmem::PixelFormatType::BGRA32:
       return fuchsia::images::PixelFormat::BGRA_8;
-    case fuchsia_sysmem_PixelFormatType_YUY2:
+    case fuchsia::sysmem::PixelFormatType::YUY2:
       return fuchsia::images::PixelFormat::YUY2;
-    case fuchsia_sysmem_PixelFormatType_NV12:
+    case fuchsia::sysmem::PixelFormatType::NV12:
       return fuchsia::images::PixelFormat::NV12;
-    case fuchsia_sysmem_PixelFormatType_YV12:
+    case fuchsia::sysmem::PixelFormatType::YV12:
       return fuchsia::images::PixelFormat::YV12;
     default:
-      FXL_LOG(ERROR) << "sysmem pixel format (" << type
+      FXL_LOG(ERROR) << "sysmem pixel format (" << static_cast<uint32_t>(type)
                      << ") has no corresponding fuchsia::images::PixelFormat";
       return static_cast<fuchsia::images::PixelFormat>(-1);
   }
@@ -58,7 +55,7 @@
 
 // Draws a scenic scene containing a single rectangle with an image pipe material,
 // constructed with buffers populated by a stream provider (in this case, the ArmIspDevice).
-class DemoView : public scenic::BaseView {
+class DemoView : public scenic::BaseView, public fuchsia::camera2::Stream_EventSender {
  public:
   explicit DemoView(scenic::ViewContext context, async::Loop* loop, bool chaos)
       : BaseView(std::move(context), "Camera Demo"),
@@ -81,27 +78,15 @@
                                           bool chaos) {
     auto view = std::make_unique<DemoView>(std::move(context), loop, chaos);
 
-    int result = open(kDevicePath, O_RDONLY);
-    if (result < 0) {
-      FXL_LOG(ERROR) << "Error opening " << kDevicePath;
-      return nullptr;
-    }
-    fbl::unique_fd isp_fd(result);
-
-    zx::handle isp_handle;
-    zx_status_t status = fdio_get_service_handle(isp_fd.get(), isp_handle.reset_and_get_address());
-    if (status != ZX_OK) {
-      FXL_PLOG(ERROR, status) << "Failed to get service handle";
+    auto stream_provider = StreamProvider::Create(StreamProvider::Source::ISP);
+    if (!stream_provider) {
+      FXL_LOG(ERROR) << "Failed to get ISP stream provider";
       return nullptr;
     }
 
-    fuchsia_sysmem_BufferCollectionInfo buffers;
-    status = fuchsia_camera_test_IspTesterCreateStream(
-        isp_handle.get(), view->stream_.NewRequest().TakeChannel().release(), &buffers);
-    if (status != ZX_OK) {
-      FXL_PLOG(ERROR, status) << "Failed to call CreateStream";
-      return nullptr;
-    }
+    fuchsia::sysmem::ImageFormat_2 format;
+    fuchsia::sysmem::BufferCollectionInfo_2 buffers;
+    view->stream_ = stream_provider->ConnectToStream(view.get(), &format, &buffers);
 
     uint32_t image_pipe_id = view->session()->AllocResourceId();
     view->session()->Enqueue(
@@ -109,28 +94,25 @@
     scenic::Material material(view->session());
     material.SetTexture(image_pipe_id);
     view->session()->ReleaseResource(image_pipe_id);
-    scenic::Rectangle shape(view->session(), buffers.format.image.width,
-                            buffers.format.image.height);
-    view->shape_width_ = buffers.format.image.width;
+    scenic::Rectangle shape(view->session(), format.display_width, format.display_height);
+    view->shape_width_ = format.display_width;
     view->node_.SetShape(shape);
     view->node_.SetMaterial(material);
     view->root_node().AddChild(view->node_);
 
     fuchsia::images::ImageInfo image_info{};
-    image_info.width = buffers.format.image.width;
-    image_info.height = buffers.format.image.height;
-    image_info.stride = buffers.format.image.planes[0].bytes_per_row;
-    image_info.pixel_format = convertFormat(buffers.format.image.pixel_format.type);
+    image_info.width = format.display_width;
+    image_info.height = format.display_height;
+    image_info.stride = format.bytes_per_row;
+    image_info.pixel_format = convertFormat(format.pixel_format.type);
     for (uint32_t i = 0; i < buffers.buffer_count; ++i) {
       uint32_t image_id = i + 1;  // Scenic doesn't allow clients to use image ID 0.
-      zx::vmo vmo(buffers.vmos[i]);
-      view->image_pipe_->AddImage(image_id, image_info, std::move(vmo), 0, buffers.vmo_size,
+      view->image_pipe_->AddImage(image_id, image_info, std::move(buffers.buffers[i].vmo), 0,
+                                  buffers.settings.buffer_settings.size_bytes,
                                   fuchsia::images::MemoryType::HOST_MEMORY);
       view->image_ids_[i] = image_id;
     }
 
-    view->stream_.events().OnFrameAvailable =
-        fit::bind_member(view.get(), &DemoView::OnFrameAvailable);
     view->stream_->Start();
 
     view->InvalidateScene();
@@ -159,13 +141,14 @@
   // |scenic::SessionListener|
   void OnScenicError(std::string error) override { FXL_LOG(ERROR) << "Scenic Error " << error; }
 
-  void OnFrameAvailable(fuchsia::camera::common::FrameAvailableEvent event) {
+  // |fuchsia::camera2::Stream_EventSender|
+  void OnFrameAvailable(fuchsia::camera2::FrameAvailableInfo info) override {
     SleepIfChaos();
     if (!has_logical_size()) {
-      stream_->ReleaseFrame(event.buffer_id);
+      stream_->ReleaseFrame(info.buffer_id);
       return;
     }
-    if (event.frame_status != fuchsia::camera::common::FrameStatus::OK) {
+    if (info.frame_status != fuchsia::camera2::FrameStatus::OK) {
       FXL_LOG(ERROR) << "Received OnFrameAvailable with error event";
       return;
     }
@@ -188,20 +171,20 @@
 
     uint64_t now_ns = zx_clock_get_monotonic();
     image_pipe_->PresentImage(
-        image_ids_[event.buffer_id], now_ns, std::move(acquire_fences), std::move(release_fences),
+        image_ids_[info.buffer_id], now_ns, std::move(acquire_fences), std::move(release_fences),
         [this](fuchsia::images::PresentationInfo presentation_info) { SleepIfChaos(); });
 
     auto waiter = std::make_unique<async::Wait>(
         release_fence.get(), ZX_EVENT_SIGNALED, 0,
-        [this, event](async_dispatcher_t* dispatcher, async::Wait* wait, zx_status_t status,
-                      const zx_packet_signal_t* signal) {
+        [this, buffer_id = info.buffer_id](async_dispatcher_t* dispatcher, async::Wait* wait,
+                                           zx_status_t status, const zx_packet_signal_t* signal) {
           if (status != ZX_OK) {
             FXL_PLOG(ERROR, status) << "Wait failed";
             loop_->Quit();
             return;
           }
           SleepIfChaos();
-          stream_->ReleaseFrame(event.buffer_id);
+          stream_->ReleaseFrame(buffer_id);
         });
     waiters_.emplace(std::move(waiter), std::move(release_fence));
     status = waiters_.back().first->Begin(loop_->dispatcher());
@@ -232,7 +215,7 @@
   bool chaos_;
   std::mt19937 chaos_gen_;
   std::binomial_distribution<uint32_t> chaos_dist_;
-  fuchsia::camera::common::StreamPtr stream_;
+  std::unique_ptr<fuchsia::camera2::Stream> stream_;
   scenic::ShapeNode node_;
   fuchsia::images::ImagePipePtr image_pipe_;
   std::map<uint32_t, uint32_t> image_ids_;
diff --git a/src/camera/examples/demo/meta/demo.cmx b/src/camera/examples/demo/meta/demo.cmx
index 5094350..057da52 100644
--- a/src/camera/examples/demo/meta/demo.cmx
+++ b/src/camera/examples/demo/meta/demo.cmx
@@ -1,18 +1,17 @@
 {
-    "program": {
-        "binary": "bin/app"
-    },
-    "sandbox": {
-        "dev": [
-            "class/isp-device-test"
-        ],
-        "services": [
-            "fuchsia.sys.Environment",
-            "fuchsia.sys.Launcher",
-            "fuchsia.tracing.provider.Registry",
-            "fuchsia.ui.policy.Presenter",
-            "fuchsia.ui.scenic.Scenic",
-            "fuchsia.camera.test.IspTester"
-        ]
-    }
-}
+  "program": {
+    "binary": "bin/app"
+  },
+  "sandbox": {
+    "dev": [
+      "class/isp-device-test"
+    ],
+    "services": [
+      "fuchsia.sys.Environment",
+      "fuchsia.sys.Launcher",
+      "fuchsia.tracing.provider.Registry",
+      "fuchsia.ui.policy.Presenter",
+      "fuchsia.ui.scenic.Scenic"
+    ]
+  }
+}
\ No newline at end of file
diff --git a/src/camera/examples/demo/stream_provider/BUILD.gn b/src/camera/examples/demo/stream_provider/BUILD.gn
new file mode 100644
index 0000000..ea58016
--- /dev/null
+++ b/src/camera/examples/demo/stream_provider/BUILD.gn
@@ -0,0 +1,53 @@
+# Copyright 2019 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+group("stream_provider") {
+  public_deps = [
+    ":stream_provider_lib",
+  ]
+  public_configs = [
+    ":stream_provider_config",
+  ]
+}
+
+source_set("stream_provider_lib") {
+  visibility = [ ":*" ]
+
+  sources = [
+    "stream_provider.cc",
+    "isp_stream_provider.cc",
+  ]
+
+  deps = [
+    "//garnet/public/lib/fsl",
+    "//garnet/public/lib/ui/base_view/cpp",
+    "//garnet/public/lib/ui/scenic/cpp",
+    "//sdk/fidl/fuchsia.camera2.hal",
+    "//sdk/fidl/fuchsia.ui.gfx",
+    "//sdk/lib/fidl/cpp",
+    "//src/lib/fxl",
+    "//src/lib/ui/scenic/cpp",
+    "//src/ui/lib/glm_workaround",
+    "//zircon/public/lib/async-loop-cpp",
+    "//zircon/system/fidl/fuchsia-camera-common",
+    "//zircon/system/fidl/fuchsia-camera-test",
+  ]
+
+  configs += [
+    ":stream_provider_config",
+  ]
+
+  public_deps = [
+    "//sdk/fidl/fuchsia.camera2",
+    "//zircon/system/fidl/fuchsia-sysmem",
+  ]
+}
+
+config("stream_provider_config") {
+  visibility = [ ":*" ]
+
+  include_dirs = [
+    "//src/camera/examples/demo/stream_provider/include",
+  ]
+}
diff --git a/src/camera/examples/demo/stream_provider/camera_common_stream_shim.h b/src/camera/examples/demo/stream_provider/camera_common_stream_shim.h
new file mode 100644
index 0000000..c2bee8da8
--- /dev/null
+++ b/src/camera/examples/demo/stream_provider/camera_common_stream_shim.h
@@ -0,0 +1,75 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SRC_CAMERA_EXAMPLES_DEMO_CAMERA_COMMON_STREAM_SHIM_H_
+#define SRC_CAMERA_EXAMPLES_DEMO_CAMERA_COMMON_STREAM_SHIM_H_
+
+#include <fuchsia/camera/common/cpp/fidl.h>
+#include <fuchsia/camera2/cpp/fidl.h>
+
+#include <memory>
+
+namespace camera {
+
+// This class provides a shim to serve a fuchsia::camera2::Stream interface to a caller using a
+// fuchsia::camera::common::Stream client connection.
+class CameraCommonStreamShim : public fuchsia::camera2::Stream {
+ public:
+  CameraCommonStreamShim(fuchsia::camera::common::StreamPtr stream,
+                         fuchsia::camera2::Stream_EventSender* event_handler)
+      : stream_(std::move(stream)), event_handler_(event_handler) {
+    stream_.events().OnFrameAvailable = [this](fuchsia::camera::common::FrameAvailableEvent event) {
+      event_handler_->OnFrameAvailable(Convert(event));
+    };
+  }
+  virtual void Start() override { stream_->Start(); }
+  virtual void Stop() override { stream_->Stop(); }
+  virtual void ReleaseFrame(uint32_t buffer_id) override { stream_->ReleaseFrame(buffer_id); }
+  virtual void AcknowledgeFrameError() override {}
+  virtual void SetRegionOfInterest(float x_min, float y_min, float x_max, float y_max,
+                                   SetRegionOfInterestCallback callback) override {
+    callback(ZX_ERR_NOT_SUPPORTED);
+  }
+  virtual void SetImageFormat(uint32_t image_format_index,
+                              SetImageFormatCallback callback) override {
+    callback(ZX_ERR_NOT_SUPPORTED);
+  }
+  virtual void GetImageFormats(GetImageFormatsCallback callback) override {
+    callback(std::vector<fuchsia::sysmem::ImageFormat_2>());
+  }
+  static fuchsia::camera2::FrameAvailableInfo Convert(
+      fuchsia::camera::common::FrameAvailableEvent x) {
+    fuchsia::camera2::FrameAvailableInfo ret;
+    ret.frame_status = Convert(x.frame_status);
+    ret.buffer_id = x.buffer_id;
+    ret.metadata = Convert(x.metadata);
+    return ret;
+  }
+  static fuchsia::camera2::FrameStatus Convert(fuchsia::camera::common::FrameStatus frame_status) {
+    switch (frame_status) {
+      case fuchsia::camera::common::FrameStatus::OK:
+        return fuchsia::camera2::FrameStatus::OK;
+      case fuchsia::camera::common::FrameStatus::ERROR_FRAME:
+        return fuchsia::camera2::FrameStatus::ERROR_FRAME;
+      case fuchsia::camera::common::FrameStatus::ERROR_BUFFER_FULL:
+        return fuchsia::camera2::FrameStatus::ERROR_BUFFER_FULL;
+      default:
+        FXL_LOG(ERROR) << "Inconvertible Value " << static_cast<uint32_t>(frame_status);
+        return fuchsia::camera2::FrameStatus::OK;
+    }
+  }
+  static fuchsia::camera2::FrameMetadata Convert(fuchsia::camera::common::Metadata metadata) {
+    fuchsia::camera2::FrameMetadata ret;
+    ret.set_timestamp(metadata.timestamp);
+    return ret;
+  }
+
+ private:
+  fuchsia::camera::common::StreamPtr stream_;
+  fuchsia::camera2::Stream_EventSender* event_handler_;
+};
+
+}  // namespace camera
+
+#endif  // SRC_CAMERA_EXAMPLES_DEMO_CAMERA_COMMON_STREAM_SHIM_H_
diff --git a/src/camera/examples/demo/stream_provider/include/stream_provider.h b/src/camera/examples/demo/stream_provider/include/stream_provider.h
new file mode 100644
index 0000000..e266d3a
--- /dev/null
+++ b/src/camera/examples/demo/stream_provider/include/stream_provider.h
@@ -0,0 +1,53 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SRC_CAMERA_EXAMPLES_DEMO_STREAM_PROVIDER_STREAM_PROVIDER_H_
+#define SRC_CAMERA_EXAMPLES_DEMO_STREAM_PROVIDER_STREAM_PROVIDER_H_
+
+#include <fuchsia/camera2/cpp/fidl.h>
+#include <fuchsia/sysmem/cpp/fidl.h>
+#include <zircon/types.h>
+
+#include <memory>
+#include <string>
+
+// The StreamProvider class allows the caller to connect to a fuchsia::camera2::Stream client
+// endpoint from a variety of sources.
+class StreamProvider {
+ public:
+  enum class Source {
+    ISP,
+    NUM_SOURCES,
+  };
+  virtual ~StreamProvider() = default;
+
+  // Creates a provider from the given source
+  // Args:
+  //   |source|: the desired source of the stream
+  // Returns:
+  //   A StreamProvider instance, or nullptr on error
+  static std::unique_ptr<StreamProvider> Create(Source source);
+
+  // Gets the friendly name of stream source specified during creation of the provider
+  // Returns:
+  //   The friendly name of the source.
+  virtual std::string GetName() = 0;
+
+  // Creates a Stream instance, routing events to the given event_handler.
+  // This method reflects the corresponding API in CameraManager, however here the caller is not
+  // able to participate in buffer format negotiation. The caller must ensure that event_handler
+  // remain valid for the lifetime of the returned Stream.
+  // Args:
+  //   |event_handler|: a caller-provided implementation of Stream event handlers
+  //   |format_out|: output parameter that describes the format of the created stream
+  //   |buffers_out|: output parameter that describes the buffers backing the created stream
+  // Returns:
+  //   A Stream instance, or nullptr on error.
+  virtual std::unique_ptr<fuchsia::camera2::Stream> ConnectToStream(
+      fuchsia::camera2::Stream_EventSender* event_handler,
+      fuchsia::sysmem::ImageFormat_2* format_out,
+      fuchsia::sysmem::BufferCollectionInfo_2* buffers_out) = 0;
+};
+
+#endif  // SRC_CAMERA_EXAMPLES_DEMO_STREAM_PROVIDER_STREAM_PROVIDER_H_
diff --git a/src/camera/examples/demo/stream_provider/isp_stream_provider.cc b/src/camera/examples/demo/stream_provider/isp_stream_provider.cc
new file mode 100644
index 0000000..436bba1
--- /dev/null
+++ b/src/camera/examples/demo/stream_provider/isp_stream_provider.cc
@@ -0,0 +1,73 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "isp_stream_provider.h"
+
+#include <fcntl.h>
+#include <fuchsia/camera/common/cpp/fidl.h>
+#include <fuchsia/camera/test/cpp/fidl.h>
+#include <lib/async-loop/cpp/loop.h>
+#include <lib/fdio/fdio.h>
+
+#include <src/lib/fxl/logging.h>
+
+#include "camera_common_stream_shim.h"
+
+static constexpr const char* kDevicePath = "/dev/class/isp-device-test/000";
+
+// Create a provider using the known IspDeviceTest device.
+std::unique_ptr<StreamProvider> IspStreamProvider::Create() {
+  auto provider = std::make_unique<IspStreamProvider>();
+
+  int result = open(kDevicePath, O_RDONLY);
+  if (result < 0) {
+    FXL_LOG(ERROR) << "Error opening " << kDevicePath;
+    return nullptr;
+  }
+  provider->isp_fd_.reset(result);
+
+  return std::move(provider);
+}
+
+// Offer a stream as served through the tester interface.
+std::unique_ptr<fuchsia::camera2::Stream> IspStreamProvider::ConnectToStream(
+    fuchsia::camera2::Stream_EventSender* event_handler, fuchsia::sysmem::ImageFormat_2* format_out,
+    fuchsia::sysmem::BufferCollectionInfo_2* buffers_out) {
+  if (!format_out || !buffers_out) {
+    return nullptr;
+  }
+
+  // Get a channel to the tester device.
+  zx::channel channel;
+  zx_status_t status = fdio_get_service_handle(isp_fd_.get(), channel.reset_and_get_address());
+  if (status != ZX_OK) {
+    FXL_PLOG(ERROR, status) << "Failed to get service handle";
+    return nullptr;
+  }
+
+  // Bind the tester interface and create a stream.
+  fuchsia::camera::test::IspTesterSyncPtr tester;
+  tester.Bind(std::move(channel));
+  fuchsia::camera::common::StreamPtr stream;
+  fuchsia::sysmem::BufferCollectionInfo buffers;
+  status = tester->CreateStream(stream.NewRequest(), &buffers);
+  if (status != ZX_OK) {
+    FXL_PLOG(ERROR, status) << "Failed to create stream";
+    return nullptr;
+  }
+
+  // Populate output parameters with ISP-provided values and known parameters.
+  format_out->pixel_format.type = buffers.format.image().pixel_format.type;
+  format_out->display_width = buffers.format.image().width;
+  format_out->display_height = buffers.format.image().height;
+  format_out->bytes_per_row = buffers.format.image().planes[0].bytes_per_row;
+  buffers_out->buffer_count = buffers.buffer_count;
+  buffers_out->settings.buffer_settings.size_bytes = buffers.vmo_size;
+  for (uint32_t i = 0; i < buffers.buffer_count; ++i) {
+    buffers_out->buffers[i].vmo = std::move(buffers.vmos[i]);
+    buffers_out->buffers[i].vmo_usable_start = 0;
+  }
+
+  return std::make_unique<camera::CameraCommonStreamShim>(std::move(stream), event_handler);
+}
diff --git a/src/camera/examples/demo/stream_provider/isp_stream_provider.h b/src/camera/examples/demo/stream_provider/isp_stream_provider.h
new file mode 100644
index 0000000..0290828
--- /dev/null
+++ b/src/camera/examples/demo/stream_provider/isp_stream_provider.h
@@ -0,0 +1,25 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SRC_CAMERA_EXAMPLES_DEMO_ISP_STREAM_PROVIDER_H_
+#define SRC_CAMERA_EXAMPLES_DEMO_ISP_STREAM_PROVIDER_H_
+
+#include <fbl/unique_fd.h>
+
+#include "stream_provider.h"
+
+class IspStreamProvider : public StreamProvider {
+ public:
+  static std::unique_ptr<StreamProvider> Create();
+  virtual std::unique_ptr<fuchsia::camera2::Stream> ConnectToStream(
+      fuchsia::camera2::Stream_EventSender* event_handler,
+      fuchsia::sysmem::ImageFormat_2* format_out,
+      fuchsia::sysmem::BufferCollectionInfo_2* buffers_out) override;
+  virtual std::string GetName() override { return "Image Signal Processor (ISP)"; }
+
+ private:
+  fbl::unique_fd isp_fd_;
+};
+
+#endif  // SRC_CAMERA_EXAMPLES_DEMO_ISP_STREAM_PROVIDER_H_
diff --git a/src/camera/examples/demo/stream_provider/stream_provider.cc b/src/camera/examples/demo/stream_provider/stream_provider.cc
new file mode 100644
index 0000000..c89940a
--- /dev/null
+++ b/src/camera/examples/demo/stream_provider/stream_provider.cc
@@ -0,0 +1,16 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "stream_provider.h"
+
+#include "isp_stream_provider.h"
+
+std::unique_ptr<StreamProvider> StreamProvider::Create(Source source) {
+  switch (source) {
+    case Source::ISP:
+      return IspStreamProvider::Create();
+    default:
+      return nullptr;
+  }
+}