diff --git a/renderscript/1.0/Android.bp b/renderscript/1.0/Android.bp
new file mode 100644
index 0000000..5ae7027
--- /dev/null
+++ b/renderscript/1.0/Android.bp
@@ -0,0 +1,175 @@
+// This file is autogenerated by hidl-gen. Do not edit manually.
+
+genrule {
+    name: "android.hardware.renderscript@1.0_genc++",
+    tools: ["hidl-gen"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.renderscript@1.0",
+    srcs: [
+        "types.hal",
+        "IContext.hal",
+        "IDevice.hal",
+    ],
+    out: [
+        "android/hardware/renderscript/1.0/types.cpp",
+        "android/hardware/renderscript/1.0/ContextAll.cpp",
+        "android/hardware/renderscript/1.0/DeviceAll.cpp",
+    ],
+}
+
+genrule {
+    name: "android.hardware.renderscript@1.0_genc++_headers",
+    tools: ["hidl-gen"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.renderscript@1.0",
+    srcs: [
+        "types.hal",
+        "IContext.hal",
+        "IDevice.hal",
+    ],
+    out: [
+        "android/hardware/renderscript/1.0/types.h",
+        "android/hardware/renderscript/1.0/IContext.h",
+        "android/hardware/renderscript/1.0/IHwContext.h",
+        "android/hardware/renderscript/1.0/BnHwContext.h",
+        "android/hardware/renderscript/1.0/BpHwContext.h",
+        "android/hardware/renderscript/1.0/BsContext.h",
+        "android/hardware/renderscript/1.0/IDevice.h",
+        "android/hardware/renderscript/1.0/IHwDevice.h",
+        "android/hardware/renderscript/1.0/BnHwDevice.h",
+        "android/hardware/renderscript/1.0/BpHwDevice.h",
+        "android/hardware/renderscript/1.0/BsDevice.h",
+    ],
+}
+
+cc_library_shared {
+    name: "android.hardware.renderscript@1.0",
+    generated_sources: ["android.hardware.renderscript@1.0_genc++"],
+    generated_headers: ["android.hardware.renderscript@1.0_genc++_headers"],
+    export_generated_headers: ["android.hardware.renderscript@1.0_genc++_headers"],
+    shared_libs: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "liblog",
+        "libutils",
+        "libcutils",
+        "android.hidl.base@1.0",
+    ],
+    export_shared_lib_headers: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "libutils",
+        "android.hidl.base@1.0",
+    ],
+}
+
+genrule {
+    name: "android.hardware.renderscript.vts.driver@1.0_genc++",
+    tools: ["hidl-gen", "vtsc"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.renderscript@1.0 && $(location vtsc) -mDRIVER -tSOURCE -b$(genDir) android/hardware/renderscript/1.0/ $(genDir)/android/hardware/renderscript/1.0/",
+    srcs: [
+        "types.hal",
+        "IContext.hal",
+        "IDevice.hal",
+    ],
+    out: [
+        "android/hardware/renderscript/1.0/types.vts.cpp",
+        "android/hardware/renderscript/1.0/Context.vts.cpp",
+        "android/hardware/renderscript/1.0/Device.vts.cpp",
+    ],
+}
+
+genrule {
+    name: "android.hardware.renderscript.vts.driver@1.0_genc++_headers",
+    tools: ["hidl-gen", "vtsc"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.renderscript@1.0 && $(location vtsc) -mDRIVER -tHEADER -b$(genDir) android/hardware/renderscript/1.0/ $(genDir)/android/hardware/renderscript/1.0/",
+    srcs: [
+        "types.hal",
+        "IContext.hal",
+        "IDevice.hal",
+    ],
+    out: [
+        "android/hardware/renderscript/1.0/types.vts.h",
+        "android/hardware/renderscript/1.0/Context.vts.h",
+        "android/hardware/renderscript/1.0/Device.vts.h",
+    ],
+}
+
+cc_library_shared {
+    name: "android.hardware.renderscript.vts.driver@1.0",
+    generated_sources: ["android.hardware.renderscript.vts.driver@1.0_genc++"],
+    generated_headers: ["android.hardware.renderscript.vts.driver@1.0_genc++_headers"],
+    export_generated_headers: ["android.hardware.renderscript.vts.driver@1.0_genc++_headers"],
+    shared_libs: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "liblog",
+        "libutils",
+        "libcutils",
+        "libvts_common",
+        "libvts_datatype",
+        "libvts_measurement",
+        "libvts_multidevice_proto",
+        "libcamera_metadata",
+        "libprotobuf-cpp-full",
+        "android.hidl.base@1.0",
+        "android.hardware.renderscript@1.0",
+    ],
+    export_shared_lib_headers: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "libutils",
+        "android.hidl.base@1.0",
+    ],
+}
+
+genrule {
+    name: "android.hardware.renderscript@1.0-vts.profiler_genc++",
+    tools: ["hidl-gen", "vtsc"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.renderscript@1.0 && $(location vtsc) -mPROFILER -tSOURCE -b$(genDir) android/hardware/renderscript/1.0/ $(genDir)/android/hardware/renderscript/1.0/",
+    srcs: [
+        "types.hal",
+        "IContext.hal",
+        "IDevice.hal",
+    ],
+    out: [
+        "android/hardware/renderscript/1.0/types.vts.cpp",
+        "android/hardware/renderscript/1.0/Context.vts.cpp",
+        "android/hardware/renderscript/1.0/Device.vts.cpp",
+    ],
+}
+
+genrule {
+    name: "android.hardware.renderscript@1.0-vts.profiler_genc++_headers",
+    tools: ["hidl-gen", "vtsc"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.renderscript@1.0 && $(location vtsc) -mPROFILER -tHEADER -b$(genDir) android/hardware/renderscript/1.0/ $(genDir)/android/hardware/renderscript/1.0/",
+    srcs: [
+        "types.hal",
+        "IContext.hal",
+        "IDevice.hal",
+    ],
+    out: [
+        "android/hardware/renderscript/1.0/types.vts.h",
+        "android/hardware/renderscript/1.0/Context.vts.h",
+        "android/hardware/renderscript/1.0/Device.vts.h",
+    ],
+}
+
+cc_library_shared {
+    name: "android.hardware.renderscript@1.0-vts.profiler",
+    generated_sources: ["android.hardware.renderscript@1.0-vts.profiler_genc++"],
+    generated_headers: ["android.hardware.renderscript@1.0-vts.profiler_genc++_headers"],
+    export_generated_headers: ["android.hardware.renderscript@1.0-vts.profiler_genc++_headers"],
+    shared_libs: [
+        "libbase",
+        "libhidlbase",
+        "libhidltransport",
+        "libvts_profiling",
+        "libvts_multidevice_proto",
+        "libprotobuf-cpp-full",
+        "android.hidl.base@1.0",
+        "android.hardware.renderscript@1.0",
+    ],
+}
diff --git a/renderscript/1.0/Android.mk b/renderscript/1.0/Android.mk
new file mode 100644
index 0000000..3a7babd
--- /dev/null
+++ b/renderscript/1.0/Android.mk
@@ -0,0 +1,41 @@
+# This file is autogenerated by hidl-gen. Do not edit manually.
+
+LOCAL_PATH := $(call my-dir)
+
+################################################################################
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.renderscript@1.0-java-constants
+LOCAL_MODULE_CLASS := JAVA_LIBRARIES
+
+intermediates := $(local-generated-sources-dir)
+
+HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
+#
+GEN := $(intermediates)/android/hardware/renderscript/V1_0/Constants.java
+$(GEN): $(HIDL)
+$(GEN): $(LOCAL_PATH)/types.hal
+$(GEN): $(LOCAL_PATH)/IContext.hal
+$(GEN): $(LOCAL_PATH)/IDevice.hal
+
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
+$(GEN): PRIVATE_CUSTOM_TOOL = \
+        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
+        -Ljava-constants \
+        -randroid.hardware:hardware/interfaces \
+        -randroid.hidl:system/libhidl/transport \
+        android.hardware.renderscript@1.0
+
+$(GEN):
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+# Avoid dependency cycle of framework.jar -> this-library -> framework.jar
+LOCAL_NO_STANDARD_LIBRARIES := true
+LOCAL_JAVA_LIBRARIES := core-oj
+
+include $(BUILD_STATIC_JAVA_LIBRARY)
+
+
+
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/renderscript/1.0/IContext.hal b/renderscript/1.0/IContext.hal
new file mode 100644
index 0000000..2e386d2
--- /dev/null
+++ b/renderscript/1.0/IContext.hal
@@ -0,0 +1,1177 @@
+/*
+ * 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.
+ */
+
+package android.hardware.renderscript@1.0;
+
+import android.hardware.renderscript@1.0::types;
+
+// TODO: is there any way to keep this documentation in sync with the
+// corresponding Java doc?
+//
+// TODO: Some of the documentation was taken from Java docs, whereas others were
+// undocumented. Because of this, there's somewhat two different styles of
+// comments. Look into having a consistent convention.
+//
+// TODO: There was some confusion as to why some paramters use vec<> and others
+// use Ptr/Size. The convention is that vec<> is used whenever the paramter is
+// only an input parameter. HIDL is not supposed to include any output
+// parameters, so a more explicit Ptr/Size is used.
+
+interface IContext {
+
+    /*
+     * TODO: Do we need to define "selectors"? It may be a property of the
+     * "adapted allocation" that's returned.
+     *
+     * Creates an arbitrary window into the base allocation. The type describes
+     * the shape of the window. Any dimensions present in the type must be
+     * equal to or smaller than the dimensions in the source allocation. A
+     * dimension present in the allocation that is not present in the type must
+     * be constrained away with the selectors. If a dimension is present in
+     * both the type and allocation, one of two things must happen. If the type
+     * is smaller than the allocation, a window must be created, the selected
+     * value in the adapter for that dimension must act as the base address,
+     * and the type must describe the size of the view starting at that point.
+     * If the type and allocation dimension are of the same size, then setting
+     * the selector for the dimension must be an error.
+     *
+     * @param type Type describing data layout
+     * @param baseAlloc Allocation
+     * @return subAlloc AllocationAdapter
+     */
+    @callflow(next={"*"})
+    allocationAdapterCreate(Type type, Allocation baseAlloc)
+                 generates (AllocationAdapter subAlloc);
+
+    /*
+     * TODO: Need to relate "offset" back to the terminology in
+     * allocationAdapterCreate() -- the latter uses the terms "selector" and
+     * "selected value". Can we use consistent terminology? Are "offset" and
+     * "selector" actually two different things?
+     *
+     * TODO: Explain the flattened layout in the offsets vec
+     *
+     * Sets the offsets for an Allocation Adapter.
+     *
+     * @param alloc AllocationAdapter
+     * @param offsets Collection of offsets
+     */
+    @callflow(next={"*"})
+    allocationAdapterOffset(AllocationAdapter alloc, vec<uint32_t> offsets);
+
+    /*
+     * TODO: add more explanation here.
+     *
+     * Returns the Type of the Allocation.
+     *
+     * @param allocation Allocation
+     * @return type Allocation's Type
+     */
+    @callflow(next={"*"})
+    allocationGetType(Allocation allocation) generates (Type type);
+
+    /*
+     * TODO: more clarification needed describing if the pointer can be aliased
+     * or if the data can outlive the allocation.
+     *
+     * Creates an Allocation for use by scripts with a given Type and a backing
+     * pointer. For use with ALLOCATION_USAGE_SHARED.
+     *
+     * @param type Type describing data layout
+     * @param mips AllocationMipmapControl specifies desired mipmap behavior for
+     *             the allocation
+     * @param usage Bit field specifying how the Allocation is utilized
+     * @param ptr Pointer to client-side data
+     * @return allocation Created Allocation
+     */
+    @callflow(next={"*"})
+    allocationCreateTyped(Type type, AllocationMipmapControl mips,
+                          bitfield<AllocationUsageType> usage, Ptr ptr)
+               generates (Allocation allocation);
+
+    /*
+     * Creates an Allocation from a Bitmap.
+     *
+     * @param type Type describing data layout
+     * @param mips AllocationMipmapControl specifies desired mipmap behavior for
+     *             the allocation
+     * @param bitmap Bitmap source for the allocation data
+     * @param usage Bit field specifying how the Allocation is utilized
+     * @return allocation Created Allocation containing bitmap data
+     */
+    @callflow(next={"*"})
+    allocationCreateFromBitmap(Type type, AllocationMipmapControl mips,
+                               vec<uint8_t> bitmap,
+                               bitfield<AllocationUsageType> usage)
+                    generates (Allocation allocation);
+
+    /*
+     * Creates a Cubemapped Allocation from a Bitmap.
+     *
+     * @param type Type describing data layout
+     * @param mips AllocationMipmapControl specifies desired mipmap behavior
+     *             for the allocation
+     * @param bitmap Bitmap with cubemap faces layed out in the following
+     *               format: right, left, top, bottom, front, back
+     * @param usage Bit field specifying how the Allocation is used
+     * @return allocation Created Allocation containing cubemap data
+     */
+    @callflow(next={"*"})
+    allocationCubeCreateFromBitmap(Type type, AllocationMipmapControl mips,
+                                   vec<uint8_t> bitmap,
+                                   bitfield<AllocationUsageType> usage)
+                        generates (Allocation allocation);
+
+    /*
+     * Returns the handle to a raw buffer that is being managed by the screen
+     * compositor. This operation is only valid for Allocations with
+     * USAGE_IO_INPUT.
+     *
+     * @param allocation Allocation
+     * @return nativeWindow NativeWindow object associated with allocation
+     */
+    @callflow(next={"*"})
+    allocationGetNativeWindow(Allocation allocation)
+                   generates (NativeWindow nativeWindow);
+
+    /*
+     * TODO: more clarification needed
+     *
+     * Sets the NativeWindow of an Allocation. This operation is only valid
+     * for Allocations with USAGE_IO_INPUT.
+     *
+     * @param allocation Allocation to be modified
+     * @pram nativeWindow NativeWindow to associate with allocation
+     */
+    @callflow(next={"*"})
+    allocationSetNativeWindow(Allocation allocation, NativeWindow nativewindow);
+
+    /*
+     * Initialize BufferQueue with specified max number of buffers.
+     *
+     * @param alloc Allocation
+     * @param numBuffer Maximum number of buffers
+     */
+    @callflow(next={"*"})
+    allocationSetupBufferQueue(Allocation alloc, uint32_t numBuffer);
+
+    /*
+     * TODO: clearly define baseAlloc vs subAlloc
+     *
+     * Shares the BufferQueue with another Allocation. Both must be
+     * USAGE_IO_INPUT Allocations.
+     *
+     * @param baseAlloc Base Allocation
+     * @param subAlloc Allocation to use the same buffer queue as the Base
+     *                 Allocation
+     */
+    @callflow(next={"*"})
+    allocationShareBufferQueue(Allocation baseAlloc, Allocation subAlloc);
+
+    /*
+     * Copies from the Allocation into a Bitmap. The bitmap must match the
+     * dimensions of the Allocation.
+     *
+     * HIDL is always running in Passthrough mode for RenderScript, so the
+     * buffer is modified directly by the driver.
+     *
+     * @param allocation Allocation
+     * @param data Buffer to be copied into
+     * @param sizeBytes Size of the buffer pointed to by "data"
+     */
+    @callflow(next={"*"})
+    allocationCopyToBitmap(Allocation allocation, Ptr data, Size sizeBytes);
+
+    /*
+     * TODO: should we consolidate all [123]DWrite functions or [123]DRead
+     * functions into the same API call? Our current plan is to be very similar
+     * to the dispatch table API. How much should we deviate from the original
+     * API?
+     * TODO: better description on Vec3/Vec4 and padding.
+     *
+     * Copies data into a 1D region of this Allocation.
+     *
+     * When this HAL entry is executed, all Vec3 elements have been explicitly
+     * padded as Vec4 elements.
+     *
+     * The size of the region is: count * Element's size.
+     *
+     * @param allocation Allocation to be modified
+     * @param offset The offset of the first element to be copied
+     * @param lod Selected mipmap level of detail
+     * @param count Number of elements to be copied
+     * @param data Source data to be copied to Allocation
+     */
+    @callflow(next={"*"})
+    allocation1DWrite(Allocation allocation, uint32_t offset, uint32_t lod,
+                      uint32_t count, vec<uint8_t> data);
+
+    /*
+     * Copies a value into a single sub-Element of this Allocation.
+     *
+     * @param allocation Allocation to be updated
+     * @param x X position of the first element in the Allocation to be updated
+     * @param y Y position of the first element in the Allocation to be
+     *          updated; for a 1D Allocation, this value must be 0
+     * @param z Z position of the first element in the Allocation to be
+     *          updated; for a 1D or 2D Allocation, this value must be 0
+     * @param lod Selected mipmap level of detail
+     * @param data Data to be copied from
+     * @param compIdx Component number to identify which sub-Element is updated
+     */
+    @callflow(next={"*"})
+    allocationElementWrite(Allocation allocation, uint32_t x, uint32_t y,
+                           uint32_t z, uint32_t lod, vec<uint8_t> data,
+                           Size compIdx);
+
+    /*
+     * Copies from an array into a rectangular region in this Allocation.
+     *
+     * When this HAL entry is executed, all Vec3 elements have been explicitly
+     * padded as Vec4 elements.
+     *
+     * The size of the region is: w * h * Element's size.
+     *
+     * @param allocation Allocation to be modified
+     * @param xoff X offset of the region to update in this Allocation
+     * @param yoff Y offset of the region to update in this Allocation
+     * @param lod Selected mipmap level of detail
+     * @param face AllocationCubemapFace
+     * @param w Width of the region to update
+     * @param h Height of the region to update
+     * @param data Data to be placed into the Allocation
+     * @param stride For 1D Allocation, the stride must be the number of bytes
+     *               of this Allocation. For 2D and 3D Allocations, the stride
+     *               must be the stride in X dimension measuring in bytes.
+     */
+    @callflow(next={"*"})
+    allocation2DWrite(Allocation allocation, uint32_t xoff, uint32_t yoff,
+                      uint32_t lod, AllocationCubemapFace face, uint32_t w,
+                      uint32_t h, vec<uint8_t> data, Size stride);
+
+    /*
+     * Copies from an array into a 3D region in this Allocation.
+     *
+     * When this HAL entry is executed, all Vec3 elements have been explicitly
+     * padded as Vec4 elements.
+     *
+     * The size of the region is: w * h * d * Element's size.
+     *
+     * @param allocation Allocation to be modified
+     * @param xoff X offset of the region to update in this Allocation
+     * @param yoff Y offset of the region to update in this Allocation
+     * @param zoff Z offset of the region to update in this Allocation
+     * @param lod Selected mipmap level of detail
+     * @param w Width of the region to update
+     * @param h Height of the region to update
+     * @param d Depth of the region to update
+     * @param data Data to be placed in the Allocation
+     * @param stride For 1D Allocation, the stride must be the number of bytes
+     *               of this Allocation. For 2D and 3D Allocations, the stride
+     *               must be the stride in X dimension measuring in bytes.
+     */
+    @callflow(next={"*"})
+    allocation3DWrite(Allocation allocation, uint32_t xoff, uint32_t yoff,
+                      uint32_t zoff, uint32_t lod, uint32_t w, uint32_t h,
+                      uint32_t d, vec<uint8_t> data, Size stride);
+
+    /*
+     * Generates a mipmap chain. This is only valid if the Type of the
+     * Allocation includes mipmaps.
+     *
+     * This function generates a complete set of mipmaps from the top level
+     * LOD.
+     *
+     * If the Allocation is also using other memory spaces, a call to
+     * allocationSyncAll(context, allocation, usage) is required.
+     *
+     * @param allocation Allocation which has its top LOD read and lower LOD
+     *                   written to
+     */
+    @callflow(next={"*"})
+    allocationGenerateMipmaps(Allocation allocation);
+
+    /*
+     * Copies all of an Allocation's data into an array.
+     *
+     * All Vec3 elements of an Allocation are padded to be Vec4, so the data
+     * returned by this function automatically includes padding.
+     *
+     * HIDL is always running in Passthrough mode for RenderScript, so the
+     * buffer is modified directly by the driver.
+     *
+     * @param allocation Allocation to be read
+     * @param data Buffer to be copied into
+     * @param sizeBytes Size of the buffer pointed to by "data"
+     */
+    @callflow(next={"*"})
+    allocationRead(Allocation allocation, Ptr data, Size sizeBytes);
+
+    /*
+     * Copies a 1D region of this Allocation into an array.
+     *
+     * All Vec3 elements of an Allocation are padded to be Vec4, so the data
+     * returned by this function automatically includes padding.
+     *
+     * The size of the region is: count * Element's size.
+     *
+     * HIDL is always running in Passthrough mode for RenderScript, so the
+     * buffer is modified directly by the driver.
+     *
+     * @param allocation Allocation to be read
+     * @param xoff X offset of the first element to be copied
+     * @param lod Mipmap level of detail
+     * @param count The number of elements to be copied
+     * @param data Buffer to be copied into
+     * @param sizeBytes Size of the buffer pointed to by "data"
+     */
+    @callflow(next={"*"})
+    allocation1DRead(Allocation allocation, uint32_t xoff, uint32_t lod,
+                     uint32_t count, Ptr data, Size sizeBytes);
+
+    /*
+     * Returns the value of a single sub-Element of this Allocation.
+     *
+     * HIDL is always running in Passthrough mode for RenderScript, so the
+     * buffer is modified directly by the driver.
+     *
+     * @param allocation Allocation to be read
+     * @param x X position of the first element in the Allocation to be read
+     * @param y Y position of the first element in the Allocation to be read
+     * @param z Z position of the first element in the Allocation to be read
+     * @param lod Mipmap level of detail
+     * @param data Buffer to be copied into
+     * @param sizeBytes Size of the buffer pointed to by "data"
+     * @param compIdx Component number to identify which sub-Element is updated
+     */
+    @callflow(next={"*"})
+    allocationElementRead(Allocation allocation, uint32_t x, uint32_t y,
+                          uint32_t z, uint32_t lod, Ptr data, Size sizeBytes,
+                          Size compIdx);
+
+    /*
+     * Copies from a rectangular region in this Allocation to an array.
+     *
+     * All Vec3 elements of an Allocation are padded to be Vec4, so the data
+     * returned by this function automatically includes padding.
+     *
+     * The size of the region is: w * h * Element's size.
+     *
+     * HIDL is always running in Passthrough mode for RenderScript, so the
+     * buffer is modified directly by the driver.
+     *
+     * @param allocation Allocation to be read
+     * @param xoff X offset of the region to copy in this array
+     * @param yoff Y offset of the region to copy in this array
+     * @param lod Mipmap level of detail
+     * @param face AllocationCubemapFace
+     * @param w Width of the region to copy
+     * @param h Height of the region to copy
+     * @param data Buffer to be copied into
+     * @param sizeBytes Size of the buffer pointed to by "data"
+     * @param stride For 1D Allocation, the stride must be the number of bytes
+     *               of this Allocation. For 2D and 3D Allocations, the stride
+     *               must be the stride in X dimension measuring in bytes.
+     */
+    @callflow(next={"*"})
+    allocation2DRead(Allocation allocation, uint32_t xoff, uint32_t yoff,
+                     uint32_t lod, AllocationCubemapFace face, uint32_t w,
+                     uint32_t h, Ptr data, Size sizeBytes, Size stride);
+
+    /*
+     * Copies from a rectangular cuboid region in this Allocation to an array.
+     *
+     * All Vec3 elements of an Allocation are padded to be Vec4, so the data
+     * returned by this function automatically includes padding.
+     *
+     * The size of the region is: w * h * d * Element's size.
+     *
+     * HIDL is always running in Passthrough mode for RenderScript, so the
+     * buffer is modified directly by the driver.
+     *
+     * @param allocation Allocation to be read
+     * @param xoff X offset of the region to copy in this array
+     * @param yoff Y offset of the region to copy in this array
+     * @param zoff Z offset of the region to copy in this array
+     * @param lod Mipmap level of detail
+     * @param w Width of the region to copy
+     * @param h Height of the region to copy
+     * @param d Depth of the region to copy
+     * @param data Buffer to be copied into
+     * @param sizeBytes Size of the buffer pointed to by "data"
+     * @param stride For 1D Allocation, the stride must be the number of bytes
+     *               of this Allocation. For 2D and 3D Allocations, the stride
+     *               must be the stride in X dimension measuring in bytes.
+     */
+    @callflow(next={"*"})
+    allocation3DRead(Allocation allocation, uint32_t xoff, uint32_t yoff,
+                     uint32_t zoff, uint32_t lod, uint32_t w, uint32_t h,
+                     uint32_t d, Ptr data, Size sizeBytes, Size stride);
+
+    /*
+     * Propagates changes from one usage of the Allocation to the other usages
+     * of the Allocation.
+     *
+     * @param allocation First usage of the Allocation
+     * @param usageType Allocation usage type
+     */
+    @callflow(next={"*"})
+    allocationSyncAll(Allocation allocation, AllocationUsageType usageType);
+
+    /*
+     * TODO: describe the functionality of resize1D better
+     * TODO: original Java Doc description seems to contradict itself ("with
+     * null contents and the region is otherwise undefined")
+     * TODO: should "new elements" be "new cells"?
+     * TODO: what does "objects are created" mean?
+     * TODO: what does "new dimension" mean? IS the type of the resized
+     * allocation different than the type before resizing?
+     *
+     * Resizes a 1D allocation. The contents of the allocation are preserved.
+     * If new elements are allocated, objects are created with null contents
+     * and the new region is otherwise undefined.
+     *
+     * If the new region is smaller, the references of any object outside the
+     * new region must be released.
+     *
+     * A new type must be created with the new dimension.
+     *
+     * @param allocation Allocation to be resized
+     * @param dimX New size along the x dimension of the Allocation
+     */
+    @callflow(next={"*"})
+    allocationResize1D(Allocation allocation, uint32_t dimX);
+
+    /*
+     * TODO: There are allocationCopy2DRange and 3DRange, but no 1DRange. Should
+     * the interface be cleaned up more?
+     *
+     * Copies a rectangular region from an Allocation into a rectangular region
+     * in this Allocation.
+     *
+     * @param dstAlloc Allocation to be updated
+     * @param dstXoff X offset of the region to update
+     * @param dstYoff Y offset of the region to update
+     * @param dstMip Selected mipmap level of the Allocation to update
+     * @param dstFace Destination AllocationCubemapFace
+     * @param width Width of the region to update
+     * @param height Height of the region to update
+     * @param srcAlloc Source Allocation, to be read
+     * @param srcXoff X offset of the region in the source Allocation
+     * @param srcYoff Y offset of the region in the source Allocation
+     * @param srcMip Selected mipmap level of the source Allocation
+     * @param srcFace Source AllocationCubemapFace
+     */
+    @callflow(next={"*"})
+    allocationCopy2DRange(Allocation dstAlloc, uint32_t dstXoff,
+                          uint32_t dstYoff, uint32_t dstMip,
+                          AllocationCubemapFace dstFace, uint32_t width,
+                          uint32_t height, Allocation srcAlloc,
+                          uint32_t srcXoff, uint32_t srcYoff, uint32_t srcMip,
+                          AllocationCubemapFace srcFace);
+
+    /*
+     * Copies a rectangular cuboid region into the allocation from another
+     * Allocation.
+     *
+     * @param dstAlloc Allocation to be updated
+     * @param dstXoff X offset of the region to update
+     * @param dstYoff Y offset of the region to update
+     * @param dstZoff Z offset of the region to update
+     * @param dstMip Selected mipmap level of the Allocation to update
+     * @param width Width of the region to update
+     * @param height Height of the region to update
+     * @param depth Depth of the region to update
+     * @param srcAlloc Source Allocation, to be read
+     * @param srcXoff Source X offset of the region in the source Allocation
+     * @param srcYoff Source Y offset of the region in the source Allocation
+     * @param srcZoff Source Z offset of the region in the souce Allocation
+     * @param srcMip Selected mipmap level of the Allocation to read
+     */
+    @callflow(next={"*"})
+    allocationCopy3DRange(Allocation dstAlloc, uint32_t dstXoff,
+                          uint32_t dstYoff, uint32_t dstZoff, uint32_t dstMip,
+                          uint32_t width, uint32_t height, uint32_t depth,
+                          Allocation srcAlloc, uint32_t srcXoff,
+                          uint32_t srcYoff, uint32_t srcZoff, uint32_t srcMip);
+
+    /*
+     * TODO: define buffer and output stream
+     *
+     * Sends a buffer to the output stream. The contents of the Allocation may
+     * be undefined after this operation. This operation is only valid if
+     * USAGE_IO_OUTPUT is set on the Allocation.
+     *
+     * @param allocation Allocation to be sent
+     */
+    @callflow(next={"*"})
+    allocationIoSend(Allocation allocation);
+
+    /*
+     * Receives the latest input into the Allocation. This operation is only
+     * valid if USAGE_IO_INPUT is set on the Allocation, otherwise an error
+     * must be reported and no operations may be executed.
+     *
+     * @param allocation Allocation to be updated
+     */
+    @callflow(next={"*"})
+    allocationIoReceive(Allocation allocation);
+
+    /*
+     * TODO: describe default values for lod, face, and z better.
+     * TODO: what cases can invalidate the pointer? Resize? It should be
+     * clarified that this method should always return a valid pointer, but the
+     * returned pointer might become invalid later.
+     *
+     * Retrieves the pointer to the actual data an Allocation contains as well
+     * as the data's stride.
+     *
+     * If Allocation lacks the corresponding dimension for lod, face, or z, an
+     * error message must be sent to the message queue and nullptr must be
+     * returned for dataPtr and 0 for stride. All missing values must be 0 or
+     * NONE in the corresponding enum.
+     *
+     * @param allocation Allocation
+     * @param lod Mipmap level of detail
+     * @param face AllocationCubemapFace
+     * @param z Z position
+     * @return pointer Pointer to the server-side data; if this points to an
+     *                 invalid location in memory (because the buffer was
+     *                 freed), this may result in undefined behavior
+     * @return stride For 1D Allocation, the stride must be the number of bytes
+     *                of this Allocation. For 2D and 3D Allocations, the stride
+     *                must be the stride in X dimension measuring in bytes.
+     */
+    @callflow(next={"*"})
+    allocationGetPointer(Allocation allocation, uint32_t lod,
+                         AllocationCubemapFace face, uint32_t z)
+              generates (Ptr dataPtr, Size stride);
+
+    /*
+     * Retrieves an Element's metadata from native code.
+     *
+     * @param element Element to be read
+     * @return elemData Element data
+     */
+    @callflow(next={"*"})
+    elementGetNativeMetadata(Element element)
+                  generates (vec<uint32_t> elemData);
+
+    /*
+     * TODO: define Sub-Element handles better.
+     *
+     * Retrieves an Element's sub Elements, specifically their identifiers,
+     * names, and sizes.
+     *
+     * @param element Element to be read
+     * @param numSubElem Number of sub-Elements
+     * @return ids Sub-Element handles
+     * @return names Sub-Element Names
+     * @return arraySizes Sizes of sub-Element arrays
+     */
+    @callflow(next={"*"})
+    elementGetSubElements(Element element, Size numSubElem)
+               generates (vec<Element> ids, vec<string> names,
+                          vec<Size> arraySizes);
+
+    /*
+     * TODO: can normalization flag be removed?
+     *
+     * Creates an Element.
+     *
+     * @param dt Data type
+     * @param dk Data kind
+     * @param norm Flag for normalization
+     * @param size Vector length, with scalar = 1
+     * @return element Created Element
+     */
+    @callflow(next={"*"})
+    elementCreate(DataType dt, DataKind dk, bool norm, uint32_t size)
+       generates (Element element);
+
+    /*
+     * Creates a complex Element.
+     *
+     * @param einsPtr Container of input Elements
+     * @param namesPtr Container of input names
+     * @param arraySizesPtr Container of array sizes
+     * @return element Created Element
+     */
+    @callflow(next={"*"})
+    elementComplexCreate(vec<Element> einsPtr, vec<string> names,
+                         vec<Size> arraySizesPtr)
+              generates (Element element);
+
+    /*
+     * Retrives a Type's metadata from native code.
+     *
+     * @param type Type describing data layout
+     * @return metadata Type's native metadata
+     */
+    @callflow(next={"*"})
+    typeGetNativeMetadata(Type type) generates (vec<OpaqueHandle> metadata);
+
+    /*
+     * Creates a new Type.
+     *
+     * If Type is 1D, Y and Z must be 0. If Type is 2D, Z must be 0.
+     *
+     * @param element Element of the Type
+     * @param dimX X dimension
+     * @param dimY Y dimension
+     * @param dimZ Z dimension
+     * @param mipmaps Flag indicating whether Type has mipmaps
+     * @param faces Flag indicating whether Type has faces
+     * @param yuv Enumeration specifying which type of YUV format, if any, Type
+     *            uses
+     * @return type Created Type
+     */
+    @callflow(next={"*"})
+    typeCreate(Element element, uint32_t dimX, uint32_t dimY, uint32_t dimZ,
+               bool mipmaps, bool faces, YuvFormat yuv)
+    generates (Type type);
+
+    /*
+     * Destroys provided RenderScript context, including all objects created in
+     * this context.
+     */
+    @exit
+    contextDestroy();
+
+    /*
+     * TODO: provide overview of messaging model and figure out if this should
+     * be part of HAL or not.
+     * TODO: what is the "client" for purposes of this interface?
+     * TODO: consider using send/receive to be more similar to other calls
+     * TODO: define the purpose of size more
+     *
+     * Fills the provided buffer with message data. "size" should be at least
+     * as large as the message size. Returns the MessageType and size of the
+     * message are returned.
+     *
+     * @param data A pointer to a buffer to be filled with a message
+     * @param size Size in bytes of the buffer pointed to by "data"
+     * @return messageType Type of message sent to the client
+     * @return receiveLen Length of the message in bytes
+     */
+    @callflow(next={"*"})
+    contextGetMessage(Ptr data, Size size)
+           generates (MessageToClientType messageType, Size receiveLen);
+
+    /*
+     * TODO: define subID better.
+     *
+     * Gets the metadata of a message to ensure entire message can be properly
+     * received. Can be used to determine size of data to allocate when calling
+     * contextGetMessage.
+     *
+     * @return messageType Type of message sent to the client
+     * @return receiveLen Length of message
+     * @return subID Message sub identifier
+     */
+    @callflow(next={"*"})
+    contextPeekMessage()
+            generates (MessageToClientType messageType, Size receiveLen,
+                       uint32_t subID);
+
+    /*
+     * TODO: Define "previous commands" better
+     * TODO: Is the message identifier the same as subID?
+     *
+     * Places a message into the message queue to be sent back to the message
+     * handler once all previous commands have been executed. The message data
+     * is copied into the queue and can be discarded by the client after this
+     * call.
+     *
+     * @param id Message identifier
+     * @param data Message data
+     */
+    @callflow(next={"*"})
+    contextSendMessage(uint32_t id, vec<uint8_t> data);
+
+    /*
+     * TODO: Can this be done automatically as part of context creation? What
+     * happens if we perform message operations before doing this?
+     *
+     * Initializes the messaging thread, so that the front-end API can receive
+     * messages from the driver. This call also waits for the messaging FIFO to
+     * start up.
+     */
+    @callflow(next={"*"})
+    contextInitToClient();
+
+    /*
+     * TODO: Why doesn't this happen automatically as part of context
+     * destruction? What happens if the FIFO is not empty?
+     *
+     * Deinitializes a the messaging thread. Shuts down the FIFO.
+     */
+    @callflow(next={"*"})
+    contextDeinitToClient();
+
+    /*
+     * TODO: do we need to mark asynchronous operations in this interface
+     * definition?
+     *
+     * Waits for any pending asynchronous operations (such as copies to a RS
+     * allocation or RS script executions) to complete.
+     */
+    @callflow(next={"*"})
+    contextFinish();
+
+    /*
+     * Prints the currently available debugging information about the state of
+     * the RS context to the logcat.
+     */
+    @callflow(next={"*"})
+    contextLog();
+
+    /*
+     * TODO: full path? relative path? Investigate further.
+     *
+     * Sets the cache directory of the context.
+     *
+     * @param cacheDir Name of the application's cache directory
+     */
+    @callflow(next={"*"})
+    contextSetCacheDir(string cacheDir);
+
+    /*
+     * TODO: does this apply to the GPU as well?
+     *
+     * Changes the priority of the cpu worker threads for this context.
+     *
+     * @param priority Priority of the thread
+     */
+    @callflow(next={"*"})
+    contextSetPriority(ThreadPriorities priority);
+
+    /*
+     * TODO: does this need to be part of the HAL? What if the object already
+     * has a name?
+     *
+     * Assigns a name to a base object.
+     *
+     * @param obj Object to be named
+     * @param name Assigned name
+     */
+    @callflow(next={"*"})
+    assignName(ObjectBase obj, string name);
+
+    /*
+     * TODO: what if the object has no name?
+     *
+     * Returns the name of an object.
+     *
+     * @param obj Object to be read
+     * @return name Name of the object
+     */
+    @callflow(next={"*"})
+    getName(ObjectBase obj) generates (string name);
+
+    /*
+     * TODO: starting here we have a set of interfaces for use with
+     * ScriptGroups. At the very least we should indicate for each one that's
+     * what it's for. Should we include ScriptGroup in the interface names?
+     * TODO: sweep whole file and remove prefix "v" from all parameter names
+     * TODO: there are some places where we use Size for size, and others where
+     * we use int32_t. Is there a reason it's int32_t? In some cases, it
+     * requires a negative value.
+     *
+     * Creates a Closure which represents a function call to a ForEach Kernel
+     * combined with arguments and values for global variables.
+     *
+     * @param kernelID Kernel identifier
+     * @param returnValue Allocation used in output of Closure
+     * @param fieldIDS Collection of Script's Field identifiers
+     * @param values Collection of Script's data values
+     * @param sizes Collection of Script's data sizes
+     * @param depClosures Collection of Closures
+     * @param depFieldIDS Collection of Script's dependent Field identifiers
+     * @return closure Created Closure
+     */
+    @callflow(next={"*"})
+    closureCreate(ScriptKernelID kernelID, Allocation returnValue,
+                  vec<ScriptFieldID> fieldIDS, vec<int64_t> values,
+                  vec<int32_t> sizes, vec<Closure> depClosures,
+                  vec<ScriptFieldID> depFieldIDS)
+       generates (Closure closure);
+
+    /*
+     * Creates a Closure which represents a function call to a invocable
+     * function, combined with arguments and values for global variables.
+     *
+     * @param invokeID Invokable function identifier
+     * @param params Collection of Invoke script parameters
+     * @param fieldIDS Collection of Script Field identifiers
+     * @param values Collection of values
+     * @param sizes Collection of sizes
+     * @return closure Created Closure
+     */
+    @callflow(next={"*"})
+    invokeClosureCreate(ScriptInvokeID invokeID, vec<uint8_t> params,
+                        vec<ScriptFieldID> fieldIDS, vec<int64_t> values,
+                        vec<int32_t> sizes)
+             generates (Closure closure);
+
+    /*
+     * Sets the argument of a Closure at specified index and size to provided
+     * value.
+     *
+     * @param closure Closure to be modified
+     * @param index Index
+     * @param value Value
+     * @param size Size
+     */
+    @callflow(next={"*"})
+    closureSetArg(Closure closure, uint32_t index, Ptr value, int32_t size);
+
+    /*
+     * Sets a global variable in a Closure.
+     *
+     * @param closure Closure
+     * @param fieldID Global's Field identifier
+     * @param value Value
+     * @param size Size
+     */
+    @callflow(next={"*"})
+    closureSetGlobal(Closure closure, ScriptFieldID fieldID, int64_t value,
+                     int32_t size);
+
+    /*
+     * TODO: should slot be unsigned? (applies to other two ID interfaces, too)
+     *
+     * Creates a Script Kernel ID.
+     *
+     * @param script Script
+     * @param slot Slot
+     * @param sig Bitfield describing Kernel signature and operation
+     * @return scriptKernelID Script's Kernel identifier
+     */
+    @callflow(next={"*"})
+    scriptKernelIDCreate(Script script, int32_t slot,
+                         bitfield<MetadataSignatureBitval> sig)
+              generates (ScriptKernelID scriptKernelID);
+
+    /*
+     * Creates a Script Invoke ID.
+     *
+     * @param script Script
+     * @param slot Slot
+     * @return scriptInvokeID Invoke Script's identifier
+     */
+    @callflow(next={"*"})
+    scriptInvokeIDCreate(Script script, int32_t slot)
+              generates (ScriptInvokeID scriptInvokeID);
+
+    /*
+     * TODO: describe the return value better. What is it?
+     *
+     * Creates a Script Field ID.
+     *
+     * @param script Script
+     * @param slot Slot
+     * @return scriptFieldID Script's Field identifier
+     */
+    @callflow(next={"*"})
+    scriptFieldIDCreate(Script script, int32_t slot)
+             generates (ScriptFieldID scriptFieldID);
+
+    /*
+     * TODO: add more description
+     *
+     * Creates a Script Group.
+     *
+     * @param kernels Collection of Scripts' Kernel identifiers
+     * @param srcK Source Kernel identifiers
+     * @param dstK Destination Kernel identifiers
+     * @param dstF Destination Script Field identifiers
+     * @param types Collection of Types describing data layout
+     * @return scriptGroup Created Script Group
+     */
+    @callflow(next={"*"})
+    scriptGroupCreate(vec<ScriptKernelID> kernels, vec<ScriptKernelID> srcK,
+                      vec<ScriptKernelID> dstK, vec<ScriptFieldID> dstF,
+                      vec<Type> types)
+           generates (ScriptGroup scriptGroup);
+
+    /*
+     * Creates a Script Group.
+     *
+     * @param name Name
+     * @param cacheDir Cache directory
+     * @param closures Collection of Closures
+     * @return scriptGroup2 Created Script Group
+     */
+    @callflow(next={"*"})
+    scriptGroup2Create(string name, string cacheDir, vec<Closure> closures)
+            generates (ScriptGroup2 scriptGroup2);
+
+    /*
+     * TODO: if SetInput/Output corresponds to the Java API setInput() and
+     * setOutput(), which are documented as deprecated in API 23, do we need to
+     * support them? Or can we fallback to the CPU when they're used? Or can't
+     * we tell whether they're used early enough to do fallback?
+     *
+     * Sets an output of the ScriptGroup. This specifies an Allocation to be
+     * used for the kernels that require an output Allocation visible after the
+     * ScriptGroup is executed.
+     *
+     * @param sg Script Group
+     * @param kid Script's Kernel identifier to be changed
+     * @param alloc Allocation to be filled by output
+     */
+    @callflow(next={"*"})
+    scriptGroupSetOutput(ScriptGroup sg, ScriptKernelID kid, Allocation alloc);
+
+    /*
+     * Sets an input of the Script Group. This specifies an Allocation to be
+     * used for kernels that require an input Allocation provided from outside
+     * of the Script Group.
+     *
+     * @param sg Script Group
+     * @param kid Script's Kernel identifier to be changed
+     * @param alloc Allocation to be read as input
+     */
+    @callflow(next={"*"})
+    scriptGroupSetInput(ScriptGroup sg, ScriptKernelID kid, Allocation alloc);
+
+    /*
+     * Executes a Script Group.
+     *
+     * @param sg Script Group to be executed.
+     */
+    @callflow(next={"*"})
+    scriptGroupExecute( ScriptGroup sg);
+
+    /*
+     * Frees any native resources associated with this object. The primary use
+     * is to force immediate cleanup of resources when it is believed the GC
+     * may not respond quickly enough.
+     *
+     * @param handle Opaque handle to the server-side object to be destroyed
+     */
+    @callflow(next={"*"})
+    objDestroy(ObjectBase obj);
+
+    /*
+     * Creates a Sampler.
+     *
+     * @param magFilter Magnification value for the filter
+     * @param minFilter Minification value for the filter
+     * @param wrapS S wrapping mode for the sampler
+     * @param wrapT T wrapping mode for the sampler
+     * @param wrapR R wrapping mode for the sampler
+     * @param aniso Anisotropy setting for the sampler
+     * @return sampler Created Sampler
+     */
+    @callflow(next={"*"})
+    samplerCreate(SamplerValue magFilter, SamplerValue minFilter,
+                  SamplerValue wrapS, SamplerValue wrapT, SamplerValue wrapR,
+                  float aniso)
+       generates (Sampler sampler);
+
+    /*
+     * Binds an Allocation to a global pointer in the Script.
+     *
+     * @param script Script to be bound to
+     * @param allocation Allocation to be bound
+     * @param slot Slot of a global variable
+     */
+    @callflow(next={"*"})
+    scriptBindAllocation(Script script, Allocation allocation, uint32_t slot);
+
+    /*
+     * TODO: is this necessary?
+     *
+     * Sets the timezone of a Script.
+     *
+     * @param script Script to be altered
+     * @param timeZone Time Zone value as text
+     */
+    @callflow(next={"*"})
+    scriptSetTimeZone(Script script, string timeZone);
+
+    /*
+     * TODO: can scriptInvoke be combined with scriptInvokeV?
+     *
+     * Launches an invokable function.
+     *
+     * @param vs Script to be invoked
+     * @param slot Slot of invokable function
+     */
+    @callflow(next={"*"})
+    scriptInvoke(Script vs, uint32_t slot);
+
+    /*
+     * Invokes a Script with values.
+     *
+     * @param vs Script to be invoked
+     * @param slot Slot
+     * @param data Data buffer of packed arguments
+     */
+    @callflow(next={"*"})
+    scriptInvokeV(Script vs, uint32_t slot, vec<uint8_t> data);
+
+    /*
+     * TODO: add documentation for params
+     * TODO: Should we rename "ScriptCall" to "LaunchOptions"?
+     *
+     * Launches a ForEach kernel.
+     *
+     * @param vs Script
+     * @param slot Slot of ForEach Kernel
+     * @param vains Collection of input Allocations or null
+     * @param vaout Output Allocation or null
+     * @param params Collection of parameters
+     * @param sc Pointer to a ScriptCall, nullptr if unused
+     */
+    @callflow(next={"*"})
+    scriptForEach(Script vs, uint32_t slot, vec<Allocation> vains,
+                  Allocation vaout, vec<uint8_t> params, Ptr sc);
+
+    /*
+     * Launches a Reduction kernel.
+     *
+     * @param vs Script
+     * @param slot Slot of Reduction Kernel
+     * @param vains Collection of input Allocations
+     * @param vaout Output Allocation
+     * @param sc Pointer to a ScriptCall, nullptr if unused
+     */
+    @callflow(next={"*"})
+    scriptReduce(Script vs, uint32_t slot, vec<Allocation> vains,
+                 Allocation vaout, Ptr sc);
+
+    /*
+     * Sets a Script's integer variable to a value.
+     *
+     * @param vs RenderScript Script
+     * @param slot Slot number of variable to be updated
+     * @param value Value to be pushed to variable
+     */
+    @callflow(next={"*"})
+    scriptSetVarI(Script vs, uint32_t slot, int32_t value);
+
+    /*
+     * Sets a Script's Object variable to a value
+     *
+     * @param vs RenderScript Script
+     * @param slot Slot number of variable to be updated
+     * @param obj ObjectBase
+     */
+    @callflow(next={"*"})
+    scriptSetVarObj( Script vs,  uint32_t slot, ObjectBase obj);
+
+    /*
+     * Sets a Script's long variable to a value.
+     *
+     * @param vs RenderScript Script
+     * @param slot Slot number of variable to be updated
+     * @param value Value to be pushed to variable
+     */
+    @callflow(next={"*"})
+    scriptSetVarJ(Script vs, uint32_t slot, int64_t value);
+
+    /*
+     * Sets a Script's float variable to a value.
+     *
+     * @param vs RenderScript Script
+     * @param slot Slot number of variable to be updated
+     * @param value Value to be pushed to variable
+     */
+    @callflow(next={"*"})
+    scriptSetVarF(Script vs, uint32_t slot, float value);
+
+    /*
+     * Sets a Script's double variable to a value.
+     *
+     * @param vs RenderScript Script
+     * @param slot Slot number of variable to be updated
+     * @param value Value to be pushed to variable
+     */
+    @callflow(next={"*"})
+    scriptSetVarD(Script vs, uint32_t slot, double value);
+
+    /*
+     * Sets a Script's struct variable to a value.
+     *
+     * @param vs RenderScript Script
+     * @param slot Slot number of variable to be updated
+     * @param data Data to be pushed to variable
+     */
+    @callflow(next={"*"})
+    scriptSetVarV(Script vs, uint32_t slot, vec<uint8_t> data);
+
+    /*
+     * TODO: Why do we have typed setters but only untyped getter?
+     *
+     * Retrieves the value from a global variable in a script.
+     *
+     * @param vs RenderScript Script
+     * @param slot Slot number of variable to be read
+     * @param len Size of data to be filled
+     * @return data Data to be updated
+     */
+    @callflow(next={"*"})
+    scriptGetVarV(Script vs, uint32_t slot, Size len)
+       generates (vec<uint8_t> data);
+
+    /*
+     * TODO: Is this a value to be replicated for each member of the array? Or
+     * is there a representation for each separate member?
+     *
+     * Sets the value of a global array of structs, given the Element and
+     * dimension.
+     *
+     * @param vs RenderScript Script
+     * @param slot Slot number of variable to be updated
+     * @param data Data
+     * @param ve Element
+     * @param dims Collection of dimensions
+     */
+    @callflow(next={"*"})
+    scriptSetVarVE(Script vs, uint32_t slot, vec<uint8_t> data, Element ve,
+                   vec<uint32_t> dims);
+
+    /*
+     * TODO: is cacheDir redundant with createCache() function? Can we remove
+     * it?
+     * TODO: define resName more clearly
+     *
+     * Creates a RenderScript C99 kernel script.
+     *
+     * @param resName Resource name of the bitcode
+     * @param cacheDir Cache directory name
+     * @param text The kernel's bitcode as a uint8_t vector
+     * @return script Created Script
+     */
+    @callflow(next={"*"})
+    scriptCCreate(string resName, string cacheDir, vec<uint8_t> text)
+       generates (Script script);
+
+    /*
+     * Creates a RenderScript Intrinsic script.
+     *
+     * @param id Intrinsic Script identifier
+     * @param elem Element
+     * @return script Created Script
+     */
+    @callflow(next={"*"})
+    scriptIntrinsicCreate(ScriptIntrinsicID id, Element elem)
+               generates (Script script);
+
+};
diff --git a/renderscript/1.0/IDevice.hal b/renderscript/1.0/IDevice.hal
new file mode 100644
index 0000000..7b1b866
--- /dev/null
+++ b/renderscript/1.0/IDevice.hal
@@ -0,0 +1,38 @@
+/*
+ * 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.
+ */
+
+package android.hardware.renderscript@1.0;
+
+import android.hardware.renderscript@1.0::types;
+import IContext;
+
+interface IDevice {
+
+    /*
+     * Creates a RenderScript context.
+     *
+     * @param sdkVersion Target RS API level
+     * @param ct Context type
+     * @param flags Optional flags for this context
+     * @return context Created context
+     */
+    @entry
+    @callflow(next={"*"})
+    contextCreate(uint32_t sdkVersion, ContextType ct,
+                  bitfield<ContextFlags> flags)
+       generates (IContext context);
+
+};
diff --git a/renderscript/1.0/default/Android.bp b/renderscript/1.0/default/Android.bp
new file mode 100644
index 0000000..348f6af
--- /dev/null
+++ b/renderscript/1.0/default/Android.bp
@@ -0,0 +1,22 @@
+cc_library_shared {
+    name: "android.hardware.renderscript@1.0-impl",
+    relative_install_path: "hw",
+    proprietary: true,
+    srcs: [
+        "Context.cpp",
+        "Device.cpp",
+    ],
+    include_dirs: [
+        "frameworks/rs",
+    ],
+    shared_libs: [
+        "libdl",
+        "liblog",
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "libutils",
+        "android.hardware.renderscript@1.0",
+        "android.hidl.base@1.0",
+    ],
+}
diff --git a/renderscript/1.0/default/Context.cpp b/renderscript/1.0/default/Context.cpp
new file mode 100644
index 0000000..5a09cf9
--- /dev/null
+++ b/renderscript/1.0/default/Context.cpp
@@ -0,0 +1,757 @@
+#define LOG_TAG "android.hardware.renderscript@1.0-impl"
+
+#include "Context.h"
+#include "Device.h"
+
+namespace android {
+namespace hardware {
+namespace renderscript {
+namespace V1_0 {
+namespace implementation {
+
+
+Context::Context(uint32_t sdkVersion, ContextType ct, int32_t flags) {
+    RsDevice _dev = nullptr;
+    uint32_t _version = 0;
+    uint32_t _sdkVersion = sdkVersion;
+    RsContextType _ct = static_cast<RsContextType>(ct);
+    int32_t _flags = flags;
+    mContext = Device::getHal().ContextCreate(_dev, _version, _sdkVersion, _ct, _flags);
+}
+
+
+// Helper functions
+template<typename ReturnType>
+static ReturnType hidl_to_rs(OpaqueHandle src) {
+    return reinterpret_cast<ReturnType>(static_cast<uintptr_t>(src));
+}
+
+template<typename ReturnType, typename SourceType>
+static ReturnType hidl_to_rs(SourceType* src) {
+    return reinterpret_cast<ReturnType>(src);
+}
+
+template<typename RsType, typename HidlType, typename Operation>
+static std::vector<RsType> hidl_to_rs(const hidl_vec<HidlType>& src, Operation operation) {
+    std::vector<RsType> dst(src.size());
+    std::transform(src.begin(), src.end(), dst.begin(), operation);
+    return dst;
+}
+
+template<typename ReturnType, typename SourceType>
+static ReturnType rs_to_hidl(SourceType* src) {
+    return static_cast<ReturnType>(reinterpret_cast<uintptr_t>(src));
+}
+
+template<typename HidlType, typename RsType, typename Operation>
+static hidl_vec<HidlType> rs_to_hidl(const std::vector<RsType>& src, Operation operation) {
+    std::vector<HidlType> dst(src.size());
+    std::transform(src.begin(), src.end(), dst.begin(), operation);
+    return dst;
+}
+
+
+// Methods from ::android::hardware::renderscript::V1_0::IContext follow.
+
+Return<Allocation> Context::allocationAdapterCreate(Type type, Allocation baseAlloc) {
+    RsType _type = hidl_to_rs<RsType>(type);
+    RsAllocation _baseAlloc = hidl_to_rs<RsAllocation>(baseAlloc);
+    RsAllocation _subAlloc = Device::getHal().AllocationAdapterCreate(mContext, _type, _baseAlloc);
+    return rs_to_hidl<Allocation>(_subAlloc);
+}
+
+Return<void> Context::allocationAdapterOffset(Allocation alloc, const hidl_vec<uint32_t>& offsets) {
+    RsAllocation _alloc = hidl_to_rs<RsAllocation>(alloc);
+    const hidl_vec<uint32_t>& _offsets = offsets;
+    Device::getHal().AllocationAdapterOffset(mContext, _alloc, _offsets.data(), _offsets.size());
+    return Void();
+}
+
+Return<Type> Context::allocationGetType(Allocation allocation) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    const void* _type = Device::getHal().AllocationGetType(mContext, _allocation);
+    return rs_to_hidl<Type>(_type);
+}
+
+Return<Allocation> Context::allocationCreateTyped(Type type, AllocationMipmapControl mips, int32_t usage, Ptr ptr) {
+    RsType _type = hidl_to_rs<RsType>(type);
+    RsAllocationMipmapControl _mips = static_cast<RsAllocationMipmapControl>(mips);
+    uint32_t _usage = usage;
+    uintptr_t _ptr = hidl_to_rs<uintptr_t>(ptr);
+    RsAllocation _allocation = Device::getHal().AllocationCreateTyped(mContext, _type, _mips, _usage, _ptr);
+    return rs_to_hidl<Allocation>(_allocation);
+}
+
+Return<Allocation> Context::allocationCreateFromBitmap(Type type, AllocationMipmapControl mips, const hidl_vec<uint8_t>& bitmap, int32_t usage) {
+    RsType _type = hidl_to_rs<RsType>(type);
+    RsAllocationMipmapControl _mips = static_cast<RsAllocationMipmapControl>(mips);
+    const hidl_vec<uint8_t>& _bitmap = bitmap;
+    uint32_t _usage = usage;
+    RsAllocation _allocation = Device::getHal().AllocationCreateFromBitmap(mContext, _type, _mips, _bitmap.data(), _bitmap.size(), _usage);
+    return rs_to_hidl<Allocation>(_allocation);
+}
+
+Return<Allocation> Context::allocationCubeCreateFromBitmap(Type type, AllocationMipmapControl mips, const hidl_vec<uint8_t>& bitmap, int32_t usage) {
+    RsType _type = hidl_to_rs<RsType>(type);
+    RsAllocationMipmapControl _mips = static_cast<RsAllocationMipmapControl>(mips);
+    const hidl_vec<uint8_t>& _bitmap = bitmap;
+    uint32_t _usage = usage;
+    RsAllocation _allocation = Device::getHal().AllocationCubeCreateFromBitmap(mContext, _type, _mips, _bitmap.data(), _bitmap.size(), _usage);
+    return rs_to_hidl<Allocation>(_allocation);
+}
+
+Return<NativeWindow> Context::allocationGetNativeWindow(Allocation allocation) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    RsNativeWindow _nativeWindow = Device::getHal().AllocationGetSurface(mContext, _allocation);
+    return rs_to_hidl<NativeWindow>(_nativeWindow);
+}
+
+Return<void> Context::allocationSetNativeWindow(Allocation allocation, NativeWindow nativewindow) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    RsNativeWindow _nativewindow = hidl_to_rs<RsNativeWindow>(nativewindow);
+    Device::getHal().AllocationSetSurface(mContext, _allocation, _nativewindow);
+    return Void();
+}
+
+Return<void> Context::allocationSetupBufferQueue(Allocation alloc, uint32_t numBuffer) {
+    RsAllocation _alloc = hidl_to_rs<RsAllocation>(alloc);
+    uint32_t _numBuffer = numBuffer;
+    Device::getHal().AllocationSetupBufferQueue(mContext, _alloc, _numBuffer);
+    return Void();
+}
+
+Return<void> Context::allocationShareBufferQueue(Allocation baseAlloc, Allocation subAlloc) {
+    RsAllocation _baseAlloc = hidl_to_rs<RsAllocation>(baseAlloc);
+    RsAllocation _subAlloc = hidl_to_rs<RsAllocation>(subAlloc);
+    Device::getHal().AllocationShareBufferQueue(mContext, _baseAlloc, _subAlloc);
+    return Void();
+}
+
+Return<void> Context::allocationCopyToBitmap(Allocation allocation, Ptr data, Size sizeBytes) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    void* _data = hidl_to_rs<void*>(data);
+    size_t _sizeBytes = static_cast<size_t>(sizeBytes);
+    Device::getHal().AllocationCopyToBitmap(mContext, _allocation, _data, _sizeBytes);
+    return Void();
+}
+
+Return<void> Context::allocation1DWrite(Allocation allocation, uint32_t offset, uint32_t lod, uint32_t count, const hidl_vec<uint8_t>& data) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    uint32_t _offset = offset;
+    uint32_t _lod = lod;
+    uint32_t _count = count;
+    const void* _dataPtr = hidl_to_rs<const void*>(data.data());
+    size_t _sizeBytes = data.size();
+    Device::getHal().Allocation1DData(mContext, _allocation, _offset, _lod, _count, _dataPtr, _sizeBytes);
+    return Void();
+}
+
+Return<void> Context::allocationElementWrite(Allocation allocation, uint32_t x, uint32_t y, uint32_t z, uint32_t lod, const hidl_vec<uint8_t>& data, Size compIdx) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    uint32_t _x = x;
+    uint32_t _y = y;
+    uint32_t _z = z;
+    uint32_t _lod = lod;
+    const void* _dataPtr = hidl_to_rs<const void*>(data.data());
+    size_t _sizeBytes = data.size();
+    size_t _compIdx = static_cast<size_t>(compIdx);
+    Device::getHal().AllocationElementData(mContext, _allocation, _x, _y, _z, _lod, _dataPtr, _sizeBytes, _compIdx);
+    return Void();
+}
+
+Return<void> Context::allocation2DWrite(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t lod, AllocationCubemapFace face, uint32_t w, uint32_t h, const hidl_vec<uint8_t>& data, Size stride) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    uint32_t _xoff = xoff;
+    uint32_t _yoff = yoff;
+    uint32_t _lod = lod;
+    RsAllocationCubemapFace _face = static_cast<RsAllocationCubemapFace>(face);
+    uint32_t _w = w;
+    uint32_t _h = h;
+    const void* _dataPtr = hidl_to_rs<const void*>(data.data());
+    size_t _sizeBytes = data.size();
+    size_t _stride = static_cast<size_t>(stride);
+    Device::getHal().Allocation2DData(mContext, _allocation, _xoff, _yoff, _lod, _face, _w, _h, _dataPtr, _sizeBytes, _stride);
+    return Void();
+}
+
+Return<void> Context::allocation3DWrite(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod, uint32_t w, uint32_t h, uint32_t d, const hidl_vec<uint8_t>& data, Size stride) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    uint32_t _xoff = xoff;
+    uint32_t _yoff = yoff;
+    uint32_t _zoff = zoff;
+    uint32_t _lod = lod;
+    uint32_t _w = w;
+    uint32_t _h = h;
+    uint32_t _d = d;
+    const void* _dataPtr = hidl_to_rs<const void*>(data.data());
+    size_t _sizeBytes = data.size();
+    size_t _stride = static_cast<size_t>(stride);
+    Device::getHal().Allocation3DData(mContext, _allocation, _xoff, _yoff, _zoff, _lod, _w, _h, _d, _dataPtr, _sizeBytes, _stride);
+    return Void();
+}
+
+Return<void> Context::allocationGenerateMipmaps(Allocation allocation) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    Device::getHal().AllocationGenerateMipmaps(mContext, _allocation);
+    return Void();
+}
+
+Return<void> Context::allocationRead(Allocation allocation, Ptr data, Size sizeBytes) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    void* _data = hidl_to_rs<void*>(data);
+    size_t _sizeBytes = static_cast<size_t>(sizeBytes);
+    Device::getHal().AllocationRead(mContext, _allocation, _data, _sizeBytes);
+    return Void();
+}
+
+Return<void> Context::allocation1DRead(Allocation allocation, uint32_t xoff, uint32_t lod, uint32_t count, Ptr data, Size sizeBytes) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    uint32_t _xoff = xoff;
+    uint32_t _lod = lod;
+    uint32_t _count = count;
+    void* _data = hidl_to_rs<void*>(data);
+    size_t _sizeBytes = static_cast<size_t>(sizeBytes);
+    Device::getHal().Allocation1DRead(mContext, _allocation, _xoff, _lod, _count, _data, _sizeBytes);
+    return Void();
+}
+
+Return<void> Context::allocationElementRead(Allocation allocation, uint32_t x, uint32_t y, uint32_t z, uint32_t lod, Ptr data, Size sizeBytes, Size compIdx) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    uint32_t _x = x;
+    uint32_t _y = y;
+    uint32_t _z = z;
+    uint32_t _lod = lod;
+    void* _data = hidl_to_rs<void*>(data);
+    size_t _sizeBytes = static_cast<size_t>(sizeBytes);
+    size_t _compIdx = static_cast<size_t>(compIdx);
+    Device::getHal().AllocationElementRead(mContext, _allocation, _x, _y, _z, _lod, _data, _sizeBytes, _compIdx);
+    return Void();
+}
+
+Return<void> Context::allocation2DRead(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t lod, AllocationCubemapFace face, uint32_t w, uint32_t h, Ptr data, Size sizeBytes, Size stride) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    uint32_t _xoff = xoff;
+    uint32_t _yoff = yoff;
+    uint32_t _lod = lod;
+    RsAllocationCubemapFace _face = static_cast<RsAllocationCubemapFace>(face);
+    uint32_t _w = w;
+    uint32_t _h = h;
+    void* _data = hidl_to_rs<void*>(data);
+    size_t _sizeBytes = static_cast<size_t>(sizeBytes);
+    size_t _stride = static_cast<size_t>(stride);
+    Device::getHal().Allocation2DRead(mContext, _allocation, _xoff, _yoff, _lod, _face, _w, _h, _data, _sizeBytes, _stride);
+    return Void();
+}
+
+Return<void> Context::allocation3DRead(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod, uint32_t w, uint32_t h, uint32_t d, Ptr data, Size sizeBytes, Size stride) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    uint32_t _xoff = xoff;
+    uint32_t _yoff = yoff;
+    uint32_t _zoff = zoff;
+    uint32_t _lod = lod;
+    uint32_t _w = w;
+    uint32_t _h = h;
+    uint32_t _d = d;
+    void* _dataPtr = hidl_to_rs<void*>(data);
+    size_t _sizeBytes = static_cast<size_t>(sizeBytes);
+    size_t _stride = static_cast<size_t>(stride);
+    Device::getHal().Allocation3DRead(mContext, _allocation, _xoff, _yoff, _zoff, _lod, _w, _h, _d, _dataPtr, _sizeBytes, _stride);
+    return Void();
+}
+
+Return<void> Context::allocationSyncAll(Allocation allocation, AllocationUsageType usageType) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    RsAllocationUsageType _usageType = static_cast<RsAllocationUsageType>(usageType);
+    Device::getHal().AllocationSyncAll(mContext, _allocation, _usageType);
+    return Void();
+}
+
+Return<void> Context::allocationResize1D(Allocation allocation, uint32_t dimX) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    uint32_t _dimX = dimX;
+    Device::getHal().AllocationResize1D(mContext, _allocation, _dimX);
+    return Void();
+}
+
+Return<void> Context::allocationCopy2DRange(Allocation dstAlloc, uint32_t dstXoff, uint32_t dstYoff, uint32_t dstMip, AllocationCubemapFace dstFace, uint32_t width, uint32_t height, Allocation srcAlloc, uint32_t srcXoff, uint32_t srcYoff, uint32_t srcMip, AllocationCubemapFace srcFace) {
+    RsAllocation _dstAlloc = hidl_to_rs<RsAllocation>(dstAlloc);
+    uint32_t _dstXoff = dstXoff;
+    uint32_t _dstYoff = dstYoff;
+    uint32_t _dstMip = dstMip;
+    RsAllocationCubemapFace _dstFace = static_cast<RsAllocationCubemapFace>(dstFace);
+    uint32_t _width = width;
+    uint32_t _height = height;
+    RsAllocation _srcAlloc = hidl_to_rs<RsAllocation>(srcAlloc);
+    uint32_t _srcXoff = srcXoff;
+    uint32_t _srcYoff = srcYoff;
+    uint32_t _srcMip = srcMip;
+    RsAllocationCubemapFace _srcFace = static_cast<RsAllocationCubemapFace>(srcFace);
+    Device::getHal().AllocationCopy2DRange(mContext, _dstAlloc, _dstXoff, _dstYoff, _dstMip, _dstFace, _width, _height, _srcAlloc, _srcXoff, _srcYoff, _srcMip, _srcFace);
+    return Void();
+}
+
+Return<void> Context::allocationCopy3DRange(Allocation dstAlloc, uint32_t dstXoff, uint32_t dstYoff, uint32_t dstZoff, uint32_t dstMip, uint32_t width, uint32_t height, uint32_t depth, Allocation srcAlloc, uint32_t srcXoff, uint32_t srcYoff, uint32_t srcZoff, uint32_t srcMip) {
+    RsAllocation _dstAlloc = hidl_to_rs<RsAllocation>(dstAlloc);
+    uint32_t _dstXoff = dstXoff;
+    uint32_t _dstYoff = dstYoff;
+    uint32_t _dstZoff = dstZoff;
+    uint32_t _dstMip = dstMip;
+    uint32_t _width = width;
+    uint32_t _height = height;
+    uint32_t _depth = depth;
+    RsAllocation _srcAlloc = hidl_to_rs<RsAllocation>(srcAlloc);
+    uint32_t _srcXoff = srcXoff;
+    uint32_t _srcYoff = srcYoff;
+    uint32_t _srcZoff = srcZoff;
+    uint32_t _srcMip = srcMip;
+    Device::getHal().AllocationCopy3DRange(mContext, _dstAlloc, _dstXoff, _dstYoff, _dstZoff, _dstMip, _width, _height, _depth, _srcAlloc, _srcXoff, _srcYoff, _srcZoff, _srcMip);
+    return Void();
+}
+
+Return<void> Context::allocationIoSend(Allocation allocation) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    Device::getHal().AllocationIoSend(mContext, _allocation);
+    return Void();
+}
+
+Return<void> Context::allocationIoReceive(Allocation allocation) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    Device::getHal().AllocationIoReceive(mContext, _allocation);
+    return Void();
+}
+
+Return<void> Context::allocationGetPointer(Allocation allocation, uint32_t lod, AllocationCubemapFace face, uint32_t z, allocationGetPointer_cb _hidl_cb) {
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    uint32_t _lod = lod;
+    RsAllocationCubemapFace _face = static_cast<RsAllocationCubemapFace>(face);
+    uint32_t _z = z;
+    uint32_t _array = 0;
+    size_t _stride = 0;
+    void* _dataPtr = Device::getHal().AllocationGetPointer(mContext, _allocation, _lod, _face, _z, _array, &_stride, sizeof(size_t));
+    Ptr dataPtr = reinterpret_cast<Ptr>(_dataPtr);
+    Size stride = static_cast<Size>(_stride);
+    _hidl_cb(dataPtr, stride);
+    return Void();
+}
+
+Return<void> Context::elementGetNativeMetadata(Element element, elementGetNativeMetadata_cb _hidl_cb) {
+    RsElement _element = hidl_to_rs<RsElement>(element);
+    std::vector<uint32_t> _elemData(5);
+    Device::getHal().ElementGetNativeData(mContext, _element, _elemData.data(), _elemData.size());
+    hidl_vec<uint32_t> elemData = _elemData;
+    _hidl_cb(elemData);
+    return Void();
+}
+
+Return<void> Context::elementGetSubElements(Element element, Size numSubElem, elementGetSubElements_cb _hidl_cb) {
+    RsElement _element = hidl_to_rs<RsElement>(element);
+    uint32_t _numSubElem = static_cast<uint32_t>(numSubElem);
+    std::vector<uintptr_t> _ids(_numSubElem);
+    std::vector<const char*> _names(_numSubElem);
+    std::vector<size_t> _arraySizes(_numSubElem);
+    Device::getHal().ElementGetSubElements(mContext, _element, _ids.data(), _names.data(), _arraySizes.data(), _numSubElem);
+    hidl_vec<Element>     ids        = rs_to_hidl<Element>(_ids,       [](uintptr_t val) { return static_cast<Element>(val); });
+    hidl_vec<hidl_string> names      = rs_to_hidl<hidl_string>(_names, [](const char* val) { return val; });
+    hidl_vec<Size>        arraySizes = rs_to_hidl<Size>(_arraySizes,   [](size_t val) { return static_cast<Size>(val); });
+    _hidl_cb(ids, names, arraySizes);
+    return Void();
+}
+
+Return<Element> Context::elementCreate(DataType dt, DataKind dk, bool norm, uint32_t size) {
+    RsDataType _dt = static_cast<RsDataType>(dt);
+    RsDataKind _dk = static_cast<RsDataKind>(dk);
+    bool _norm = norm;
+    uint32_t _size = size;
+    RsElement _element = Device::getHal().ElementCreate(mContext, _dt, _dk, _norm, _size);
+    return rs_to_hidl<Element>(_element);
+}
+
+Return<Element> Context::elementComplexCreate(const hidl_vec<Element>& eins, const hidl_vec<hidl_string>& names, const hidl_vec<Size>& arraySizes) {
+    std::vector<RsElement>   _eins           = hidl_to_rs<RsElement>(eins,      [](Element val) { return hidl_to_rs<RsElement>(val); });
+    std::vector<const char*> _namesPtr       = hidl_to_rs<const char*>(names,   [](const hidl_string& val) { return val.c_str(); });
+    std::vector<size_t>      _nameLengthsPtr = hidl_to_rs<size_t>(names,        [](const hidl_string& val) { return val.size(); });
+    std::vector<uint32_t>    _arraySizes     = hidl_to_rs<uint32_t>(arraySizes, [](Size val) { return static_cast<uint32_t>(val); });
+    RsElement _element = Device::getHal().ElementCreate2(mContext, _eins.data(), _eins.size(), _namesPtr.data(), _namesPtr.size(), _nameLengthsPtr.data(), _arraySizes.data(), _arraySizes.size());
+    return rs_to_hidl<Element>(_element);
+}
+
+Return<void> Context::typeGetNativeMetadata(Type type, typeGetNativeMetadata_cb _hidl_cb) {
+    RsType _type = hidl_to_rs<RsType>(type);
+    std::vector<uintptr_t> _metadata(6);
+    Device::getHal().TypeGetNativeData(mContext, _type, _metadata.data(), _metadata.size());
+    hidl_vec<OpaqueHandle> metadata = rs_to_hidl<OpaqueHandle>(_metadata, [](uintptr_t val) { return static_cast<OpaqueHandle>(val); });
+    _hidl_cb(metadata);
+    return Void();
+}
+
+Return<Type> Context::typeCreate(Element element, uint32_t dimX, uint32_t dimY, uint32_t dimZ, bool mipmaps, bool faces, YuvFormat yuv) {
+    RsElement _element = hidl_to_rs<RsElement>(element);
+    uint32_t _dimX = dimX;
+    uint32_t _dimY = dimY;
+    uint32_t _dimZ = dimZ;
+    bool _mipmaps = mipmaps;
+    bool _faces = faces;
+    RsYuvFormat _yuv = static_cast<RsYuvFormat>(yuv);
+    RsType _type = Device::getHal().TypeCreate(mContext, _element, _dimX, _dimY, _dimZ, _mipmaps, _faces, _yuv);
+    return rs_to_hidl<Type>(_type);
+}
+
+Return<void> Context::contextDestroy() {
+    Device::getHal().ContextDestroy(mContext);
+    mContext = nullptr;
+    return Void();
+}
+
+Return<void> Context::contextGetMessage(Ptr data, Size size, contextGetMessage_cb _hidl_cb) {
+    void* _data = hidl_to_rs<void*>(data);
+    size_t _size = static_cast<size_t>(size);
+    size_t _receiveLen = 0;
+    uint32_t _subID = 0;
+    RsMessageToClientType _messageType = Device::getHal().ContextGetMessage(mContext, _data, _size, &_receiveLen, sizeof(size_t), &_subID, sizeof(uint32_t));
+    MessageToClientType messageType = static_cast<MessageToClientType>(_messageType);
+    Size receiveLen = static_cast<Size>(_receiveLen);
+    _hidl_cb(messageType, receiveLen);
+    return Void();
+}
+
+Return<void> Context::contextPeekMessage(contextPeekMessage_cb _hidl_cb) {
+    size_t _receiveLen = 0;
+    uint32_t _subID = 0;
+    RsMessageToClientType _messageType = Device::getHal().ContextPeekMessage(mContext, &_receiveLen, sizeof(size_t), &_subID, sizeof(uint32_t));
+    MessageToClientType messageType = static_cast<MessageToClientType>(_messageType);
+    Size receiveLen = static_cast<Size>(_receiveLen);
+    uint32_t subID = _subID;
+    _hidl_cb(messageType, receiveLen, subID);
+    return Void();
+}
+
+Return<void> Context::contextSendMessage(uint32_t id, const hidl_vec<uint8_t>& data) {
+    uint32_t _id = id;
+    const uint8_t* _dataPtr = data.data();
+    size_t _dataSize = data.size();
+    Device::getHal().ContextSendMessage(mContext, _id, _dataPtr, _dataSize);
+    return Void();
+}
+
+Return<void> Context::contextInitToClient() {
+    Device::getHal().ContextInitToClient(mContext);
+    return Void();
+}
+
+Return<void> Context::contextDeinitToClient() {
+    Device::getHal().ContextDeinitToClient(mContext);
+    return Void();
+}
+
+Return<void> Context::contextFinish() {
+    Device::getHal().ContextFinish(mContext);
+    return Void();
+}
+
+Return<void> Context::contextLog() {
+    uint32_t _bits = 0;
+    Device::getHal().ContextDump(mContext, _bits);
+    return Void();
+}
+
+Return<void> Context::contextSetPriority(ThreadPriorities priority) {
+    RsThreadPriorities _priority = static_cast<RsThreadPriorities>(priority);
+    Device::getHal().ContextSetPriority(mContext, _priority);
+    return Void();
+}
+
+Return<void> Context::contextSetCacheDir(const hidl_string& cacheDir) {
+    Device::getHal().ContextSetCacheDir(mContext, cacheDir.c_str(), cacheDir.size());
+    return Void();
+}
+
+Return<void> Context::assignName(ObjectBase obj, const hidl_string& name) {
+    RsObjectBase _obj = hidl_to_rs<RsObjectBase>(obj);
+    const hidl_string& _name = name;
+    Device::getHal().AssignName(mContext, _obj, _name.c_str(), _name.size());
+    return Void();
+}
+
+Return<void> Context::getName(ObjectBase obj, getName_cb _hidl_cb) {
+    void* _obj = hidl_to_rs<void*>(obj);
+    const char* _name = nullptr;
+    Device::getHal().GetName(mContext, _obj, &_name);
+    hidl_string name = _name;
+    _hidl_cb(name);
+    return Void();
+}
+
+Return<Closure> Context::closureCreate(ScriptKernelID kernelID, Allocation returnValue, const hidl_vec<ScriptFieldID>& fieldIDS, const hidl_vec<int64_t>& values, const hidl_vec<int32_t>& sizes, const hidl_vec<Closure>& depClosures, const hidl_vec<ScriptFieldID>& depFieldIDS) {
+    RsScriptKernelID _kernelID = hidl_to_rs<RsScriptKernelID>(kernelID);
+    RsAllocation _returnValue = hidl_to_rs<RsAllocation>(returnValue);
+    std::vector<RsScriptFieldID> _fieldIDS = hidl_to_rs<RsScriptFieldID>(fieldIDS, [](ScriptFieldID val) { return hidl_to_rs<RsScriptFieldID>(val); });
+    int64_t* _valuesPtr = const_cast<int64_t*>(values.data());
+    size_t _valuesLength = values.size();
+    std::vector<int>             _sizes       = hidl_to_rs<int>(sizes,                   [](int32_t val) { return static_cast<int>(val); });
+    std::vector<RsClosure>       _depClosures = hidl_to_rs<RsClosure>(depClosures,       [](Closure val) { return hidl_to_rs<RsClosure>(val); });
+    std::vector<RsScriptFieldID> _depFieldIDS = hidl_to_rs<RsScriptFieldID>(depFieldIDS, [](ScriptFieldID val) { return hidl_to_rs<RsScriptFieldID>(val); });
+    RsClosure _closure = Device::getHal().ClosureCreate(mContext, _kernelID, _returnValue, _fieldIDS.data(), _fieldIDS.size(), _valuesPtr, _valuesLength, _sizes.data(), _sizes.size(), _depClosures.data(), _depClosures.size(), _depFieldIDS.data(), _depFieldIDS.size());
+    return rs_to_hidl<Closure>(_closure);
+}
+
+Return<Closure> Context::invokeClosureCreate(ScriptInvokeID invokeID, const hidl_vec<uint8_t>& params, const hidl_vec<ScriptFieldID>& fieldIDS, const hidl_vec<int64_t>& values, const hidl_vec<int32_t>& sizes) {
+    RsScriptInvokeID _invokeID = hidl_to_rs<RsScriptInvokeID>(invokeID);
+    const void* _paramsPtr = params.data();
+    size_t _paramsSize = params.size();
+    std::vector<RsScriptFieldID> _fieldIDS = hidl_to_rs<RsScriptFieldID>(fieldIDS, [](ScriptFieldID val) { return hidl_to_rs<RsScriptFieldID>(val); });
+    const int64_t* _valuesPtr = values.data();
+    size_t _valuesLength = values.size();
+    std::vector<int> _sizes = hidl_to_rs<int>(sizes, [](int32_t val) { return static_cast<int>(val); });
+    RsClosure _closure = Device::getHal().InvokeClosureCreate(mContext, _invokeID, _paramsPtr, _paramsSize, _fieldIDS.data(), _fieldIDS.size(), _valuesPtr, _valuesLength, _sizes.data(), _sizes.size());
+    return rs_to_hidl<Closure>(_closure);
+}
+
+Return<void> Context::closureSetArg(Closure closure, uint32_t index, Ptr value, int32_t size) {
+    RsClosure _closure = hidl_to_rs<RsClosure>(closure);
+    uint32_t _index = index;
+    uintptr_t _value = hidl_to_rs<uintptr_t>(value);
+    int _size = static_cast<int>(size);
+    Device::getHal().ClosureSetArg(mContext, _closure, _index, _value, _size);
+    return Void();
+}
+
+Return<void> Context::closureSetGlobal(Closure closure, ScriptFieldID fieldID, int64_t value, int32_t size) {
+    RsClosure _closure = hidl_to_rs<RsClosure>(closure);
+    RsScriptFieldID _fieldID = hidl_to_rs<RsScriptFieldID>(fieldID);
+    int64_t _value = value;
+    int _size = static_cast<int>(size);
+    Device::getHal().ClosureSetGlobal(mContext, _closure, _fieldID, _value, _size);
+    return Void();
+}
+
+Return<ScriptKernelID> Context::scriptKernelIDCreate(Script script, int32_t slot, int32_t sig) {
+    RsScript _script = hidl_to_rs<RsScript>(script);
+    int _slot = static_cast<int>(slot);
+    int _sig = static_cast<int>(sig);
+    RsScriptKernelID _scriptKernelID = Device::getHal().ScriptKernelIDCreate(mContext, _script, _slot, _sig);
+    return rs_to_hidl<ScriptKernelID>(_scriptKernelID);
+}
+
+Return<ScriptInvokeID> Context::scriptInvokeIDCreate(Script script, int32_t slot) {
+    RsScript _script = hidl_to_rs<RsScript>(script);
+    int _slot = static_cast<int>(slot);
+    RsScriptInvokeID _scriptInvokeID = Device::getHal().ScriptInvokeIDCreate(mContext, _script, _slot);
+    return rs_to_hidl<ScriptInvokeID>(_scriptInvokeID);
+}
+
+Return<ScriptFieldID> Context::scriptFieldIDCreate(Script script, int32_t slot) {
+    RsScript _script = hidl_to_rs<RsScript>(script);
+    int _slot = static_cast<int>(slot);
+    RsScriptFieldID _scriptFieldID = Device::getHal().ScriptFieldIDCreate(mContext, _script, _slot);
+    return rs_to_hidl<ScriptFieldID>(_scriptFieldID);
+}
+
+Return<ScriptGroup> Context::scriptGroupCreate(const hidl_vec<ScriptKernelID>& kernels, const hidl_vec<ScriptKernelID>& srcK, const hidl_vec<ScriptKernelID>& dstK, const hidl_vec<ScriptFieldID>& dstF, const hidl_vec<Type>& types) {
+    std::vector<RsScriptKernelID> _kernels = hidl_to_rs<RsScriptKernelID>(kernels, [](ScriptFieldID val) { return hidl_to_rs<RsScriptKernelID>(val); });
+    std::vector<RsScriptKernelID> _srcK    = hidl_to_rs<RsScriptKernelID>(srcK,    [](ScriptFieldID val) { return hidl_to_rs<RsScriptKernelID>(val); });
+    std::vector<RsScriptKernelID> _dstK    = hidl_to_rs<RsScriptKernelID>(dstK,    [](ScriptFieldID val) { return hidl_to_rs<RsScriptKernelID>(val); });
+    std::vector<RsScriptFieldID>  _dstF    = hidl_to_rs<RsScriptFieldID>(dstF,     [](ScriptFieldID val) { return hidl_to_rs<RsScriptFieldID>(val); });
+    std::vector<RsType>           _types   = hidl_to_rs<RsType>(types,             [](Type val) { return hidl_to_rs<RsType>(val); });
+    RsScriptGroup _scriptGroup = Device::getHal().ScriptGroupCreate(mContext, _kernels.data(), _kernels.size(), _srcK.data(), _srcK.size(), _dstK.data(), _dstK.size(), _dstF.data(), _dstF.size(), _types.data(), _types.size());
+    return rs_to_hidl<ScriptGroup>(_scriptGroup);
+}
+
+Return<ScriptGroup2> Context::scriptGroup2Create(const hidl_string& name, const hidl_string& cacheDir, const hidl_vec<Closure>& closures) {
+    const hidl_string& _name = name;
+    const hidl_string& _cacheDir = cacheDir;
+    std::vector<RsClosure> _closures = hidl_to_rs<RsClosure>(closures, [](Closure val) { return hidl_to_rs<RsClosure>(val); });
+    RsScriptGroup2 _scriptGroup2 = Device::getHal().ScriptGroup2Create(mContext, _name.c_str(), _name.size(), _cacheDir.c_str(), _cacheDir.size(), _closures.data(), _closures.size());
+    return rs_to_hidl<ScriptGroup2>(_scriptGroup2);
+}
+
+Return<void> Context::scriptGroupSetOutput(ScriptGroup sg, ScriptKernelID kid, Allocation alloc) {
+    RsScriptGroup _sg = hidl_to_rs<RsScriptGroup>(sg);
+    RsScriptKernelID _kid = hidl_to_rs<RsScriptKernelID>(kid);
+    RsAllocation _alloc = hidl_to_rs<RsAllocation>(alloc);
+    Device::getHal().ScriptGroupSetOutput(mContext, _sg, _kid, _alloc);
+    return Void();
+}
+
+Return<void> Context::scriptGroupSetInput(ScriptGroup sg, ScriptKernelID kid, Allocation alloc) {
+    RsScriptGroup _sg = hidl_to_rs<RsScriptGroup>(sg);
+    RsScriptKernelID _kid = hidl_to_rs<RsScriptKernelID>(kid);
+    RsAllocation _alloc = hidl_to_rs<RsAllocation>(alloc);
+    Device::getHal().ScriptGroupSetInput(mContext, _sg, _kid, _alloc);
+    return Void();
+}
+
+Return<void> Context::scriptGroupExecute(ScriptGroup sg) {
+    RsScriptGroup _sg = hidl_to_rs<RsScriptGroup>(sg);
+    Device::getHal().ScriptGroupExecute(mContext, _sg);
+    return Void();
+}
+
+Return<void> Context::objDestroy(ObjectBase obj) {
+    RsAsyncVoidPtr _obj = hidl_to_rs<RsAsyncVoidPtr>(obj);
+    Device::getHal().ObjDestroy(mContext, _obj);
+    return Void();
+}
+
+Return<Sampler> Context::samplerCreate(SamplerValue magFilter, SamplerValue minFilter, SamplerValue wrapS, SamplerValue wrapT, SamplerValue wrapR, float aniso) {
+    RsSamplerValue _magFilter = static_cast<RsSamplerValue>(magFilter);
+    RsSamplerValue _minFilter = static_cast<RsSamplerValue>(minFilter);
+    RsSamplerValue _wrapS = static_cast<RsSamplerValue>(wrapS);
+    RsSamplerValue _wrapT = static_cast<RsSamplerValue>(wrapT);
+    RsSamplerValue _wrapR = static_cast<RsSamplerValue>(wrapR);
+    float _aniso = static_cast<float>(aniso);
+    RsSampler _sampler = Device::getHal().SamplerCreate(mContext, _magFilter, _minFilter, _wrapS, _wrapT, _wrapR, _aniso);
+    return rs_to_hidl<Sampler>(_sampler);
+}
+
+Return<void> Context::scriptBindAllocation(Script script, Allocation allocation, uint32_t slot) {
+    RsScript _script = hidl_to_rs<RsScript>(script);
+    RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
+    uint32_t _slot = slot;
+    Device::getHal().ScriptBindAllocation(mContext, _script, _allocation, _slot);
+    return Void();
+}
+
+Return<void> Context::scriptSetTimeZone(Script script, const hidl_string& timeZone) {
+    RsScript _script = hidl_to_rs<RsScript>(script);
+    const hidl_string& _timeZone = timeZone;
+    Device::getHal().ScriptSetTimeZone(mContext, _script, _timeZone.c_str(), _timeZone.size());
+    return Void();
+}
+
+Return<void> Context::scriptInvoke(Script vs, uint32_t slot) {
+    RsScript _vs = hidl_to_rs<RsScript>(vs);
+    uint32_t _slot = slot;
+    Device::getHal().ScriptInvoke(mContext, _vs, _slot);
+    return Void();
+}
+
+Return<void> Context::scriptInvokeV(Script vs, uint32_t slot, const hidl_vec<uint8_t>& data) {
+    RsScript _vs = hidl_to_rs<RsScript>(vs);
+    uint32_t _slot = slot;
+    const void* _dataPtr = hidl_to_rs<const void*>(data.data());
+    size_t _len = data.size();
+    Device::getHal().ScriptInvokeV(mContext, _vs, _slot, _dataPtr, _len);
+    return Void();
+}
+
+Return<void> Context::scriptForEach(Script vs, uint32_t slot, const hidl_vec<Allocation>& vains, Allocation vaout, const hidl_vec<uint8_t>& params, Ptr sc) {
+    RsScript _vs = hidl_to_rs<RsScript>(vs);
+    uint32_t _slot = slot;
+    std::vector<RsAllocation> _vains = hidl_to_rs<RsAllocation>(vains, [](Allocation val) { return hidl_to_rs<RsAllocation>(val); });
+    RsAllocation _vaout = hidl_to_rs<RsAllocation>(vaout);
+    const void* _paramsPtr = hidl_to_rs<const void*>(params.data());
+    size_t _paramLen = params.size();
+    const RsScriptCall* _sc = hidl_to_rs<const RsScriptCall*>(sc);
+    size_t _scLen = _sc != nullptr ? sizeof(ScriptCall) : 0;
+    Device::getHal().ScriptForEachMulti(mContext, _vs, _slot, _vains.data(), _vains.size(), _vaout, _paramsPtr, _paramLen, _sc, _scLen);
+    return Void();
+}
+
+Return<void> Context::scriptReduce(Script vs, uint32_t slot, const hidl_vec<Allocation>& vains, Allocation vaout, Ptr sc) {
+    RsScript _vs = hidl_to_rs<RsScript>(vs);
+    uint32_t _slot = slot;
+    std::vector<RsAllocation> _vains = hidl_to_rs<RsAllocation>(vains, [](Allocation val) { return hidl_to_rs<RsAllocation>(val); });
+    RsAllocation _vaout = hidl_to_rs<RsAllocation>(vaout);
+    const RsScriptCall* _sc = hidl_to_rs<const RsScriptCall*>(sc);
+    size_t _scLen = _sc != nullptr ? sizeof(ScriptCall) : 0;
+    Device::getHal().ScriptReduce(mContext, _vs, _slot, _vains.data(), _vains.size(), _vaout, _sc, _scLen);
+    return Void();
+}
+
+Return<void> Context::scriptSetVarI(Script vs, uint32_t slot, int32_t value) {
+    RsScript _vs = hidl_to_rs<RsScript>(vs);
+    uint32_t _slot = slot;
+    int _value = static_cast<int>(value);
+    Device::getHal().ScriptSetVarI(mContext, _vs, _slot, _value);
+    return Void();
+}
+
+Return<void> Context::scriptSetVarObj(Script vs, uint32_t slot, ObjectBase obj) {
+    RsScript _vs = hidl_to_rs<RsScript>(vs);
+    uint32_t _slot = slot;
+    RsObjectBase _obj = hidl_to_rs<RsObjectBase>(obj);
+    Device::getHal().ScriptSetVarObj(mContext, _vs, _slot, _obj);
+    return Void();
+}
+
+Return<void> Context::scriptSetVarJ(Script vs, uint32_t slot, int64_t value) {
+    RsScript _vs = hidl_to_rs<RsScript>(vs);
+    uint32_t _slot = slot;
+    int64_t _value = static_cast<int64_t>(value);
+    Device::getHal().ScriptSetVarJ(mContext, _vs, _slot, _value);
+    return Void();
+}
+
+Return<void> Context::scriptSetVarF(Script vs, uint32_t slot, float value) {
+    RsScript _vs = hidl_to_rs<RsScript>(vs);
+    uint32_t _slot = slot;
+    float _value = value;
+    Device::getHal().ScriptSetVarF(mContext, _vs, _slot, _value);
+    return Void();
+}
+
+Return<void> Context::scriptSetVarD(Script vs, uint32_t slot, double value) {
+    RsScript _vs = hidl_to_rs<RsScript>(vs);
+    uint32_t _slot = slot;
+    double _value = value;
+    Device::getHal().ScriptSetVarD(mContext, _vs, _slot, _value);
+    return Void();
+}
+
+Return<void> Context::scriptSetVarV(Script vs, uint32_t slot, const hidl_vec<uint8_t>& data) {
+    RsScript _vs = hidl_to_rs<RsScript>(vs);
+    uint32_t _slot = slot;
+    const void* _dataPtr = hidl_to_rs<const void*>(data.data());
+    size_t _len = data.size();
+    Device::getHal().ScriptSetVarV(mContext, _vs, _slot, _dataPtr, _len);
+    return Void();
+}
+
+Return<void> Context::scriptGetVarV(Script vs, uint32_t slot, Size len, scriptGetVarV_cb _hidl_cb) {
+    RsScript _vs = hidl_to_rs<RsScript>(vs);
+    uint32_t _slot = slot;
+    size_t _len = static_cast<size_t>(len);
+    std::vector<uint8_t> _data(static_cast<size_t>(len));
+    Device::getHal().ScriptGetVarV(mContext, _vs, _slot, _data.data(), _data.size());
+    hidl_vec<uint8_t> data = _data;
+    _hidl_cb(data);
+    return Void();
+}
+
+Return<void> Context::scriptSetVarVE(Script vs, uint32_t slot, const hidl_vec<uint8_t>& data, Element ve, const hidl_vec<uint32_t>& dims) {
+    RsScript _vs = hidl_to_rs<RsScript>(vs);
+    uint32_t _slot = slot;
+    const void* _dataPtr = hidl_to_rs<const void*>(data.data());
+    size_t _len = data.size();
+    RsElement _ve = hidl_to_rs<RsElement>(ve);
+    const uint32_t* _dimsPtr = dims.data();
+    size_t _dimLen = dims.size();
+    Device::getHal().ScriptSetVarVE(mContext, _vs, _slot, _dataPtr, _len, _ve, _dimsPtr, _dimLen);
+    return Void();
+}
+
+Return<Script> Context::scriptCCreate(const hidl_string& resName, const hidl_string& cacheDir, const hidl_vec<uint8_t>& text) {
+    const hidl_string& _resName = resName;
+    const hidl_string& _cacheDir = cacheDir;
+    const char* _textPtr = hidl_to_rs<const char*>(text.data());
+    size_t _textSize = text.size();
+    RsScript _script = Device::getHal().ScriptCCreate(mContext, _resName.c_str(), _resName.size(), _cacheDir.c_str(), _cacheDir.size(), _textPtr, _textSize);
+    return rs_to_hidl<Script>(_script);
+}
+
+Return<Script> Context::scriptIntrinsicCreate(ScriptIntrinsicID id, Element elem) {
+    RsScriptIntrinsicID _id = static_cast<RsScriptIntrinsicID>(id);
+    RsElement _elem = hidl_to_rs<RsElement>(elem);
+    RsScript _script = Device::getHal().ScriptIntrinsicCreate(mContext, _id, _elem);
+    return rs_to_hidl<Script>(_script);
+}
+
+
+// Methods from ::android::hidl::base::V1_0::IBase follow.
+
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace renderscript
+}  // namespace hardware
+}  // namespace android
diff --git a/renderscript/1.0/default/Context.h b/renderscript/1.0/default/Context.h
new file mode 100644
index 0000000..38c45c5
--- /dev/null
+++ b/renderscript/1.0/default/Context.h
@@ -0,0 +1,129 @@
+#ifndef ANDROID_HARDWARE_RENDERSCRIPT_V1_0_CONTEXT_H
+#define ANDROID_HARDWARE_RENDERSCRIPT_V1_0_CONTEXT_H
+
+#include "cpp/rsDispatch.h"
+#include "dlfcn.h"
+#include <android/hardware/renderscript/1.0/IContext.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace renderscript {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::renderscript::V1_0::AllocationCubemapFace;
+using ::android::hardware::renderscript::V1_0::AllocationMipmapControl;
+using ::android::hardware::renderscript::V1_0::AllocationUsageType;
+using ::android::hardware::renderscript::V1_0::ContextType;
+using ::android::hardware::renderscript::V1_0::DataKind;
+using ::android::hardware::renderscript::V1_0::DataType;
+using ::android::hardware::renderscript::V1_0::IContext;
+using ::android::hardware::renderscript::V1_0::MessageToClientType;
+using ::android::hardware::renderscript::V1_0::SamplerValue;
+using ::android::hardware::renderscript::V1_0::ScriptCall;
+using ::android::hardware::renderscript::V1_0::ScriptIntrinsicID;
+using ::android::hardware::renderscript::V1_0::ThreadPriorities;
+using ::android::hardware::renderscript::V1_0::YuvFormat;
+using ::android::hidl::base::V1_0::IBase;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::sp;
+
+struct Context : public IContext {
+    Context(uint32_t sdkVersion, ContextType ct, int32_t flags);
+
+    // Methods from ::android::hardware::renderscript::V1_0::IContext follow.
+    Return<Allocation> allocationAdapterCreate(Type type, Allocation baseAlloc) override;
+    Return<void> allocationAdapterOffset(Allocation alloc, const hidl_vec<uint32_t>& offsets) override;
+    Return<Type> allocationGetType(Allocation allocation) override;
+    Return<Allocation> allocationCreateTyped(Type type, AllocationMipmapControl mips, int32_t usage, Ptr ptr) override;
+    Return<Allocation> allocationCreateFromBitmap(Type type, AllocationMipmapControl mips, const hidl_vec<uint8_t>& bitmap, int32_t usage) override;
+    Return<Allocation> allocationCubeCreateFromBitmap(Type type, AllocationMipmapControl mips, const hidl_vec<uint8_t>& bitmap, int32_t usage) override;
+    Return<NativeWindow> allocationGetNativeWindow(Allocation allocation) override;
+    Return<void> allocationSetNativeWindow(Allocation allocation, NativeWindow nativewindow) override;
+    Return<void> allocationSetupBufferQueue(Allocation alloc, uint32_t numBuffer) override;
+    Return<void> allocationShareBufferQueue(Allocation baseAlloc, Allocation subAlloc) override;
+    Return<void> allocationCopyToBitmap(Allocation allocation, Ptr data, Size sizeBytes) override;
+    Return<void> allocation1DWrite(Allocation allocation, uint32_t offset, uint32_t lod, uint32_t count, const hidl_vec<uint8_t>& data) override;
+    Return<void> allocationElementWrite(Allocation allocation, uint32_t x, uint32_t y, uint32_t z, uint32_t lod, const hidl_vec<uint8_t>& data, Size compIdx) override;
+    Return<void> allocation2DWrite(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t lod, AllocationCubemapFace face, uint32_t w, uint32_t h, const hidl_vec<uint8_t>& data, Size stride) override;
+    Return<void> allocation3DWrite(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod, uint32_t w, uint32_t h, uint32_t d, const hidl_vec<uint8_t>& data, Size stride) override;
+    Return<void> allocationGenerateMipmaps(Allocation allocation) override;
+    Return<void> allocationRead(Allocation allocation, Ptr data, Size sizeBytes) override;
+    Return<void> allocation1DRead(Allocation allocation, uint32_t xoff, uint32_t lod, uint32_t count, Ptr data, Size sizeBytes) override;
+    Return<void> allocationElementRead(Allocation allocation, uint32_t x, uint32_t y, uint32_t z, uint32_t lod, Ptr data, Size sizeBytes, Size compIdx) override;
+    Return<void> allocation2DRead(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t lod, AllocationCubemapFace face, uint32_t w, uint32_t h, Ptr data, Size sizeBytes, Size stride) override;
+    Return<void> allocation3DRead(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod, uint32_t w, uint32_t h, uint32_t d, Ptr data, Size sizeBytes, Size stride) override;
+    Return<void> allocationSyncAll(Allocation allocation, AllocationUsageType usageType) override;
+    Return<void> allocationResize1D(Allocation allocation, uint32_t dimX) override;
+    Return<void> allocationCopy2DRange(Allocation dstAlloc, uint32_t dstXoff, uint32_t dstYoff, uint32_t dstMip, AllocationCubemapFace dstFace, uint32_t width, uint32_t height, Allocation srcAlloc, uint32_t srcXoff, uint32_t srcYoff, uint32_t srcMip, AllocationCubemapFace srcFace) override;
+    Return<void> allocationCopy3DRange(Allocation dstAlloc, uint32_t dstXoff, uint32_t dstYoff, uint32_t dstZoff, uint32_t dstMip, uint32_t width, uint32_t height, uint32_t depth, Allocation srcAlloc, uint32_t srcXoff, uint32_t srcYoff, uint32_t srcZoff, uint32_t srcMip) override;
+    Return<void> allocationIoSend(Allocation allocation) override;
+    Return<void> allocationIoReceive(Allocation allocation) override;
+    Return<void> allocationGetPointer(Allocation allocation, uint32_t lod, AllocationCubemapFace face, uint32_t z, allocationGetPointer_cb _hidl_cb) override;
+    Return<void> elementGetNativeMetadata(Element element, elementGetNativeMetadata_cb _hidl_cb) override;
+    Return<void> elementGetSubElements(Element element, Size numSubElem, elementGetSubElements_cb _hidl_cb) override;
+    Return<Element> elementCreate(DataType dt, DataKind dk, bool norm, uint32_t size) override;
+    Return<Element> elementComplexCreate(const hidl_vec<Element>& eins, const hidl_vec<hidl_string>& names, const hidl_vec<Size>& arraySizes) override;
+    Return<void> typeGetNativeMetadata(Type type, typeGetNativeMetadata_cb _hidl_cb) override;
+    Return<Type> typeCreate(Element element, uint32_t dimX, uint32_t dimY, uint32_t dimZ, bool mipmaps, bool faces, YuvFormat yuv) override;
+    Return<void> contextDestroy() override;
+    Return<void> contextGetMessage(Ptr data, Size size, contextGetMessage_cb _hidl_cb) override;
+    Return<void> contextPeekMessage(contextPeekMessage_cb _hidl_cb) override;
+    Return<void> contextSendMessage(uint32_t id, const hidl_vec<uint8_t>& data) override;
+    Return<void> contextInitToClient() override;
+    Return<void> contextDeinitToClient() override;
+    Return<void> contextFinish() override;
+    Return<void> contextLog() override;
+    Return<void> contextSetPriority(ThreadPriorities priority) override;
+    Return<void> contextSetCacheDir(const hidl_string& cacheDir) override;
+    Return<void> assignName(ObjectBase obj, const hidl_string& name) override;
+    Return<void> getName(ObjectBase obj, getName_cb _hidl_cb) override;
+    Return<Closure> closureCreate(ScriptKernelID kernelID, Allocation returnValue, const hidl_vec<ScriptFieldID>& fieldIDS, const hidl_vec<int64_t>& values, const hidl_vec<int32_t>& sizes, const hidl_vec<Closure>& depClosures, const hidl_vec<ScriptFieldID>& depFieldIDS) override;
+    Return<Closure> invokeClosureCreate(ScriptInvokeID invokeID, const hidl_vec<uint8_t>& params, const hidl_vec<ScriptFieldID>& fieldIDS, const hidl_vec<int64_t>& values, const hidl_vec<int32_t>& sizes) override;
+    Return<void> closureSetArg(Closure closure, uint32_t index, Ptr value, int32_t size) override;
+    Return<void> closureSetGlobal(Closure closure, ScriptFieldID fieldID, int64_t value, int32_t size) override;
+    Return<ScriptKernelID> scriptKernelIDCreate(Script script, int32_t slot, int32_t sig) override;
+    Return<ScriptInvokeID> scriptInvokeIDCreate(Script script, int32_t slot) override;
+    Return<ScriptFieldID> scriptFieldIDCreate(Script script, int32_t slot) override;
+    Return<ScriptGroup> scriptGroupCreate(const hidl_vec<ScriptKernelID>& kernels, const hidl_vec<ScriptKernelID>& srcK, const hidl_vec<ScriptKernelID>& dstK, const hidl_vec<ScriptFieldID>& dstF, const hidl_vec<Type>& types) override;
+    Return<ScriptGroup2> scriptGroup2Create(const hidl_string& name, const hidl_string& cacheDir, const hidl_vec<Closure>& closures) override;
+    Return<void> scriptGroupSetOutput(ScriptGroup sg, ScriptKernelID kid, Allocation alloc) override;
+    Return<void> scriptGroupSetInput(ScriptGroup sg, ScriptKernelID kid, Allocation alloc) override;
+    Return<void> scriptGroupExecute(ScriptGroup sg) override;
+    Return<void> objDestroy(ObjectBase obj) override;
+    Return<Sampler> samplerCreate(SamplerValue magFilter, SamplerValue minFilter, SamplerValue wrapS, SamplerValue wrapT, SamplerValue wrapR, float aniso) override;
+    Return<void> scriptBindAllocation(Script script, Allocation allocation, uint32_t slot) override;
+    Return<void> scriptSetTimeZone(Script script, const hidl_string& timeZone) override;
+    Return<void> scriptInvoke(Script vs, uint32_t slot) override;
+    Return<void> scriptInvokeV(Script vs, uint32_t slot, const hidl_vec<uint8_t>& data) override;
+    Return<void> scriptForEach(Script vs, uint32_t slot, const hidl_vec<Allocation>& vains, Allocation vaout, const hidl_vec<uint8_t>& params, Ptr sc) override;
+    Return<void> scriptReduce(Script vs, uint32_t slot, const hidl_vec<Allocation>& vains, Allocation vaout, Ptr sc) override;
+    Return<void> scriptSetVarI(Script vs, uint32_t slot, int32_t value) override;
+    Return<void> scriptSetVarObj(Script vs, uint32_t slot, ObjectBase obj) override;
+    Return<void> scriptSetVarJ(Script vs, uint32_t slot, int64_t value) override;
+    Return<void> scriptSetVarF(Script vs, uint32_t slot, float value) override;
+    Return<void> scriptSetVarD(Script vs, uint32_t slot, double value) override;
+    Return<void> scriptSetVarV(Script vs, uint32_t slot, const hidl_vec<uint8_t>& data) override;
+    Return<void> scriptGetVarV(Script vs, uint32_t slot, Size len, scriptGetVarV_cb _hidl_cb) override;
+    Return<void> scriptSetVarVE(Script vs, uint32_t slot, const hidl_vec<uint8_t>& data, Element ve, const hidl_vec<uint32_t>& dims) override;
+    Return<Script> scriptCCreate(const hidl_string& resName, const hidl_string& cacheDir, const hidl_vec<uint8_t>& text) override;
+    Return<Script> scriptIntrinsicCreate(ScriptIntrinsicID id, Element elem) override;
+
+    // Methods from ::android::hidl::base::V1_0::IBase follow.
+
+ private:
+    RsContext mContext;
+};
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace renderscript
+}  // namespace hardware
+}  // namespace android
+
+#endif  // ANDROID_HARDWARE_RENDERSCRIPT_V1_0_CONTEXT_H
diff --git a/renderscript/1.0/default/Device.cpp b/renderscript/1.0/default/Device.cpp
new file mode 100644
index 0000000..86cf8eb
--- /dev/null
+++ b/renderscript/1.0/default/Device.cpp
@@ -0,0 +1,139 @@
+#include "Context.h"
+#include "Device.h"
+
+namespace android {
+namespace hardware {
+namespace renderscript {
+namespace V1_0 {
+namespace implementation {
+
+
+static dispatchTable loadHAL();
+dispatchTable Device::mDispatchHal = loadHAL();
+
+Device::Device() {
+}
+
+dispatchTable& Device::getHal() {
+    return mDispatchHal;
+}
+
+
+// Methods from ::android::hardware::renderscript::V1_0::IDevice follow.
+
+Return<sp<IContext>> Device::contextCreate(uint32_t sdkVersion, ContextType ct, int32_t flags) {
+    return new Context(sdkVersion, ct, flags);
+}
+
+
+// Methods from ::android::hidl::base::V1_0::IBase follow.
+
+IDevice* HIDL_FETCH_IDevice(const char* /* name */) {
+    return new Device();
+}
+
+// Helper function
+dispatchTable loadHAL() {
+
+    static_assert(sizeof(void*) <= sizeof(uint64_t), "RenderScript HIDL Error: sizeof(void*) > sizeof(uint64_t)");
+    static_assert(sizeof(size_t) <= sizeof(uint64_t), "RenderScript HIDL Error: sizeof(size_t) > sizeof(uint64_t)");
+
+    const char* filename = "libRS_internal.so";
+    void* handle = dlopen(filename, RTLD_LAZY | RTLD_LOCAL);
+
+    dispatchTable dispatchHal = {
+        .SetNativeLibDir = (SetNativeLibDirFnPtr)nullptr,
+
+        .Allocation1DData = (Allocation1DDataFnPtr)dlsym(handle, "rsAllocation1DData"),
+        .Allocation1DElementData = (Allocation1DElementDataFnPtr)nullptr,
+        .Allocation1DRead = (Allocation1DReadFnPtr)dlsym(handle, "rsAllocation1DRead"),
+        .Allocation2DData = (Allocation2DDataFnPtr)dlsym(handle, "rsAllocation2DData"),
+        .Allocation2DRead = (Allocation2DReadFnPtr)dlsym(handle, "rsAllocation2DRead"),
+        .Allocation3DData = (Allocation3DDataFnPtr)dlsym(handle, "rsAllocation3DData"),
+        .Allocation3DRead = (Allocation3DReadFnPtr)dlsym(handle, "rsAllocation3DRead"),
+        .AllocationAdapterCreate = (AllocationAdapterCreateFnPtr)dlsym(handle, "rsAllocationAdapterCreate"),
+        .AllocationAdapterOffset = (AllocationAdapterOffsetFnPtr)dlsym(handle, "rsAllocationAdapterOffset"),
+        .AllocationCopy2DRange = (AllocationCopy2DRangeFnPtr)dlsym(handle, "rsAllocationCopy2DRange"),
+        .AllocationCopy3DRange = (AllocationCopy3DRangeFnPtr)dlsym(handle, "rsAllocationCopy3DRange"),
+        .AllocationCopyToBitmap = (AllocationCopyToBitmapFnPtr)dlsym(handle, "rsAllocationCopyToBitmap"),
+        .AllocationCreateFromBitmap = (AllocationCreateFromBitmapFnPtr)dlsym(handle, "rsAllocationCreateFromBitmap"),
+        .AllocationCreateStrided = (AllocationCreateStridedFnPtr)dlsym(handle, "rsAllocationCreateStrided"),
+        .AllocationCreateTyped = (AllocationCreateTypedFnPtr)dlsym(handle, "rsAllocationCreateTyped"),
+        .AllocationCubeCreateFromBitmap = (AllocationCubeCreateFromBitmapFnPtr)dlsym(handle, "rsAllocationCubeCreateFromBitmap"),
+        .AllocationElementData = (AllocationElementDataFnPtr)dlsym(handle, "rsAllocationElementData"),
+        .AllocationElementRead = (AllocationElementReadFnPtr)dlsym(handle, "rsAllocationElementRead"),
+        .AllocationGenerateMipmaps = (AllocationGenerateMipmapsFnPtr)dlsym(handle, "rsAllocationGenerateMipmaps"),
+        .AllocationGetPointer = (AllocationGetPointerFnPtr)dlsym(handle, "rsAllocationGetPointer"),
+        .AllocationGetSurface = (AllocationGetSurfaceFnPtr)dlsym(handle, "rsAllocationGetSurface"),
+        .AllocationGetType = (AllocationGetTypeFnPtr)dlsym(handle, "rsaAllocationGetType"),
+        .AllocationIoReceive = (AllocationIoReceiveFnPtr)dlsym(handle, "rsAllocationIoReceive"),
+        .AllocationIoSend = (AllocationIoSendFnPtr)dlsym(handle, "rsAllocationIoSend"),
+        .AllocationRead = (AllocationReadFnPtr)dlsym(handle, "rsAllocationRead"),
+        .AllocationResize1D = (AllocationResize1DFnPtr)dlsym(handle, "rsAllocationResize1D"),
+        .AllocationSetSurface = (AllocationSetSurfaceFnPtr)dlsym(handle, "rsAllocationSetSurface"),
+        .AllocationSetupBufferQueue = (AllocationSetupBufferQueueFnPtr)dlsym(handle, "rsAllocationSetupBufferQueue"),
+        .AllocationShareBufferQueue = (AllocationShareBufferQueueFnPtr)dlsym(handle, "rsAllocationShareBufferQueue"),
+        .AllocationSyncAll = (AllocationSyncAllFnPtr)dlsym(handle, "rsAllocationSyncAll"),
+        .AssignName = (AssignNameFnPtr)dlsym(handle, "rsAssignName"),
+        .ClosureCreate = (ClosureCreateFnPtr)dlsym(handle, "rsClosureCreate"),
+        .ClosureSetArg = (ClosureSetArgFnPtr)dlsym(handle, "rsClosureSetArg"),
+        .ClosureSetGlobal = (ClosureSetGlobalFnPtr)dlsym(handle, "rsClosureSetGlobal"),
+        .ContextCreate = (ContextCreateFnPtr)dlsym(handle, "rsContextCreate"),
+        .ContextDeinitToClient = (ContextDeinitToClientFnPtr)dlsym(handle, "rsContextDeinitToClient"),
+        .ContextDestroy = (ContextDestroyFnPtr)dlsym(handle, "rsContextDestroy"),
+        .ContextDump = (ContextDumpFnPtr)dlsym(handle, "rsContextDump"),
+        .ContextFinish = (ContextFinishFnPtr)dlsym(handle, "rsContextFinish"),
+        .ContextGetMessage = (ContextGetMessageFnPtr)dlsym(handle, "rsContextGetMessage"),
+        .ContextInitToClient = (ContextInitToClientFnPtr)dlsym(handle, "rsContextInitToClient"),
+        .ContextPeekMessage = (ContextPeekMessageFnPtr)dlsym(handle, "rsContextPeekMessage"),
+        .ContextSendMessage = (ContextSendMessageFnPtr)dlsym(handle, "rsContextSendMessage"),
+        .ContextSetCacheDir = (ContextSetCacheDirFnPtr)dlsym(handle, "rsContextSetCacheDir"),
+        .ContextSetPriority = (ContextSetPriorityFnPtr)dlsym(handle, "rsContextSetPriority"),
+        .DeviceCreate = (DeviceCreateFnPtr)nullptr,
+        .DeviceDestroy = (DeviceDestroyFnPtr)nullptr,
+        .DeviceSetConfig = (DeviceSetConfigFnPtr)nullptr,
+        .ElementCreate2 = (ElementCreate2FnPtr)dlsym(handle, "rsElementCreate2"),
+        .ElementCreate = (ElementCreateFnPtr)dlsym(handle, "rsElementCreate"),
+        .ElementGetNativeData = (ElementGetNativeDataFnPtr)dlsym(handle, "rsaElementGetNativeData"),
+        .ElementGetSubElements = (ElementGetSubElementsFnPtr)dlsym(handle, "rsaElementGetSubElements"),
+        .GetName = (GetNameFnPtr)dlsym(handle, "rsaGetName"),
+        .InvokeClosureCreate = (InvokeClosureCreateFnPtr)dlsym(handle, "rsInvokeClosureCreate"),
+        .ObjDestroy = (ObjDestroyFnPtr)dlsym(handle, "rsObjDestroy"),
+        .SamplerCreate = (SamplerCreateFnPtr)dlsym(handle, "rsSamplerCreate"),
+        .ScriptBindAllocation = (ScriptBindAllocationFnPtr)dlsym(handle, "rsScriptBindAllocation"),
+        .ScriptCCreate = (ScriptCCreateFnPtr)dlsym(handle, "rsScriptCCreate"),
+        .ScriptFieldIDCreate = (ScriptFieldIDCreateFnPtr)dlsym(handle, "rsScriptFieldIDCreate"),
+        .ScriptForEach = (ScriptForEachFnPtr)nullptr,
+        .ScriptForEachMulti = (ScriptForEachMultiFnPtr)dlsym(handle, "rsScriptForEachMulti"),
+        .ScriptGetVarV = (ScriptGetVarVFnPtr)dlsym(handle, "rsScriptGetVarV"),
+        .ScriptGroup2Create = (ScriptGroup2CreateFnPtr)dlsym(handle, "rsScriptGroup2Create"),
+        .ScriptGroupCreate = (ScriptGroupCreateFnPtr)dlsym(handle, "rsScriptGroupCreate"),
+        .ScriptGroupExecute = (ScriptGroupExecuteFnPtr)dlsym(handle, "rsScriptGroupExecute"),
+        .ScriptGroupSetInput = (ScriptGroupSetInputFnPtr)dlsym(handle, "rsScriptGroupSetInput"),
+        .ScriptGroupSetOutput = (ScriptGroupSetOutputFnPtr)dlsym(handle, "rsScriptGroupSetOutput"),
+        .ScriptIntrinsicCreate = (ScriptIntrinsicCreateFnPtr)dlsym(handle, "rsScriptIntrinsicCreate"),
+        .ScriptInvoke = (ScriptInvokeFnPtr)dlsym(handle, "rsScriptInvoke"),
+        .ScriptInvokeIDCreate = (ScriptInvokeIDCreateFnPtr)dlsym(handle, "rsScriptInvokeIDCreate"),
+        .ScriptInvokeV = (ScriptInvokeVFnPtr)dlsym(handle, "rsScriptInvokeV"),
+        .ScriptKernelIDCreate = (ScriptKernelIDCreateFnPtr)dlsym(handle, "rsScriptKernelIDCreate"),
+        .ScriptReduce = (ScriptReduceFnPtr)dlsym(handle, "rsScriptReduce"),
+        .ScriptSetTimeZone = (ScriptSetTimeZoneFnPtr)dlsym(handle, "rsScriptSetTimeZone"),
+        .ScriptSetVarD = (ScriptSetVarDFnPtr)dlsym(handle, "rsScriptSetVarD"),
+        .ScriptSetVarF = (ScriptSetVarFFnPtr)dlsym(handle, "rsScriptSetVarF"),
+        .ScriptSetVarI = (ScriptSetVarIFnPtr)dlsym(handle, "rsScriptSetVarI"),
+        .ScriptSetVarJ = (ScriptSetVarJFnPtr)dlsym(handle, "rsScriptSetVarJ"),
+        .ScriptSetVarObj = (ScriptSetVarObjFnPtr)dlsym(handle, "rsScriptSetVarObj"),
+        .ScriptSetVarVE = (ScriptSetVarVEFnPtr)dlsym(handle, "rsScriptSetVarVE"),
+        .ScriptSetVarV = (ScriptSetVarVFnPtr)dlsym(handle, "rsScriptSetVarV"),
+        .TypeCreate = (TypeCreateFnPtr)dlsym(handle, "rsTypeCreate"),
+        .TypeGetNativeData = (TypeGetNativeDataFnPtr)dlsym(handle, "rsaTypeGetNativeData"),
+    };
+
+    return dispatchHal;
+}
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace renderscript
+}  // namespace hardware
+}  // namespace android
diff --git a/renderscript/1.0/default/Device.h b/renderscript/1.0/default/Device.h
new file mode 100644
index 0000000..f5bda37
--- /dev/null
+++ b/renderscript/1.0/default/Device.h
@@ -0,0 +1,44 @@
+#ifndef ANDROID_HARDWARE_RENDERSCRIPT_V1_0_DEVICE_H
+#define ANDROID_HARDWARE_RENDERSCRIPT_V1_0_DEVICE_H
+
+#include "cpp/rsDispatch.h"
+#include "dlfcn.h"
+#include <android/hardware/renderscript/1.0/IDevice.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace renderscript {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::renderscript::V1_0::ContextType;
+using ::android::hardware::renderscript::V1_0::IContext;
+using ::android::hardware::renderscript::V1_0::IDevice;
+using ::android::hidl::base::V1_0::IBase;
+using ::android::hardware::Return;
+using ::android::sp;
+
+struct Device : public IDevice {
+    Device();
+    static dispatchTable& getHal();
+
+    // Methods from ::android::hardware::renderscript::V1_0::IDevice follow.
+    Return<sp<IContext>> contextCreate(uint32_t sdkVersion, ContextType ct, int32_t flags) override;
+
+    // Methods from ::android::hidl::base::V1_0::IBase follow.
+
+ private:
+    static dispatchTable mDispatchHal;
+};
+
+extern "C" IDevice* HIDL_FETCH_IDevice(const char* name);
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace renderscript
+}  // namespace hardware
+}  // namespace android
+
+#endif  // ANDROID_HARDWARE_RENDERSCRIPT_V1_0_DEVICE_H
diff --git a/renderscript/1.0/types.hal b/renderscript/1.0/types.hal
new file mode 100644
index 0000000..7c32188
--- /dev/null
+++ b/renderscript/1.0/types.hal
@@ -0,0 +1,253 @@
+/*
+ * 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.
+ */
+
+// TODO: Currently, most of the types are simply typedefs of uint64_t, so
+// misusing one type as another won't be caught by the compiler. Should we wrap
+// each type in a unique class to have stronger type guarantees?
+// TODO: is there an enum for intrinsics?
+
+package android.hardware.renderscript@1.0;
+
+// OpaqueHandle is an object that is used entirely in the driver but still needs
+// to be identified by the framework.
+typedef uint64_t OpaqueHandle;
+
+// A pointer is an actual local pointer that can be accessed by both the
+// framework and the driver. This is possible because RenderScript is always
+// running in Passthrough mode.
+typedef pointer Ptr;
+
+// This is an abstraction of size_t because it is not supported in HIDL.
+typedef uint64_t Size;
+
+// In RenderScript code, these are all defined as void*, but act only as
+// handles.
+typedef OpaqueHandle Allocation;
+typedef OpaqueHandle AllocationAdapter;
+typedef OpaqueHandle Closure;
+typedef OpaqueHandle Element;
+typedef OpaqueHandle NativeWindow;
+typedef OpaqueHandle ObjectBase;
+typedef OpaqueHandle Sampler;
+typedef OpaqueHandle Script;
+typedef OpaqueHandle ScriptFieldID;
+typedef OpaqueHandle ScriptGroup;
+typedef OpaqueHandle ScriptGroup2;
+typedef OpaqueHandle ScriptInvokeID;
+typedef OpaqueHandle ScriptKernelID;
+typedef OpaqueHandle Type;
+
+// types below are same as those in frameworks/rs/rsDefines.h
+
+@export(name="RsContextType", value_prefix="RS_CONTEXT_TYPE_")
+enum ContextType : int32_t {
+    NORMAL,
+    DEBUG,
+    PROFILE,
+};
+
+@export(name="RsAllocationUsageType", value_prefix="RS_ALLOCATION_USAGE_")
+enum AllocationUsageType : int32_t {
+    SCRIPT                 = 0x0001,
+    GRAPHICS_TEXTURE       = 0x0002,
+    GRAPHICS_VERTEX        = 0x0004,
+    GRAPHICS_CONSTANTS     = 0x0008,
+    GRAPHICS_RENDER_TARGET = 0x0010,
+    IO_INPUT               = 0x0020,
+    IO_OUTPUT              = 0x0040,
+    SHARED                 = 0x0080,
+    OEM                    = 0x8000,
+    ALL                    = 0x80FF,
+};
+
+@export(name="RsAllocationMipmapControl", value_prefix="RS_ALLOCATION_MIPMAP_")
+enum AllocationMipmapControl : int32_t {
+    NONE               = 0,
+    FULL               = 1,
+    ON_SYNC_TO_TEXTURE = 2,
+};
+
+@export(name="RsAllocationCubemapFace",
+        value_prefix="RS_ALLOCATION_CUBEMAP_FACE_")
+enum AllocationCubemapFace : int32_t {
+    POSITIVE_X = 0,
+    NEGATIVE_X = 1,
+    POSITIVE_Y = 2,
+    NEGATIVE_Y = 3,
+    POSITIVE_Z = 4,
+    NEGATIVE_Z = 5,
+};
+
+@export(name="RsDataType", value_prefix="RS_TYPE_")
+enum DataType : int32_t {
+    NONE = 0,
+    FLOAT_16,
+    FLOAT_32,
+    FLOAT_64,
+    SIGNED_8,
+    SIGNED_16,
+    SIGNED_32,
+    SIGNED_64,
+    UNSIGNED_8,
+    UNSIGNED_16,
+    UNSIGNED_32,
+    UNSIGNED_64,
+    BOOLEAN,
+    UNSIGNED_5_6_5,
+    UNSIGNED_5_5_5_1,
+    UNSIGNED_4_4_4_4,
+    MATRIX_4X4,
+    MATRIX_3X3,
+    MATRIX_2X2,
+    ELEMENT = 1000,
+    TYPE,
+    ALLOCATION,
+    SAMPLER,
+    SCRIPT,
+    MESH,
+    PROGRAM_FRAGMENT,
+    PROGRAM_VERTEX,
+    PROGRAM_RASTER,
+    PROGRAM_STORE,
+    FONT,
+    INVALID = 10000,
+};
+
+@export(name="RsDataKind", value_prefix="RS_KIND_")
+enum DataKind : int32_t {
+    USER,
+    PIXEL_L = 7,
+    PIXEL_A,
+    PIXEL_LA,
+    PIXEL_RGB,
+    PIXEL_RGBA,
+    PIXEL_DEPTH,
+    PIXEL_YUV,
+    INVALID = 100,
+};
+
+@export(name="RsYuvFormat", value_prefix="RS_")
+enum YuvFormat : int32_t {
+    YUV_NONE    = 0,
+    YUV_YV12    = 0x32315659, // HAL_PIXEL_FORMAT_YV12 in system/graphics.h
+    YUV_NV21    = 0x11,       // HAL_PIXEL_FORMAT_YCrCb_420_SP
+    YUV_420_888 = 0x23,       // HAL_PIXEL_FORMAT_YCbCr_420_888
+};
+
+@export(name="RsSamplerValue", value_prefix="RS_SAMPLER_")
+enum SamplerValue : int32_t {
+    NEAREST,
+    LINEAR,
+    LINEAR_MIP_LINEAR,
+    WRAP,
+    CLAMP,
+    LINEAR_MIP_NEAREST,
+    MIRRORED_REPEAT,
+    INVALID = 100,
+};
+
+@export(name="RsForEachStrategy", value_prefix="RS_FOR_EACH_STRATEGY_")
+enum ForEachStrategy : int32_t {
+    SERIAL      = 0,
+    DONT_CARE   = 1,
+    DST_LINEAR  = 2,
+    TILE_SMALL  = 3,
+    TILE_MEDIUM = 4,
+    TILE_LARGE  = 5,
+};
+
+// Script to Script
+@export(name="RsScriptCall")
+struct ScriptCall {
+    ForEachStrategy strategy;
+    uint32_t        xStart;
+    uint32_t        xEnd;
+    uint32_t        yStart;
+    uint32_t        yEnd;
+    uint32_t        zStart;
+    uint32_t        zEnd;
+    uint32_t        arrayStart;
+    uint32_t        arrayEnd;
+    uint32_t        array2Start;
+    uint32_t        array2End;
+    uint32_t        array3Start;
+    uint32_t        array3End;
+    uint32_t        array4Start;
+    uint32_t        array4End;
+};
+
+@export(name="RsContextFlags", value_prefix="RS_CONTEXT_")
+enum ContextFlags : int32_t {
+    SYNCHRONOUS     = 1<<0,
+    LOW_LATENCY     = 1<<1,
+    LOW_POWER       = 1<<2,
+    WAIT_FOR_ATTACH = 1<<3,
+};
+
+// types below are same as those in frameworks/rs/rsInternalDefines.h
+
+@export(name="RsMessageToClientType", value_prefix="RS_MESSAGE_TO_CLIENT_")
+enum MessageToClientType : int32_t {
+    NONE       = 0,
+    EXCEPTION  = 1,
+    RESIZE     = 2,
+    ERROR      = 3,
+    USER       = 4,
+    NEW_BUFFER = 5,
+};
+
+@export(name="RsScriptIntrinsicID", value_prefix="RS_SCRIPT_INTRINSIC_")
+enum ScriptIntrinsicID : int32_t {
+    ID_UNDEFINED    = 0,
+    ID_CONVOLVE_3X3 = 1,
+    ID_COLOR_MATRIX = 2,
+    ID_LUT          = 3,
+    ID_CONVOLVE_5X5 = 4,
+    ID_BLUR         = 5,
+    ID_YUV_TO_RGB   = 6,
+    ID_BLEND        = 7,
+    ID_3DLUT        = 8,
+    ID_HISTOGRAM    = 9,
+    // unused 10, 11
+    ID_RESIZE       = 12,
+    ID_BLAS         = 13,
+    ID_EXTBLAS      = 14,
+    ID_OEM_START    = 0x10000000,
+};
+
+@export(name="RsThreadPriorities", value_prefix="RS_THREAD_PRIORITY_")
+enum ThreadPriorities : int32_t {
+    LOW             = 15,
+    NORMAL_GRAPHICS = -8,
+    NORMAL          = -1,
+    LOW_LATENCY     = -4,
+};
+
+// types below are same as those in
+// frameworks/compile/libbcc/include/bcinfo/MetadataExtractor.h
+
+@export(name="", value_prefix="RS_MD_")
+enum MetadataSignatureBitval : int32_t {
+    SIG_None        = 0,
+    SIG_In          = 1<<0,
+    SIG_Out         = 1<<1,
+    SIG_Usr         = 1<<2,
+    SIG_X           = 1<<3,
+    SIG_Y           = 1<<4,
+    SIG_Kernel      = 1<<5,
+    SIG_Z           = 1<<6,
+    SIG_Ctxt        = 1<<7,
+};