add support for ByteBuffer to ArrayBuffer conversion

Author: Mihail Slavchev

src/jni/Android.mk

@@ -65,7 +65,7 @@ LOCAL_MODULE    := NativeScript
 LOCAL_SRC_FILES :=	com_tns_AssetExtractor.cpp AssetExtractor.cpp\
 					com_tns_Platform.cpp NativePlatform.cpp \
 					com_tns_JsDebugger.cpp \
-					JEnv.cpp DirectBuffer.cpp NativeScriptException.cpp \
+					JEnv.cpp DirectBuffer.cpp ArrayBufferHelper.cpp NativeScriptException.cpp \
 					JsDebugger.cpp SimpleAllocator.cpp \
 					NativeScriptRuntime.cpp MetadataNode.cpp MetadataTreeNode.cpp MetadataReader.cpp \
 					MethodCache.cpp JavaObjectArrayCache.cpp \

src/jni/ArrayBufferHelper.cpp

@@ -0,0 +1,114 @@
+#include "ArrayBufferHelper.h"
+#include "JEnv.h"
+#include "V8GlobalHelpers.h"
+#include "NativeScriptException.h"
+#include <sstream>
+
+
+using namespace v8;
+using namespace tns;
+
+ArrayBufferHelper::ArrayBufferHelper(ObjectManager *objectManager)
+	: m_objectManager(objectManager), m_ByteBufferClass(nullptr), m_isDirectMethodID(nullptr)
+{
+}
+
+void ArrayBufferHelper::CreateConvertFunctions(const Local<Object>& global)
+{
+	auto isolate = Isolate::GetCurrent();
+	auto extData = External::New(isolate, this);
+	auto fromFunc = FunctionTemplate::New(isolate, CreateFromCallbackStatic, extData)->GetFunction();
+	auto ctx = isolate->GetCurrentContext();
+	auto arrBufferCtorFunc = global->Get(ConvertToV8String("ArrayBuffer")).As<Function>();
+	arrBufferCtorFunc->Set(ctx, ConvertToV8String("from"), fromFunc);
+}
+
+void ArrayBufferHelper::CreateFromCallbackStatic(const FunctionCallbackInfo<Value>& info)
+{
+	try
+	{
+		auto extData = info.Data().As<External>();
+		auto thiz = reinterpret_cast<ArrayBufferHelper*>(extData->Value());
+		thiz->CreateFromCallbackImpl(info);
+	}
+	catch (NativeScriptException& e)
+	{
+		e.ReThrowToV8();
+	}
+	catch (std::exception e) {
+		std::stringstream ss;
+		ss << "Error: c++ exception: " << e.what() << std::endl;
+		NativeScriptException nsEx(ss.str());
+		nsEx.ReThrowToV8();
+	}
+	catch (...) {
+		NativeScriptException nsEx(std::string("Error: c++ exception!"));
+		nsEx.ReThrowToV8();
+	}
+}
+
+void ArrayBufferHelper::CreateFromCallbackImpl(const FunctionCallbackInfo<Value>& info)
+{
+	auto isolate = info.GetIsolate();
+	auto len = info.Length();
+
+	if (len != 1)
+	{
+		throw NativeScriptException("Wrong number of arguments (1 expected)");
+	}
+
+	auto arg = info[0];
+
+	if (!arg->IsObject())
+	{
+		throw NativeScriptException("Wrong type of argument (object expected)");
+	}
+
+	auto argObj = arg.As<Object>();
+
+	auto obj = m_objectManager->GetJavaObjectByJsObject(argObj);
+
+	if (obj.IsNull())
+	{
+		throw NativeScriptException("Wrong type of argument (object expected)");
+	}
+
+	JEnv env;
+
+	if (m_ByteBufferClass == nullptr)
+	{
+		m_ByteBufferClass = env.FindClass("java/nio/ByteBuffer");
+		assert(m_ByteBufferClass != nullptr);
+	}
+
+	auto isByteBuffer = env.IsInstanceOf(obj, m_ByteBufferClass);
+
+	if (!isByteBuffer)
+	{
+		throw NativeScriptException("Wrong type of argument (ByteBuffer expected)");
+	}
+
+	if (m_isDirectMethodID == nullptr)
+	{
+		m_isDirectMethodID = env.GetMethodID(m_ByteBufferClass, "isDirect", "()Z");
+		assert(m_isDirectMethodID != nullptr);
+	}
+
+	auto ret = env.CallBooleanMethod(obj, m_isDirectMethodID);
+
+	auto isDirectBuffer = ret == JNI_TRUE;
+
+	if (!isDirectBuffer)
+	{
+		throw NativeScriptException("Direct ByteBuffer expected)");
+	}
+
+	auto data = env.GetDirectBufferAddress(obj);
+	auto size = env.GetDirectBufferCapacity(obj);
+
+	auto arrayBuffer = ArrayBuffer::New(isolate, data, size);
+	auto ctx = isolate->GetCurrentContext();
+	arrayBuffer->Set(ctx, ConvertToV8String("nativeObject"), argObj);
+
+	info.GetReturnValue().Set(arrayBuffer);
+}

src/jni/ArrayBufferHelper.h

@@ -0,0 +1,31 @@
+#ifndef ARRAYBUFFERHELPER_H_
+#define ARRAYBUFFERHELPER_H_
+
+#include "v8.h"
+#include "ObjectManager.h"
+
+namespace tns
+{
+	class ArrayBufferHelper
+	{
+		public:
+			ArrayBufferHelper(ObjectManager *objectManager);
+
+			void CreateConvertFunctions(const v8::Local<v8::Object>& global);
+
+		private:
+
+			static void CreateFromCallbackStatic(const v8::FunctionCallbackInfo<v8::Value>& info);
+
+			void CreateFromCallbackImpl(const v8::FunctionCallbackInfo<v8::Value>& info);
+
+			ObjectManager *m_objectManager;
+
+			jclass m_ByteBufferClass;
+
+			jmethodID m_isDirectMethodID;
+	};
+}
+
+
+#endif /* ARRAYBUFFERHELPER_H_ */

