diff --git a/Android.bp b/Android.bp
index e039773..8e2c849 100644
--- a/Android.bp
+++ b/Android.bp
@@ -36,6 +36,10 @@
 cc_binary {
     name: "chre_test_client",
     proprietary: true,
+    local_include_dirs: [
+        "chre_api/include/chre_api",
+        "util/include",
+    ],
     srcs: [
         "host/common/test/chre_test_client.cc",
     ],
diff --git a/Makefile b/Makefile
index f8a6c99..4066d5b 100644
--- a/Makefile
+++ b/Makefile
@@ -41,6 +41,7 @@
 HEXAGON_CFLAGS += -I$(SLPI_PREFIX)/core/api/dal
 HEXAGON_CFLAGS += -I$(SLPI_PREFIX)/core/api/mproc
 HEXAGON_CFLAGS += -I$(SLPI_PREFIX)/core/api/systemdrivers
+HEXAGON_CFLAGS += -I$(SLPI_PREFIX)/platform/rtld/inc
 HEXAGON_CFLAGS += -I$(SLPI_PREFIX)/Sensors/api
 HEXAGON_CFLAGS += -I$(SLPI_PREFIX)/Sensors/common/idl/inc
 HEXAGON_CFLAGS += -I$(SLPI_PREFIX)/Sensors/common/util/mathtools/inc
diff --git a/apps/gnss_world/gnss_world.cc b/apps/gnss_world/gnss_world.cc
index 291641c..7ebb895 100644
--- a/apps/gnss_world/gnss_world.cc
+++ b/apps/gnss_world/gnss_world.cc
@@ -22,8 +22,6 @@
 #define LOG_TAG "[GnssWorld]"
 
 #ifdef CHRE_NANOAPP_INTERNAL
-#include "chre/platform/platform_static_nanoapp_init.h"
-
 namespace chre {
 namespace {
 #endif  // CHRE_NANOAPP_INTERNAL
@@ -62,14 +60,16 @@
   // TODO: Implement this.
 }
 
-void nanoappStop() {
+void nanoappEnd() {
   LOGI("Stopped");
 }
 
 #ifdef CHRE_NANOAPP_INTERNAL
-}  // namespace
-
-PLATFORM_STATIC_NANOAPP_INIT(GnssWorld);
-
+}  // anonymous namespace
 }  // namespace chre
+
+#include "chre/util/nanoapp/app_id.h"
+#include "chre/platform/static_nanoapp_init.h"
+
+CHRE_STATIC_NANOAPP_INIT(GnssWorld, chre::kGnssWorldAppId, 0);
 #endif  // CHRE_NANOAPP_INTERNAL
diff --git a/apps/hello_world/Makefile b/apps/hello_world/Makefile
index c98268d..981d01c 100644
--- a/apps/hello_world/Makefile
+++ b/apps/hello_world/Makefile
@@ -5,13 +5,22 @@
 # Environment Checks ###########################################################
 
 ifeq ($(CHRE_PREFIX),)
-$(error "The CHRE_PREFIX environment variable must be set to a path to the \
-         CHRE project root. Example: export CHRE_PREFIX=$$HOME/chre")
+ifneq ($(ANDROID_BUILD_TOP),)
+CHRE_PREFIX = $(ANDROID_BUILD_TOP)/system/chre
+else
+$(error "You must run 'lunch' to setup ANDROID_BUILD_TOP, or explicitly define \
+         the CHRE_PREFIX environment variable to point to the CHRE root \
+	 directory.")
+endif
 endif
 
 # Nanoapp Configuration ########################################################
 
 NANOAPP_NAME = hello_world
+NANOAPP_ID = 0x0123456789000001
+NANOAPP_VERSION = 0x00000001
+
+NANOAPP_NAME_STRING = \"Hello\ World\"
 
 # Common Compiler Flags ########################################################
 
diff --git a/apps/hello_world/hello_world.cc b/apps/hello_world/hello_world.cc
index 71ff230..3b49b75 100644
--- a/apps/hello_world/hello_world.cc
+++ b/apps/hello_world/hello_world.cc
@@ -15,40 +15,43 @@
  */
 
 #include <chre.h>
-#include <cinttypes>
+#include <inttypes.h>
 
-#include "chre/util/nanoapp/log.h"
-
-#define LOG_TAG "[HelloWorld]"
+/**
+ * @file
+ * A very basic example nanoapp that just logs activity in its entry points.
+ * Note that code wrapped in #ifdef CHRE_NANOAPP_INTERNAL is only relevant when
+ * a nanoapp is to be statically built into the CHRE system binary, which would
+ * make it a "system nanoapp" rather than a true dynamically loadable nanoapp.
+ */
 
 #ifdef CHRE_NANOAPP_INTERNAL
-#include "chre/platform/platform_static_nanoapp_init.h"
-
 namespace chre {
 namespace {
 #endif  // CHRE_NANOAPP_INTERNAL
 
 bool nanoappStart() {
-  LOGI("App started on platform ID %" PRIx64, chreGetPlatformId());
+  chreLog(CHRE_LOG_INFO, "Hello, world!");
   return true;
 }
 
 void nanoappHandleEvent(uint32_t senderInstanceId,
                         uint16_t eventType,
-                        const void *eventData) {
-  uint64_t currentTime = chreGetTime();
-  LOGI("Received event 0x%" PRIx16 " at time %" PRIu64,
-       eventType, currentTime);
+                        const void * /*eventData*/) {
+  chreLog(CHRE_LOG_INFO, "Received event 0x%" PRIx16 " from 0x%" PRIx32 " at "
+          "time %" PRIu64, eventType, senderInstanceId, chreGetTime());
 }
 
-void nanoappStop() {
-  LOGI("Stopped");
+void nanoappEnd() {
+  chreLog(CHRE_LOG_INFO, "Goodbye, world!");
 }
 
 #ifdef CHRE_NANOAPP_INTERNAL
-}  // namespace
-
-PLATFORM_STATIC_NANOAPP_INIT(HelloWorld);
-
+}  // anonymous namespace
 }  // namespace chre
+
+#include "chre/util/nanoapp/app_id.h"
+#include "chre/platform/static_nanoapp_init.h"
+
+CHRE_STATIC_NANOAPP_INIT(HelloWorld, chre::kHelloWorldAppId, 0);
 #endif  // CHRE_NANOAPP_INTERNAL
diff --git a/apps/imu_cal/imu_cal.cc b/apps/imu_cal/imu_cal.cc
index 127d892..9f540d5 100644
--- a/apps/imu_cal/imu_cal.cc
+++ b/apps/imu_cal/imu_cal.cc
@@ -25,8 +25,6 @@
 #define LOG_TAG "[ImuCal]"
 
 #ifdef CHRE_NANOAPP_INTERNAL
-#include "chre/platform/platform_static_nanoapp_init.h"
-
 namespace chre {
 namespace {
 #endif  // CHRE_NANOAPP_INTERNAL
@@ -162,15 +160,17 @@
   }
 }
 
-void nanoappStop() {
+void nanoappEnd() {
   // TODO: Unscribe to sensors
   LOGI("Stopped");
 }
 
 #ifdef CHRE_NANOAPP_INTERNAL
-}  // namespace
-
-PLATFORM_STATIC_NANOAPP_INIT(ImuCal);
-
+}  // anonymous namespace
 }  // namespace chre
+
+#include "chre/util/nanoapp/app_id.h"
+#include "chre/platform/static_nanoapp_init.h"
+
+CHRE_STATIC_NANOAPP_INIT(ImuCal, chre::kImuCalAppId, 0);
 #endif  // CHRE_NANOAPP_INTERNAL
diff --git a/apps/include/chre/apps/apps.h b/apps/include/chre/apps/apps.h
index 70d4781..61ae234 100644
--- a/apps/include/chre/apps/apps.h
+++ b/apps/include/chre/apps/apps.h
@@ -17,18 +17,19 @@
 #ifndef CHRE_APPS_APPS_H_
 #define CHRE_APPS_APPS_H_
 
-#include "chre/platform/platform_nanoapp.h"
+#include "chre/core/nanoapp.h"
+#include "chre/util/unique_ptr.h"
 
 namespace chre {
 
-extern PlatformNanoapp gNanoappGnssWorld;
-extern PlatformNanoapp gNanoappHelloWorld;
-extern PlatformNanoapp gNanoappImuCal;
-extern PlatformNanoapp gNanoappMessageWorld;
-extern PlatformNanoapp gNanoappSensorWorld;
-extern PlatformNanoapp gNanoappTimerWorld;
-extern PlatformNanoapp gNanoappWifiWorld;
-extern PlatformNanoapp gNanoappWwanWorld;
+extern UniquePtr<Nanoapp> *gNanoappGnssWorld;
+extern UniquePtr<Nanoapp> *gNanoappHelloWorld;
+extern UniquePtr<Nanoapp> *gNanoappImuCal;
+extern UniquePtr<Nanoapp> *gNanoappMessageWorld;
+extern UniquePtr<Nanoapp> *gNanoappSensorWorld;
+extern UniquePtr<Nanoapp> *gNanoappTimerWorld;
+extern UniquePtr<Nanoapp> *gNanoappWifiWorld;
+extern UniquePtr<Nanoapp> *gNanoappWwanWorld;
 
 } // namespace chre
 
diff --git a/apps/message_world/message_world.cc b/apps/message_world/message_world.cc
index 5bd8b3e..a6ac289 100644
--- a/apps/message_world/message_world.cc
+++ b/apps/message_world/message_world.cc
@@ -22,8 +22,6 @@
 #define LOG_TAG "[MsgWorld]"
 
 #ifdef CHRE_NANOAPP_INTERNAL
-#include "chre/platform/platform_static_nanoapp_init.h"
-
 namespace chre {
 namespace {
 #endif  // CHRE_NANOAPP_INTERNAL
@@ -75,14 +73,16 @@
   }
 }
 
-void nanoappStop() {
+void nanoappEnd() {
   LOGI("Stopped");
 }
 
 #ifdef CHRE_NANOAPP_INTERNAL
-}  // namespace
-
-PLATFORM_STATIC_NANOAPP_INIT(MessageWorld);
-
+}  // anonymous namespace
 }  // namespace chre
+
+#include "chre/util/nanoapp/app_id.h"
+#include "chre/platform/static_nanoapp_init.h"
+
+CHRE_STATIC_NANOAPP_INIT(MessageWorld, chre::kMessageWorldAppId, 0);
 #endif  // CHRE_NANOAPP_INTERNAL
diff --git a/apps/sensor_world/sensor_world.cc b/apps/sensor_world/sensor_world.cc
index f084626..62aac96 100644
--- a/apps/sensor_world/sensor_world.cc
+++ b/apps/sensor_world/sensor_world.cc
@@ -25,8 +25,6 @@
 #define LOG_TAG "[SensorWorld]"
 
 #ifdef CHRE_NANOAPP_INTERNAL
-#include "chre/platform/platform_static_nanoapp_init.h"
-
 namespace chre {
 namespace {
 #endif  // CHRE_NANOAPP_INTERNAL
@@ -255,14 +253,16 @@
   }
 }
 
-void nanoappStop() {
+void nanoappEnd() {
   LOGI("Stopped");
 }
 
 #ifdef CHRE_NANOAPP_INTERNAL
-}  // namespace
-
-PLATFORM_STATIC_NANOAPP_INIT(SensorWorld);
-
+}  // anonymous namespace
 }  // namespace chre
+
+#include "chre/util/nanoapp/app_id.h"
+#include "chre/platform/static_nanoapp_init.h"
+
+CHRE_STATIC_NANOAPP_INIT(SensorWorld, chre::kSensorWorldAppId, 0);
 #endif  // CHRE_NANOAPP_INTERNAL
diff --git a/apps/timer_world/timer_world.cc b/apps/timer_world/timer_world.cc
index 5a65231..48dbed2 100644
--- a/apps/timer_world/timer_world.cc
+++ b/apps/timer_world/timer_world.cc
@@ -22,8 +22,6 @@
 #define LOG_TAG "[TimerWorld]"
 
 #ifdef CHRE_NANOAPP_INTERNAL
-#include "chre/platform/platform_static_nanoapp_init.h"
-
 namespace chre {
 namespace {
 #endif  // CHRE_NANOAPP_INTERNAL
@@ -71,14 +69,16 @@
   }
 }
 
-void nanoappStop() {
+void nanoappEnd() {
   LOGI("Stopped");
 }
 
 #ifdef CHRE_NANOAPP_INTERNAL
-}  // namespace
-
-PLATFORM_STATIC_NANOAPP_INIT(TimerWorld);
-
+}  // anonymous namespace
 }  // namespace chre
+
+#include "chre/util/nanoapp/app_id.h"
+#include "chre/platform/static_nanoapp_init.h"
+
+CHRE_STATIC_NANOAPP_INIT(TimerWorld, chre::kTimerWorldAppId, 0);
 #endif  // CHRE_NANOAPP_INTERNAL
diff --git a/apps/wifi_world/wifi_world.cc b/apps/wifi_world/wifi_world.cc
index 0a0f0f8..0a9e3c5 100644
--- a/apps/wifi_world/wifi_world.cc
+++ b/apps/wifi_world/wifi_world.cc
@@ -26,8 +26,6 @@
 //#define WIFI_WORLD_VERBOSE_WIFI_RESULT_LOGS
 
 #ifdef CHRE_NANOAPP_INTERNAL
-#include "chre/platform/platform_static_nanoapp_init.h"
-
 namespace chre {
 namespace {
 #endif  // CHRE_NANOAPP_INTERNAL
@@ -214,14 +212,16 @@
   }
 }
 
-void nanoappStop() {
+void nanoappEnd() {
   LOGI("Wifi world app stopped");
 }
 
 #ifdef CHRE_NANOAPP_INTERNAL
-}  // namespace
-
-PLATFORM_STATIC_NANOAPP_INIT(WifiWorld);
-
+}  // anonymous namespace
 }  // namespace chre
+
+#include "chre/util/nanoapp/app_id.h"
+#include "chre/platform/static_nanoapp_init.h"
+
+CHRE_STATIC_NANOAPP_INIT(WifiWorld, chre::kWifiWorldAppId, 0);
 #endif  // CHRE_NANOAPP_INTERNAL
diff --git a/apps/wwan_world/wwan_world.cc b/apps/wwan_world/wwan_world.cc
index a803bb2..7717000 100644
--- a/apps/wwan_world/wwan_world.cc
+++ b/apps/wwan_world/wwan_world.cc
@@ -22,8 +22,6 @@
 #define LOG_TAG "[WwanWorld]"
 
 #ifdef CHRE_NANOAPP_INTERNAL
-#include "chre/platform/platform_static_nanoapp_init.h"
-
 namespace chre {
 namespace {
 #endif  // CHRE_NANOAPP_INTERNAL
@@ -55,14 +53,16 @@
   // TODO: Implement this.
 }
 
-void nanoappStop() {
+void nanoappEnd() {
   LOGI("Stopped");
 }
 
 #ifdef CHRE_NANOAPP_INTERNAL
-}  // namespace
-
-PLATFORM_STATIC_NANOAPP_INIT(WwanWorld);
-
+}  // anonymous namespace
 }  // namespace chre
+
+#include "chre/util/nanoapp/app_id.h"
+#include "chre/platform/static_nanoapp_init.h"
+
+CHRE_STATIC_NANOAPP_INIT(WwanWorld, chre::kWwanWorldAppId, 0);
 #endif  // CHRE_NANOAPP_INTERNAL
diff --git a/build/app_support/google_slpi/libchre_slpi_skel.so b/build/app_support/google_slpi/libchre_slpi_skel.so
new file mode 100755
index 0000000..05ba1b5
--- /dev/null
+++ b/build/app_support/google_slpi/libchre_slpi_skel.so
Binary files differ
diff --git a/build/arch/x86.mk b/build/arch/x86.mk
index 63858b9..116d8e3 100644
--- a/build/arch/x86.mk
+++ b/build/arch/x86.mk
@@ -22,6 +22,9 @@
 # Add x86 compiler flags.
 TARGET_CFLAGS += $(X86_CFLAGS)
 
+# x86 is purely used for testing, so always include debugging symbols
+TARGET_CFLAGS += -g
+
 # Enable position independence.
 TARGET_CFLAGS += -fpic
 
diff --git a/build/nanoapp/app.mk b/build/nanoapp/app.mk
index fdb8bcf..0d9be6e 100644
--- a/build/nanoapp/app.mk
+++ b/build/nanoapp/app.mk
@@ -22,6 +22,22 @@
          This should be assigned by the Makefile that includes app.mk.")
 endif
 
+ifeq ($(NANOAPP_NAME_STRING),)
+$(error The NANOAPP_NAME_STRING variable must be set to the friendly name of \
+        the nanoapp. This should be assigned by the Makefile that includes \
+        app.mk.)
+endif
+
+ifeq ($(NANOAPP_VENDOR_STRING),)
+$(info NANOAPP_VENDOR_STRING not supplied, defaulting to "Google".)
+NANOAPP_VENDOR_STRING = \"Google\"
+endif
+
+ifeq ($(NANOAPP_IS_SYSTEM_NANOAPP),)
+$(info NANOAPP_IS_SYSTEM_NANOAPP not supplied, defaulting to 0.)
+NANOAPP_IS_SYSTEM_NANOAPP = 0
+endif
+
 # Nanoapp Build ################################################################
 
 # This variable indicates to the variants that some post-processing may be
@@ -40,7 +56,10 @@
 # Variant-specific Nanoapp Support Source Files ################################
 
 APP_SUPPORT_PATH = $(CHRE_PREFIX)/build/app_support
+DSO_SUPPORT_LIB_PATH = $(CHRE_PREFIX)/platform/shared/nanoapp
 
+GOOGLE_HEXAGONV60_SLPI_SRCS += $(DSO_SUPPORT_LIB_PATH)/nanoapp_support_lib_dso.c
+GOOGLE_HEXAGONV62_SLPI_SRCS += $(DSO_SUPPORT_LIB_PATH)/nanoapp_support_lib_dso.c
 QCOM_HEXAGONV60_NANOHUB_SRCS += $(APP_SUPPORT_PATH)/qcom_nanohub/app_support.cc
 
 # Makefile Includes ############################################################
diff --git a/build/nanoapp/google_slpi.mk b/build/nanoapp/google_slpi.mk
index dfcb317..2e629bb 100644
--- a/build/nanoapp/google_slpi.mk
+++ b/build/nanoapp/google_slpi.mk
@@ -15,6 +15,14 @@
 #
 ################################################################################
 
+TARGET_CFLAGS += -DNANOAPP_ID=$(NANOAPP_ID)
+TARGET_CFLAGS += -DNANOAPP_VERSION=$(NANOAPP_VERSION)
+TARGET_CFLAGS += -DNANOAPP_VENDOR_STRING=$(NANOAPP_VENDOR_STRING)
+TARGET_CFLAGS += -DNANOAPP_NAME_STRING=$(NANOAPP_NAME_STRING)
+TARGET_CFLAGS += -DNANOAPP_IS_SYSTEM_NANOAPP=$(NANOAPP_IS_SYSTEM_NANOAPP)
+TARGET_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/include
+TARGET_CFLAGS += -I$(CHRE_PREFIX)/util/include
+
 ifndef GOOGLE_SLPI_NANOAPP_BUILD_TEMPLATE
 define GOOGLE_SLPI_NANOAPP_BUILD_TEMPLATE
 
diff --git a/build/variant/google_hexagonv60_slpi.mk b/build/variant/google_hexagonv60_slpi.mk
index 410076c..1fe3e43 100644
--- a/build/variant/google_hexagonv60_slpi.mk
+++ b/build/variant/google_hexagonv60_slpi.mk
@@ -11,10 +11,11 @@
 HEXAGON_ARCH = v60
 
 ifneq ($(filter $(TARGET_NAME)% all, $(MAKECMDGOALS)),)
-include $(CHRE_PREFIX)/build/arch/hexagon.mk
-include $(CHRE_PREFIX)/build/build_template.mk
-
 ifneq ($(IS_NANOAPP_BUILD),)
+TARGET_SO_LATE_LIBS += $(CHRE_PREFIX)/build/app_support/google_slpi/libchre_slpi_skel.so
 include $(CHRE_PREFIX)/build/nanoapp/google_slpi.mk
 endif
+
+include $(CHRE_PREFIX)/build/arch/hexagon.mk
+include $(CHRE_PREFIX)/build/build_template.mk
 endif
diff --git a/build/variant/google_hexagonv62_slpi.mk b/build/variant/google_hexagonv62_slpi.mk
index c55b96d..266bc68 100644
--- a/build/variant/google_hexagonv62_slpi.mk
+++ b/build/variant/google_hexagonv62_slpi.mk
@@ -11,10 +11,11 @@
 HEXAGON_ARCH = v62
 
 ifneq ($(filter $(TARGET_NAME)% all, $(MAKECMDGOALS)),)
-include $(CHRE_PREFIX)/build/arch/hexagon.mk
-include $(CHRE_PREFIX)/build/build_template.mk
-
 ifneq ($(IS_NANOAPP_BUILD),)
+TARGET_SO_LATE_LIBS += $(CHRE_PREFIX)/build/app_support/google_slpi/libchre_slpi_skel.so
 include $(CHRE_PREFIX)/build/nanoapp/google_slpi.mk
 endif
+
+include $(CHRE_PREFIX)/build/arch/hexagon.mk
+include $(CHRE_PREFIX)/build/build_template.mk
 endif
diff --git a/chre_api/include/chre_api/chre/version.h b/chre_api/include/chre_api/chre/version.h
index 8544749..32b066c 100644
--- a/chre_api/include/chre_api/chre/version.h
+++ b/chre_api/include/chre_api/chre/version.h
@@ -22,7 +22,7 @@
  * Definitions and methods for the versioning of the Context Hub Runtime
  * Environment.
  *
- * The CHRE API versioning pertains to all the chre_*.h files and chre.h.
+ * The CHRE API versioning pertains to all header files in the CHRE API.
  */
 
 #include <stdint.h>
@@ -82,6 +82,41 @@
  */
 #define CHRE_API_VERSION CHRE_API_VERSION_1_1
 
