diff --git a/aidl_to_ndk.cpp b/aidl_to_ndk.cpp
index 56473a5..d5b0072 100644
--- a/aidl_to_ndk.cpp
+++ b/aidl_to_ndk.cpp
@@ -16,6 +16,7 @@
 #include "aidl_language.h"
 #include "aidl_to_cpp_common.h"
 #include "logging.h"
+#include "os.h"
 
 #include <android-base/strings.h>
 
@@ -28,6 +29,12 @@
 namespace aidl {
 namespace ndk {
 
+std::string NdkHeaderFile(const AidlDefinedType& defined_type, cpp::ClassNames name,
+                          bool use_os_sep) {
+  char seperator = (use_os_sep) ? OS_PATH_SEPARATOR : '/';
+  return std::string("aidl") + seperator + cpp::HeaderFile(defined_type, name, use_os_sep);
+}
+
 struct TypeInfo {
   // name of the type in C++ output
   std::string cpp_name;
diff --git a/aidl_to_ndk.h b/aidl_to_ndk.h
index cfbab17..54de198 100644
--- a/aidl_to_ndk.h
+++ b/aidl_to_ndk.h
@@ -28,6 +28,9 @@
   OUT_ARGUMENT,  // Pointer to raw type
 };
 
+std::string NdkHeaderFile(const AidlDefinedType& defined_type, cpp::ClassNames name,
+                          bool use_os_sep = true);
+
 // Returns ::aidl::some_package::some_sub_package::foo::IFoo/BpFoo/BnFoo
 std::string NdkFullClassName(const AidlDefinedType& type, cpp::ClassNames name);
 
diff --git a/build/aidl_interface.go b/build/aidl_interface.go
index 239bfd1..35135b4 100644
--- a/build/aidl_interface.go
+++ b/build/aidl_interface.go
@@ -188,12 +188,18 @@
 			strings.ToUpper(baseName)[1] == baseName[1] {
 			baseName = strings.TrimPrefix(typeName, "I")
 		}
+
+		prefix := ""
+		if g.properties.Lang == langNdk {
+			prefix = "aidl"
+		}
+
 		var headers android.WritablePaths
-		headers = append(headers, g.genHeaderDir.Join(ctx, packagePath,
+		headers = append(headers, g.genHeaderDir.Join(ctx, prefix, packagePath,
 			typeName+".h"))
-		headers = append(headers, g.genHeaderDir.Join(ctx, packagePath,
+		headers = append(headers, g.genHeaderDir.Join(ctx, prefix, packagePath,
 			"Bp"+baseName+".h"))
-		headers = append(headers, g.genHeaderDir.Join(ctx, packagePath,
+		headers = append(headers, g.genHeaderDir.Join(ctx, prefix, packagePath,
 			"Bn"+baseName+".h"))
 		ctx.ModuleBuild(pctx, android.ModuleBuildParams{
 			Rule:            aidlCppRule,
diff --git a/generate_ndk.cpp b/generate_ndk.cpp
index fe2ad53..678608d 100644
--- a/generate_ndk.cpp
+++ b/generate_ndk.cpp
@@ -33,17 +33,19 @@
                           const AidlTypenames& types, const AidlInterface& defined_type,
                           const IoDelegate& io_delegate) {
   const string i_header =
-      options.OutputHeaderDir() + HeaderFile(defined_type, ClassNames::INTERFACE);
+      options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::INTERFACE);
   unique_ptr<CodeWriter> i_writer(io_delegate.GetCodeWriter(i_header));
   GenerateInterfaceHeader(*i_writer, types, defined_type, options);
   CHECK(i_writer->Close());
 
-  const string bp_header = options.OutputHeaderDir() + HeaderFile(defined_type, ClassNames::CLIENT);
+  const string bp_header =
+      options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::CLIENT);
   unique_ptr<CodeWriter> bp_writer(io_delegate.GetCodeWriter(bp_header));
   GenerateClientHeader(*bp_writer, types, defined_type, options);
   CHECK(bp_writer->Close());
 
-  const string bn_header = options.OutputHeaderDir() + HeaderFile(defined_type, ClassNames::SERVER);
+  const string bn_header =
+      options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::SERVER);
   unique_ptr<CodeWriter> bn_writer(io_delegate.GetCodeWriter(bn_header));
   GenerateServerHeader(*bn_writer, types, defined_type, options);
   CHECK(bn_writer->Close());
@@ -56,17 +58,20 @@
 void GenerateNdkParcel(const string& output_file, const Options& options,
                        const AidlTypenames& types, const AidlStructuredParcelable& defined_type,
                        const IoDelegate& io_delegate) {
-  const string header_path = options.OutputHeaderDir() + HeaderFile(defined_type, ClassNames::BASE);
+  const string header_path =
+      options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::BASE);
   unique_ptr<CodeWriter> header_writer(io_delegate.GetCodeWriter(header_path));
   GenerateParcelHeader(*header_writer, types, defined_type, options);
   CHECK(header_writer->Close());
 
-  const string bp_header = options.OutputHeaderDir() + HeaderFile(defined_type, ClassNames::CLIENT);
+  const string bp_header =
+      options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::CLIENT);
   unique_ptr<CodeWriter> bp_writer(io_delegate.GetCodeWriter(bp_header));
   *bp_writer << "#error TODO(b/111362593) defined_types do not have bp classes\n";
   CHECK(bp_writer->Close());
 
-  const string bn_header = options.OutputHeaderDir() + HeaderFile(defined_type, ClassNames::SERVER);
+  const string bn_header =
+      options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::SERVER);
   unique_ptr<CodeWriter> bn_writer(io_delegate.GetCodeWriter(bn_header));
   *bn_writer << "#error TODO(b/111362593) defined_types do not have bn classes\n";
   CHECK(bn_writer->Close());
@@ -122,10 +127,11 @@
 
     if (other_defined_type.AsInterface() != nullptr) {
       out << "#include <"
-          << HeaderFile(other_defined_type, ClassNames::INTERFACE, false /*use_os_sep*/) << ">\n";
-    } else if (other_defined_type.AsStructuredParcelable() != nullptr) {
-      out << "#include <" << HeaderFile(other_defined_type, ClassNames::BASE, false /*use_os_sep*/)
+          << NdkHeaderFile(other_defined_type, ClassNames::INTERFACE, false /*use_os_sep*/)
           << ">\n";
+    } else if (other_defined_type.AsStructuredParcelable() != nullptr) {
+      out << "#include <"
+          << NdkHeaderFile(other_defined_type, ClassNames::BASE, false /*use_os_sep*/) << ">\n";
     } else if (other_defined_type.AsParcelable() != nullptr) {
       out << "#include \"" << other_defined_type.AsParcelable()->GetCppHeader() << "\"\n";
     } else {
@@ -137,12 +143,12 @@
                                    const AidlDefinedType& /*defined_type*/) {
   types.IterateTypes([&](const AidlDefinedType& a_defined_type) {
     if (a_defined_type.AsInterface() != nullptr) {
-      out << "#include <" << HeaderFile(a_defined_type, ClassNames::CLIENT, false /*use_os_sep*/)
+      out << "#include <" << NdkHeaderFile(a_defined_type, ClassNames::CLIENT, false /*use_os_sep*/)
           << ">\n";
-      out << "#include <" << HeaderFile(a_defined_type, ClassNames::SERVER, false /*use_os_sep*/)
+      out << "#include <" << NdkHeaderFile(a_defined_type, ClassNames::SERVER, false /*use_os_sep*/)
           << ">\n";
-      out << "#include <" << HeaderFile(a_defined_type, ClassNames::INTERFACE, false /*use_os_sep*/)
-          << ">\n";
+      out << "#include <"
+          << NdkHeaderFile(a_defined_type, ClassNames::INTERFACE, false /*use_os_sep*/) << ">\n";
     }
   });
 }
@@ -474,7 +480,7 @@
   const std::string clazz = ClassName(defined_type, ClassNames::CLIENT);
 
   out << "#pragma once\n\n";
-  out << "#include \"" << HeaderFile(defined_type, ClassNames::INTERFACE, false /*use_os_sep*/)
+  out << "#include \"" << NdkHeaderFile(defined_type, ClassNames::INTERFACE, false /*use_os_sep*/)
       << "\"\n";
   out << "\n";
   out << "#include <android/binder_ibinder.h>\n";
@@ -503,7 +509,7 @@
   const std::string clazz = ClassName(defined_type, ClassNames::SERVER);
 
   out << "#pragma once\n\n";
-  out << "#include \"" << HeaderFile(defined_type, ClassNames::INTERFACE, false /*use_os_sep*/)
+  out << "#include \"" << NdkHeaderFile(defined_type, ClassNames::INTERFACE, false /*use_os_sep*/)
       << "\"\n";
   out << "\n";
   out << "#include <android/binder_ibinder.h>\n";
@@ -596,7 +602,7 @@
                           const Options& /*options*/) {
   const std::string clazz = ClassName(defined_type, ClassNames::BASE);
 
-  out << "#include \"" << HeaderFile(defined_type, ClassNames::BASE, false /*use_os_sep*/)
+  out << "#include \"" << NdkHeaderFile(defined_type, ClassNames::BASE, false /*use_os_sep*/)
       << "\"\n";
   out << "\n";
   GenerateSourceIncludes(out, types, defined_type);