src/jni/NativePlatform.cpp

@@ -382,6 +382,9 @@ Isolate* NativePlatform::PrepareV8Runtime(JEnv& env, const string& filesPath, js
 
 	ArrayHelper::Init(g_objectManager, context);
 
+	s_arrayBufferHeper = ArrayBufferHelper(g_objectManager);
+	s_arrayBufferHeper.CreateConvertFunctions(global);
+
 	return isolate;
 }
 
@@ -398,45 +401,5 @@ jobject NativePlatform::ConvertJsValueToJavaObject(JEnv& env, const Local<Value>
 	return javaResult;
 }
 
-void NativePlatform::PrepareExtendFunction(Isolate *isolate, jstring filesPath)
-{
-	string fullPath = ArgConverter::jstringToString(filesPath);
-	fullPath.append("/internal/prepareExtend.js");
-
-	int length;
-	bool isNew;
-	const char* content = File::ReadText(fullPath, length, isNew);
-
-	TryCatch tc;
-	auto cmd = ConvertToV8String(content, length);
-
-	if (isNew)
-	{
-		delete[] content;
-	}
-
-	auto origin = ConvertToV8String(fullPath);
-	DEBUG_WRITE("Compiling prepareExtend.js script");
-
-	auto script = Script::Compile(cmd, origin);
-	DEBUG_WRITE("Compile prepareExtend.js script");
-
-	if (script.IsEmpty() || tc.HasCaught())
-	{
-		DEBUG_WRITE("Cannot compile prepareExtend.js script");
-		return;
-	}
-
-	DEBUG_WRITE("Compiled prepareExtend.js script");
-
-	script->Run();
-
-	if (tc.HasCaught())
-	{
-		throw NativeScriptException(tc);
-	}
-
-	DEBUG_WRITE("Executed prepareExtend.js script");
-}
-
 Isolate* NativePlatform::s_isolate = nullptr;
+ArrayBufferHelper NativePlatform::s_arrayBufferHeper = ArrayBufferHelper(nullptr);

src/jni/NativePlatform.h

@@ -5,6 +5,7 @@
 #include "JniLocalRef.h"
 #include "ObjectManager.h"
 #include "SimpleAllocator.h"
+#include "ArrayBufferHelper.h"
 
 jobject ConvertJsValueToJavaObject(tns::JEnv& env, const v8::Local<v8::Value>& value, int classReturnType);
 
@@ -26,11 +27,12 @@ namespace tns
 			bool LogEnabled = true;
 			private:
 
-			static void PrepareExtendFunction(v8::Isolate *isolate, jstring filesPath);
 			static v8::Isolate* PrepareV8Runtime(JEnv& env, const std::string& filesPath, jstring packageName, jobject jsDebugger);
 			static jobject ConvertJsValueToJavaObject(JEnv& env, const v8::Local<v8::Value>& value, int classReturnType);
 
 			static v8::Isolate *s_isolate;
+
+			static ArrayBufferHelper s_arrayBufferHeper;
 	};
 }
 

test-app/assets/app/mainpage.js

@@ -41,3 +41,4 @@ require("./tests/testNativeModules");
 require("./tests/requireExceptionTests");
 require("./tests/java-array-test");
 require("./tests/field-access-test");
+require("./tests/byte-buffer-test");

test-app/assets/app/tests/byte-buffer-test.js

@@ -0,0 +1,52 @@
+describe("Tests mapped ByteBuffer conversion", function () {
+	it("should convert ByteBuffer to ArrayBuffer", function () {
+		var bb = java.nio.ByteBuffer.allocateDirect(12);
+		var ab = ArrayBuffer.from(bb);
+		var int8arr = new Int8Array(ab);
+		expect(int8arr.length).toBe(12);
+		var int32arr = new Int32Array(ab);
+		expect(int32arr.length).toBe(3);
+	});
+
+	it("should share the same memory of all typed arrays", function () {
+		var bb = java.nio.ByteBuffer.allocateDirect(12);
+		var ab = ArrayBuffer.from(bb);
+		var int8arr = new Int8Array(ab);
+		expect(int8arr.length).toBe(12);
+		var int32arr = new Int32Array(ab);
+		expect(int32arr.length).toBe(3);
+		int8arr[0] = 0x11;
+		int8arr[1] = 0x22;
+		int8arr[2] = 0x33;
+		int8arr[3] = 0x44;
+		var value = int32arr[0];
+		expect(value).toBe(0x44332211);
+	});
+
+	it("should keep original ByteBuffer after conversion", function () {
+		var bb = java.nio.ByteBuffer.allocateDirect(12);
+		var ab = ArrayBuffer.from(bb);
+		var same = bb === ab.nativeObject;
+		expect(same).toBe(true);
+	});
+
+	it("should throw exception when ArrayBuffer.from is called with wrong number of arguments", function () {
+		var exceptionCaught = false;
+		try {
+			var ab = ArrayBuffer.from(1, 2);
+		} catch(e) {
+			exceptionCaught = true
+		}
+		expect(exceptionCaught).toBe(true);
+	});
+
+	it("should throw exception when ArrayBuffer.from is called with wrong argument type", function () {
+		var exceptionCaught = false;
+		try {
+			var ab = ArrayBuffer.from({});
+		} catch(e) {
+			exceptionCaught = true
+		}
+		expect(exceptionCaught).toBe(true);
+	});
+});