+/**
+ * Utility macro to extract only the API major version of a composite CHRE
+ * version.
+ *
+ * @param version A uint32_t version, e.g. the value returned by
+ *     chreGetApiVersion()
+ *
+ * @returns The API major version in the least significant byte, e.g. 0x01
+ */
+#define CHRE_EXTRACT_MAJOR_VERSION(version) \
+    (((version) & UINT32_C(0xFF000000)) >> 24)
+
+/**
+ * Utility macro to extract only the API minor version of a composite CHRE
+ * version.
+ *
+ * @param version A uint32_t version, e.g. the CHRE_API_VERSION constant
+ *
+ * @returns The API minor version in the least significant byte, e.g. 0x01
+ */
+#define CHRE_EXTRACT_MINOR_VERSION(version) \
+    (((version) & UINT32_C(0x00FF0000)) >> 16)
+
+/**
+ * Utility macro to extract only the API minor version of a composite CHRE
+ * version.
+ *
+ * @param version A complete uint32_t version, e.g. the value returned by
+ *     chreGetVersion()
+ *
+ * @returns The implementation patch version in the least significant two bytes,
+ *     e.g. 0x0123, with all other bytes set to 0
+ */
+#define CHRE_EXTRACT_PATCH_VERSION(version)  ((version) & UINT32_C(0xFFFF))
+
 
 /**
  * Get the API version the CHRE implementation was compiled against.
diff --git a/core/core.mk b/core/core.mk
index 413eb71..3e60c4e 100644
--- a/core/core.mk
+++ b/core/core.mk
@@ -9,8 +9,10 @@
 
 # Common Source Files ##########################################################
 
+COMMON_SRCS += core/event.cc
 COMMON_SRCS += core/event_loop.cc
 COMMON_SRCS += core/event_loop_manager.cc
+COMMON_SRCS += core/event_ref_queue.cc
 COMMON_SRCS += core/gnss_request_manager.cc
 COMMON_SRCS += core/host_comms_manager.cc
 COMMON_SRCS += core/init.cc
diff --git a/core/event.cc b/core/event.cc
new file mode 100644
index 0000000..8af721e
--- /dev/null
+++ b/core/event.cc
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include "chre/core/event.h"
+
+#include "chre/platform/assert.h"
+
+namespace chre {
+
+Event::Event(uint16_t eventType_, void *eventData_,
+             chreEventCompleteFunction *freeCallback_,
+             uint32_t senderInstanceId_, uint32_t targetInstanceId_)
+    : eventType(eventType_), eventData(eventData_), freeCallback(freeCallback_),
+      senderInstanceId(senderInstanceId_),
+      targetInstanceId(targetInstanceId_) {}
+
+void Event::incrementRefCount() {
+  mRefCount++;
+  CHRE_ASSERT(mRefCount != 0);
+}
+
+void Event::decrementRefCount() {
+  CHRE_ASSERT(mRefCount > 0);
+  mRefCount--;
+}
+
+bool Event::isUnreferenced() const {
+  return (mRefCount == 0);
+}
+
+}  // namespace chre
diff --git a/core/event_loop.cc b/core/event_loop.cc
index 51c0c67..7331e28 100644
--- a/core/event_loop.cc
+++ b/core/event_loop.cc
@@ -17,6 +17,7 @@
 #include "chre/core/event_loop.h"
 
 #include "chre/core/event.h"
+#include "chre/core/event_loop_manager.h"
 #include "chre/core/nanoapp.h"
 #include "chre/platform/context.h"
 #include "chre/platform/log.h"
@@ -39,7 +40,7 @@
   }
 
   bool found = false;
-  for (auto& app : mNanoapps) {
+  for (const UniquePtr<Nanoapp>& app : mNanoapps) {
     if (app->getAppId() == appId) {
       *instanceId = app->getInstanceId();
       found = true;
@@ -60,7 +61,7 @@
     mNanoappsLock.lock();
   }
 
-  for (const auto& nanoapp : mNanoapps) {
+  for (const UniquePtr<Nanoapp>& nanoapp : mNanoapps) {
     callback(nanoapp.get(), data);
   }
 
@@ -83,7 +84,7 @@
       // there is no safety mechanism that ensures an event is not freed twice,
       // or that its free callback is invoked in the proper EventLoop, etc.
       Event *event = mEvents.pop();
-      for (auto& app : mNanoapps) {
+      for (const UniquePtr<Nanoapp>& app : mNanoapps) {
         if ((event->targetInstanceId == chre::kBroadcastInstanceId
                 && app->isRegisteredForBroadcastEvent(event->eventType))
             || event->targetInstanceId == app->getInstanceId()) {
@@ -105,53 +106,51 @@
     // TODO: most basic round-robin implementation - we might want to have some
     // kind of priority in the future, but this should be good enough for now
     havePendingEvents = false;
-    for (auto& app : mNanoapps) {
+    for (const UniquePtr<Nanoapp>& app : mNanoapps) {
       if (app->hasPendingEvent()) {
-        // TODO: cleaner way to set/clear this? RAII-style?
-        mCurrentApp = app.get();
-        Event *event = app->processNextEvent();
-        mCurrentApp = nullptr;
-
-        if (event->isUnreferenced()) {
-          freeEvent(event);
-        }
-
-        havePendingEvents |= app->hasPendingEvent();
+        havePendingEvents |= deliverNextEvent(app);
       }
     }
   }
 
+  // Drop any events pending distribution
+  while (!mEvents.empty()) {
+    freeEvent(mEvents.pop());
+  }
+
+  // Stop all running nanoapps
   while (!mNanoapps.empty()) {
-    stopNanoapp(mNanoapps.front().get());
+    stopNanoapp(mNanoapps.size() - 1);
   }
 
   LOGI("Exiting EventLoop");
-
-  // TODO: need to purge/cleanup events, etc.
 }
 
-bool EventLoop::startNanoapp(PlatformNanoapp *platformNanoapp) {
-  CHRE_ASSERT(platformNanoapp != nullptr);
-
+bool EventLoop::startNanoapp(UniquePtr<Nanoapp>& nanoapp) {
+  CHRE_ASSERT(!nanoapp.isNull());
   bool success = false;
-  if (!mNanoapps.prepareForPush()) {
+  auto *eventLoopManager = EventLoopManagerSingleton::get();
+  uint32_t existingInstanceId;
+
+  if (nanoapp.isNull()) {
+    // no-op, invalid argument
+  } else if (eventLoopManager->findNanoappInstanceIdByAppId(nanoapp->getAppId(),
+                                                            &existingInstanceId,
+                                                            nullptr)) {
+    LOGE("App with ID 0x%016" PRIx64 " already exists as instance ID 0x%"
+         PRIx32, nanoapp->getAppId(), existingInstanceId);
+  } else if (!mNanoapps.prepareForPush()) {
     LOGE("Failed to allocate space for new nanoapp");
   } else {
-    // TODO: get these parameters from somewhere
-    UniquePtr<Nanoapp> nanoapp(0, 1, CHRE_API_VERSION_1_1, getNextInstanceId(),
-                               true, platformNanoapp);
-    if (nanoapp.isNull()) {
-      LOGE("Failed to allocate new nanoapp");
+    nanoapp->setInstanceId(eventLoopManager->getNextInstanceId());
+    mCurrentApp = nanoapp.get();
+    success = nanoapp->start();
+    mCurrentApp = nullptr;
+    if (!success) {
+      LOGE("Nanoapp %" PRIu32 " failed to start", nanoapp->getInstanceId());
     } else {
-      mCurrentApp = nanoapp.get();
-      success = nanoapp->start();
-      mCurrentApp = nullptr;
-      if (!success) {
-        LOGE("Nanoapp %" PRIu32 " failed to start", nanoapp->getInstanceId());
-      } else {
-        LockGuard<Mutex> lock(mNanoappsLock);
-        mNanoapps.push_back(std::move(nanoapp));
-      }
+      LockGuard<Mutex> lock(mNanoappsLock);
+      mNanoapps.push_back(std::move(nanoapp));
     }
   }
 
@@ -159,18 +158,9 @@
 }
 
 void EventLoop::stopNanoapp(Nanoapp *nanoapp) {
-  CHRE_ASSERT(nanoapp != nullptr);
-
   for (size_t i = 0; i < mNanoapps.size(); i++) {
     if (nanoapp == mNanoapps[i].get()) {
-      {
-        LockGuard<Mutex> lock(mNanoappsLock);
-        mNanoapps.erase(i);
-      }
-
-      mCurrentApp = nanoapp;
-      nanoapp->stop();
-      mCurrentApp = nullptr;
+      stopNanoapp(i);
       return;
     }
   }
@@ -182,20 +172,24 @@
 bool EventLoop::postEvent(uint16_t eventType, void *eventData,
     chreEventCompleteFunction *freeCallback, uint32_t senderInstanceId,
     uint32_t targetInstanceId) {
-  // TODO: Consider adding a CHRE_ASSERT(mRunning) here.
   bool success = false;
-  Event *event = mEventPool.allocate(eventType, eventData, freeCallback,
-      senderInstanceId, targetInstanceId);
-  if (event != nullptr) {
-    success = mEvents.push(event);
-  } else {
-    LOGE("Failed to allocate event");
+
+  if (mRunning) {
+    Event *event = mEventPool.allocate(eventType, eventData, freeCallback,
+        senderInstanceId, targetInstanceId);
+    if (event != nullptr) {
+      success = mEvents.push(event);
+    } else {
+      LOGE("Failed to allocate event");
+    }
   }
+
   return success;
 }
 
 void EventLoop::stop() {
   postEvent(0, nullptr, nullptr, kSystemInstanceId, kSystemInstanceId);
+  // Stop accepting new events and tell the main loop to finish
   mRunning = false;
 }
 
@@ -209,25 +203,6 @@
   return mNanoapps.size();
 }
 
-uint32_t EventLoop::getNextInstanceId() {
-  // This is a simple unique ID generator that checks a newly generated ID
-  // against all existing IDs using a search (currently linear search).
-  // Instance ID generation will slow with more apps. We generally expect there
-  // to be few apps and IDs are generated infrequently.
-  //
-  // The benefit of generating IDs this way is that there is no memory overhead
-  // to track issued IDs.
-  uint32_t nextInstanceId = mLastInstanceId + 1;
-  while (nextInstanceId == kSystemInstanceId
-      || nextInstanceId == kBroadcastInstanceId
-      || lookupAppByInstanceId(nextInstanceId) != nullptr) {
-    nextInstanceId++;
-  }
-
-  mLastInstanceId = nextInstanceId;
-  return nextInstanceId;
-}
-
 TimerPool& EventLoop::getTimerPool() {
   return mTimerPool;
 }
@@ -247,11 +222,35 @@
   return nanoapp;
 }
 
+void EventLoop::freeEvent(Event *event) {
+  if (event->freeCallback != nullptr) {
+    // TODO: find a better way to set the context to the creator of the event
+    mCurrentApp = lookupAppByInstanceId(event->senderInstanceId);
+    event->freeCallback(event->eventType, event->eventData);
+    mCurrentApp = nullptr;
+
+    mEventPool.deallocate(event);
+  }
+}
+
+bool EventLoop::deliverNextEvent(const UniquePtr<Nanoapp>& app) {
+  // TODO: cleaner way to set/clear this? RAII-style?
+  mCurrentApp = app.get();
+  Event *event = app->processNextEvent();
+  mCurrentApp = nullptr;
+
+  if (event->isUnreferenced()) {
+    freeEvent(event);
+  }
+
+  return app->hasPendingEvent();
+}
+
 Nanoapp *EventLoop::lookupAppByInstanceId(uint32_t instanceId) {
   // The system instance ID always has nullptr as its Nanoapp pointer, so can
   // skip iterating through the nanoapp list for that case
   if (instanceId != kSystemInstanceId) {
-    for (auto& app : mNanoapps) {
+    for (const UniquePtr<Nanoapp>& app : mNanoapps) {
       if (app->getInstanceId() == instanceId) {
         return app.get();
       }
@@ -261,14 +260,32 @@
   return nullptr;
 }
 
-void EventLoop::freeEvent(Event *event) {
-  if (event->freeCallback != nullptr) {
-    // TODO: find a better way to set the context to the creator of the event
-    mCurrentApp = lookupAppByInstanceId(event->senderInstanceId);
-    event->freeCallback(event->eventType, event->eventData);
-    mCurrentApp = nullptr;
+void EventLoop::stopNanoapp(size_t index) {
+  const UniquePtr<Nanoapp>& nanoapp = mNanoapps[index];
 
-    mEventPool.deallocate(event);
+  // Process any events pending in this app's queue. Note that since we're
+  // running in the context of this EventLoop, no new events will be added to
+  // this nanoapp's event queue while we're doing this, so once it's empty, we
+  // can be assured it will stay that way.
+  while (nanoapp->hasPendingEvent()) {
+    deliverNextEvent(nanoapp);
+  }
+
+  // TODO: to safely stop a nanoapp while the EventLoop is still running, we
+  // need to deliver/purge any events that the nanoapp sent itself prior to
+  // calling end(), so that we won't try to invoke a free callback after
+  // unloading the nanoapp where that callback resides. Likewise, we need to
+  // make sure any messages to the host from this nanoapp are flushed as well.
+
+  // Let the app know it's going away
+  mCurrentApp = nanoapp.get();
+  nanoapp->end();
+  mCurrentApp = nullptr;
+
+  // Destroy the Nanoapp instance
+  {
+    LockGuard<Mutex> lock(mNanoappsLock);
+    mNanoapps.erase(index);
   }
 }
 
diff --git a/core/event_loop_manager.cc b/core/event_loop_manager.cc
index 6d7b5b5..cc57a19 100644
--- a/core/event_loop_manager.cc
+++ b/core/event_loop_manager.cc
@@ -17,6 +17,7 @@
 #include "chre/core/event_loop_manager.h"
 
 #include "chre/platform/context.h"
+#include "chre/platform/fatal_error.h"
 #include "chre/util/lock_guard.h"
 
 namespace chre {
@@ -36,7 +37,7 @@
   // support multiple EventLoop instances, for example the Event freeing
   // mechanism is not thread-safe.
   CHRE_ASSERT(mEventLoops.empty());
-  if (!mEventLoops.emplace_back()) {
+  if (!mEventLoops.emplace_back(MakeUnique<EventLoop>())) {
     return nullptr;
   }
 
@@ -85,6 +86,23 @@
   return nanoapp;
 }
 
+uint32_t EventLoopManager::getNextInstanceId() {
+  // TODO: this needs to be an atomic integer when we have > 1 event loop, or
+  // use a mutex
+  ++mLastInstanceId;
+
+  // ~4 billion instance IDs should be enough for anyone... if we need to
+  // support wraparound for stress testing load/unload, then we can set a flag
+  // when wraparound occurs and use EventLoop::findNanoappByInstanceId to ensure
+  // we avoid conflicts
+  if (mLastInstanceId == kBroadcastInstanceId
+      || mLastInstanceId == kSystemInstanceId) {
+    FATAL_ERROR("Exhausted instance IDs!");
+  }
+
+  return mLastInstanceId;
+}
+
 bool EventLoopManager::postEvent(uint16_t eventType, void *eventData,
                                  chreEventCompleteFunction *freeCallback,
                                  uint32_t senderInstanceId,
diff --git a/core/event_ref_queue.cc b/core/event_ref_queue.cc
new file mode 100644
index 0000000..68cec92
--- /dev/null
+++ b/core/event_ref_queue.cc
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include "chre/core/event_ref_queue.h"
+
+#include "chre/platform/assert.h"
+
+namespace chre {
+
+EventRefQueue::~EventRefQueue() {
+  CHRE_ASSERT_LOG(empty(), "Potentially leaking events if queue not empty "
+                  "when destroyed");
+}
+
+bool EventRefQueue::empty() const {
+  return mQueue.empty();
+}
+
+bool EventRefQueue::push(Event *event) {
+  CHRE_ASSERT(event != nullptr);
+
+  bool pushed = mQueue.push(event);
+  if (pushed) {
+    event->incrementRefCount();
+  }
+
+  return pushed;
+}
+
+Event *EventRefQueue::pop() {
+  CHRE_ASSERT(!mQueue.empty());
+
+  Event *event = mQueue.front();
+  mQueue.pop();
+  event->decrementRefCount();
+
+  return event;
+}
+
+}  // namespace chre
diff --git a/core/include/chre/core/event.h b/core/include/chre/core/event.h
index f20a196..d073c63 100644
--- a/core/include/chre/core/event.h
+++ b/core/include/chre/core/event.h
@@ -18,47 +18,33 @@
 #define CHRE_CORE_EVENT_H_
 
 #include "chre_api/chre/event.h"
-#include "chre/platform/assert.h"
-#include "chre/platform/log.h"
 #include "chre/util/non_copyable.h"
 
 #include <cstdint>
 
 namespace chre {
 
-// TODO: put these in a more common place
+//! Instance ID used for events sent by the system
 constexpr uint32_t kSystemInstanceId = 0;
+
+//! Target instance ID used to deliver a message to all nanoapps registered for
+//! the event
 constexpr uint32_t kBroadcastInstanceId = UINT32_MAX;
 
-// Can be used in the context of a specific Nanoapp's instance ID
+//! This value can be used in a nanoapp's own instance ID to indicate that the
+//! ID is invalid/not assigned yet
 constexpr uint32_t kInvalidInstanceId = kBroadcastInstanceId;
 
 class Event : public NonCopyable {
  public:
-  Event(uint16_t eventType_,
-        void *eventData_,
-        chreEventCompleteFunction *freeCallback_,
-        uint32_t senderInstanceId_ = kSystemInstanceId,
-        uint32_t targetInstanceId_ = kBroadcastInstanceId)
-      : eventType(eventType_),
-        eventData(eventData_),
-        freeCallback(freeCallback_),
-        senderInstanceId(senderInstanceId_),
-        targetInstanceId(targetInstanceId_) {}
+  Event(uint16_t eventType, void *eventData,
+        chreEventCompleteFunction *freeCallback,
+        uint32_t senderInstanceId = kSystemInstanceId,
+        uint32_t targetInstanceId = kBroadcastInstanceId);
 
-  void incrementRefCount() {
-    mRefCount++;
-    CHRE_ASSERT(mRefCount != 0);
-  }
-
-  void decrementRefCount() {
-    CHRE_ASSERT(mRefCount > 0);
-    mRefCount--;
-  }
-
-  bool isUnreferenced() {
-    return (mRefCount == 0);
-  }
+  void incrementRefCount();
+  void decrementRefCount();
+  bool isUnreferenced() const;
 
   const uint16_t eventType;
   void * const eventData;
diff --git a/core/include/chre/core/event_loop.h b/core/include/chre/core/event_loop.h
index 1719b10..dcf4abd 100644
--- a/core/include/chre/core/event_loop.h
+++ b/core/include/chre/core/event_loop.h
@@ -73,21 +73,25 @@
   void forEachNanoapp(NanoappCallbackFunction *callback, void *data);
 
   /**
-   * Starts a nanoapp by constructing a Nanoapp instance, invoking the start
-   * entry point and adding it to the list of nanoapps owned by this event
-   * loop.
+   * Invokes the Nanoapp's start callback, and if successful, adds it to the
+   * set of Nanoapps managed by this EventLoop. This function must only be
+   * called from the context of the thread that runs this event loop (i.e. from
+   * the same thread that will call run() or from a callback invoked within
+   * run()).
    *
-   * @param platformNanoapp A pointer to the platform nanoapp to start. This
-   *        pointer must remain valid after this function returns.
-   * @return True if the app was started successfully.
+   * @param nanoapp The nanoapp that will be started. Upon success, this
+   *        UniquePtr will become invalid, as the underlying Nanoapp instance
+   *        will have been transferred to be managed by this EventLoop.
+   * @return true if the app was started successfully
    */
-  bool startNanoapp(PlatformNanoapp *platformNanoapp);
+  bool startNanoapp(UniquePtr<Nanoapp>& nanoapp);
 
   /**
    * Stops a nanoapp by invoking the stop entry point. The nanoapp passed in
-   * must have been previously started by the startNanoapp method.
+   * must have been previously started by the startNanoapp method. After this
+   * function returns, all references to the Nanoapp are invalid.
    *
-   * @param A pointer to the nanoapp to stop.
+   * @param nanoapp A pointer to the nanoapp to stop.
    */
   void stopNanoapp(Nanoapp *nanoapp);
 
@@ -110,13 +114,16 @@
    *
    * This function is safe to call from any thread.
    *
-   * @param The type of data being posted.
-   * @param The data being posted.
-   * @param The callback to invoke when the event is no longer needed.
-   * @param The instance ID of the sender of this event.
-   * @param The instance ID of the destination of this event.
+   * @param eventType The type of data being posted.
+   * @param eventData The data being posted.
+   * @param freeCallback The callback to invoke when the event is no longer
+   *        needed.
+   * @param senderInstanceId The instance ID of the sender of this event.
+   * @param targetInstanceId The instance ID of the destination of this event.
    *
    * @return true if the event was successfully added to the queue
+   *
+   * @see chreSendEvent
    */
   bool postEvent(uint16_t eventType, void *eventData,
                  chreEventCompleteFunction *freeCallback,
@@ -141,16 +148,6 @@
   size_t getNanoappCount() const;
 
   /**
-   * Returns a guaranteed unique instance ID that can be used to construct a
-   * nanoapp.
-   *
-   * @return a unique instance ID to assign to a nanoapp.
-   */
-  // TODO: move this to EventLoopManager as it must be unique across all event
-  // loops; we currently really only support one EventLoop so it's OK for now
-  uint32_t getNextInstanceId();
-
-  /**
    * Obtains the TimerPool associated with this event loop.
    *
    * @return The timer pool owned by this event loop.
@@ -176,9 +173,6 @@
   //! events are in a queue to be distributed to apps.
   static constexpr size_t kMaxUnscheduledEventCount = 1024;
 
-  //! The instance ID that was previously generated by getNextInstanceId.
-  uint32_t mLastInstanceId = kSystemInstanceId;
-
   //! The memory pool to allocate incoming events from.
   SynchronizedMemoryPool<Event, kMaxEventCount> mEventPool;
 
@@ -206,6 +200,15 @@
   Nanoapp *mCurrentApp = nullptr;
 
   /**
+   * Delivers the next event pending in the Nanoapp's queue, and takes care of
+   * freeing events once they have been delivered to all nanoapps. Must only be
+   * called after confirming that the app has at least 1 pending event.
+   *
+   * @return true if the nanoapp has another event pending in its queue
+   */
+  bool deliverNextEvent(const UniquePtr<Nanoapp>& app);
+
+  /**
    * Call after when an Event has been delivered to all intended recipients.
    * Invokes the event's free callback (if given) and releases resources.
    *
@@ -222,6 +225,11 @@
    * @return Nanoapp with the given instanceId, or nullptr if not found
    */
   Nanoapp *lookupAppByInstanceId(uint32_t instanceId);
+
+  /**
+   * Stops the Nanoapp at the given index in mNanoapps
+   */
+  void stopNanoapp(size_t index);
 };
 
 }  // namespace chre
diff --git a/core/include/chre/core/event_loop_manager.h b/core/include/chre/core/event_loop_manager.h
index f10d0e6..fc12e34 100644
--- a/core/include/chre/core/event_loop_manager.h
+++ b/core/include/chre/core/event_loop_manager.h
@@ -43,6 +43,7 @@
   WifiHandleScanEvent,
   NanoappListResponse,
   SensorLastEventUpdate,
+  FinishLoadingNanoapp,
 };
 
 //! The function signature of a system callback mirrors the CHRE event free
@@ -128,6 +129,14 @@
                                    EventLoop **eventLoop = nullptr);
 
   /**
+   * Returns a guaranteed unique instance identifier to associate with a newly
+   * constructed nanoapp.
+   *
+   * @return a unique instance ID
+   */
+  uint32_t getNextInstanceId();
+
+  /**
    * Posts an event to all event loops owned by this event loop manager. This
    * method is thread-safe and is used to post events that all event loops would
    * be interested in, such as sensor event data.
@@ -186,6 +195,9 @@
   //! of event order between event loops.
   Mutex mMutex;
 
+  //! The instance ID that was previously generated by getNextInstanceId()
+  uint32_t mLastInstanceId = kSystemInstanceId;
+
   //! The list of event loops managed by this event loop manager. The EventLoops
   //! are stored in UniquePtr because they are large objects. They do not
   //! provide an implementation of the move constructor so it is best left to
diff --git a/core/include/chre/core/event_ref_queue.h b/core/include/chre/core/event_ref_queue.h
index 3bacb7c..32c523b 100644
--- a/core/include/chre/core/event_ref_queue.h
+++ b/core/include/chre/core/event_ref_queue.h
@@ -14,45 +14,45 @@
  * limitations under the License.
  */
 
-#ifndef CHRE_EVENT_QUEUE_H
-#define CHRE_EVENT_QUEUE_H
+#ifndef CHRE_EVENT_REF_QUEUE_H
+#define CHRE_EVENT_REF_QUEUE_H
 
 #include "chre/core/event.h"
-#include "chre/platform/assert.h"
 #include "chre/util/array_queue.h"
 
 namespace chre {
 
 /**
- * TODO
- * NOT thread-safe, non-blocking.
+ * A non-thread-safe, non-blocking wrapper around ArrayQueue that stores Event*
+ * and manages the Event reference counter.
+ * TODO: make this a template specialization? Or rework the ref count design?
  */
 class EventRefQueue {
  public:
-  bool empty() {
-    return mQueue.empty();
-  }
+  ~EventRefQueue();
 
-  bool push(Event *event) {
-    CHRE_ASSERT(event != nullptr);
+  /**
+   * @return true if there are no events in the queue
+   */
+  bool empty() const;
 
-    bool pushed = mQueue.push(event);
-    if (pushed) {
-      event->incrementRefCount();
-    }
+  /**
+   * Adds an event to the queue, and increments its reference counter
+   *
+   * @param event The event to add
+   * @return true on success
+   */
+  bool push(Event *event);
 
-    return pushed;
-  }
-
-  Event *pop() {
-    CHRE_ASSERT(!mQueue.empty());
-
-    Event *event = mQueue.front();
-    mQueue.pop();
-    event->decrementRefCount();
-
-    return event;
-  }
+  /**
+   * Removes the oldest event from the queue, and decrements its reference
+   * counter. Does not trigger freeing of the event if the reference count
+   * reaches 0 as a result of this function call. The queue must be non-empty as
+   * a precondition to calling this function, or undefined behavior will result.
+   *
+   * @return Pointer to the next event in the queue
+   */
+  Event *pop();
 
  private:
   //! The maximum number of events that can be outstanding for an app.
@@ -64,4 +64,4 @@
 
 }  // namespace chre
 
-#endif //CHRE_EVENT_QUEUE_H
+#endif  // CHRE_EVENT_REF_QUEUE_H
diff --git a/core/include/chre/core/nanoapp.h b/core/include/chre/core/nanoapp.h
index 8cecb8b..ab40f30 100644
--- a/core/include/chre/core/nanoapp.h
+++ b/core/include/chre/core/nanoapp.h
@@ -23,45 +23,37 @@
 #include "chre/core/event_ref_queue.h"
 #include "chre/platform/platform_nanoapp.h"
 #include "chre/util/dynamic_vector.h"
-#include "chre/util/non_copyable.h"
 
 namespace chre {
 
 /**
  * A class that tracks the state of a Nanoapp including incoming events and
  * event registrations.
+ *
+ * Inheritance is used to separate the common interface with common
+ * implementation part (chre::Nanoapp) from the common interface with
+ * platform-specific implementation part (chre::PlatformNanoapp) from the purely
+ * platform-specific part (chre::PlatformNanoappBase). However, this inheritance
+ * relationship does *not* imply polymorphism, and this object must only be
+ * referred to via the most-derived type, i.e. chre::Nanoapp.
  */
-class Nanoapp : public NonCopyable {
+class Nanoapp : public PlatformNanoapp {
  public:
   /**
-   * Constructs a Nanoapp that manages the lifecycle of events and calls into
-   * the entry points of the app.
-   *
-   * @param appId Identifies the nanoapp vendor and the app itself
-   * @param appVersion An application-defined version number
-   * @param targetApiVersion The CHRE API version that this app was compiled
-   *        against
-   * @param instanceId A unique identifier for this application instance that
-   *        can be used to target unicast events, etc.
-   * @param isSystemNanoapp true if this is a nanoapp that should not appear in
-   *        the list of nanoapps exposed through the context hub HAL. System
-   *        nanoapps can be used to leverage CHRE to implement device
-   *        functionality below the HAL, where the nanoapp does not communicate
-   *        with host-side entities through the context hub HAL.
-   * @param platformNanoapp A pointer to the platform-specific nanoapp
-   *        functionality which allows calling the entry points and managing the
-   *        lifecycle of the app (such as unloading the app).
+   * @return uint32_t The globally unique identifier for this Nanoapp instance
    */
-  Nanoapp(uint64_t appId, uint32_t appVersion, uint32_t targetApiVersion,
-          uint32_t instanceId, bool isSystemNanoapp,
-          PlatformNanoapp *platformNanoapp);
-
-  uint64_t getAppId() const;
-  uint32_t getAppVersion() const;
   uint32_t getInstanceId() const;
-  uint32_t getTargetApiVersion() const;
-  bool isSystemNanoapp() const;
 
+  /**
+   * Assigns an instance ID to this Nanoapp. This must be called prior to
+   * starting this nanoapp.
+   */
+  void setInstanceId(uint32_t instanceId);
+
+  /**
+   * @return true if the nanoapp should receive broadcast events with the given
+   *         type
+   */
   bool isRegisteredForBroadcastEvent(uint16_t eventType) const;
 
   /**
@@ -88,19 +80,6 @@
   void postEvent(Event *event);
 
   /**
-   * Starts the nanoapp by invoking the start handler and returns the result of
-   * the handler.
-   *
-   * @return True indicating that the app was started successfully.
-   */
-  bool start();
-
-  /**
-   * Stops the nanoapp by invoking the stop handler.
-   */
-  void stop();
-
-  /**
    * Indicates whether there are any pending events in this apps queue.
    *
    * @return True indicating that there are events available to be processed.
@@ -116,12 +95,7 @@
   Event *processNextEvent();
 
  private:
-  const uint64_t mAppId;
-  const uint32_t mAppVersion;
-  const uint32_t mTargetApiVersion;
-  const uint32_t mInstanceId;
-  const bool mIsSystemNanoapp;
-  PlatformNanoapp * const mPlatformNanoapp;
+  uint32_t mInstanceId = kInvalidInstanceId;
 
   //! The set of broadcast events that this app is registered for.
   // TODO: Implement a set container and replace DynamicVector here. There may
diff --git a/core/nanoapp.cc b/core/nanoapp.cc
index 3d30678..8a8e983 100644
--- a/core/nanoapp.cc
+++ b/core/nanoapp.cc
@@ -16,18 +16,20 @@
 
 #include "chre/core/nanoapp.h"
 
+#include "chre/core/event_loop_manager.h"
 #include "chre/platform/assert.h"
 #include "chre/platform/fatal_error.h"
 #include "chre/platform/log.h"
 
 namespace chre {
 
-Nanoapp::Nanoapp(
-    uint64_t appId, uint32_t appVersion, uint32_t targetApiVersion,
-    uint32_t instanceId, bool isSystemNanoapp, PlatformNanoapp *platformNanoapp)
-    : mAppId(appId), mAppVersion(appVersion),
-      mTargetApiVersion(targetApiVersion), mInstanceId(instanceId),
-      mIsSystemNanoapp(isSystemNanoapp), mPlatformNanoapp(platformNanoapp) {}
+uint32_t Nanoapp::getInstanceId() const {
+  return mInstanceId;
+}
+
+void Nanoapp::setInstanceId(uint32_t instanceId) {
+  mInstanceId = instanceId;
+}
 
 bool Nanoapp::isRegisteredForBroadcastEvent(uint16_t eventType) const {
   return (mRegisteredEvents.find(eventType) != mRegisteredEvents.size());
@@ -55,38 +57,10 @@
   return true;
 }
 
-uint64_t Nanoapp::getAppId() const {
-  return mAppId;
-}
-
-uint32_t Nanoapp::getAppVersion() const {
-  return mAppVersion;
-}
-
-uint32_t Nanoapp::getInstanceId() const {
-  return mInstanceId;
-}
-
-uint32_t Nanoapp::getTargetApiVersion() const {
-  return mTargetApiVersion;
-}
-
-bool Nanoapp::isSystemNanoapp() const {
-  return mIsSystemNanoapp;
-}
-
 void Nanoapp::postEvent(Event *event) {
   mEventQueue.push(event);
 }
 
-bool Nanoapp::start() {
-  return mPlatformNanoapp->start();
-}
-
-void Nanoapp::stop() {
-  mPlatformNanoapp->stop();
-}
-
 bool Nanoapp::hasPendingEvent() {
   return !mEventQueue.empty();
 }
@@ -96,8 +70,7 @@
 
   CHRE_ASSERT_LOG(event != nullptr, "Tried delivering event, but queue empty");
   if (event != nullptr) {
-    mPlatformNanoapp->handleEvent(event->senderInstanceId, event->eventType,
-                                  event->eventData);
+    handleEvent(event->senderInstanceId, event->eventType, event->eventData);
   }
 
   return event;
diff --git a/host/common/host_protocol_host.cc b/host/common/host_protocol_host.cc
index 2f17cdd..a00ff79 100644
--- a/host/common/host_protocol_host.cc
+++ b/host/common/host_protocol_host.cc
@@ -100,6 +100,15 @@
         break;
       }
 
+      case fbs::ChreMessage::LoadNanoappResponse: {
+        const auto *resp = static_cast<const fbs::LoadNanoappResponse *>(
+            container->message());
+        fbs::LoadNanoappResponseT response;
+        resp->UnPackTo(&response);
+        handlers.handleLoadNanoappResponse(response);
+        break;
+      }
+
       default:
         LOGW("Got invalid/unexpected message type %" PRIu8,
              static_cast<uint8_t>(container->message_type()));
@@ -112,16 +121,55 @@
 
 void HostProtocolHost::encodeHubInfoRequest(FlatBufferBuilder& builder) {
   auto request = fbs::CreateHubInfoRequest(builder);
-  auto container = fbs::CreateMessageContainer(
-      builder, fbs::ChreMessage::HubInfoRequest, request.Union());
-  builder.Finish(container);
+  finalize(builder, fbs::ChreMessage::HubInfoRequest, request.Union());
+}
+
+void HostProtocolHost::encodeLoadNanoappRequest(
+    FlatBufferBuilder& builder, uint32_t transactionId, uint64_t appId,
+    uint32_t appVersion, uint32_t targetApiVersion,
+    const std::vector<uint8_t>& nanoappBinary) {
+  auto appBinary = builder.CreateVector(nanoappBinary);
+  auto request = fbs::CreateLoadNanoappRequest(
+      builder, transactionId, appId, appVersion, targetApiVersion, appBinary);
+  finalize(builder, fbs::ChreMessage::LoadNanoappRequest, request.Union());
 }
 
 void HostProtocolHost::encodeNanoappListRequest(FlatBufferBuilder& builder) {
   auto request = fbs::CreateNanoappListRequest(builder);
-  auto container = fbs::CreateMessageContainer(
-      builder, fbs::ChreMessage::NanoappListRequest, request.Union());
-  builder.Finish(container);
+  finalize(builder, fbs::ChreMessage::NanoappListRequest, request.Union());
+}
+
+bool HostProtocolHost::extractHostClientId(const void *message,
+                                           size_t messageLen,
+                                           uint16_t *hostClientId) {
+  bool success = verifyMessage(message, messageLen);
+
+  if (success && hostClientId != nullptr) {
+    const fbs::MessageContainer *container = fbs::GetMessageContainer(message);
+    // host_addr guaranteed to be non-null via verifyMessage (it's a required
+    // field)
+    *hostClientId = container->host_addr()->client_id();
+    success = true;
+  }
+
+  return success;
+}
+
+bool HostProtocolHost::mutateHostClientId(void *message, size_t messageLen,
+                                          uint16_t hostClientId) {
+  bool success = verifyMessage(message, messageLen);
+
+  if (!success) {
+    LOGE("Message verification failed - can't mutate host ID");
+  } else {
+    fbs::MessageContainer *container = fbs::GetMutableMessageContainer(message);
+    // host_addr guaranteed to be non-null via verifyMessage (it's a required
+    // field)
+    container->mutable_host_addr()->mutate_client_id(hostClientId);
+    success = true;
+  }
+
+  return success;
 }
 
 }  // namespace chre
diff --git a/host/common/include/chre_host/host_messages_generated.h b/host/common/include/chre_host/host_messages_generated.h
index d23e447..4dfe1d7 100644
--- a/host/common/include/chre_host/host_messages_generated.h
+++ b/host/common/include/chre_host/host_messages_generated.h
@@ -27,6 +27,14 @@
 struct NanoappListResponse;
 struct NanoappListResponseT;
 
+struct LoadNanoappRequest;
+struct LoadNanoappRequestT;
+
+struct LoadNanoappResponse;
+struct LoadNanoappResponseT;
+
+struct HostAddress;
+
 struct MessageContainer;
 struct MessageContainerT;
 
@@ -39,8 +47,10 @@
   HubInfoResponse = 3,
   NanoappListRequest = 4,
   NanoappListResponse = 5,
+  LoadNanoappRequest = 6,
+  LoadNanoappResponse = 7,
   MIN = NONE,
-  MAX = NanoappListResponse
+  MAX = LoadNanoappResponse
 };
 
 inline const char **EnumNamesChreMessage() {
@@ -51,6 +61,8 @@
     "HubInfoResponse",
     "NanoappListRequest",
     "NanoappListResponse",
+    "LoadNanoappRequest",
+    "LoadNanoappResponse",
     nullptr
   };
   return names;
@@ -85,6 +97,14 @@
   static const ChreMessage enum_value = ChreMessage::NanoappListResponse;
 };
 
+template<> struct ChreMessageTraits<LoadNanoappRequest> {
+  static const ChreMessage enum_value = ChreMessage::LoadNanoappRequest;
+};
+
+template<> struct ChreMessageTraits<LoadNanoappResponse> {
+  static const ChreMessage enum_value = ChreMessage::LoadNanoappResponse;
+};
+
 struct ChreMessageUnion {
   ChreMessage type;
   flatbuffers::NativeTable *table;
@@ -130,11 +150,42 @@
     return type == ChreMessage::NanoappListResponse ?
       reinterpret_cast<NanoappListResponseT *>(table) : nullptr;
   }
+  LoadNanoappRequestT *AsLoadNanoappRequest() {
+    return type == ChreMessage::LoadNanoappRequest ?
+      reinterpret_cast<LoadNanoappRequestT *>(table) : nullptr;
+  }
+  LoadNanoappResponseT *AsLoadNanoappResponse() {
+    return type == ChreMessage::LoadNanoappResponse ?
+      reinterpret_cast<LoadNanoappResponseT *>(table) : nullptr;
+  }
 };
 
 bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type);
 bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
 
+MANUALLY_ALIGNED_STRUCT(2) HostAddress FLATBUFFERS_FINAL_CLASS {
+ private:
+  uint16_t client_id_;
+
+ public:
+  HostAddress() {
+    memset(this, 0, sizeof(HostAddress));
+  }
+  HostAddress(const HostAddress &_o) {
+    memcpy(this, &_o, sizeof(HostAddress));
+  }
+  HostAddress(uint16_t _client_id)
+      : client_id_(flatbuffers::EndianScalar(_client_id)) {
+  }
+  uint16_t client_id() const {
+    return flatbuffers::EndianScalar(client_id_);
+  }
+  void mutate_client_id(uint16_t _client_id) {
+    flatbuffers::WriteScalar(&client_id_, _client_id);
+  }
+};
+STRUCT_END(HostAddress, 2);
+
 struct NanoappMessageT : public flatbuffers::NativeTable {
   typedef NanoappMessage TableType;
   uint64_t app_id;
@@ -772,9 +823,216 @@
 
 flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
 
+struct LoadNanoappRequestT : public flatbuffers::NativeTable {
+  typedef LoadNanoappRequest TableType;
+  uint32_t transaction_id;
+  uint64_t app_id;
+  uint32_t app_version;
+  uint32_t target_api_version;
+  std::vector<uint8_t> app_binary;
+  LoadNanoappRequestT()
+      : transaction_id(0),
+        app_id(0),
+        app_version(0),
+        target_api_version(0) {
+  }
+};
+
+struct LoadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef LoadNanoappRequestT NativeTableType;
+  enum {
+    VT_TRANSACTION_ID = 4,
+    VT_APP_ID = 6,
+    VT_APP_VERSION = 8,
+    VT_TARGET_API_VERSION = 10,
+    VT_APP_BINARY = 12
+  };
+  uint32_t transaction_id() const {
+    return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
+  }
+  bool mutate_transaction_id(uint32_t _transaction_id) {
+    return SetField(VT_TRANSACTION_ID, _transaction_id);
+  }
+  uint64_t app_id() const {
+    return GetField<uint64_t>(VT_APP_ID, 0);
+  }
+  bool mutate_app_id(uint64_t _app_id) {
+    return SetField(VT_APP_ID, _app_id);
+  }
+  uint32_t app_version() const {
+    return GetField<uint32_t>(VT_APP_VERSION, 0);
+  }
+  bool mutate_app_version(uint32_t _app_version) {
+    return SetField(VT_APP_VERSION, _app_version);
+  }
+  uint32_t target_api_version() const {
+    return GetField<uint32_t>(VT_TARGET_API_VERSION, 0);
+  }
+  bool mutate_target_api_version(uint32_t _target_api_version) {
+    return SetField(VT_TARGET_API_VERSION, _target_api_version);
+  }
+  const flatbuffers::Vector<uint8_t> *app_binary() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_app_binary() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
+           VerifyField<uint64_t>(verifier, VT_APP_ID) &&
+           VerifyField<uint32_t>(verifier, VT_APP_VERSION) &&
+           VerifyField<uint32_t>(verifier, VT_TARGET_API_VERSION) &&
+           VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_APP_BINARY) &&
+           verifier.Verify(app_binary()) &&
+           verifier.EndTable();
+  }
+  LoadNanoappRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(LoadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<LoadNanoappRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct LoadNanoappRequestBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_transaction_id(uint32_t transaction_id) {
+    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0);
+  }
+  void add_app_id(uint64_t app_id) {
+    fbb_.AddElement<uint64_t>(LoadNanoappRequest::VT_APP_ID, app_id, 0);
+  }
+  void add_app_version(uint32_t app_version) {
+    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_VERSION, app_version, 0);
+  }
+  void add_target_api_version(uint32_t target_api_version) {
+    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TARGET_API_VERSION, target_api_version, 0);
+  }
+  void add_app_binary(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary) {
+    fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY, app_binary);
+  }
+  LoadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  LoadNanoappRequestBuilder &operator=(const LoadNanoappRequestBuilder &);
+  flatbuffers::Offset<LoadNanoappRequest> Finish() {
+    const auto end = fbb_.EndTable(start_, 5);
+    auto o = flatbuffers::Offset<LoadNanoappRequest>(end);
+    fbb_.Required(o, LoadNanoappRequest::VT_APP_BINARY);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t transaction_id = 0,
+    uint64_t app_id = 0,
+    uint32_t app_version = 0,
+    uint32_t target_api_version = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary = 0) {
+  LoadNanoappRequestBuilder builder_(_fbb);
+  builder_.add_app_id(app_id);
+  builder_.add_app_binary(app_binary);
+  builder_.add_target_api_version(target_api_version);
+  builder_.add_app_version(app_version);
+  builder_.add_transaction_id(transaction_id);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t transaction_id = 0,
+    uint64_t app_id = 0,
+    uint32_t app_version = 0,
+    uint32_t target_api_version = 0,
+    const std::vector<uint8_t> *app_binary = nullptr) {
+  return chre::fbs::CreateLoadNanoappRequest(
+      _fbb,
+      transaction_id,
+      app_id,
+      app_version,
+      target_api_version,
+      app_binary ? _fbb.CreateVector<uint8_t>(*app_binary) : 0);
+}
+
+flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct LoadNanoappResponseT : public flatbuffers::NativeTable {
+  typedef LoadNanoappResponse TableType;
+  uint32_t transaction_id;
+  bool success;
+  LoadNanoappResponseT()
+      : transaction_id(0),
+        success(false) {
+  }
+};
+
+struct LoadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef LoadNanoappResponseT NativeTableType;
+  enum {
+    VT_TRANSACTION_ID = 4,
+    VT_SUCCESS = 6
+  };
+  uint32_t transaction_id() const {
+    return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
+  }
+  bool mutate_transaction_id(uint32_t _transaction_id) {
+    return SetField(VT_TRANSACTION_ID, _transaction_id);
+  }
+  bool success() const {
+    return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
+  }
+  bool mutate_success(bool _success) {
+    return SetField(VT_SUCCESS, static_cast<uint8_t>(_success));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
+           VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
+           verifier.EndTable();
+  }
+  LoadNanoappResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(LoadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<LoadNanoappResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct LoadNanoappResponseBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_transaction_id(uint32_t transaction_id) {
+    fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0);
+  }
+  void add_success(bool success) {
+    fbb_.AddElement<uint8_t>(LoadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
+  }
+  LoadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  LoadNanoappResponseBuilder &operator=(const LoadNanoappResponseBuilder &);
+  flatbuffers::Offset<LoadNanoappResponse> Finish() {
+    const auto end = fbb_.EndTable(start_, 2);
+    auto o = flatbuffers::Offset<LoadNanoappResponse>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t transaction_id = 0,
+    bool success = false) {
+  LoadNanoappResponseBuilder builder_(_fbb);
+  builder_.add_transaction_id(transaction_id);
+  builder_.add_success(success);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
 struct MessageContainerT : public flatbuffers::NativeTable {
   typedef MessageContainer TableType;
   ChreMessageUnion message;
+  std::unique_ptr<HostAddress> host_addr;
   MessageContainerT() {
   }
 };
@@ -786,7 +1044,8 @@
   typedef MessageContainerT NativeTableType;
   enum {
     VT_MESSAGE_TYPE = 4,
-    VT_MESSAGE = 6
+    VT_MESSAGE = 6,
+    VT_HOST_ADDR = 8
   };
   ChreMessage message_type() const {
     return static_cast<ChreMessage>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0));
@@ -800,11 +1059,24 @@
   void *mutable_message() {
     return GetPointer<void *>(VT_MESSAGE);
   }
+  /// The originating or destination client ID on the host side, used to direct
+  /// responses only to the client that sent the request. Although initially
+  /// populated by the requesting client, this is enforced to be the correct
+  /// value by the entity guarding access to CHRE.
+  /// This is wrapped in a struct to ensure that it is always included when
+  /// encoding the message, so it can be mutated by the host daemon.
+  const HostAddress *host_addr() const {
+    return GetStruct<const HostAddress *>(VT_HOST_ADDR);
+  }
+  HostAddress *mutable_host_addr() {
+    return GetStruct<HostAddress *>(VT_HOST_ADDR);
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) &&
            VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) &&
            VerifyChreMessage(verifier, message(), message_type()) &&
+           VerifyFieldRequired<HostAddress>(verifier, VT_HOST_ADDR) &&
            verifier.EndTable();
   }
   MessageContainerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -821,15 +1093,19 @@
   void add_message(flatbuffers::Offset<void> message) {
     fbb_.AddOffset(MessageContainer::VT_MESSAGE, message);
   }
+  void add_host_addr(const HostAddress *host_addr) {
+    fbb_.AddStruct(MessageContainer::VT_HOST_ADDR, host_addr);
+  }
   MessageContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
   MessageContainerBuilder &operator=(const MessageContainerBuilder &);
   flatbuffers::Offset<MessageContainer> Finish() {
-    const auto end = fbb_.EndTable(start_, 2);
+    const auto end = fbb_.EndTable(start_, 3);
     auto o = flatbuffers::Offset<MessageContainer>(end);
     fbb_.Required(o, MessageContainer::VT_MESSAGE);
+    fbb_.Required(o, MessageContainer::VT_HOST_ADDR);
     return o;
   }
 };
@@ -837,8 +1113,10 @@
 inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(
     flatbuffers::FlatBufferBuilder &_fbb,
     ChreMessage message_type = ChreMessage::NONE,
-    flatbuffers::Offset<void> message = 0) {
+    flatbuffers::Offset<void> message = 0,
+    const HostAddress *host_addr = 0) {
   MessageContainerBuilder builder_(_fbb);
+  builder_.add_host_addr(host_addr);
   builder_.add_message(message);
   builder_.add_message_type(message_type);
   return builder_.Finish();
@@ -1041,6 +1319,71 @@
       _nanoapps);
 }
 
+inline LoadNanoappRequestT *LoadNanoappRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new LoadNanoappRequestT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void LoadNanoappRequest::UnPackTo(LoadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = transaction_id(); _o->transaction_id = _e; };
+  { auto _e = app_id(); _o->app_id = _e; };
+  { auto _e = app_version(); _o->app_version = _e; };
+  { auto _e = target_api_version(); _o->target_api_version = _e; };
+  { auto _e = app_binary(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->app_binary.push_back(_e->Get(_i)); } };
+}
+
+inline flatbuffers::Offset<LoadNanoappRequest> LoadNanoappRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateLoadNanoappRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  auto _transaction_id = _o->transaction_id;
+  auto _app_id = _o->app_id;
+  auto _app_version = _o->app_version;
+  auto _target_api_version = _o->target_api_version;
+  auto _app_binary = _fbb.CreateVector(_o->app_binary);
+  return chre::fbs::CreateLoadNanoappRequest(
+      _fbb,
+      _transaction_id,
+      _app_id,
+      _app_version,
+      _target_api_version,
+      _app_binary);
+}
+
+inline LoadNanoappResponseT *LoadNanoappResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new LoadNanoappResponseT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void LoadNanoappResponse::UnPackTo(LoadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = transaction_id(); _o->transaction_id = _e; };
+  { auto _e = success(); _o->success = _e; };
+}
+
+inline flatbuffers::Offset<LoadNanoappResponse> LoadNanoappResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateLoadNanoappResponse(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  auto _transaction_id = _o->transaction_id;
+  auto _success = _o->success;
+  return chre::fbs::CreateLoadNanoappResponse(
+      _fbb,
+      _transaction_id,
+      _success);
+}
+
 inline MessageContainerT *MessageContainer::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
   auto _o = new MessageContainerT();
   UnPackTo(_o, _resolver);
@@ -1052,6 +1395,7 @@
   (void)_resolver;
   { auto _e = message_type(); _o->message.type = _e; };
   { auto _e = message(); if (_e) _o->message.table = ChreMessageUnion::UnPack(_e, message_type(),_resolver); };
+  { auto _e = host_addr(); if (_e) _o->host_addr = std::unique_ptr<HostAddress>(new HostAddress(*_e)); };
 }
 
 inline flatbuffers::Offset<MessageContainer> MessageContainer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -1063,10 +1407,12 @@
   (void)_o;
   auto _message_type = _o->message.type;
   auto _message = _o->message.Pack(_fbb);
+  auto _host_addr = _o->host_addr ? _o->host_addr.get() : 0;
   return chre::fbs::CreateMessageContainer(
       _fbb,
       _message_type,
-      _message);
+      _message,
+      _host_addr);
 }
 
 inline bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type) {
@@ -1094,6 +1440,14 @@
       auto ptr = reinterpret_cast<const NanoappListResponse *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case ChreMessage::LoadNanoappRequest: {
+      auto ptr = reinterpret_cast<const LoadNanoappRequest *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case ChreMessage::LoadNanoappResponse: {
+      auto ptr = reinterpret_cast<const LoadNanoappResponse *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
     default: return false;
   }
 }
@@ -1131,6 +1485,14 @@
       auto ptr = reinterpret_cast<const NanoappListResponse *>(obj);
       return ptr->UnPack(resolver);
     }
+    case ChreMessage::LoadNanoappRequest: {
+      auto ptr = reinterpret_cast<const LoadNanoappRequest *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    case ChreMessage::LoadNanoappResponse: {
+      auto ptr = reinterpret_cast<const LoadNanoappResponse *>(obj);
+      return ptr->UnPack(resolver);
+    }
     default: return nullptr;
   }
 }
@@ -1157,6 +1519,14 @@
       auto ptr = reinterpret_cast<const NanoappListResponseT *>(table);
       return CreateNanoappListResponse(_fbb, ptr, _rehasher).Union();
     }
+    case ChreMessage::LoadNanoappRequest: {
+      auto ptr = reinterpret_cast<const LoadNanoappRequestT *>(table);
+      return CreateLoadNanoappRequest(_fbb, ptr, _rehasher).Union();
+    }
+    case ChreMessage::LoadNanoappResponse: {
+      auto ptr = reinterpret_cast<const LoadNanoappResponseT *>(table);
+      return CreateLoadNanoappResponse(_fbb, ptr, _rehasher).Union();
+    }
     default: return 0;
   }
 }
@@ -1188,6 +1558,16 @@
       delete ptr;
       break;
     }
+    case ChreMessage::LoadNanoappRequest: {
+      auto ptr = reinterpret_cast<LoadNanoappRequestT *>(table);
+      delete ptr;
+      break;
+    }
+    case ChreMessage::LoadNanoappResponse: {
+      auto ptr = reinterpret_cast<LoadNanoappResponseT *>(table);
+      delete ptr;
+      break;
+    }
     default: break;
   }
   table = nullptr;
diff --git a/host/common/include/chre_host/host_protocol_host.h b/host/common/include/chre_host/host_protocol_host.h
index c6b1cd9..c11d1b7 100644
--- a/host/common/include/chre_host/host_protocol_host.h
+++ b/host/common/include/chre_host/host_protocol_host.h
@@ -48,6 +48,9 @@
 
   virtual void handleNanoappListResponse(
       const ::chre::fbs::NanoappListResponseT& response) = 0;
+
+  virtual void handleLoadNanoappResponse(
+      const ::chre::fbs::LoadNanoappResponseT& response) = 0;
 };
 
 /**
@@ -81,12 +84,51 @@
   static void encodeHubInfoRequest(flatbuffers::FlatBufferBuilder& builder);
 
   /**
+   * Encodes a message requesting to load a nanoapp specified by the included
+   * binary payload and metadata.
+   *
+   * @param builder A newly constructed FlatBufferBuilder that will be used to
+   *        construct the message
+   */
+  static void encodeLoadNanoappRequest(
+      flatbuffers::FlatBufferBuilder& builder, uint32_t transactionId,
+      uint64_t appId, uint32_t appVersion, uint32_t targetApiVersion,
+      const std::vector<uint8_t>& nanoappBinary);
+
+  /**
    * Encodes a message requesting the list of loaded nanoapps from CHRE
    *
    * @param builder A newly constructed FlatBufferBuilder that will be used to
    *        construct the message
    */
   static void encodeNanoappListRequest(flatbuffers::FlatBufferBuilder& builder);
+
+  /**
+   * Decodes the host client ID included in the message container
+   *
+   * @param message Buffer containing a complete FlatBuffers CHRE message
+   * @param messageLen Size of the message, in bytes
+   * @param hostClientId Output parameter that will be populated with the client
+   *        ID included in the message on success
+   *
+   * @return true if the host client ID was successfully decoded from the
+   *         message
+   */
+  static bool extractHostClientId(const void *message, size_t messageLen,
+                                  uint16_t *hostClientId);
+
+  /**
+   * Update the host client ID field in the MessageContainer.
+   *
+   * @param message Buffer containing a complete FlatBuffers CHRE message
+   * @param messageLen Size of the message, in bytes
+   * @param hostClientId The value to set the host client ID to
+   *
+   * @return true if the message was verified successfully, and we were able to
+   *         modify the host client ID field
+   */
+  static bool mutateHostClientId(void *message, size_t messageLen,
+                                 uint16_t hostClientId);
 };
 
 }  // namespace chre
diff --git a/host/common/include/chre_host/socket_server.h b/host/common/include/chre_host/socket_server.h
index a14447d..5cbbdb0 100644
--- a/host/common/include/chre_host/socket_server.h
+++ b/host/common/include/chre_host/socket_server.h
@@ -43,7 +43,7 @@
    * @param data Pointer to buffer containing the raw message data
    * @param len Number of bytes of data received
    */
-  typedef std::function<void(uint16_t clientId, const void *data, size_t len)>
+  typedef std::function<void(uint16_t clientId, void *data, size_t len)>
       ClientMessageCallback;
 
   /**
@@ -68,6 +68,18 @@
    */
   void sendToAllClients(const void *data, size_t length);
 
+  /**
+   * Sends a message to one client, specified via its unique client ID. This
+   * method is thread-safe.
+   *
+   * @param data
+   * @param length
+   * @param clientId
+   *
+   * @return true if the message was successfully sent to the specified client
+   */
+  bool sendToClientById(const void *data, size_t length, uint16_t clientId);
+
  private:
   DISALLOW_COPY_AND_ASSIGN(SocketServer);
 
@@ -96,6 +108,8 @@
   void acceptClientConnection();
   void disconnectClient(int clientSocket);
   void handleClientData(int clientSocket);
+  bool sendToClientSocket(const void *data, size_t length, int clientSocket,
+                          uint16_t clientId);
   void serviceSocket();
 
   static std::atomic<bool> sSignalReceived;
diff --git a/host/common/socket_server.cc b/host/common/socket_server.cc
index b0d2d8a..53c5d3f 100644
--- a/host/common/socket_server.cc
+++ b/host/common/socket_server.cc
@@ -109,21 +109,12 @@
   for (const auto& pair : mClients) {
     int clientSocket = pair.first;
     uint16_t clientId = pair.second.clientId;
-
-    ssize_t bytesSent = send(clientSocket, data, length, 0);
-    if (bytesSent < 0) {
-      LOGE("Error sending packet of size %zu to client %" PRIu16 ": %s",
-           length, clientId, strerror(errno));
-      if (errno == EINTR) {
-        break;
-      }
-    } else if (bytesSent == 0) {
-      LOGW("Client %" PRIu16 " disconnected before message could be delivered",
-           clientId);
-    } else {
-      LOGV("Delivered message of size %zu bytes to client %" PRIu16, length,
-           clientId);
+    if (sendToClientSocket(data, length, clientSocket, clientId)) {
       deliveredCount++;
+    } else if (errno == EINTR) {
+      // Exit early if we were interrupted - we should only get this for
+      // SIGINT/SIGTERM, so we should exit quickly
+      break;
     }
   }
 
@@ -132,6 +123,23 @@
   }
 }
 
+bool SocketServer::sendToClientById(const void *data, size_t length,
+                                    uint16_t clientId) {
+  std::lock_guard<std::mutex> lock(mClientsMutex);
+
+  bool sent = false;
+  for (const auto& pair : mClients) {
+    uint16_t thisClientId = pair.second.clientId;
+    if (thisClientId == clientId) {
+      int clientSocket = pair.first;
+      sent = sendToClientSocket(data, length, clientSocket, thisClientId);
+      break;
+    }
+  }
+
+  return sent;
+}
+
 void SocketServer::acceptClientConnection() {
   int clientSocket = accept(mSockFd, NULL, NULL);
   if (clientSocket < 0) {
@@ -216,6 +224,24 @@
   }
 }
 
+bool SocketServer::sendToClientSocket(const void *data, size_t length,
+                                      int clientSocket, uint16_t clientId) {
+  errno = 0;
+  ssize_t bytesSent = send(clientSocket, data, length, 0);
+  if (bytesSent < 0) {
+    LOGE("Error sending packet of size %zu to client %" PRIu16 ": %s",
+         length, clientId, strerror(errno));
+  } else if (bytesSent == 0) {
+    LOGW("Client %" PRIu16 " disconnected before message could be delivered",
+         clientId);
+  } else {
+    LOGV("Delivered message of size %zu bytes to client %" PRIu16, length,
+         clientId);
+  }
+
+  return (bytesSent > 0);
+}
+
 void SocketServer::serviceSocket() {
   constexpr size_t kListenIndex = 0;
   static_assert(kListenIndex == 0, "Code assumes that the first index is "
diff --git a/host/common/test/chre_test_client.cc b/host/common/test/chre_test_client.cc
index 0fe9c3e..d155b3f 100644
--- a/host/common/test/chre_test_client.cc
+++ b/host/common/test/chre_test_client.cc
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "chre/util/nanoapp/app_id.h"
 #include "chre_host/host_protocol_host.h"
 #include "chre_host/log.h"
 #include "chre_host/socket_client.h"
@@ -22,6 +23,7 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 
+#include <fstream>
 #include <thread>
 
 #include <cutils/sockets.h>
@@ -97,7 +99,7 @@
   }
 
   void handleNanoappListResponse(
-      const fbs::NanoappListResponseT& response) {
+      const fbs::NanoappListResponseT& response) override {
     LOGI("Got nanoapp list response with %zu apps:", response.nanoapps.size());
     for (const std::unique_ptr<fbs::NanoappListEntryT>& nanoapp
            : response.nanoapps) {
@@ -106,6 +108,12 @@
            nanoapp->is_system);
     }
   }
+
+  void handleLoadNanoappResponse(
+      const ::chre::fbs::LoadNanoappResponseT& response) override {
+    LOGI("Got load nanoapp response, transaction ID 0x%" PRIx32 " result %d",
+         response.transaction_id, response.success);
+  }
 };
 
 void requestHubInfo(SocketClient& client) {
@@ -132,7 +140,8 @@
   FlatBufferBuilder builder(64);
   uint8_t messageData[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
   HostProtocolHost::encodeNanoappMessage(
-      builder, 0, kHostEndpoint, 1234, messageData, sizeof(messageData));
+      builder, chre::kMessageWorldAppId, kHostEndpoint, 1234, messageData,
+      sizeof(messageData));
 
   LOGI("Sending message to nanoapp (%u bytes w/%zu bytes of payload)",
        builder.GetSize(), sizeof(messageData));
@@ -141,8 +150,34 @@
   }
 }
 
+void sendLoadNanoappRequest(SocketClient& client, const char *filename) {
+  std::ifstream file(filename, std::ios::binary | std::ios::ate);
+  if (!file) {
+    LOGE("Couldn't open file '%s': %s", filename, strerror(errno));
+    return;
+  }
+  ssize_t size = file.tellg();
+  file.seekg(0, std::ios::beg);
+
+  std::vector<uint8_t> buffer(size);
+  if (!file.read(reinterpret_cast<char *>(buffer.data()), size)) {
+    LOGE("Couldn't read from file: %s", strerror(errno));
+    return;
+  }
+
+  FlatBufferBuilder builder(size + 128);
+  HostProtocolHost::encodeLoadNanoappRequest(
+      builder, 1, 0x476f6f676c00100b, 0, 0x01000000, buffer);
+
+  LOGI("Sending load nanoapp request (%u bytes total w/%zu bytes of payload)",
+       builder.GetSize(), buffer.size());
+  if (!client.sendMessage(builder.GetBufferPointer(), builder.GetSize())) {
+    LOGE("Failed to send message");
+  }
 }
 
+}  // anonymous namespace
+
 int main() {
   int ret = -1;
   SocketClient client;
@@ -154,6 +189,7 @@
     requestHubInfo(client);
     requestNanoappList(client);
     sendMessageToNanoapp(client);
+    sendLoadNanoappRequest(client, "/data/activity.so");
 
     LOGI("Sleeping, waiting on responses");
     std::this_thread::sleep_for(std::chrono::seconds(5));
diff --git a/host/hal_generic/generic_context_hub.cc b/host/hal_generic/generic_context_hub.cc
index 2a7fd21..a122bea 100644
--- a/host/hal_generic/generic_context_hub.cc
+++ b/host/hal_generic/generic_context_hub.cc
@@ -15,6 +15,7 @@
  */
 
 #define LOG_TAG "ContextHubHal"
+#define LOG_NDEBUG 0
 
 #include "generic_context_hub.h"
 
@@ -31,7 +32,9 @@
 namespace implementation {
 
 using ::android::hardware::Return;
+using ::android::hardware::contexthub::V1_0::AsyncEventType;
 using ::android::hardware::contexthub::V1_0::Result;
+using ::android::hardware::contexthub::V1_0::TransactionResult;
 using ::android::chre::HostProtocolHost;
 using ::flatbuffers::FlatBufferBuilder;
 
@@ -149,12 +152,30 @@
 
 Return<Result> GenericContextHub::loadNanoApp(
     uint32_t hubId, const NanoAppBinary& appBinary, uint32_t transactionId) {
-  // TODO
-  UNUSED(hubId);
-  UNUSED(appBinary);
-  UNUSED(transactionId);
+  Result result;
   ALOGV("%s", __func__);
-  return Result::UNKNOWN_FAILURE;
+
+  if (hubId != kDefaultHubId) {
+    result = Result::BAD_PARAMS;
+  } else {
+    FlatBufferBuilder builder(128 + appBinary.customBinary.size());
+    uint32_t targetApiVersion = (appBinary.targetChreApiMajorVersion << 24) |
+                                (appBinary.targetChreApiMinorVersion << 16);
+    HostProtocolHost::encodeLoadNanoappRequest(
+        builder, transactionId, appBinary.appId, appBinary.appVersion,
+        targetApiVersion, appBinary.customBinary);
+    if (!mClient.sendMessage(builder.GetBufferPointer(), builder.GetSize())) {
+      result = Result::UNKNOWN_FAILURE;
+    } else {
+      result = Result::OK;
+    }
+  }
+
+  ALOGD("Attempted to send load nanoapp request for app of size %zu with ID "
+        "0x%016" PRIx64 " as transaction ID %" PRIu32 ": result %" PRIu32,
+        appBinary.customBinary.size(), appBinary.appId, transactionId, result);
+
+  return result;
 }
 
 Return<Result> GenericContextHub::unloadNanoApp(
@@ -188,9 +209,21 @@
 }
 
 Return<Result> GenericContextHub::queryApps(uint32_t hubId) {
-  // TODO
-  UNUSED(hubId);
+  Result result;
   ALOGV("%s", __func__);
+
+  if (hubId != kDefaultHubId) {
+    result = Result::BAD_PARAMS;
+  } else {
+    FlatBufferBuilder builder(64);
+    HostProtocolHost::encodeNanoappListRequest(builder);
+    if (!mClient.sendMessage(builder.GetBufferPointer(), builder.GetSize())) {
+      result = Result::UNKNOWN_FAILURE;
+    } else {
+      result = Result::OK;
+    }
+  }
+
   return Result::UNKNOWN_FAILURE;
 }
 
@@ -204,6 +237,20 @@
   }
 }
 
+void GenericContextHub::SocketCallbacks::onConnected() {
+  if (mHaveConnected) {
+    ALOGI("Reconnected to CHRE daemon");
+    if (mParent.mCallbacks != nullptr) {
+      mParent.mCallbacks->handleHubEvent(AsyncEventType::RESTARTED);
+    }
+  }
+  mHaveConnected = true;
+}
+
+void GenericContextHub::SocketCallbacks::onDisconnected() {
+  ALOGW("Lost connection to CHRE daemon");
+}
+
 void GenericContextHub::SocketCallbacks::handleNanoappMessage(
     uint64_t appId, uint32_t messageType, uint16_t hostEndpoint,
     const void *messageData, size_t messageDataLen) {
@@ -294,6 +341,16 @@
   mParent.mCallbacks->handleAppsInfo(appInfoList);
 }
 
+void GenericContextHub::SocketCallbacks::handleLoadNanoappResponse(
+    const ::chre::fbs::LoadNanoappResponseT& response) {
+  ALOGV("Got load nanoapp response for transaction %" PRIu32 " with result %d",
+        response.transaction_id, response.success);
+
+  TransactionResult result = (response.success) ?
+      TransactionResult::SUCCESS : TransactionResult::FAILURE;
+  mParent.mCallbacks->handleTxnResult(response.transaction_id, result);
+}
+
 IContexthub* HIDL_FETCH_IContexthub(const char* /* name */) {
   return new GenericContextHub();
 }
diff --git a/host/hal_generic/generic_context_hub.h b/host/hal_generic/generic_context_hub.h
index 2e140ef..6b3abb6 100644
--- a/host/hal_generic/generic_context_hub.h
+++ b/host/hal_generic/generic_context_hub.h
@@ -66,6 +66,8 @@
    public:
     SocketCallbacks(GenericContextHub& parent);
     void onMessageReceived(const void *data, size_t length) override;
+    void onConnected() override;
+    void onDisconnected() override;
 
     void handleNanoappMessage(
         uint64_t appId, uint32_t messageType, uint16_t hostEndpoint,
@@ -80,8 +82,12 @@
     void handleNanoappListResponse(
         const ::chre::fbs::NanoappListResponseT& response) override;
 
+    void handleLoadNanoappResponse(
+      const ::chre::fbs::LoadNanoappResponseT& response) override;
+
    private:
     GenericContextHub& mParent;
+    bool mHaveConnected = false;
   };
 
   sp<SocketCallbacks> mSocketCallbacks;
diff --git a/host/msm/daemon/chre_daemon.cc b/host/msm/daemon/chre_daemon.cc
index 023e61f..9e838dd 100644
--- a/host/msm/daemon/chre_daemon.cc
+++ b/host/msm/daemon/chre_daemon.cc
@@ -40,6 +40,8 @@
  * should be fully converted to C++.
  */
 
+#define LOG_NDEBUG 0  // TODO: for initial testing only
+
 #include <ctype.h>
 #include <pthread.h>
 #include <stdbool.h>
@@ -50,9 +52,12 @@
 
 #include "chre/platform/slpi/fastrpc.h"
 #include "chre_host/log.h"
+#include "chre_host/host_protocol_host.h"
 #include "chre_host/socket_server.h"
 #include "generated/chre_slpi.h"
 
+using android::chre::HostProtocolHost;
+
 typedef void *(thread_entry_point_f)(void *);
 
 struct reverse_monitor_thread_data {
@@ -79,7 +84,13 @@
   char line_chars[32];
   int offset_chars = 0;
 
-  LOGD("Dumping buffer of size %zu bytes", size);
+  size_t orig_size = size;
+  if (size > 128) {
+    size = 128;
+    LOGV("Dumping first 128 bytes of buffer of size %zu", orig_size);
+  } else {
+    LOGV("Dumping buffer of size %zu bytes", size);
+  }
   for (size_t i = 1; i <= size; ++i) {
     offset += snprintf(&line[offset], sizeof(line) - offset, "%02x ",
                        buffer[i - 1]);
@@ -87,7 +98,7 @@
         &line_chars[offset_chars], sizeof(line_chars) - offset_chars,
         "%c", (isprint(buffer[i - 1])) ? buffer[i - 1] : '.');
     if ((i % 8) == 0) {
-      LOGD("  %s\t%s", line, line_chars);
+      LOGV("  %s\t%s", line, line_chars);
       offset = 0;
       offset_chars = 0;
     } else if ((i % 4) == 0) {
@@ -103,7 +114,7 @@
       offset += 8;
     }
     *pos = '\0';
-    LOGD("  %s%s%s", line, tabs, line_chars);
+    LOGV("  %s%s%s", line, tabs, line_chars);
   }
 }
 
@@ -131,7 +142,21 @@
       break;
     } else if (result == CHRE_FASTRPC_SUCCESS && messageLen > 0) {
       log_buffer(messageBuffer, messageLen);
-      server->sendToAllClients(messageBuffer, static_cast<size_t>(messageLen));
+      uint16_t hostClientId;
+      if (!HostProtocolHost::extractHostClientId(messageBuffer, messageLen,
+                                                 &hostClientId)) {
+        LOGW("Failed to extract host client ID from message - sending "
+             "broadcast");
+        hostClientId = chre::kHostClientIdUnspecified;
+      }
+
+      if (hostClientId == chre::kHostClientIdUnspecified) {
+        server->sendToAllClients(messageBuffer,
+                                 static_cast<size_t>(messageLen));
+      } else {
+        server->sendToClientById(messageBuffer,
+                                 static_cast<size_t>(messageLen), hostClientId);
+      }
     }
   }
 
@@ -227,8 +252,7 @@
 
 namespace {
 
-void onMessageReceivedFromClient(uint16_t /*clientId*/, const void *data,
-                                 size_t length) {
+void onMessageReceivedFromClient(uint16_t clientId, void *data, size_t length) {
   constexpr size_t kMaxPayloadSize = 1024 * 1024;  // 1 MiB
 
   // This limitation is due to FastRPC, but there's no case where we should come
@@ -239,6 +263,8 @@
   if (length > kMaxPayloadSize) {
     LOGE("Message too large to pass to SLPI (got %zu, max %zu bytes)", length,
          kMaxPayloadSize);
+  } else if (!HostProtocolHost::mutateHostClientId(data, length, clientId)) {
+    LOGE("Couldn't set host client ID in message container!");
   } else {
     LOGD("Delivering message from host (size %zu)", length);
     log_buffer(static_cast<const uint8_t *>(data), length);
diff --git a/platform/include/chre/platform/platform_nanoapp.h b/platform/include/chre/platform/platform_nanoapp.h
index f0725e4..47b78eb 100644
--- a/platform/include/chre/platform/platform_nanoapp.h
+++ b/platform/include/chre/platform/platform_nanoapp.h
@@ -19,41 +19,86 @@
 
 #include <cstdint>
 
+#include "chre/util/non_copyable.h"
 #include "chre/target_platform/platform_nanoapp_base.h"
 
 namespace chre {
 
 /**
- * An interface for calling into nanoapp entry points and managing the
- * lifecycle of a nanoapp.
- *
- * TODO: Look at unloading the app and freeing events that originate from this
- * nanoapp.
+ * The common interface to Nanoapp functionality that has platform-specific
+ * implementation but must be supported for every platform.
  */
-class PlatformNanoapp : public PlatformNanoappBase {
+class PlatformNanoapp : public PlatformNanoappBase, public NonCopyable {
  public:
   /**
-   * Calls the start function of the nanoapp.
+   * Unloads the nanoapp from memory.
+   */
+  ~PlatformNanoapp();
+
+  /**
+   * Calls the start function of the nanoapp. For dynamically loaded nanoapps,
+   * this must also result in calling through to any of the nanoapp's static
+   * global constructors/init functions, etc., prior to invoking the
+   * nanoappStart.
    *
-   * @return Returns true if the app was able to start successfully.
+   * @return true if the app was able to start successfully
+   *
+   * @see nanoappStart
    */
   bool start();
 
   /**
-   * Calls the handleEvent function of the nanoapp.
+   * Passes an event to the nanoapp.
    *
-   * @param the instance ID of the sender
-   * @param the type of the event being sent
-   * @param the data passed in
+   * @see nanoappHandleEvent
    */
-  void handleEvent(uint32_t senderInstanceId,
-                   uint16_t eventType,
+  void handleEvent(uint32_t senderInstanceId, uint16_t eventType,
                    const void *eventData);
 
   /**
-   * Calls the stop function of the nanoapp.
+   * Calls the nanoapp's end callback. For dynamically loaded nanoapps, this
+   * must also result in calling through to any of the nanoapp's static global
+   * destructors, atexit functions, etc., after nanoappEnd returns.
+   *
+   * This function must leave the nanoapp in a state where it can be started
+   * again via start().
+   *
+   * After this function returns, the only
+   *
+   * @see nanoappEnd
    */
-  void stop();
+  void end();
+
+  /**
+   * Retrieves the nanoapp's 64-bit identifier. This function must always return
+   * a valid identifier - either the one supplied by the host via the HAL (from
+   * the header), or the authoritative value inside the nanoapp binary if one
+   * exists. In the event that both are available and they do not match, the
+   * platform implementation must return false from start().
+   */
+  uint64_t getAppId() const;
+
+  /**
+   * Retrieves the nanoapp's own version number. The same restrictions apply
+   * here as for getAppId().
+   *
+   * @see #getAppId
+   */
+  uint32_t getAppVersion() const;
+
+  /**
+   * Retrieves the API version that this nanoapp was compiled against. This
+   * function must only be called while the nanoapp is running (i.e. between
+   * calls to start() and end()).
+   */
+  uint32_t getTargetApiVersion() const;
+
+  /**
+   * Returns true if the nanoapp should not appear in the context hub HAL list
+   * of nanoapps, e.g. because it implements some device functionality purely
+   * beneath the HAL.
+   */
+  bool isSystemNanoapp() const;
 };
 
 }  // namespace chre
diff --git a/platform/include/chre/platform/platform_static_nanoapp_init.h b/platform/include/chre/platform/platform_static_nanoapp_init.h
deleted file mode 100644
index 3c4555f..0000000
--- a/platform/include/chre/platform/platform_static_nanoapp_init.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2017 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.
- */
-
-#ifndef CHRE_PLATFORM_PLATFORM_STATIC_NANOAPP_INIT_H_
-#define CHRE_PLATFORM_PLATFORM_STATIC_NANOAPP_INIT_H_
-
-/**
- * @file
- *
- * Includes the appropriate platform-specific header file that supplies the
- * macro to initialize a static nanoapp. The platform header file must supply the
- * following macro:
- *
- * PLATFORM_STATIC_NANOAPP_INIT(appName)
- *
- * Where appName is the name of a global variable that will be created with type
- * PlatformNanoapp.
- */
-
-#include "chre/platform/platform_nanoapp.h"
-#include "chre/target_platform/platform_static_nanoapp_init.h"
-
-#ifndef PLATFORM_STATIC_NANOAPP_INIT
-#error "PLATFORM_STATIC_NANOAPP_INIT must be defined"
-#endif  // PLATFORM_STATIC_NANOAPP_INIT
-
-#endif  // CHRE_PLATFORM_PLATFORM_STATIC_NANOAPP_INIT_H_
diff --git a/platform/include/chre/platform/static_nanoapp_init.h b/platform/include/chre/platform/static_nanoapp_init.h
new file mode 100644
index 0000000..c607a82
--- /dev/null
+++ b/platform/include/chre/platform/static_nanoapp_init.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef CHRE_PLATFORM_STATIC_NANOAPP_INIT_H_
+#define CHRE_PLATFORM_STATIC_NANOAPP_INIT_H_
+
+/**
+ * @file
+ * Includes the appropriate platform-specific header file that supplies the
+ * macro to initialize a static nanoapp. The platform header file must supply
+ * the following macro:
+ *
+ * CHRE_STATIC_NANOAPP_INIT(appName, appId, appVersion)
+ *
+ * Where appName is the name of a global variable that will be created with type
+ * PlatformNanoapp, appId is the app's 64-bit identifier, and appVersion is the
+ * application-defined 32-bit version number.
+ */
+
+// Since this file is included in nanoapp code, it's likely that the nanoapp log
+// macro will have been included, resulting in conflicting definitions of the
+// log macros with the ones pulled in via nanoapp.h. Undefine these macros to
+// allow their redefinition for CHRE system code.
+#ifdef CHRE_UTIL_NANOAPP_LOG_H_
+#undef LOGE
+#undef LOGW
+#undef LOGI
+#undef LOGD
+#endif // CHRE_UTIL_NANOAPP_LOG_H_
+
+#include "chre/target_platform/static_nanoapp_init.h"
+
+#ifndef CHRE_STATIC_NANOAPP_INIT
+#error "CHRE_STATIC_NANOAPP_INIT must be defined by the target platform's static_nanoapp_init.h"
+#endif
+
+#endif  // CHRE_PLATFORM_STATIC_NANOAPP_INIT_H_
diff --git a/platform/shared/include/chre/platform/static_nanoapps.h b/platform/include/chre/platform/static_nanoapps.h
similarity index 95%
rename from platform/shared/include/chre/platform/static_nanoapps.h
rename to platform/include/chre/platform/static_nanoapps.h
index f2f14f7..4bbf7d0 100644
--- a/platform/shared/include/chre/platform/static_nanoapps.h
+++ b/platform/include/chre/platform/static_nanoapps.h
@@ -22,7 +22,7 @@
 namespace chre {
 
 //! The list of static nanoapps to load.
-extern PlatformNanoapp *const kStaticNanoappList[];
+extern UniquePtr<Nanoapp> *const kStaticNanoappList[];
 
 //! The number of static nanoapps to load.
 extern const size_t kStaticNanoappCount;
diff --git a/platform/linux/include/chre/target_platform/platform_nanoapp_base.h b/platform/linux/include/chre/target_platform/platform_nanoapp_base.h
index ae30ece..1dd1543 100644
--- a/platform/linux/include/chre/target_platform/platform_nanoapp_base.h
+++ b/platform/linux/include/chre/target_platform/platform_nanoapp_base.h
@@ -28,13 +28,16 @@
  */
 struct PlatformNanoappBase {
   //! The function pointer of the nanoapp start entry point.
-  NanoappStartFunction *mStart;
+  chreNanoappStartFunction *mStart;
 
   //! The function pointer of the nanoapp handle event entry point.
-  NanoappHandleEventFunction *mHandleEvent;
+  chreNanoappHandleEventFunction *mHandleEvent;
 
-  //! The function pointer of the nanoapp stop entry point.
-  NanoappStopFunction *mStop;
+  //! The function pointer of the nanoapp end entry point.
+  chreNanoappEndFunction *mEnd;
+
+  uint64_t mAppId;
+  uint32_t mAppVersion;
 };
 
 }  // namespace chre
diff --git a/platform/linux/include/chre/target_platform/static_nanoapp_init.h b/platform/linux/include/chre/target_platform/static_nanoapp_init.h
new file mode 100644
index 0000000..c9fb5bf
--- /dev/null
+++ b/platform/linux/include/chre/target_platform/static_nanoapp_init.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef CHRE_PLATFORM_LINUX_STATIC_NANOAPP_INIT_H_
+#define CHRE_PLATFORM_LINUX_STATIC_NANOAPP_INIT_H_
+
+#include "chre/core/nanoapp.h"
+#include "chre/platform/fatal_error.h"
+#include "chre/util/unique_ptr.h"
+
+/**
+ * Initializes a static nanoapp that is based on the Linux implementation of
+ * PlatformNanoappBase.
+ *
+ * @param appName the name of the nanoapp. This will be prefixed by gNanoapp
+ * when creating the global instance of the nanoapp.
+ * @param appId the app's unique 64-bit ID
+ */
+#define CHRE_STATIC_NANOAPP_INIT(appName, appId, appVersion) \
+namespace chre {                                             \
+UniquePtr<Nanoapp> *gNanoapp##appName;                       \
+                                                             \
+__attribute__((constructor))                                 \
+static void initializeStaticNanoapp##appName() {             \
+  static UniquePtr<Nanoapp> nanoapp = MakeUnique<Nanoapp>(); \
+  if (nanoapp.isNull()) {                                    \
+    FATAL_ERROR("Failed to allocate nanoapp " #appName);     \
+  } else {                                                   \
+    nanoapp->mStart = nanoappStart;                          \
+    nanoapp->mHandleEvent = nanoappHandleEvent;              \
+    nanoapp->mEnd = nanoappEnd;                              \
+    nanoapp->mAppId = appId;                                 \
+    nanoapp->mAppVersion = appVersion;                       \
+    gNanoapp##appName = &nanoapp;                            \
+  }                                                          \
+}                                                            \
+}  /* namespace chre */
+
+#endif  // CHRE_PLATFORM_LINUX_STATIC_NANOAPP_INIT_H_
diff --git a/platform/shared/platform_nanoapp.cc b/platform/linux/platform_nanoapp.cc
similarity index 70%
rename from platform/shared/platform_nanoapp.cc
rename to platform/linux/platform_nanoapp.cc
index 88f6756..39266c8 100644
--- a/platform/shared/platform_nanoapp.cc
+++ b/platform/linux/platform_nanoapp.cc
@@ -14,10 +14,13 @@
  * limitations under the License.
  */
 
+#include "chre_api/chre/version.h"
 #include "chre/platform/platform_nanoapp.h"
 
 namespace chre {
 
+PlatformNanoapp::~PlatformNanoapp() {}
+
 bool PlatformNanoapp::start() {
   return mStart();
 }
@@ -28,8 +31,24 @@
   mHandleEvent(senderInstanceId, eventType, eventData);
 }
 
-void PlatformNanoapp::stop() {
-  mStop();
+void PlatformNanoapp::end() {
+  mEnd();
+}
+
+uint64_t PlatformNanoapp::getAppId() const {
+  return mAppId;
+}
+
+uint32_t PlatformNanoapp::getAppVersion() const {
+  return mAppVersion;
+}
+
+uint32_t PlatformNanoapp::getTargetApiVersion() const {
+  return CHRE_API_VERSION;
+}
+
+bool PlatformNanoapp::isSystemNanoapp() const {
+  return true;
 }
 
 }  // namespace chre
diff --git a/platform/linux/static_nanoapps.cc b/platform/linux/static_nanoapps.cc
index 8df55ff..817a535 100644
--- a/platform/linux/static_nanoapps.cc
+++ b/platform/linux/static_nanoapps.cc
@@ -24,15 +24,15 @@
 
 //! The list of static nanoapps to load for the Linux platform.
 __attribute__((weak))
-PlatformNanoapp *const kStaticNanoappList[] = {
-  &gNanoappGnssWorld,
-  &gNanoappHelloWorld,
-  &gNanoappImuCal,
-  &gNanoappMessageWorld,
-  &gNanoappSensorWorld,
-  &gNanoappTimerWorld,
-  &gNanoappWifiWorld,
-  &gNanoappWwanWorld,
+UniquePtr<Nanoapp> *const kStaticNanoappList[] = {
+  gNanoappGnssWorld,
+  gNanoappHelloWorld,
+  gNanoappImuCal,
+  gNanoappMessageWorld,
+  gNanoappSensorWorld,
+  gNanoappTimerWorld,
+  gNanoappWifiWorld,
+  gNanoappWwanWorld,
 };
 
 //! The size of the static nanoapp list.
diff --git a/platform/platform.mk b/platform/platform.mk
index 8389a41..f060c8e 100644
--- a/platform/platform.mk
+++ b/platform/platform.mk
@@ -34,7 +34,6 @@
 HEXAGON_SRCS += platform/shared/memory.cc
 HEXAGON_SRCS += platform/shared/pal_system_api.cc
 HEXAGON_SRCS += platform/shared/platform_gnss.cc
-HEXAGON_SRCS += platform/shared/platform_nanoapp.cc
 HEXAGON_SRCS += platform/shared/platform_sensor.cc
 HEXAGON_SRCS += platform/shared/platform_wifi.cc
 HEXAGON_SRCS += platform/shared/platform_wwan.cc
@@ -42,6 +41,7 @@
 HEXAGON_SRCS += platform/shared/system_time.cc
 HEXAGON_SRCS += platform/slpi/host_link.cc
 HEXAGON_SRCS += platform/slpi/init.cc
+HEXAGON_SRCS += platform/slpi/platform_nanoapp.cc
 HEXAGON_SRCS += platform/slpi/platform_sensor.cc
 HEXAGON_SRCS += platform/slpi/platform_sensor_util.cc
 HEXAGON_SRCS += platform/slpi/static_nanoapps.cc
@@ -60,6 +60,7 @@
 X86_SRCS += platform/linux/static_nanoapps.cc
 X86_SRCS += platform/linux/system_time.cc
 X86_SRCS += platform/linux/system_timer.cc
+X86_SRCS += platform/linux/platform_nanoapp.cc
 X86_SRCS += platform/linux/platform_sensor.cc
 X86_SRCS += platform/shared/chre_api_core.cc
 X86_SRCS += platform/shared/chre_api_gnss.cc
@@ -74,7 +75,6 @@
 X86_SRCS += platform/shared/pal_wwan_stub.cc
 X86_SRCS += platform/shared/pal_system_api.cc
 X86_SRCS += platform/shared/platform_gnss.cc
-X86_SRCS += platform/shared/platform_nanoapp.cc
 X86_SRCS += platform/shared/platform_sensor.cc
 X86_SRCS += platform/shared/platform_wifi.cc
 X86_SRCS += platform/shared/platform_wwan.cc
diff --git a/platform/shared/dso_csl_api.cc b/platform/shared/dso_csl_api.cc
deleted file mode 100644
index 5c96372..0000000
--- a/platform/shared/dso_csl_api.cc
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (C) 2016 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.
- */
-
-#include "chre/target_platform/dso_csl_api.h"
-
-bool chreDsoCslGetApi(uint32_t apiId, void **apiHandle) {
-  // TODO: implement this some time after nanoapps become DSOs
-  return false;
-}
diff --git a/platform/shared/host_protocol_chre.cc b/platform/shared/host_protocol_chre.cc
index 43cc762..dccdc2b 100644
--- a/platform/shared/host_protocol_chre.cc
+++ b/platform/shared/host_protocol_chre.cc
@@ -36,6 +36,7 @@
          messageLen);
   } else {
     const fbs::MessageContainer *container = fbs::GetMessageContainer(message);
+    uint16_t hostClientId = container->host_addr()->client_id();
 
     switch (container->message_type()) {
       case fbs::ChreMessage::NanoappMessage: {
@@ -51,13 +52,24 @@
       }
 
       case fbs::ChreMessage::HubInfoRequest:
-        HostMessageHandlers::handleHubInfoRequest();
+        HostMessageHandlers::handleHubInfoRequest(hostClientId);
         break;
 
       case fbs::ChreMessage::NanoappListRequest:
-        HostMessageHandlers::handleNanoappListRequest();
+        HostMessageHandlers::handleNanoappListRequest(hostClientId);
         break;
 
+      case fbs::ChreMessage::LoadNanoappRequest: {
+        const auto *request = static_cast<const fbs::LoadNanoappRequest *>(
+            container->message());
+        const flatbuffers::Vector<uint8_t> *appBinary = request->app_binary();
+        HostMessageHandlers::handleLoadNanoappRequest(
+            hostClientId, request->transaction_id(), request->app_id(),
+            request->app_version(), request->target_api_version(),
+            appBinary->data(), appBinary->size());
+        break;
+      }
+
       default:
         LOGW("Got invalid/unexpected message type %" PRIu8,
              static_cast<uint8_t>(container->message_type()));
@@ -73,7 +85,7 @@
     const char *toolchain, uint32_t legacyPlatformVersion,
     uint32_t legacyToolchainVersion, float peakMips, float stoppedPower,
     float sleepPower, float peakPower, uint32_t maxMessageLen,
-    uint64_t platformId, uint32_t version) {
+    uint64_t platformId, uint32_t version, uint16_t hostClientId) {
   auto nameOffset = addStringAsByteVector(builder, name);
   auto vendorOffset = addStringAsByteVector(builder, vendor);
   auto toolchainOffset = addStringAsByteVector(builder, toolchain);
@@ -82,9 +94,8 @@
       builder, nameOffset, vendorOffset, toolchainOffset, legacyPlatformVersion,
       legacyToolchainVersion, peakMips, stoppedPower, sleepPower, peakPower,
       maxMessageLen, platformId, version);
-  auto container = fbs::CreateMessageContainer(
-      builder, fbs::ChreMessage::HubInfoResponse, response.Union());
-  builder.Finish(container);
+  finalize(builder, fbs::ChreMessage::HubInfoResponse, response.Union(),
+           hostClientId);
 }
 
 void HostProtocolChre::addNanoappListEntry(
@@ -100,13 +111,22 @@
 
 void HostProtocolChre::finishNanoappListResponse(
     FlatBufferBuilder& builder,
-    DynamicVector<Offset<fbs::NanoappListEntry>>& offsetVector) {
+    DynamicVector<Offset<fbs::NanoappListEntry>>& offsetVector,
+    uint16_t hostClientId) {
   auto vectorOffset = builder.CreateVector<Offset<fbs::NanoappListEntry>>(
       offsetVector);
   auto response = fbs::CreateNanoappListResponse(builder, vectorOffset);
-  auto container = fbs::CreateMessageContainer(
-      builder, fbs::ChreMessage::NanoappListResponse, response.Union());
-  builder.Finish(container);
+  finalize(builder, fbs::ChreMessage::NanoappListResponse, response.Union(),
+           hostClientId);
+}
+
+void HostProtocolChre::encodeLoadNanoappResponse(
+    flatbuffers::FlatBufferBuilder& builder, uint16_t hostClientId,
+    uint32_t transactionId, bool success) {
+  auto response = fbs::CreateLoadNanoappResponse(builder, transactionId,
+                                                 success);
+  finalize(builder, fbs::ChreMessage::LoadNanoappResponse, response.Union(),
+           hostClientId);
 }
 
 }  // namespace chre
diff --git a/platform/shared/host_protocol_common.cc b/platform/shared/host_protocol_common.cc
index f7d187a..eab72bf 100644
--- a/platform/shared/host_protocol_common.cc
+++ b/platform/shared/host_protocol_common.cc
@@ -26,12 +26,32 @@
 
 namespace chre {
 
+void HostProtocolCommon::encodeNanoappMessage(
+    FlatBufferBuilder& builder, uint64_t appId, uint32_t messageType,
+    uint16_t hostEndpoint, const void *messageData, size_t messageDataLen) {
+  auto messageDataOffset = builder.CreateVector(
+      static_cast<const uint8_t *>(messageData), messageDataLen);
+
+  auto nanoappMessage = fbs::CreateNanoappMessage(
+      builder, appId, messageType, hostEndpoint, messageDataOffset);
+  finalize(builder, fbs::ChreMessage::NanoappMessage, nanoappMessage.Union());
+}
+
 Offset<Vector<int8_t>> HostProtocolCommon::addStringAsByteVector(
     FlatBufferBuilder& builder, const char *str) {
   return builder.CreateVector(reinterpret_cast<const int8_t *>(str),
                               strlen(str) + 1);
 }
 
+void HostProtocolCommon::finalize(
+    FlatBufferBuilder& builder, fbs::ChreMessage messageType,
+    flatbuffers::Offset<void> message, uint16_t hostClientId) {
+  fbs::HostAddress hostAddr(hostClientId);
+  auto container = fbs::CreateMessageContainer(
+      builder, messageType, message, &hostAddr);
+  builder.Finish(container);
+}
+
 bool HostProtocolCommon::verifyMessage(const void *message, size_t messageLen) {
   bool valid = false;
 
@@ -45,17 +65,5 @@
   return valid;
 }
 
-void HostProtocolCommon::encodeNanoappMessage(
-    FlatBufferBuilder& builder, uint64_t appId, uint32_t messageType,
-    uint16_t hostEndpoint, const void *messageData, size_t messageDataLen) {
-  auto messageDataOffset = builder.CreateVector(
-      static_cast<const uint8_t *>(messageData), messageDataLen);
-
-  auto nanoappMessage = fbs::CreateNanoappMessage(
-      builder, appId, messageType, hostEndpoint, messageDataOffset);
-  auto container = fbs::CreateMessageContainer(
-      builder, fbs::ChreMessage::NanoappMessage, nanoappMessage.Union());
-  builder.Finish(container);
-}
 
 }  // namespace chre
diff --git a/platform/shared/idl/host_messages.fbs b/platform/shared/idl/host_messages.fbs
index 30bb2fc..7472553 100644
--- a/platform/shared/idl/host_messages.fbs
+++ b/platform/shared/idl/host_messages.fbs
@@ -82,6 +82,23 @@
   nanoapps:[NanoappListEntry] (required);
 }
 
+table LoadNanoappRequest {
+  transaction_id:uint;
+
+  app_id:ulong;
+  app_version:uint;
+  target_api_version:uint;
+
+  app_binary:[ubyte] (required);
+}
+
+table LoadNanoappResponse {
+  transaction_id:uint;
+  success:bool;
+
+  // TODO: detailed error code?
+}
+
 /// A union that joins together all possible messages. Note that in FlatBuffers,
 /// unions have an implicit type
 union ChreMessage {
@@ -93,14 +110,29 @@
   NanoappListRequest,
   NanoappListResponse,
 
+  LoadNanoappRequest,
+  LoadNanoappResponse,
+
   // TODO: extend with system-specific messages, e.g. load app command, etc.
 }
 
+struct HostAddress {
+  client_id:ushort;
+}
+
 /// The top-level container that encapsulates all possible messages. Note that
 /// per FlatBuffers requirements, we can't use a union as the top-level structure
 /// (root type), so we must wrap it in a table.
 table MessageContainer {
   message:ChreMessage (required);
+
+  /// The originating or destination client ID on the host side, used to direct
+  /// responses only to the client that sent the request. Although initially
+  /// populated by the requesting client, this is enforced to be the correct
+  /// value by the entity guarding access to CHRE.
+  /// This is wrapped in a struct to ensure that it is always included when
+  /// encoding the message, so it can be mutated by the host daemon.
+  host_addr:HostAddress (required);
 }
 
 root_type MessageContainer;
diff --git a/platform/shared/include/chre/platform/shared/host_messages_generated.h b/platform/shared/include/chre/platform/shared/host_messages_generated.h
index 1d65ade..45bd73a 100644
--- a/platform/shared/include/chre/platform/shared/host_messages_generated.h
+++ b/platform/shared/include/chre/platform/shared/host_messages_generated.h
@@ -21,6 +21,12 @@
 
 struct NanoappListResponse;
 
+struct LoadNanoappRequest;
+
+struct LoadNanoappResponse;
+
+struct HostAddress;
+
 struct MessageContainer;
 
 /// A union that joins together all possible messages. Note that in FlatBuffers,
@@ -32,8 +38,10 @@
   HubInfoResponse = 3,
   NanoappListRequest = 4,
   NanoappListResponse = 5,
+  LoadNanoappRequest = 6,
+  LoadNanoappResponse = 7,
   MIN = NONE,
-  MAX = NanoappListResponse
+  MAX = LoadNanoappResponse
 };
 
 inline const char **EnumNamesChreMessage() {
@@ -44,6 +52,8 @@
     "HubInfoResponse",
     "NanoappListRequest",
     "NanoappListResponse",
+    "LoadNanoappRequest",
+    "LoadNanoappResponse",
     nullptr
   };
   return names;
@@ -78,9 +88,37 @@
   static const ChreMessage enum_value = ChreMessage::NanoappListResponse;
 };
 
+template<> struct ChreMessageTraits<LoadNanoappRequest> {
+  static const ChreMessage enum_value = ChreMessage::LoadNanoappRequest;
+};
+
+template<> struct ChreMessageTraits<LoadNanoappResponse> {
+  static const ChreMessage enum_value = ChreMessage::LoadNanoappResponse;
+};
+
 bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type);
 bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
 
+MANUALLY_ALIGNED_STRUCT(2) HostAddress FLATBUFFERS_FINAL_CLASS {
+ private:
+  uint16_t client_id_;
+
+ public:
+  HostAddress() {
+    memset(this, 0, sizeof(HostAddress));
+  }
+  HostAddress(const HostAddress &_o) {
+    memcpy(this, &_o, sizeof(HostAddress));
+  }
+  HostAddress(uint16_t _client_id)
+      : client_id_(flatbuffers::EndianScalar(_client_id)) {
+  }
+  uint16_t client_id() const {
+    return flatbuffers::EndianScalar(client_id_);
+  }
+};
+STRUCT_END(HostAddress, 2);
+
 /// Represents a message sent to/from a nanoapp from/to a client on the host
 struct NanoappMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   enum {
@@ -546,13 +584,162 @@
       nanoapps ? _fbb.CreateVector<flatbuffers::Offset<NanoappListEntry>>(*nanoapps) : 0);
 }
 
+struct LoadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum {
+    VT_TRANSACTION_ID = 4,
+    VT_APP_ID = 6,
+    VT_APP_VERSION = 8,
+    VT_TARGET_API_VERSION = 10,
+    VT_APP_BINARY = 12
+  };
+  uint32_t transaction_id() const {
+    return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
+  }
+  uint64_t app_id() const {
+    return GetField<uint64_t>(VT_APP_ID, 0);
+  }
+  uint32_t app_version() const {
+    return GetField<uint32_t>(VT_APP_VERSION, 0);
+  }
+  uint32_t target_api_version() const {
+    return GetField<uint32_t>(VT_TARGET_API_VERSION, 0);
+  }
+  const flatbuffers::Vector<uint8_t> *app_binary() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
+           VerifyField<uint64_t>(verifier, VT_APP_ID) &&
+           VerifyField<uint32_t>(verifier, VT_APP_VERSION) &&
+           VerifyField<uint32_t>(verifier, VT_TARGET_API_VERSION) &&
+           VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_APP_BINARY) &&
+           verifier.Verify(app_binary()) &&
+           verifier.EndTable();
+  }
+};
+
+struct LoadNanoappRequestBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_transaction_id(uint32_t transaction_id) {
+    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0);
+  }
+  void add_app_id(uint64_t app_id) {
+    fbb_.AddElement<uint64_t>(LoadNanoappRequest::VT_APP_ID, app_id, 0);
+  }
+  void add_app_version(uint32_t app_version) {
+    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_VERSION, app_version, 0);
+  }
+  void add_target_api_version(uint32_t target_api_version) {
+    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TARGET_API_VERSION, target_api_version, 0);
+  }
+  void add_app_binary(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary) {
+    fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY, app_binary);
+  }
+  LoadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  LoadNanoappRequestBuilder &operator=(const LoadNanoappRequestBuilder &);
+  flatbuffers::Offset<LoadNanoappRequest> Finish() {
+    const auto end = fbb_.EndTable(start_, 5);
+    auto o = flatbuffers::Offset<LoadNanoappRequest>(end);
+    fbb_.Required(o, LoadNanoappRequest::VT_APP_BINARY);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t transaction_id = 0,
+    uint64_t app_id = 0,
+    uint32_t app_version = 0,
+    uint32_t target_api_version = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary = 0) {
+  LoadNanoappRequestBuilder builder_(_fbb);
+  builder_.add_app_id(app_id);
+  builder_.add_app_binary(app_binary);
+  builder_.add_target_api_version(target_api_version);
+  builder_.add_app_version(app_version);
+  builder_.add_transaction_id(transaction_id);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t transaction_id = 0,
+    uint64_t app_id = 0,
+    uint32_t app_version = 0,
+    uint32_t target_api_version = 0,
+    const std::vector<uint8_t> *app_binary = nullptr) {
+  return chre::fbs::CreateLoadNanoappRequest(
+      _fbb,
+      transaction_id,
+      app_id,
+      app_version,
+      target_api_version,
+      app_binary ? _fbb.CreateVector<uint8_t>(*app_binary) : 0);
+}
+
+struct LoadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum {
+    VT_TRANSACTION_ID = 4,
+    VT_SUCCESS = 6
+  };
+  uint32_t transaction_id() const {
+    return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
+  }
+  bool success() const {
+    return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
+           VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
+           verifier.EndTable();
+  }
+};
+
+struct LoadNanoappResponseBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_transaction_id(uint32_t transaction_id) {
+    fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0);
+  }
+  void add_success(bool success) {
+    fbb_.AddElement<uint8_t>(LoadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
+  }
+  LoadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  LoadNanoappResponseBuilder &operator=(const LoadNanoappResponseBuilder &);
+  flatbuffers::Offset<LoadNanoappResponse> Finish() {
+    const auto end = fbb_.EndTable(start_, 2);
+    auto o = flatbuffers::Offset<LoadNanoappResponse>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t transaction_id = 0,
+    bool success = false) {
+  LoadNanoappResponseBuilder builder_(_fbb);
+  builder_.add_transaction_id(transaction_id);
+  builder_.add_success(success);
+  return builder_.Finish();
+}
+
 /// The top-level container that encapsulates all possible messages. Note that
 /// per FlatBuffers requirements, we can't use a union as the top-level structure
 /// (root type), so we must wrap it in a table.
 struct MessageContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   enum {
     VT_MESSAGE_TYPE = 4,
-    VT_MESSAGE = 6
+    VT_MESSAGE = 6,
+    VT_HOST_ADDR = 8
   };
   ChreMessage message_type() const {
     return static_cast<ChreMessage>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0));
@@ -560,11 +747,21 @@
   const void *message() const {
     return GetPointer<const void *>(VT_MESSAGE);
   }
+  /// The originating or destination client ID on the host side, used to direct
+  /// responses only to the client that sent the request. Although initially
+  /// populated by the requesting client, this is enforced to be the correct
+  /// value by the entity guarding access to CHRE.
+  /// This is wrapped in a struct to ensure that it is always included when
+  /// encoding the message, so it can be mutated by the host daemon.
+  const HostAddress *host_addr() const {
+    return GetStruct<const HostAddress *>(VT_HOST_ADDR);
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) &&
            VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) &&
            VerifyChreMessage(verifier, message(), message_type()) &&
+           VerifyFieldRequired<HostAddress>(verifier, VT_HOST_ADDR) &&
            verifier.EndTable();
   }
 };
@@ -578,15 +775,19 @@
   void add_message(flatbuffers::Offset<void> message) {
     fbb_.AddOffset(MessageContainer::VT_MESSAGE, message);
   }
+  void add_host_addr(const HostAddress *host_addr) {
+    fbb_.AddStruct(MessageContainer::VT_HOST_ADDR, host_addr);
+  }
   MessageContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
   MessageContainerBuilder &operator=(const MessageContainerBuilder &);
   flatbuffers::Offset<MessageContainer> Finish() {
-    const auto end = fbb_.EndTable(start_, 2);
+    const auto end = fbb_.EndTable(start_, 3);
     auto o = flatbuffers::Offset<MessageContainer>(end);
     fbb_.Required(o, MessageContainer::VT_MESSAGE);
+    fbb_.Required(o, MessageContainer::VT_HOST_ADDR);
     return o;
   }
 };
@@ -594,8 +795,10 @@
 inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(
     flatbuffers::FlatBufferBuilder &_fbb,
     ChreMessage message_type = ChreMessage::NONE,
-    flatbuffers::Offset<void> message = 0) {
+    flatbuffers::Offset<void> message = 0,
+    const HostAddress *host_addr = 0) {
   MessageContainerBuilder builder_(_fbb);
+  builder_.add_host_addr(host_addr);
   builder_.add_message(message);
   builder_.add_message_type(message_type);
   return builder_.Finish();
@@ -626,6 +829,14 @@
       auto ptr = reinterpret_cast<const NanoappListResponse *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case ChreMessage::LoadNanoappRequest: {
+      auto ptr = reinterpret_cast<const LoadNanoappRequest *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case ChreMessage::LoadNanoappResponse: {
+      auto ptr = reinterpret_cast<const LoadNanoappResponse *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
     default: return false;
   }
 }
diff --git a/platform/shared/include/chre/platform/shared/host_protocol_chre.h b/platform/shared/include/chre/platform/shared/host_protocol_chre.h
index 737d9a8..ee2642d 100644
--- a/platform/shared/include/chre/platform/shared/host_protocol_chre.h
+++ b/platform/shared/include/chre/platform/shared/host_protocol_chre.h
@@ -37,8 +37,14 @@
     uint64_t appId, uint32_t messageType, uint16_t hostEndpoint,
     const void *messageData, size_t messageDataLen);
 
-  static void handleHubInfoRequest();
-  static void handleNanoappListRequest();
+  static void handleHubInfoRequest(uint16_t hostClientId);
+
+  static void handleNanoappListRequest(uint16_t hostClientId);
+
+  static void handleLoadNanoappRequest(
+      uint16_t hostClientId, uint32_t transactionId, uint64_t appId,
+      uint32_t appVersion, uint32_t targetApiVersion, const void *appBinary,
+      size_t appBinaryLen);
 };
 
 /**
@@ -70,7 +76,7 @@
       const char *vendor, const char *toolchain, uint32_t legacyPlatformVersion,
       uint32_t legacyToolchainVersion, float peakMips, float stoppedPower,
       float sleepPower, float peakPower, uint32_t maxMessageLen,
-      uint64_t platformId, uint32_t version);
+      uint64_t platformId, uint32_t version, uint16_t hostClientId);
 
   /**
    * Supports construction of a NanoappListResponse by adding a single
@@ -101,12 +107,22 @@
    *
    * @param builder The FlatBufferBuilder used with addNanoappListEntry()
    * @param offsetVector The vector used with addNanoappListEntry()
+   * @param hostClientId
    *
    * @see addNanoappListEntry()
    */
   static void finishNanoappListResponse(
       flatbuffers::FlatBufferBuilder& builder,
-      DynamicVector<NanoappListEntryOffset>& offsetVector);
+      DynamicVector<NanoappListEntryOffset>& offsetVector,
+      uint16_t hostClientId);
+
+  /**
+   * Encodes a response to the host communicating the result of dynamically
+   * loading a nanoapp.
+   */
+  static void encodeLoadNanoappResponse(
+      flatbuffers::FlatBufferBuilder& builder, uint16_t hostClientId,
+      uint32_t transactionId, bool success);
 };
 
 }  // namespace chre
diff --git a/platform/shared/include/chre/platform/shared/host_protocol_common.h b/platform/shared/include/chre/platform/shared/host_protocol_common.h
index 68ec136..69e487f 100644
--- a/platform/shared/include/chre/platform/shared/host_protocol_common.h
+++ b/platform/shared/include/chre/platform/shared/host_protocol_common.h
@@ -23,6 +23,20 @@
 
 namespace chre {
 
+namespace fbs {
+
+// Forward declaration of the ChreMessage enum defined in the generated
+// FlatBuffers header file
+enum class ChreMessage : uint8_t;
+
+}  // namespace fbs
+
+//! On a message sent from CHRE, specifies that the host daemon should determine
+//! which client to send the message to. Usually, this is all clients, but for a
+//! message from a nanoapp, the host daemon can use the endpoint ID to determine
+//! the destination client ID.
+constexpr uint16_t kHostClientIdUnspecified = 0;
+
 /**
  * Functions that are shared between the CHRE and host to assist with
  * communications between the two. Note that normally these functions are
@@ -48,6 +62,25 @@
    static flatbuffers::Offset<flatbuffers::Vector<int8_t>>
        addStringAsByteVector(flatbuffers::FlatBufferBuilder& builder,
                              const char *str);
+
+   /**
+    * Constructs the message container and finalizes the FlatBufferBuilder
+    *
+    * @param builder The FlatBufferBuilder that was used to construct the
+    *        message prior to adding the container
+    * @param messageType Type of message that was constructed
+    * @param message Offset of the message to include (normally the return value
+    *        of flatbuffers::Offset::Union() on the message offset)
+    * @param hostClientId The source/client ID of the host-side entity that
+    *        sent/should receive this message. Leave unspecified (default 0)
+    *        when constructing a message on the host, as this field will be
+    *        set before the message is sent to CHRE.
+    */
+   static void finalize(
+       flatbuffers::FlatBufferBuilder& builder, fbs::ChreMessage messageType,
+       flatbuffers::Offset<void> message,
+       uint16_t hostClientId = kHostClientIdUnspecified);
+
    static bool verifyMessage(const void *message, size_t messageLen);
 };
 
diff --git a/platform/shared/include/chre/platform/shared/nanoapp_support_lib_dso.h b/platform/shared/include/chre/platform/shared/nanoapp_support_lib_dso.h
new file mode 100644
index 0000000..e824927
--- /dev/null
+++ b/platform/shared/include/chre/platform/shared/nanoapp_support_lib_dso.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#ifndef CHRE_PLATFORM_SHARED_NANOAPP_SUPPORT_LIB_DSO_H_
+#define CHRE_PLATFORM_SHARED_NANOAPP_SUPPORT_LIB_DSO_H_
+
+/**
+ * @file
+ * This provides the interface that the dynamic shared object (DSO) nanoapp
+ * nanoapp support library (NSL) uses to interface with the underlying CHRE
+ * implementation in a compatible manner.
+ *
+ * This header file must retain compatibility with C, and have minimal or no
+ * dependencies on other CHRE system header files, as it will be used when
+ * compiling external/dynamic nanoapps.
+ */
+
+#include "chre/util/entry_points.h"
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//! Special magic value to uniquely identify the nanoapp info structure
+#define CHRE_NSL_NANOAPP_INFO_MAGIC  UINT32_C(0x50e69977)
+
+//! The minor version in the nanoapp info structure helps identify whether
+#define CHRE_NSL_NANOAPP_INFO_STRUCT_MINOR_VERSION  UINT8_C(0)
+
+//! The symbol name expected from the nanoapp's definition of its info struct
+#define CHRE_NSL_DSO_NANOAPP_INFO_SYMBOL_NAME  "_chreNslDsoNanoappInfo"
+
+//! Maximum length of vendor and name strings
+#define CHRE_NSL_DSO_NANOAPP_STRING_MAX_LEN  (32)
+
+/**
+ * DSO-based nanoapps must expose this struct under a symbol whose name is given
+ * by CHRE_NSL_DSO_NANOAPP_INFO_SYMBOL_NAME. When the nanoapp is loaded, dlsym()
+ * will be used to locate this symbol to register the nanoapp with the system.
+ */
+struct chreNslNanoappInfo {
+  //! @see CHRE_NSL_NANOAPP_INFO_MAGIC
+  uint32_t magic;
+
+  //! @see CHRE_NSL_NANOAPP_INFO_STRUCT_MINOR_VERSION
+  uint8_t structMinorVersion;
+
+  //! Set to 1 if this nanoapp is a "system nanoapp" that should not show up in
+  //! the context hub HAL, likely because it implements some device
+  //! functionality beneath the HAL.
+  uint8_t isSystemNanoapp:1;
+
+  //! Reserved for future use, set to 0. Assignment of this field to some use
+  //! must be accompanied by an increase of the struct minor version.
+  uint8_t reservedFlags:7;
+  uint8_t reserved;
+
+  //! The CHRE API version that the nanoapp was compiled against
+  uint32_t targetApiVersion;
+
+  //! A human-friendly name of the nanoapp vendor (null-terminated string,
+  //! maximum length CHRE_NSL_DSO_NANOAPP_STRING_MAX_LEN)
+  const char *vendor;
+
+  //! A human-friendly name for the nanoapp (null-terminated string, maximum
+  //! length CHRE_NSL_DSO_NANOAPP_STRING_MAX_LEN)
+  const char *name;
+
+  //! Identifies the vendor (most significant 5 bytes) and application
+  uint64_t appId;
+
+  //! Application-specific version number
+  uint32_t appVersion;
+
+  struct {
+    chreNanoappStartFunction *start;
+    chreNanoappHandleEventFunction *handleEvent;
+    chreNanoappEndFunction *end;
+  } entryPoints;
+};
+
+/**
+ * Defined as a placeholder to enable future functionality extension.
+ *
+ * @param apiId
+ * @param apiHandle If this function returns true, this will be set to a pointer
+ *        to the associated structure containing the API
+ *
+ * @return true if the requested API is supported, false otherwise
+ */
+bool chreNslDsoGetApi(uint32_t apiId, void **apiHandle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CHRE_PLATFORM_SHARED_NANOAPP_SUPPORT_LIB_DSO_H_
diff --git a/platform/shared/include/chre/target_platform/dso_csl_api.h b/platform/shared/include/chre/target_platform/dso_csl_api.h
deleted file mode 100644
index 3d0a489..0000000
--- a/platform/shared/include/chre/target_platform/dso_csl_api.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (C) 2016 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.
- */
-
-#ifndef CHRE_PLATFORM_DSO_CSL_API_H_
-#define CHRE_PLATFORM_DSO_CSL_API_H_
-
-/**
- * @file
- * This provides the interface that the dynamic shared object (DSO) nanoapp
- * client support library (CSL) uses to interface with the underlying CHRE
- * implementation in a compatible manner. These functions are not directly
- * called by the nanoapp itself, but rather the nanoapp calls CHRE APIs, which
- * are implemented in the CSL to call through to APIs retrieved via this
- * interface. While originally intended for use with the SLPI, this API can be
- * applied to any platform where the nanoapp is a dynamic module that can
- * directly call system functions, but the nanoapp does not know ahead of time
- * which functions are implemented, therefore a layer of indirection is
- * necessary to avoid unresolved symbol errors when running on older platforms.
- *
- * Note that this is *not* required to implemented/supported on all CHRE
- * platforms, only those that use the DSO CSL.
- */
-
-// TODO: sidenote - not planning on using this for Linux, at least not
-// initially... we can just implement the CHRE APIs directly and compile
-// nanoapps into the system executable for initial testing. Will need to use
-// this for SLPI, though, for compatibility reasons. And once it's used on SLPI,
-// it would make sense to have it there on Linux too, to make sure we are
-// testing apples to apples.
-
-#include <cstdint>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
-  // TODO: populate with references to any function calls that were not present
-  // in the initial API release, or could potentially be changed in the future.
-  // note that we're not completely against the nanoapp calling directly into
-  // the CHRE system for things that are unlikely to change; we would just need
-  // to use this method after any change happens. consider the case where we
-  // have:
-  //   chreFoo(int x); // v1.0
-  //   chreFoo(int x, int y); // v1.1
-  // if nanoapps called chreFoo(int) directly @ v1.0, then that version of the
-  // function must be kept like that indefinitely for v1.0 apps to use. v1.1
-  // apps would need to go through this indirection to call into something like
-  // chreFoo_v1_1
-
-  char placeholder;
-} chreSlpiCoreSystemApi;
-
-typedef struct {
-  // TODO
-  char placeholder;
-} chreSlpiGnssApi;
-
-typedef struct {
-  // TODO
-  char placeholder;
-} chreSlpiWifiApi;
-
-typedef struct {
-  // TODO
-  char placeholder;
-} chreSlpiWwanApi;
-
-enum chreDsoCslApiId {
-  CHRE_DSO_CSL_API_ID_CORE_SYSTEM = 1,
-  CHRE_DSO_CSL_API_ID_SENSORS = 2,
-  CHRE_DSO_CSL_API_ID_GNSS = 3,
-  CHRE_DSO_CSL_API_ID_WIFI = 4,
-  CHRE_DSO_CSL_API_ID_WWAN = 5,
-};
-
-/**
- * TODO
- *
- * @param apiId
- * @param apiHandle If this function returns true, this will be set to a pointer
- *        to the associated structure containing the API
- *
- * @return true if the requested API is supported, false otherwise
- */
-extern "C" bool chreDsoCslGetApi(uint32_t apiId, void **apiHandle);
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif  // CHRE_NANOAPP_API_H_
diff --git a/platform/shared/include/chre/target_platform/platform_static_nanoapp_init.h b/platform/shared/include/chre/target_platform/platform_static_nanoapp_init.h
deleted file mode 100644
index 7774124..0000000
--- a/platform/shared/include/chre/target_platform/platform_static_nanoapp_init.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2017 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.
- */
-
-#ifndef CHRE_PLATFORM_SHARED_PLATFORM_STATIC_NANOAPP_INIT_H_
-#define CHRE_PLATFORM_SHARED_PLATFORM_STATIC_NANOAPP_INIT_H_
-
-/**
- * Initializes a nanoapp that is based on the shared implementation of
- * PlatformNanoappBase.
- *
- * @param appName the name of the nanoapp. This will be prefixed by gNanoapp
- * when creating the global instance of the nanoapp.
- */
-#define PLATFORM_STATIC_NANOAPP_INIT(appName)          \
-::chre::PlatformNanoapp gNanoapp##appName;             \
-                                                       \
-__attribute__((constructor))                           \
-static void InitializeStaticNanoapp() {                \
-  gNanoapp##appName.mStart = nanoappStart;             \
-  gNanoapp##appName.mHandleEvent = nanoappHandleEvent; \
-  gNanoapp##appName.mStop = nanoappStop;               \
-}
-
-#endif  // CHRE_PLATFORM_SHARED_PLATFORM_STATIC_NANOAPP_INIT_H_
diff --git a/platform/shared/nanoapp/nanoapp_support_lib_dso.c b/platform/shared/nanoapp/nanoapp_support_lib_dso.c
new file mode 100644
index 0000000..8d1ab05
--- /dev/null
+++ b/platform/shared/nanoapp/nanoapp_support_lib_dso.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#include "chre/platform/shared/nanoapp_support_lib_dso.h"
+
+#include <chre.h>
+
+/**
+ * @file
+ * The Nanoapp Support Library (NSL) that gets built with nanoapps to act as an
+ * intermediary to the reference CHRE implementation. It provides hooks so the
+ * app can be registered with the system, and also provides a layer where we can
+ * implement cross-version compatibility features as needed.
+ */
+
+__attribute__((used)) __attribute__((visibility("default")))
+const struct chreNslNanoappInfo _chreNslDsoNanoappInfo = {
+  .magic = CHRE_NSL_NANOAPP_INFO_MAGIC,
+  .structMinorVersion = CHRE_NSL_NANOAPP_INFO_STRUCT_MINOR_VERSION,
+  .targetApiVersion = CHRE_API_VERSION,
+
+  // These values are supplied by the build environment
+  .vendor = NANOAPP_VENDOR_STRING,
+  .name = NANOAPP_NAME_STRING,
+  .isSystemNanoapp = NANOAPP_IS_SYSTEM_NANOAPP,
+  .appId = NANOAPP_ID,
+  .appVersion = NANOAPP_VERSION,
+
+  .entryPoints = {
+    .start = nanoappStart,
+    .handleEvent = nanoappHandleEvent,
+    .end = nanoappEnd,
+  },
+};
+
diff --git a/platform/shared/static_nanoapps.cc b/platform/shared/static_nanoapps.cc
index 2b5d764..eea6b9f 100644
--- a/platform/shared/static_nanoapps.cc
+++ b/platform/shared/static_nanoapps.cc
@@ -20,7 +20,7 @@
 
 void loadStaticNanoapps(EventLoop *eventLoop) {
   for (size_t i = 0; i < kStaticNanoappCount; i++) {
-    eventLoop->startNanoapp(kStaticNanoappList[i]);
+    eventLoop->startNanoapp(*(kStaticNanoappList[i]));
   }
 }
 
diff --git a/platform/slpi/host_link.cc b/platform/slpi/host_link.cc
index c63ce27..39e3485 100644
--- a/platform/slpi/host_link.cc
+++ b/platform/slpi/host_link.cc
@@ -28,6 +28,7 @@
 #include "chre/platform/slpi/fastrpc.h"
 #include "chre/util/fixed_size_blocking_queue.h"
 #include "chre/util/macros.h"
+#include "chre/util/unique_ptr.h"
 #include "chre_api/chre/version.h"
 
 using flatbuffers::FlatBufferBuilder;
@@ -38,17 +39,39 @@
 
 constexpr size_t kOutboundQueueSize = 32;
 
+//! Used to pass the client ID through the user data pointer in deferCallback
+union HostClientIdCallbackData {
+  uint16_t hostClientId;
+  void *ptr;
+};
+static_assert(sizeof(uint16_t) <= sizeof(void*),
+              "Pointer must at least fit a u16 for passing the host client ID");
+
+struct LoadNanoappCallbackData {
+  uint64_t appId;
+  uint32_t transactionId;
+  uint16_t hostClientId;
+  UniquePtr<Nanoapp> nanoapp = MakeUnique<Nanoapp>();
+};
+
 enum class PendingMessageType {
   Shutdown,
   NanoappMessageToHost,
   HubInfoResponse,
   NanoappListResponse,
+  LoadNanoappResponse,
 };
 
 struct PendingMessage {
-  PendingMessage(PendingMessageType msgType, const void *msgData = nullptr) {
+  PendingMessage(PendingMessageType msgType, uint16_t hostClientId) {
     type = msgType;
-    data.data = msgData;
+    data.hostClientId = hostClientId;
+  }
+
+  PendingMessage(PendingMessageType msgType,
+                 const MessageToHost *msgToHost = nullptr) {
+    type = msgType;
+    data.msgToHost = msgToHost;
   }
 
   PendingMessage(PendingMessageType msgType, FlatBufferBuilder *builder) {
@@ -59,7 +82,7 @@
   PendingMessageType type;
   union {
     const MessageToHost *msgToHost;
-    const void *data;
+    uint16_t hostClientId;
     FlatBufferBuilder *builder;
   } data;
 };
@@ -78,7 +101,6 @@
          size, bufferSize);
     result = CHRE_FASTRPC_ERROR;
   } else {
-    LOGD("Copy %zu bytes to buffer @ %p", size, buffer);
     memcpy(buffer, data, size);
     *messageLen = size;
     result = CHRE_FASTRPC_SUCCESS;
@@ -87,11 +109,13 @@
   return result;
 }
 
-
-void constructNanoappListCallback(uint16_t /*eventType*/, void * /*data*/) {
+void constructNanoappListCallback(uint16_t /*eventType*/, void *deferCbData) {
   constexpr size_t kFixedOverhead = 56;
   constexpr size_t kPerNanoappSize = 16;
 
+  HostClientIdCallbackData clientIdCbData;
+  clientIdCbData.ptr = deferCbData;
+
   // TODO: need to add support for getting apps from multiple event loops
   bool pushed = false;
   EventLoop *eventLoop = getCurrentEventLoop();
@@ -125,7 +149,8 @@
     // Add a NanoappListEntry to the FlatBuffer for each nanoapp
     CallbackData cbData(*builder, nanoappEntries);
     eventLoop->forEachNanoapp(callback, &cbData);
-    HostProtocolChre::finishNanoappListResponse(*builder, nanoappEntries);
+    HostProtocolChre::finishNanoappListResponse(*builder, nanoappEntries,
+                                                clientIdCbData.hostClientId);
 
     pushed = gOutboundQueue.push(
         PendingMessage(PendingMessageType::NanoappListResponse, builder));
@@ -139,6 +164,33 @@
   }
 }
 
+void finishLoadingNanoappCallback(uint16_t /*eventType*/, void *data) {
+  UniquePtr<LoadNanoappCallbackData> cbData(
+      static_cast<LoadNanoappCallbackData *>(data));
+
+  EventLoop *eventLoop = getCurrentEventLoop();
+  bool startedSuccessfully = (cbData->nanoapp->isLoaded()) ?
+      eventLoop->startNanoapp(cbData->nanoapp) : false;
+
+  constexpr size_t kInitialBufferSize = 48;
+  auto *builder = memoryAlloc<FlatBufferBuilder>(kInitialBufferSize);
+  if (builder == nullptr) {
+    LOGE("Couldn't allocate memory for load nanoapp response");
+  } else {
+    HostProtocolChre::encodeLoadNanoappResponse(
+        *builder, cbData->hostClientId, cbData->transactionId,
+        startedSuccessfully);
+
+    // TODO: if this fails, ideally we should block for some timeout until
+    // there's space in the queue (like up to 1 second)
+    if (!gOutboundQueue.push(PendingMessage(
+            PendingMessageType::LoadNanoappResponse, builder))) {
+      LOGE("Couldn't push load nanoapp response to outbound queue");
+      memoryFree(builder);
+    }
+  }
+}
+
 int generateMessageToHost(const MessageToHost *msgToHost, unsigned char *buffer,
                           size_t bufferSize, unsigned int *messageLen) {
   // TODO: ideally we'd construct our flatbuffer directly in the
@@ -159,8 +211,8 @@
   return result;
 }
 
-int generateHubInfoResponse(unsigned char *buffer, size_t bufferSize,
-                            unsigned int *messageLen) {
+int generateHubInfoResponse(uint16_t hostClientId, unsigned char *buffer,
+                            size_t bufferSize, unsigned int *messageLen) {
   constexpr size_t kInitialBufferSize = 192;
 
   constexpr char kHubName[] = "CHRE on SLPI";
@@ -184,12 +236,12 @@
       builder, kHubName, kVendor, kToolchain, kLegacyPlatformVersion,
       kLegacyToolchainVersion, kPeakMips, kStoppedPower, kSleepPower,
       kPeakPower, CHRE_MESSAGE_TO_HOST_MAX_SIZE, chreGetPlatformId(),
-      chreGetVersion());
+      chreGetVersion(), hostClientId);
 
   return copyToHostBuffer(builder, buffer, bufferSize, messageLen);
 }
 
-int generateNanoappListResponse(
+int generateMessageFromBuilder(
     FlatBufferBuilder *builder, unsigned char *buffer, size_t bufferSize,
     unsigned int *messageLen) {
   CHRE_ASSERT(builder != nullptr);
@@ -235,12 +287,14 @@
         break;
 
       case PendingMessageType::HubInfoResponse:
-        result = generateHubInfoResponse(buffer, bufferSize, messageLen);
+        result = generateHubInfoResponse(pendingMsg.data.hostClientId, buffer,
+                                         bufferSize, messageLen);
         break;
 
       case PendingMessageType::NanoappListResponse:
-        result = generateNanoappListResponse(pendingMsg.data.builder,
-                                             buffer, bufferSize, messageLen);
+      case PendingMessageType::LoadNanoappResponse:
+        result = generateMessageFromBuilder(pendingMsg.data.builder,
+                                            buffer, bufferSize, messageLen);
         break;
 
       default:
@@ -248,6 +302,7 @@
     }
   }
 
+  LOGD("Returning message to host (result %d length %u)", result, *messageLen);
   return result;
 }
 
@@ -334,15 +389,49 @@
       appId, messageType, hostEndpoint, messageData, messageDataLen);
 }
 
-void HostMessageHandlers::handleHubInfoRequest() {
+void HostMessageHandlers::handleHubInfoRequest(uint16_t hostClientId) {
   // We generate the response in the context of chre_slpi_get_message_to_host
-  gOutboundQueue.push(PendingMessage(PendingMessageType::HubInfoResponse));
+  LOGD("Got hub info request from client ID %" PRIu16, hostClientId);
+  gOutboundQueue.push(PendingMessage(
+      PendingMessageType::HubInfoResponse, hostClientId));
 }
 
-void HostMessageHandlers::handleNanoappListRequest() {
+void HostMessageHandlers::handleNanoappListRequest(uint16_t hostClientId) {
+  LOGD("Got nanoapp list request from client ID %" PRIu16, hostClientId);
+  HostClientIdCallbackData cbData = {};
+  cbData.hostClientId = hostClientId;
   EventLoopManagerSingleton::get()->deferCallback(
-      SystemCallbackType::NanoappListResponse, nullptr,
+      SystemCallbackType::NanoappListResponse, cbData.ptr,
       constructNanoappListCallback);
 }
 
+void HostMessageHandlers::handleLoadNanoappRequest(
+    uint16_t hostClientId, uint32_t transactionId, uint64_t appId,
+    uint32_t appVersion, uint32_t targetApiVersion, const void *appBinary,
+    size_t appBinaryLen) {
+  auto cbData = MakeUnique<LoadNanoappCallbackData>();
+
+  LOGD("Got load nanoapp request (txnId %" PRIu32 ") for appId 0x%016" PRIx64
+       " version 0x%" PRIx32 " target API version 0x%08" PRIx32 " size %zu",
+       transactionId, appId, appVersion, targetApiVersion, appBinaryLen);
+  if (cbData.isNull() || cbData->nanoapp.isNull()) {
+    LOGE("Couldn't allocate load nanoapp callback data");
+  } else {
+    cbData->transactionId = transactionId;
+    cbData->hostClientId  = hostClientId;
+    cbData->appId = appId;
+
+    // Note that if this fails, we'll generate the error response in
+    // the normal deferred callback
+    cbData->nanoapp->loadFromBuffer(appId, appVersion, appBinary, appBinaryLen);
+    if (!EventLoopManagerSingleton::get()->deferCallback(
+            SystemCallbackType::FinishLoadingNanoapp, cbData.get(),
+            finishLoadingNanoappCallback)) {
+      LOGE("Couldn't post callback to finish loading nanoapp");
+    } else {
+      cbData.release();
+    }
+  }
+}
+
 }  // namespace chre
diff --git a/platform/slpi/include/chre/target_platform/platform_nanoapp_base.h b/platform/slpi/include/chre/target_platform/platform_nanoapp_base.h
index cf3a381..8a0dde7 100644
--- a/platform/slpi/include/chre/target_platform/platform_nanoapp_base.h
+++ b/platform/slpi/include/chre/target_platform/platform_nanoapp_base.h
@@ -17,8 +17,10 @@
 #ifndef CHRE_PLATFORM_SLPI_PLATFORM_NANOAPP_BASE_H_
 #define CHRE_PLATFORM_SLPI_PLATFORM_NANOAPP_BASE_H_
 
+#include <cstddef>
 #include <cstdint>
 
+#include "chre/platform/shared/nanoapp_support_lib_dso.h"
 #include "chre/util/entry_points.h"
 
 namespace chre {
@@ -26,15 +28,76 @@
 /**
  * SLPI-specific nanoapp functionality.
  */
-struct PlatformNanoappBase {
-  //! The function pointer of the nanoapp start entry point.
-  NanoappStartFunction *mStart;
+class PlatformNanoappBase {
+ public:
+  /**
+   * Copies the supplied application binary data into a new buffer. The
+   * application may be invalid - full checking and initialization happens just
+   * before invoking start() nanoapp entry point.
+   *
+   * @param appId The unique app identifier associated with this binary
+   * @param appVersion An application-defined version number
+   * @param appBinary Buffer containing the complete ELF binary for this
+   *        nanoapp, without any CHRE-specific header
+   * @param appBinaryLen Size of appBinary, in bytes
+   *
+   * @return true if the allocation was successful
+   */
+  bool loadFromBuffer(uint64_t appId, uint32_t appVersion,
+                      const void *appBinary, size_t appBinaryLen);
 
-  //! The function pointer of the nanoapp handle event entry point.
-  NanoappHandleEventFunction *mHandleEvent;
+  /**
+   * Associate this PlatformNanoapp with a nanoapp that is statically built into
+   * the CHRE binary with the given app info structure.
+   */
+  void loadStatic(const struct chreNslNanoappInfo *appInfo);
 
-  //! The function pointer of the nanoapp stop entry point.
-  NanoappStopFunction *mStop;
+  /**
+   * @return true if the app's binary data is resident in memory, i.e. a
+   *         previous call to loadFromBuffer() or loadStatic() was successful
+   */
+  bool isLoaded() const;
+
+ protected:
+  //! The app ID we received in the metadata alongside the nanoapp binary. This
+  //! is also included in (and checked against) mAppInfo.
+  uint64_t mExpectedAppId;
+
+  //! The application-defined version number we received in the metadata
+  //! alongside the nanoapp binary. This is also included in (and checked
+  //! against) mAppInfo.
+  uint32_t mExpectedAppVersion;
+
+  //! Buffer containing the complete DSO binary
+  void *mAppBinary = nullptr;
+  size_t mAppBinaryLen = 0;
+
+  //! The dynamic shared object (DSO) handle returned by dlopen[buf]()
+  void *mDsoHandle = nullptr;
+
+  //! Pointer to the app info structure within this nanoapp
+  const struct chreNslNanoappInfo *mAppInfo = nullptr;
+
+  //! Set to true if this app is built into the CHRE binary, and was loaded via
+  //! loadStatic(). In this case, the member variables above are not valid or
+  //! applicable.
+  bool mIsStatic = false;
+
+  /**
+   * Calls dlopenbuf on the app binary, and fetches and validates the app info
+   * pointer. This will result in execution of any on-load handlers (e.g. static
+   * global constructors) in the nanoapp.
+   *
+   * @return true if the app was opened successfully and the app info structure
+   *         passed validation
+   */
+  bool openNanoapp();
+
+  /**
+   * Releases the DSO handle if it was active, by calling dlclose(). This will
+   * result in execution of any unload handlers in the nanoapp.
+   */
+  void closeNanoapp();
 };
 
 }  // namespace chre
diff --git a/platform/slpi/include/chre/target_platform/static_nanoapp_init.h b/platform/slpi/include/chre/target_platform/static_nanoapp_init.h
new file mode 100644
index 0000000..26bc4b2
--- /dev/null
+++ b/platform/slpi/include/chre/target_platform/static_nanoapp_init.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef CHRE_PLATFORM_SLPI_STATIC_NANOAPP_INIT_H_
+#define CHRE_PLATFORM_SLPI_STATIC_NANOAPP_INIT_H_
+
+#include "chre/core/nanoapp.h"
+#include "chre/platform/fatal_error.h"
+#include "chre/platform/shared/nanoapp_support_lib_dso.h"
+#include "chre/util/unique_ptr.h"
+
+/**
+ * Initializes a static nanoapp that is based on the SLPI implementation of
+ * PlatformNanoappBase.
+ *
+ * @param appName the name of the nanoapp. This will be prefixed by gNanoapp
+ * when creating the global instance of the nanoapp.
+ * @param appId the app's unique 64-bit ID
+ * @param appVersion the application-defined 32-bit version number
+ */
+#define CHRE_STATIC_NANOAPP_INIT(appName, appId_, appVersion_) \
+namespace chre {                                               \
+UniquePtr<Nanoapp> *gNanoapp##appName;                         \
+                                                               \
+__attribute__((constructor))                                   \
+static void initializeStaticNanoapp##appName() {               \
+  static UniquePtr<Nanoapp> nanoapp = MakeUnique<Nanoapp>();   \
+  static struct chreNslNanoappInfo appInfo;                    \
+  appInfo.magic = CHRE_NSL_NANOAPP_INFO_MAGIC;                 \
+  appInfo.structMinorVersion =                                 \
+    CHRE_NSL_NANOAPP_INFO_STRUCT_MINOR_VERSION;                \
+  appInfo.targetApiVersion = CHRE_API_VERSION;                 \
+  appInfo.vendor = "Google"; /* TODO: make this configurable */\
+  appInfo.name = #appName;                                     \
+  appInfo.isSystemNanoapp = true;                              \
+  appInfo.appId = appId_;                                      \
+  appInfo.appVersion = appVersion_;                            \
+  appInfo.entryPoints.start = nanoappStart;                    \
+  appInfo.entryPoints.handleEvent = nanoappHandleEvent;        \
+  appInfo.entryPoints.end = nanoappEnd;                        \
+  if (nanoapp.isNull()) {                                      \
+    FATAL_ERROR("Failed to allocate nanoapp " #appName);       \
+  } else {                                                     \
+    nanoapp->loadStatic(&appInfo);                             \
+    gNanoapp##appName = &nanoapp;                              \
+  }                                                            \
+}                                                              \
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_SLPI_STATIC_NANOAPP_INIT_H_
diff --git a/platform/slpi/platform_nanoapp.cc b/platform/slpi/platform_nanoapp.cc
new file mode 100644
index 0000000..14a6df7
--- /dev/null
+++ b/platform/slpi/platform_nanoapp.cc
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include "chre/platform/platform_nanoapp.h"
+
+#include "chre/platform/assert.h"
+#include "chre/platform/log.h"
+#include "chre/platform/memory.h"
+#include "chre/platform/shared/nanoapp_support_lib_dso.h"
+#include "chre_api/chre/version.h"
+
+#include "dlfcn.h"
+
+#include <inttypes.h>
+#include <string.h>
+
+namespace chre {
+
+namespace {
+
+/**
+ * Performs sanity checks on the app info structure included in a dynamically
+ * loaded nanoapp.
+ *
+ * @param expectedAppId
+ * @param expectedAppVersion
+ * @param appInfo
+ *
+ * @return true if validation was successful
+ */
+bool validateAppInfo(uint64_t expectedAppId, uint32_t expectedAppVersion,
+                     const struct chreNslNanoappInfo *appInfo) {
+  uint32_t ourApiMajorVersion = CHRE_EXTRACT_MAJOR_VERSION(chreGetApiVersion());
+  uint32_t targetApiMajorVersion = CHRE_EXTRACT_MAJOR_VERSION(
+      appInfo->targetApiVersion);
+
+  bool success = false;
+  if (appInfo->magic != CHRE_NSL_NANOAPP_INFO_MAGIC) {
+    LOGE("Invalid app info magic: got 0x%08" PRIx32 " expected 0x%08" PRIx32,
+         appInfo->magic, CHRE_NSL_NANOAPP_INFO_MAGIC);
+  } else if (appInfo->appId == 0) {
+    LOGE("Rejecting invalid app ID 0");
+  } else if (expectedAppId != appInfo->appId) {
+    LOGE("Expected app ID (0x%016" PRIx64 ") doesn't match internal one (0x%016"
+         PRIx64 ")", expectedAppId, appInfo->appId);
+  } else if (expectedAppVersion != appInfo->appVersion) {
+    LOGE("Expected app version (0x%" PRIx32 ") doesn't match internal one (0x%"
+         PRIx32 ")", expectedAppVersion, appInfo->appVersion);
+  } else if (targetApiMajorVersion != ourApiMajorVersion) {
+    LOGE("App targets a different major API version (%" PRIu32 ") than what we "
+         "provide (%" PRIu32 ")", targetApiMajorVersion, ourApiMajorVersion);
+  } else if (strlen(appInfo->name) > CHRE_NSL_DSO_NANOAPP_STRING_MAX_LEN) {
+    LOGE("App name is too long");
+  } else if (strlen(appInfo->name) > CHRE_NSL_DSO_NANOAPP_STRING_MAX_LEN) {
+    LOGE("App vendor is too long");
+  } else {
+    success = true;
+  }
+
+  return success;
+}
+
+}  // anonymous namespace
+
+PlatformNanoapp::~PlatformNanoapp() {
+  closeNanoapp();
+  if (mAppBinary != nullptr) {
+    memoryFree(mAppBinary);
+  }
+}
+
+bool PlatformNanoapp::start() {
+  // Invoke the start entry point after successfully opening the app
+  return (mIsStatic || openNanoapp()) ? mAppInfo->entryPoints.start() : false;
+}
+
+void PlatformNanoapp::handleEvent(uint32_t senderInstanceId,
+                                  uint16_t eventType,
+                                  const void *eventData) {
+  mAppInfo->entryPoints.handleEvent(senderInstanceId, eventType, eventData);
+}
+
+void PlatformNanoapp::end() {
+  mAppInfo->entryPoints.end();
+  closeNanoapp();
+}
+
+bool PlatformNanoappBase::loadFromBuffer(uint64_t appId, uint32_t appVersion,
+                                         const void *appBinary,
+                                         size_t appBinaryLen) {
+  CHRE_ASSERT(!isLoaded());
+  bool success = false;
+  constexpr size_t kMaxAppSize = 2 * 1024 * 1024;  // 2 MiB
+
+  if (appBinaryLen > kMaxAppSize) {
+    LOGE("Rejecting app size %zu above limit %zu", appBinaryLen, kMaxAppSize);
+  } else {
+    mAppBinary = memoryAlloc(appBinaryLen);
+    if (mAppBinary == nullptr) {
+      LOGE("Couldn't allocate %zu byte buffer for nanoapp 0x%016" PRIx64,
+           appBinaryLen, appId);
+    } else {
+      mExpectedAppId = appId;
+      mExpectedAppVersion = appVersion;
+      mAppBinaryLen = appBinaryLen;
+      memcpy(mAppBinary, appBinary, appBinaryLen);
+      success = true;
+    }
+  }
+
+  return success;
+}
+
+void PlatformNanoappBase::loadStatic(const struct chreNslNanoappInfo *appInfo) {
+  CHRE_ASSERT(!isLoaded());
+  mIsStatic = true;
+  mAppInfo = appInfo;
+}
+
+bool PlatformNanoappBase::isLoaded() const {
+  return (mIsStatic || mAppBinary != nullptr);
+}
+
+void PlatformNanoappBase::closeNanoapp() {
+  if (mDsoHandle != nullptr) {
+    if (dlclose(mDsoHandle) != 0) {
+      const char *name = (mAppInfo != nullptr) ? mAppInfo->name : "unknown";
+      LOGE("dlclose of %s failed: %s", name, dlerror());
+    }
+    mDsoHandle = nullptr;
+  }
+}
+
+bool PlatformNanoappBase::openNanoapp() {
+  bool success = false;
+
+  // Populate a filename string (just a requirement of the dlopenbuf API)
+  constexpr size_t kMaxFilenameLen = 17;
+  char filename[kMaxFilenameLen];
+  snprintf(filename, sizeof(filename), "%016" PRIx64, mExpectedAppId);
+
+  CHRE_ASSERT(mAppBinary != nullptr);
+  CHRE_ASSERT_LOG(mDsoHandle == nullptr, "Re-opening nanoapp");
+  mDsoHandle = dlopenbuf(
+      filename, static_cast<const char *>(mAppBinary),
+      static_cast<int>(mAppBinaryLen), RTLD_NOW);
+  if (mDsoHandle == nullptr) {
+    LOGE("Failed to load nanoapp: %s", dlerror());
+  } else {
+    mAppInfo = static_cast<const struct chreNslNanoappInfo *>(
+        dlsym(mDsoHandle, CHRE_NSL_DSO_NANOAPP_INFO_SYMBOL_NAME));
+    if (mAppInfo == nullptr) {
+      LOGE("Failed to find app info symbol: %s", dlerror());
+    } else {
+      success = validateAppInfo(mExpectedAppId, mExpectedAppVersion, mAppInfo);
+      if (!success) {
+        mAppInfo = nullptr;
+      } else {
+        LOGI("Successfully loaded nanoapp: %s (0x%016" PRIx64 ") version 0x%"
+             PRIx32, mAppInfo->name, mAppInfo->appId, mAppInfo->appVersion);
+      }
+    }
+  }
+
+  return success;
+}
+
+uint64_t PlatformNanoapp::getAppId() const {
+  return (mAppInfo != nullptr) ? mAppInfo->appId : mExpectedAppId;
+}
+
+uint32_t PlatformNanoapp::getAppVersion() const {
+  return (mAppInfo != nullptr) ? mAppInfo->appVersion : mExpectedAppVersion;
+}
+
+uint32_t PlatformNanoapp::getTargetApiVersion() const {
+  return (mAppInfo != nullptr) ? mAppInfo->targetApiVersion : 0;
+}
+
+bool PlatformNanoapp::isSystemNanoapp() const {
+  // Right now, we assume that system nanoapps are always static nanoapps. Since
+  // mAppInfo can only be null either prior to loading the app (in which case
+  // this function is not expected to return a valid value anyway), or when a
+  // dynamic nanoapp is not running, "false" is the correct return value in that
+  // case.
+  return (mAppInfo != nullptr) ? mAppInfo->isSystemNanoapp : false;
+}
+
+}  // namespace chre
diff --git a/platform/slpi/static_nanoapps.cc b/platform/slpi/static_nanoapps.cc
index 17368ad..f3ac3d0 100644
--- a/platform/slpi/static_nanoapps.cc
+++ b/platform/slpi/static_nanoapps.cc
@@ -26,15 +26,15 @@
 //! disabled by default, uncomment them as needed for local testing. This is
 //! supplied as a weak symbol so that device builds can override this list.
 __attribute__((weak))
-PlatformNanoapp *const kStaticNanoappList[] = {
-//  &gNanoappGnssWorld,
-//  &gNanoappHelloWorld,
-//  &gNanoappImuCal,
-//  &gNanoappMessageWorld,
-//  &gNanoappSensorWorld,
-//  &gNanoappTimerWorld,
-//  &gNanoappWifiWorld,
-//  &gNanoappWwanWorld,
+UniquePtr<Nanoapp> *const kStaticNanoappList[] = {
+//  gNanoappGnssWorld,
+//  gNanoappHelloWorld,
+//  gNanoappImuCal,
+//  gNanoappMessageWorld,
+//  gNanoappSensorWorld,
+//  gNanoappTimerWorld,
+//  gNanoappWifiWorld,
+//  gNanoappWwanWorld,
 };
 
 //! The size of the static nanoapp list.
diff --git a/util/include/chre/util/array_queue.h b/util/include/chre/util/array_queue.h
index fc4f9c2..d92532c 100644
--- a/util/include/chre/util/array_queue.h
+++ b/util/include/chre/util/array_queue.h
@@ -97,14 +97,15 @@
   const ElementType& operator[](size_t index) const;
 
   /**
-   * Pushes an element onto the back of the array queue. It returns false if
-   * the array queue is full already and there is no room for the elements. All
-   * iterators and references are unaffected.
+   * Pushes an element onto the back of the array queue via copy or move
+   * construction. It returns false if the array queue is full already and there
+   * is no room for the elements. All iterators and references are unaffected.
    *
    * @param element The element to push onto the array queue.
    * @return true if the element is pushed successfully.
    */
   bool push(const ElementType& element);
+  bool push(ElementType&& element);
 
   /**
    * Removes the front element from the array queue if the array queue is not
diff --git a/util/include/chre/util/array_queue_impl.h b/util/include/chre/util/array_queue_impl.h
index e5ede30..2d3061e 100644
--- a/util/include/chre/util/array_queue_impl.h
+++ b/util/include/chre/util/array_queue_impl.h
@@ -17,6 +17,7 @@
 #ifndef CHRE_UTIL_ARRAY_QUEUE_IMPL_H_
 #define CHRE_UTIL_ARRAY_QUEUE_IMPL_H_
 
+#include <new>
 #include <utility>
 
 #include "chre/platform/assert.h"
@@ -75,7 +76,16 @@
 bool ArrayQueue<ElementType, kCapacity>::push(const ElementType& element) {
   bool success = pushTail();
   if (success) {
-    data()[mTail] = element;
+    new (&data()[mTail]) ElementType(element);
+  }
+  return success;
+}
+
+template<typename ElementType, size_t kCapacity>
+bool ArrayQueue<ElementType, kCapacity>::push(ElementType&& element) {
+  bool success = pushTail();
+  if (success) {
+    new (&data()[mTail]) ElementType(std::move(element));
   }
   return success;
 }
diff --git a/util/include/chre/util/dynamic_vector.h b/util/include/chre/util/dynamic_vector.h
index ce0d770..2e8bb0f 100644
--- a/util/include/chre/util/dynamic_vector.h
+++ b/util/include/chre/util/dynamic_vector.h
@@ -95,25 +95,15 @@
   bool empty() const;
 
   /**
-   * Pushes an element onto the back of the vector. If the vector requires a
-   * resize and that allocation fails this function will return false. All
-   * iterators and references are invalidated if the container has been
-   * resized. Otherwise, only the past-the-end iterator is invalidated.
+   * Copy- or move-constructs an element onto the back of the vector. If the
+   * vector requires a resize and that allocation fails this function will
+   * return false. All iterators and references are invalidated if the container
+   * has been resized. Otherwise, only the past-the-end iterator is invalidated.
    *
    * @param The element to push onto the vector.
    * @return true if the element was pushed successfully.
    */
   bool push_back(const ElementType& element);
-
-  /**
-   * Moves an element onto the back of the vector. If the vector requires a
-   * resize and that allocation fails this function will return false. All
-   * iterators and references are invalidated if the container has been
-   * resized. Otherwise, only the past-the-end iterator is invalidated.
-   *
-   * @param The element to move onto the vector.
-   * @return true if the element was moved successfully.
-   */
   bool push_back(ElementType&& element);
 
   /**
@@ -178,6 +168,7 @@
    * @return Whether or not the insert operation was successful.
    */
   bool insert(size_t index, const ElementType& element);
+  bool insert(size_t index, ElementType&& element);
 
   /**
    * Similar to wrap(), except makes a copy of the supplied C-style array,
@@ -348,6 +339,15 @@
 
   //! Set to true when the buffer (mData) was supplied via wrap()
   bool mDataIsWrapped = false;
+
+  /**
+   * Prepares the vector for insertion - upon successful return, the memory at
+   * the given index will be allocated but uninitialized
+   *
+   * @param index
+   * @return true
+   */
+  bool prepareInsert(size_t index);
 };
 
 }  // namespace chre
diff --git a/util/include/chre/util/dynamic_vector_impl.h b/util/include/chre/util/dynamic_vector_impl.h
index 2585650..633a459 100644
--- a/util/include/chre/util/dynamic_vector_impl.h
+++ b/util/include/chre/util/dynamic_vector_impl.h
@@ -17,12 +17,13 @@
 #ifndef CHRE_UTIL_DYNAMIC_VECTOR_IMPL_H_
 #define CHRE_UTIL_DYNAMIC_VECTOR_IMPL_H_
 
-#include <algorithm>
+#include <memory>
+#include <new>
 #include <utility>
 
 #include "chre/platform/assert.h"
 #include "chre/platform/memory.h"
-#include "chre/util/dynamic_vector.h"
+#include "chre/util/memory.h"
 
 namespace chre {
 
@@ -51,9 +52,7 @@
 
 template <typename ElementType>
 void DynamicVector<ElementType>::clear() {
-  for (size_t i = 0; i < mSize; i++) {
-    mData[i].~ElementType();
-  }
+  destroy(mData, mSize);
   mSize = 0;
 }
 
@@ -86,7 +85,7 @@
 bool DynamicVector<ElementType>::push_back(const ElementType& element) {
   bool spaceAvailable = prepareForPush();
   if (spaceAvailable) {
-    mData[mSize++] = element;
+    new (&mData[mSize++]) ElementType(element);
   }
 
   return spaceAvailable;
@@ -96,7 +95,7 @@
 bool DynamicVector<ElementType>::push_back(ElementType&& element) {
   bool spaceAvailable = prepareForPush();
   if (spaceAvailable) {
-    mData[mSize++] = std::move(element);
+    new (&mData[mSize++]) ElementType(std::move(element));
   }
 
   return spaceAvailable;
@@ -133,34 +132,6 @@
   return data()[index];
 }
 
-/**
- *  Moves a range of data items. This is part of the template specialization for
- *  when the underlying type is move-assignable.
- *
- *  @param data The beginning of the data to move.
- *  @param count The number of data items to move.
- *  @param newData The location to move these items to.
- */
-template<typename ElementType>
-void moveOrCopy(ElementType *data, size_t count, ElementType *newData,
-                std::true_type) {
-  std::move(data, data + count, newData);
-}
-
-/**
- * Copies a range of data items. This is part of the template specialization
- * for when the underlying type is not move-assignable.
- *
- * @param data The beginning of the data to copy.
- * @param count The number of data items to copy.
- * @param newData The location to copy these items to.
- */
-template<typename ElementType>
-void moveOrCopy(ElementType *data, size_t count, ElementType *newData,
-                std::false_type) {
-  std::copy(data, data + count, newData);
-}
-
 template<typename ElementType>
 bool DynamicVector<ElementType>::reserve(size_t newCapacity) {
   bool success = false;
@@ -172,9 +143,8 @@
     ElementType *newData = static_cast<ElementType *>(
         memoryAlloc(newCapacity * sizeof(ElementType)));
     if (newData != nullptr) {
-      moveOrCopy(mData, mSize, newData,
-                 typename std::is_move_assignable<ElementType>::type());
-
+      uninitializedMoveOrCopy(mData, mSize, newData);
+      destroy(mData, mSize);
       memoryFree(mData);
       mData = newData;
       mCapacity = newCapacity;
@@ -188,24 +158,48 @@
 template<typename ElementType>
 bool DynamicVector<ElementType>::insert(size_t index,
                                         const ElementType& element) {
+  bool inserted = prepareInsert(index);
+  if (inserted) {
+    new (&mData[index]) ElementType(element);
+  }
+  return inserted;
+}
+
+template<typename ElementType>
+bool DynamicVector<ElementType>::insert(size_t index, ElementType&& element) {
+  bool inserted = prepareInsert(index);
+  if (inserted) {
+    new (&mData[index]) ElementType(std::move(element));
+  }
+  return inserted;
+}
+
+template<typename ElementType>
+bool DynamicVector<ElementType>::prepareInsert(size_t index) {
   // Insertions are not allowed to create a sparse array.
   CHRE_ASSERT(index <= mSize);
 
-  bool inserted = false;
-  if (index <= mSize && prepareForPush()) {
-    // Shift all elements starting at the given index backward one position.
-    for (size_t i = mSize; i > index; i--) {
-      mData[i] = std::move(mData[i - 1]);
+  // TODO: this can be optimized in the case where we need to grow the vector to
+  // do the shift when transferring the values from the old array to the new.
+  bool readyForInsert = (index <= mSize && prepareForPush());
+  if (readyForInsert) {
+    // If we aren't simply appending the new object, create an opening where
+    // we'll insert it
+    if (index < mSize) {
+      // Make a duplicate of the last item in the slot where we're growing
+      uninitializedMoveOrCopy(&mData[mSize - 1], 1, &mData[mSize]);
+      // Shift all elements starting at index towards the end
+      for (size_t i = mSize - 1; i > index; i--) {
+        moveOrCopyAssign(mData[i], mData[i - 1]);
+      }
+
+      mData[index].~ElementType();
     }
 
-    mData[index].~ElementType();
-    mData[index] = element;
     mSize++;
-
-    inserted = true;
   }
 
-  return inserted;
+  return readyForInsert;
 }
 
 template<typename ElementType>
@@ -230,7 +224,7 @@
   if (index < mSize) {
     mSize--;
     for (size_t i = index; i < mSize; i++) {
-      mData[i] = std::move(mData[i + 1]);
+      moveOrCopyAssign(mData[i], mData[i + 1]);
     }
 
     mData[mSize].~ElementType();
@@ -253,10 +247,13 @@
 template<typename ElementType>
 void DynamicVector<ElementType>::swap(size_t index0, size_t index1) {
   CHRE_ASSERT(index0 < mSize && index1 < mSize);
-  if (index0 < mSize && index1 < mSize) {
-    ElementType temp = std::move(mData[index0]);
-    mData[index0] = std::move(mData[index1]);
-    mData[index1] = std::move(temp);
+  if (index0 < mSize && index1 < mSize && index0 != index1) {
+    typename std::aligned_storage<sizeof(ElementType),
+        alignof(ElementType)>::type tempStorage;
+    ElementType& temp = *reinterpret_cast<ElementType *>(&tempStorage);
+    uninitializedMoveOrCopy(&mData[index0], 1, &temp);
+    moveOrCopyAssign(mData[index0], mData[index1]);
+    moveOrCopyAssign(mData[index1], temp);
   }
 }
 
diff --git a/util/include/chre/util/entry_points.h b/util/include/chre/util/entry_points.h
index cd794a7..e5350d5 100644
--- a/util/include/chre/util/entry_points.h
+++ b/util/include/chre/util/entry_points.h
@@ -17,19 +17,18 @@
 #ifndef CHRE_UTIL_ENTRY_POINTS_H_
 #define CHRE_UTIL_ENTRY_POINTS_H_
 
-namespace chre {
+#include <stdbool.h>
+#include <stdint.h>
 
-//! The type for the Nanoapp start function pointer.
-typedef bool (NanoappStartFunction)();
+//! @see nanoappStart()
+typedef bool (chreNanoappStartFunction)();
 
-//! The type of the Nanoapp handle event function pointer.
-typedef void (NanoappHandleEventFunction)(uint32_t senderInstanceId,
-                                          uint16_t eventType,
-                                          const void *eventData);
+//! @see nanoappHandleEvent()
+typedef void (chreNanoappHandleEventFunction)(uint32_t senderInstanceId,
+                                              uint16_t eventType,
+                                              const void *eventData);
 
-//! The type of the Nanoapp stop function pointer.
-typedef void (NanoappStopFunction)();
-
-}  // namespace chre
+//! @see nanoappEnd()
+typedef void (chreNanoappEndFunction)();
 
 #endif  // CHRE_UTIL_ENTRY_POINTS_H_
diff --git a/util/include/chre/util/fixed_size_vector_impl.h b/util/include/chre/util/fixed_size_vector_impl.h
index 8e8fe55..90f131a 100644
--- a/util/include/chre/util/fixed_size_vector_impl.h
+++ b/util/include/chre/util/fixed_size_vector_impl.h
@@ -17,10 +17,10 @@
 #ifndef CHRE_UTIL_FIXED_SIZE_VECTOR_IMPL_H_
 #define CHRE_UTIL_FIXED_SIZE_VECTOR_IMPL_H_
 
-#include <utility>
+#include <new>
 
 #include "chre/platform/assert.h"
-#include "chre/util/fixed_size_vector.h"
+#include "chre/util/memory.h"
 
 namespace chre {
 
@@ -59,7 +59,7 @@
     const ElementType& element) {
   CHRE_ASSERT(!full());
   if (!full()) {
-    data()[mSize++] = element;
+    new (&data()[mSize++]) ElementType(element);
   }
 }
 
@@ -100,7 +100,7 @@
   if (index < mSize) {
     mSize--;
     for (size_t i = index; i < mSize; i++) {
-      data()[i] = std::move(data()[i + 1]);
+      moveOrCopyAssign(data()[i], data()[i + 1]);
     }
 
     data()[mSize].~ElementType();
@@ -111,10 +111,13 @@
 void FixedSizeVector<ElementType, kCapacity>::swap(size_t index0,
                                                    size_t index1) {
   CHRE_ASSERT(index0 < mSize && index1 < mSize);
-  if (index0 < mSize && index1 < mSize) {
-    ElementType temp = std::move(data()[index0]);
-    data()[index0] = std::move(data()[index1]);
-    data()[index1] = std::move(temp);
+  if (index0 < mSize && index1 < mSize && index0 != index1) {
+    typename std::aligned_storage<sizeof(ElementType),
+        alignof(ElementType)>::type tempStorage;
+    ElementType& temp = *reinterpret_cast<ElementType *>(&tempStorage);
+    uninitializedMoveOrCopy(&data()[index0], 1, &temp);
+    moveOrCopyAssign(data()[index0], data()[index1]);
+    moveOrCopyAssign(data()[index1], temp);
   }
 }
 
diff --git a/util/include/chre/util/memory.h b/util/include/chre/util/memory.h
new file mode 100644
index 0000000..ccfb5ce
--- /dev/null
+++ b/util/include/chre/util/memory.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef CHRE_UTIL_MEMORY_H_
+#define CHRE_UTIL_MEMORY_H_
+
+namespace chre {
+
+/**
+ * Destroys count objects starting at first. This function is similar to
+ * std::destroy_n.
+ *
+ * @param first Starting address of count objects to destroy
+ * @param count The number of objects to destroy
+ */
+template<typename ElementType>
+void destroy(ElementType *first, size_t count);
+
+/**
+ * Performs move assignment (dest = std::move(source)) if supported by
+ * ElementType, otherwise copy assignment (dest = source).
+ */
+template<typename ElementType>
+void moveOrCopyAssign(ElementType& dest, ElementType& source);
+
+/**
+ * Initializes a new block of memory by transferring objects from another block,
+ * using memcpy if valid for the underlying type, or the move constructor if
+ * available, or the copy constructor. This function is similar to
+ * std::uninitialized_move_n.
+ *
+ * @param source The beginning of the data to transfer
+ * @param count The number of elements to transfer
+ * @param dest An uninitialized buffer to be populated with count elements
+ */
+template<typename ElementType>
+void uninitializedMoveOrCopy(ElementType *source, size_t count,
+                             ElementType *dest);
+
+}  // namespace chre
+
+#include "chre/util/memory_impl.h"
+
+#endif  // CHRE_UTIL_MEMORY_H
diff --git a/util/include/chre/util/memory_impl.h b/util/include/chre/util/memory_impl.h
new file mode 100644
index 0000000..cf9b712
--- /dev/null
+++ b/util/include/chre/util/memory_impl.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef CHRE_UTIL_MEMORY_IMPL_H_
+#define CHRE_UTIL_MEMORY_IMPL_H_
+
+#include <cstring>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+namespace chre {
+
+template<typename ElementType>
+inline void destroy(ElementType *first, size_t count) {
+  for (size_t i = 0; i < count; i++) {
+    first[i].~ElementType();
+  }
+}
+
+//! Overload used when the type is move assignable
+template<typename ElementType>
+inline void moveOrCopyAssign(ElementType& dest, ElementType& source,
+                             std::true_type) {
+  dest = std::move(source);
+}
+
+//! Overload used when the type is not move assignable
+template<typename ElementType>
+inline void moveOrCopyAssign(ElementType& dest, ElementType& source,
+                             std::false_type) {
+  dest = source;
+}
+
+template<typename ElementType>
+inline void moveOrCopyAssign(ElementType& dest, ElementType& source) {
+  moveOrCopyAssign(dest, source,
+                   typename std::is_move_assignable<ElementType>::type());
+}
+
+//! Overload used when type is trivially copy constructible
+template<typename ElementType>
+inline void uninitializedMoveOrCopy(ElementType *source, size_t count,
+                                    ElementType *dest, std::true_type) {
+  std::memcpy(dest, source, count * sizeof(ElementType));
+}
+
+//! Overload used when type is not trivially copy constructible, but is move
+//! constructible
+template<typename ElementType>
+inline void uninitializedMoveOrCopy(ElementType *source, size_t count,
+                                    ElementType *dest, std::false_type,
+                                    std::true_type) {
+  for (size_t i = 0; i < count; i++) {
+    new (&dest[i]) ElementType(std::move(source[i]));
+  }
+}
+
+//! Overload used when type is not trivially copy constructible or move
+//! constructible
+template<typename ElementType>
+inline void uninitializedMoveOrCopy(ElementType *source, size_t count,
+                                    ElementType *dest, std::false_type,
+                                    std::false_type) {
+  for (size_t i = 0; i < count; i++) {
+    new (&dest[i]) ElementType(source[i]);
+  }
+}
+
+//! Overload used when type is not trivially copy constructible
+template<typename ElementType>
+inline void uninitializedMoveOrCopy(
+    ElementType *source, size_t count, ElementType *dest, std::false_type) {
+  // Check the assumption that if is_move_constructible is false, then
+  // is_copy_constructible is true
+  static_assert(std::is_move_constructible<ElementType>()
+                || std::is_copy_constructible<ElementType>(),
+                "Object must be copy- or move- constructible to use "
+                "unintializedMoveOrCopy");
+  uninitializedMoveOrCopy(
+      source, count, dest, std::false_type(),
+      typename std::is_move_constructible<ElementType>::type());
+}
+
+template<typename ElementType>
+inline void uninitializedMoveOrCopy(ElementType *source, size_t count,
+                                    ElementType *dest) {
+  // TODO: we should be able to use std::is_trivially_copy_constructible here,
+  // but it's not found in the linux x86 build, because our build uses GCC 4.8's
+  // C++ standard library, which doesn't support it. Works in the SLPI build,
+  // though...
+  uninitializedMoveOrCopy(
+      source, count, dest, typename std::is_trivial<ElementType>::type());
+      //typename std::is_trivially_copy_constructible<ElementType>::type());
+}
+
+}  // namespace chre
+
+#endif  // CHRE_UTIL_MEMORY_IMPL_H_
diff --git a/util/include/chre/util/nanoapp/app_id.h b/util/include/chre/util/nanoapp/app_id.h
new file mode 100644
index 0000000..fca6257
--- /dev/null
+++ b/util/include/chre/util/nanoapp/app_id.h
@@ -0,0 +1,79 @@
+
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef CHRE_UTIL_NANOAPP_APP_ID_H_
+#define CHRE_UTIL_NANOAPP_APP_ID_H_
+
+#include <chre/common.h>
+#include <stdint.h>
+
+/**
+ * @file
+ * Helpers for defining static nanoapp IDs, e.g. for use with
+ * CHRE_STATIC_NANOAPP_INIT.
+ */
+
+//! Sample Vendor ID for example nanoapps. The vendor ID portion is the 5 most
+//! significant bytes of the app ID. This vendor ID should not appear in
+//! production.
+#define CHRE_VENDOR_ID_EXAMPLE  UINT64_C(0x0123456789000000)
+
+namespace chre {
+
+/**
+ * Constructs a fully qualified nanoapp ID from a vendor portion (most
+ * significant 5 bytes) and app number (least significant 3 bytes)
+ *
+ * @param vendor Value with vendor unique identifier in the most significant 5
+ *        bytes
+ * @param appNumber Value with vendor-scoped app number in the least significant
+ *        3 bytes
+ *
+ * @return app ID combining vendor and app number
+ */
+constexpr uint64_t makeNanoappId(uint64_t vendor, uint32_t appNumber) {
+  return ((vendor & CHRE_VENDOR_ID_MASK) | (appNumber & ~CHRE_VENDOR_ID_MASK));
+}
+
+/**
+ * @return App ID combining the given 3-byte app number and Google's 5-byte
+ *         vendor ID
+ */
+constexpr uint64_t makeExampleNanoappId(uint32_t appNumber) {
+  return makeNanoappId(CHRE_VENDOR_ID_EXAMPLE, appNumber);
+}
+
+/**
+ * @return App ID combining the given 3-byte app number and Google's 5-byte
+ *         vendor ID
+ */
+constexpr uint64_t makeGoogleNanoappId(uint32_t appNumber) {
+  return makeNanoappId(CHRE_VENDOR_ID_GOOGLE, appNumber);
+}
+
+constexpr uint64_t kHelloWorldAppId   = makeExampleNanoappId(1);
+constexpr uint64_t kMessageWorldAppId = makeExampleNanoappId(2);
+constexpr uint64_t kTimerWorldAppId   = makeExampleNanoappId(3);
+constexpr uint64_t kSensorWorldAppId  = makeExampleNanoappId(4);
+constexpr uint64_t kGnssWorldAppId    = makeExampleNanoappId(5);
+constexpr uint64_t kWifiWorldAppId    = makeExampleNanoappId(6);
+constexpr uint64_t kWwanWorldAppId    = makeExampleNanoappId(7);
+constexpr uint64_t kImuCalAppId       = makeExampleNanoappId(8);
+
+}  // namespace chre
+
+#endif  // CHRE_UTIL_NANOAPP_APP_ID_H_
diff --git a/util/include/chre/util/unique_ptr.h b/util/include/chre/util/unique_ptr.h
index 2fbeff1..78feb53 100644
--- a/util/include/chre/util/unique_ptr.h
+++ b/util/include/chre/util/unique_ptr.h
@@ -23,20 +23,33 @@
 
 /**
  * Wraps a pointer to a dynamically allocated object and manages the underlying
- * memory. The goal is to be similar to std::unique_ptr.
+ * memory. The goal is to be similar to std::unique_ptr, but we do not support
+ * custom deleters - deletion is always done via memoryFree().
  */
 template<typename ObjectType>
 class UniquePtr : public NonCopyable {
  public:
   /**
-   * Allocates and constructs a new object of type ObjectType on the heap. If
-   * memory allocation fails the constructor is not invoked. This constructor is
-   * similar to std::make_unique.
-   *
-   * @param args The arguments to pass to the object's constructor.
+   * Construct a UniquePtr instance that does not own any object.
    */
-  template<typename... Args>
-  UniquePtr(Args&&... args);
+  UniquePtr();
+
+  /**
+   * Constructs a UniquePtr instance that owns the given object, and will free
+   * its memory when the UniquePtr is destructed.
+   *
+   * @param object Pointer to an object allocated via memoryAlloc. It is not
+   *        valid for this object's memory to come from any other source,
+   *        including the stack, or static allocation on the heap.
+   */
+  UniquePtr(ObjectType *object);
+
+  /**
+   * Constructs a new UniquePtr via moving the Object from another UniquePtr.
+   *
+   * @param other UniquePtr instance to move into this object
+   */
+  UniquePtr(UniquePtr<ObjectType>&& other);
 
   /**
    * Deconstructs the object (if necessary) and releases associated memory.
@@ -44,9 +57,9 @@
   ~UniquePtr();
 
   /**
-   * Determines if the object was constructed correctly.
+   * Determines if this UniquePtr owns an object, or references null.
    *
-   * @return true if the object is null and not constructed.
+   * @return true if get() returns nullptr
    */
   bool isNull() const;
 
@@ -59,7 +72,7 @@
   /**
    * Releases ownership of the underlying object, so it will not be freed when
    * this object is destructed. After this function returns, get() will return
-   * null.
+   * nullptr.
    *
    * @return A pointer to the underlying object (i.e. what get() would return
    *         prior to this function call)
@@ -96,6 +109,16 @@
   ObjectType *mObject;
 };
 
+/**
+ * Allocates and constructs a new object of type ObjectType on the heap, and
+ * returns a UniquePtr that owns the object. This function is similar to
+ * std::make_unique.
+ *
+ * @param args The arguments to pass to the object's constructor.
+ */
+template<typename ObjectType, typename... Args>
+UniquePtr<ObjectType> MakeUnique(Args&&... args);
+
 }  // namespace chre
 
 #include "chre/util/unique_ptr_impl.h"
diff --git a/util/include/chre/util/unique_ptr_impl.h b/util/include/chre/util/unique_ptr_impl.h
index 3059abc..aac1411 100644
--- a/util/include/chre/util/unique_ptr_impl.h
+++ b/util/include/chre/util/unique_ptr_impl.h
@@ -24,12 +24,15 @@
 namespace chre {
 
 template<typename ObjectType>
-template<typename... Args>
-UniquePtr<ObjectType>::UniquePtr(Args&&... args) {
-  mObject = static_cast<ObjectType *>(memoryAlloc(sizeof(ObjectType)));
-  if (mObject != nullptr) {
-    new (mObject) ObjectType(std::forward<Args>(args)...);
-  }
+UniquePtr<ObjectType>::UniquePtr() : mObject(nullptr) {}
+
+template<typename ObjectType>
+UniquePtr<ObjectType>::UniquePtr(ObjectType *object) : mObject(object) {}
+
+template<typename ObjectType>
+UniquePtr<ObjectType>::UniquePtr(UniquePtr<ObjectType>&& other) {
+  mObject = other.mObject;
+  other.mObject = nullptr;
 }
 
 template<typename ObjectType>
@@ -82,6 +85,12 @@
   return *this;
 }
 
+template<typename ObjectType, typename... Args>
+inline UniquePtr<ObjectType> MakeUnique(Args&&... args) {
+  return UniquePtr<ObjectType>(memoryAlloc<ObjectType>(
+      std::forward<Args>(args)...));
+}
+
 }  // namespace chre
 
 #endif  // CHRE_UTIL_UNIQUE_PTR_IMPL_H_
diff --git a/util/tests/dynamic_vector_test.cc b/util/tests/dynamic_vector_test.cc
index 5b167e9..a660036 100644
--- a/util/tests/dynamic_vector_test.cc
+++ b/util/tests/dynamic_vector_test.cc
@@ -19,6 +19,8 @@
 #include "chre/util/dynamic_vector.h"
 #include "chre/util/macros.h"
 
+#include <stdint.h>
+
 using chre::DynamicVector;
 
 namespace {
@@ -52,39 +54,61 @@
 
 TEST(DynamicVector, EmptyByDefault) {
   DynamicVector<int> vector;
-  ASSERT_EQ(vector.data(), nullptr);
-  ASSERT_EQ(vector.size(), 0);
-  ASSERT_EQ(vector.capacity(), 0);
+  EXPECT_EQ(vector.data(), nullptr);
+  EXPECT_TRUE(vector.empty());
+  EXPECT_EQ(vector.size(), 0);
+  EXPECT_EQ(vector.capacity(), 0);
+  vector.clear();
 }
 
 TEST(DynamicVector, PushBackAndRead) {
   DynamicVector<int> vector;
   ASSERT_TRUE(vector.push_back(0x1337));
-  ASSERT_EQ(vector[0], 0x1337);
-  ASSERT_EQ(vector.data()[0], 0x1337);
+  EXPECT_EQ(vector.size(), 1);
+  EXPECT_EQ(vector.capacity(), 1);
+  EXPECT_EQ(vector.data(), &vector[0]);
+  EXPECT_FALSE(vector.empty());
+  EXPECT_EQ(vector[0], 0x1337);
 }
 
-TEST(DynamicVector, PushBackReserveAndRead) {
+TEST(DynamicVector, PushBackReserveAndReadTrivialType) {
   DynamicVector<int> vector;
-  ASSERT_TRUE(vector.push_back(0x1337));
+  ASSERT_TRUE(vector.emplace_back(0x1337));
   ASSERT_TRUE(vector.push_back(0xface));
-  ASSERT_TRUE(vector.reserve(4));
-  ASSERT_EQ(vector[0], 0x1337);
-  ASSERT_EQ(vector.data()[0], 0x1337);
-  ASSERT_EQ(vector[1], 0xface);
-  ASSERT_EQ(vector.data()[1], 0xface);
+  int x = 0xcafe;
+  ASSERT_TRUE(vector.push_back(std::move(x)));
+  ASSERT_TRUE(vector.insert(vector.size(), 0xd00d));
+  EXPECT_EQ(vector.size(), 4);
+  EXPECT_EQ(vector.capacity(), 4);
+  EXPECT_EQ(vector[0], 0x1337);
+  EXPECT_EQ(vector[1], 0xface);
+  EXPECT_EQ(vector[2], 0xcafe);
+  EXPECT_EQ(vector[3], 0xd00d);
+
+  ASSERT_TRUE(vector.reserve(8));
+  EXPECT_EQ(vector.size(), 4);
+  EXPECT_EQ(vector.capacity(), 8);
+  EXPECT_EQ(vector[0], 0x1337);
+  EXPECT_EQ(vector[1], 0xface);
+  EXPECT_EQ(vector[2], 0xcafe);
+  EXPECT_EQ(vector[3], 0xd00d);
 }
 
+constexpr int kConstructedMagic = 0xdeadbeef;
+
 class MovableButNonCopyable : public chre::NonCopyable {
  public:
   MovableButNonCopyable(int value) : mValue(value) {}
 
   MovableButNonCopyable(MovableButNonCopyable&& other) {
     mValue = other.mValue;
+    other.mValue = -1;
   }
 
   MovableButNonCopyable& operator=(MovableButNonCopyable&& other) {
+    assert(mMagic == kConstructedMagic);
     mValue = other.mValue;
+    other.mValue = -1;
     return *this;
   }
 
@@ -93,6 +117,7 @@
   }
 
  private:
+  int mMagic = kConstructedMagic;
   int mValue;
 };
 
@@ -100,11 +125,20 @@
   DynamicVector<MovableButNonCopyable> vector;
   ASSERT_TRUE(vector.emplace_back(0x1337));
   ASSERT_TRUE(vector.emplace_back(0xface));
-  ASSERT_TRUE(vector.reserve(4));
+  MovableButNonCopyable mbnc(0xcafe);
+  ASSERT_TRUE(vector.push_back(std::move(mbnc)));
+  EXPECT_EQ(mbnc.getValue(), -1);
+  MovableButNonCopyable mbnc2(0xd00d);
+  ASSERT_TRUE(vector.insert(vector.size(), std::move(mbnc2)));
+  EXPECT_EQ(mbnc2.getValue(), -1);
+
+  ASSERT_TRUE(vector.reserve(8));
   EXPECT_EQ(vector[0].getValue(), 0x1337);
-  EXPECT_EQ(vector.data()[0].getValue(), 0x1337);
   EXPECT_EQ(vector[1].getValue(), 0xface);
-  EXPECT_EQ(vector.data()[1].getValue(), 0xface);
+  EXPECT_EQ(vector[2].getValue(), 0xcafe);
+  EXPECT_EQ(vector[3].getValue(), 0xd00d);
+  EXPECT_EQ(vector.size(), 4);
+  EXPECT_EQ(vector.capacity(), 8);
 }
 
 class CopyableButNonMovable {
@@ -115,13 +149,13 @@
     mValue = other.mValue;
   }
 
-  CopyableButNonMovable(CopyableButNonMovable&& other) = delete;
-
   CopyableButNonMovable& operator=(const CopyableButNonMovable& other) {
+    assert(mMagic == kConstructedMagic);
     mValue = other.mValue;
     return *this;
   }
 
+  CopyableButNonMovable(CopyableButNonMovable&& other) = delete;
   CopyableButNonMovable& operator=(CopyableButNonMovable&& other) = delete;
 
   int getValue() const {
@@ -129,18 +163,26 @@
   }
 
  private:
+  int mMagic = kConstructedMagic;
   int mValue;
 };
 
 TEST(DynamicVector, PushBackReserveAndReadCopyableButNonMovable) {
   DynamicVector<CopyableButNonMovable> vector;
-  ASSERT_TRUE(vector.emplace_back(0xcafe));
+  ASSERT_TRUE(vector.emplace_back(0x1337));
   ASSERT_TRUE(vector.emplace_back(0xface));
-  ASSERT_TRUE(vector.reserve(4));
-  EXPECT_EQ(vector[0].getValue(), 0xcafe);
-  EXPECT_EQ(vector.data()[0].getValue(), 0xcafe);
+  CopyableButNonMovable cbnm(0xcafe);
+  ASSERT_TRUE(vector.push_back(cbnm));
+  CopyableButNonMovable cbnm2(0xd00d);
+  ASSERT_TRUE(vector.insert(vector.size(), cbnm2));
+
+  ASSERT_TRUE(vector.reserve(8));
+  EXPECT_EQ(vector[0].getValue(), 0x1337);
   EXPECT_EQ(vector[1].getValue(), 0xface);
-  EXPECT_EQ(vector.data()[1].getValue(), 0xface);
+  EXPECT_EQ(vector[2].getValue(), 0xcafe);
+  EXPECT_EQ(vector[3].getValue(), 0xd00d);
+  EXPECT_EQ(vector.size(), 4);
+  EXPECT_EQ(vector.capacity(), 8);
 }
 
 class MovableAndCopyable {
@@ -152,18 +194,21 @@
   }
 
   MovableAndCopyable(MovableAndCopyable&& other) {
-    mValue = other.mValue;
+    // The move constructor multiplies the value by 2 so that we can see that it
+    // was used
+    mValue = other.mValue * 2;
   }
 
   MovableAndCopyable& operator=(const MovableAndCopyable& other) {
+    assert(mMagic == kConstructedMagic);
     mValue = other.mValue;
     return *this;
   }
 
   MovableAndCopyable& operator=(MovableAndCopyable&& other) {
-    // The move operation multiplies the value by 2 so that we can see that the
-    // move assignment operator was used.
+    assert(mMagic == kConstructedMagic);
     mValue = other.mValue * 2;
+    other.mValue = -1;
     return *this;
   }
 
@@ -172,11 +217,12 @@
   }
 
  private:
+  int mMagic = kConstructedMagic;
   int mValue;
 };
 
-TEST(DynamicVector, PushBackReserveAndReadMovableAndCopyable) {
-  // Ensure that preference is given to std::move.
+TEST(DynamicVector, ReservePrefersMove) {
+  // Ensure that preference is given to std::move in reserve()
   DynamicVector<MovableAndCopyable> vector;
 
   // Reserve enough space for the first two elements.
@@ -190,9 +236,7 @@
   // Move on this type results in a multiplication by 2. Verify that all
   // elements have been multiplied by 2.
   EXPECT_EQ(vector[0].getValue(), 2000);
-  EXPECT_EQ(vector.data()[0].getValue(), 2000);
   EXPECT_EQ(vector[1].getValue(), 4000);
-  EXPECT_EQ(vector.data()[1].getValue(), 4000);
 }
 
 /**
@@ -208,6 +252,13 @@
     sConstructedCounter++;
   }
 
+  Foo(const Foo& other) {
+    value = other.value;
+    sConstructedCounter++;
+  }
+
+  Foo(Foo&& other) = delete;
+
   /**
    * Tear down the object, decrementing the number of objects that have been
    * constructed of this type.
@@ -217,7 +268,7 @@
   }
 
   //! The number of objects of this type that have been constructed.
-  static size_t sConstructedCounter;
+  static ssize_t sConstructedCounter;
 
   //! The value stored in the object to verify the contents of this object after
   //! construction.
@@ -225,9 +276,10 @@
 };
 
 //! Storage for the Foo reference counter.
-size_t Foo::sConstructedCounter = 0;
+ssize_t Foo::sConstructedCounter = 0;
 
 TEST(DynamicVector, EmplaceBackAndDestruct) {
+  Foo::sConstructedCounter = 0;
   {
     DynamicVector<Foo> vector;
     ASSERT_TRUE(vector.emplace_back(1000));
@@ -236,26 +288,75 @@
     ASSERT_TRUE(vector.emplace_back(4000));
 
     ASSERT_EQ(vector[0].value, 1000);
-    ASSERT_EQ(vector.data()[0].value, 1000);
     ASSERT_EQ(vector[1].value, 2000);
-    ASSERT_EQ(vector.data()[1].value, 2000);
     ASSERT_EQ(vector[2].value, 3000);
-    ASSERT_EQ(vector.data()[2].value, 3000);
     ASSERT_EQ(vector[3].value, 4000);
-    ASSERT_EQ(vector.data()[3].value, 4000);
 
-    ASSERT_EQ(Foo::sConstructedCounter, 4);
+    EXPECT_EQ(Foo::sConstructedCounter, 4);
   }
 
-  ASSERT_EQ(Foo::sConstructedCounter, 0);
+  EXPECT_EQ(Foo::sConstructedCounter, 0);
 }
 
 TEST(DynamicVector, InsertEmpty) {
   DynamicVector<int> vector;
   EXPECT_CHRE_ASSERT(EXPECT_FALSE(vector.insert(1, 0x1337)));
+
+  // Insert to empty vector
   ASSERT_TRUE(vector.insert(0, 0x1337));
   EXPECT_EQ(vector[0], 0x1337);
-  EXPECT_EQ(vector.data()[0], 0x1337);
+
+  // Insert at end triggering grow
+  ASSERT_EQ(vector.capacity(), 1);
+  EXPECT_TRUE(vector.insert(1, 0xface));
+  EXPECT_EQ(vector[0], 0x1337);
+  EXPECT_EQ(vector[1], 0xface);
+
+  // Insert at beginning triggering grow
+  ASSERT_EQ(vector.capacity(), 2);
+  EXPECT_TRUE(vector.insert(0, 0xcafe));
+  EXPECT_EQ(vector[0], 0xcafe);
+  EXPECT_EQ(vector[1], 0x1337);
+  EXPECT_EQ(vector[2], 0xface);
+
+  // Insert at middle with spare capacity
+  ASSERT_EQ(vector.capacity(), 4);
+  EXPECT_TRUE(vector.insert(1, 0xdead));
+  EXPECT_EQ(vector[0], 0xcafe);
+  EXPECT_EQ(vector[1], 0xdead);
+  EXPECT_EQ(vector[2], 0x1337);
+  EXPECT_EQ(vector[3], 0xface);
+
+  // Insert at middle triggering grow
+  ASSERT_EQ(vector.capacity(), 4);
+  EXPECT_TRUE(vector.insert(2, 0xbeef));
+  EXPECT_EQ(vector[0], 0xcafe);
+  EXPECT_EQ(vector[1], 0xdead);
+  EXPECT_EQ(vector[2], 0xbeef);
+  EXPECT_EQ(vector[3], 0x1337);
+  EXPECT_EQ(vector[4], 0xface);
+
+  // Insert at beginning with spare capacity
+  ASSERT_EQ(vector.capacity(), 8);
+  ASSERT_EQ(vector.size(), 5);
+  EXPECT_TRUE(vector.insert(0, 0xabad));
+  EXPECT_EQ(vector[0], 0xabad);
+  EXPECT_EQ(vector[1], 0xcafe);
+  EXPECT_EQ(vector[2], 0xdead);
+  EXPECT_EQ(vector[3], 0xbeef);
+  EXPECT_EQ(vector[4], 0x1337);
+  EXPECT_EQ(vector[5], 0xface);
+
+  // Insert at end with spare capacity
+  ASSERT_EQ(vector.size(), 6);
+  EXPECT_TRUE(vector.insert(vector.size(), 0xc0de));
+  EXPECT_EQ(vector[0], 0xabad);
+  EXPECT_EQ(vector[1], 0xcafe);
+  EXPECT_EQ(vector[2], 0xdead);
+  EXPECT_EQ(vector[3], 0xbeef);
+  EXPECT_EQ(vector[4], 0x1337);
+  EXPECT_EQ(vector[5], 0xface);
+  EXPECT_EQ(vector[6], 0xc0de);
 }
 
 TEST(DynamicVector, PushBackInsertInMiddleAndRead) {
@@ -266,13 +367,9 @@
   ASSERT_TRUE(vector.insert(1, 0xbeef));
 
   ASSERT_EQ(vector[0], 0x1337);
-  ASSERT_EQ(vector.data()[0], 0x1337);
   ASSERT_EQ(vector[1], 0xbeef);
-  ASSERT_EQ(vector.data()[1], 0xbeef);
   ASSERT_EQ(vector[2], 0xface);
-  ASSERT_EQ(vector.data()[2], 0xface);
   ASSERT_EQ(vector[3], 0xcafe);
-  ASSERT_EQ(vector.data()[3], 0xcafe);
 }
 
 TEST(DynamicVector, PushBackAndErase) {
@@ -285,11 +382,8 @@
   vector.erase(1);
 
   ASSERT_EQ(vector[0], 0x1337);
-  ASSERT_EQ(vector.data()[0], 0x1337);
   ASSERT_EQ(vector[1], 0xbeef);
-  ASSERT_EQ(vector.data()[1], 0xbeef);
   ASSERT_EQ(vector[2], 0xface);
-  ASSERT_EQ(vector.data()[2], 0xface);
   ASSERT_EQ(vector.size(), 3);
 }
 
@@ -314,8 +408,9 @@
   resetDestructorCounts();
 
   DynamicVector<Dummy> vector;
+  vector.reserve(4);
   for (size_t i = 0; i < 4; ++i) {
-    vector.push_back(Dummy());
+    vector.emplace_back();
     vector[i].setValue(i);
   }
 
@@ -345,8 +440,9 @@
   resetDestructorCounts();
 
   DynamicVector<Dummy> vector;
+  vector.reserve(4);
   for (size_t i = 0; i < 4; ++i) {
-    vector.push_back(Dummy());
+    vector.emplace_back();
     vector[i].setValue(i);
   }
 
@@ -774,3 +870,8 @@
   EXPECT_EQ(vector.size(), 1);
   EXPECT_EQ(vector.capacity(), 2);
 }
+
+TEST(DynamicVector, RidiculouslyHugeReserveFails) {
+  DynamicVector<int> vector;
+  ASSERT_FALSE(vector.reserve(SIZE_MAX));
+}
diff --git a/util/tests/unique_ptr_test.cc b/util/tests/unique_ptr_test.cc
index 0f1dc6d..5d53901 100644
--- a/util/tests/unique_ptr_test.cc
+++ b/util/tests/unique_ptr_test.cc
@@ -3,6 +3,7 @@
 #include "chre/util/unique_ptr.h"
 
 using chre::UniquePtr;
+using chre::MakeUnique;
 
 struct Value {
   Value(int value) : value(value) {
@@ -25,7 +26,7 @@
 int Value::constructionCounter = 0;
 
 TEST(UniquePtr, Construct) {
-  UniquePtr<Value> myInt(0xcafe);
+  UniquePtr<Value> myInt = MakeUnique<Value>(0xcafe);
   ASSERT_FALSE(myInt.isNull());
   EXPECT_EQ(myInt.get()->value, 0xcafe);
   EXPECT_EQ(myInt->value, 0xcafe);
@@ -33,15 +34,25 @@
   EXPECT_EQ(myInt[0].value, 0xcafe);
 }
 
+TEST(UniquePtr, MoveConstruct) {
+  UniquePtr<Value> myInt = MakeUnique<Value>(0xcafe);
+  ASSERT_FALSE(myInt.isNull());
+  Value *value = myInt.get();
+
+  UniquePtr<Value> moved(std::move(myInt));
+  EXPECT_EQ(moved.get(), value);
+  EXPECT_EQ(myInt.get(), nullptr);
+}
+
 TEST(UniquePtr, Move) {
   Value::constructionCounter = 0;
 
   {
-    UniquePtr<Value> myInt(0xcafe);
+    UniquePtr<Value> myInt = MakeUnique<Value>(0xcafe);
     ASSERT_FALSE(myInt.isNull());
     EXPECT_EQ(Value::constructionCounter, 1);
 
-    UniquePtr<Value> myMovedInt(0);
+    UniquePtr<Value> myMovedInt = MakeUnique<Value>(0);
     ASSERT_FALSE(myMovedInt.isNull());
     EXPECT_EQ(Value::constructionCounter, 2);
     myMovedInt = std::move(myInt);
@@ -58,7 +69,7 @@
 
   Value *value1, *value2;
   {
-    UniquePtr<Value> myInt(0xcafe);
+    UniquePtr<Value> myInt = MakeUnique<Value>(0xcafe);
     ASSERT_FALSE(myInt.isNull());
     EXPECT_EQ(Value::constructionCounter, 1);
     value1 = myInt.get();