resolved issue #40 Make possible to handle uncaught exception in JavaScript

Author: Plamen5kov

build/project-template/.classpath

@@ -1,7 +1,10 @@
 // A sample code how to catch uncaught errors
 global.__onUncaughtError = function(error){
 	if(error.nativeException){
-		// false == do not continue execution
+		// false == do not continue executionW
+		Log("ERROR.MESSAGE:---- " + error.message);
+		Log("ERROR.STACK_TRACE:---- " + error.stackTrace);
+		
 		return false;
 	}
 

build/project-template/.project

@@ -159,23 +159,19 @@ void ExceptionUtil::OnUncaughtError(Handle<Message> message, Handle<Value> error
 	auto isFunction = handler->IsFunction();
 
 	if(!isEmpty && isFunction){
-		// call the global exception handler
 		Handle<Value> errorObject;
 
+		//if the passed error is object
 		if(error->IsObject()){
+			//create exception object
 			errorObject = error.As<Object>();
-			error.As<Object>()->Set(ConvertToV8String("message"), ConvertToV8String(errorMessage));
+			ExceptionUtil::SetMessageToErrorObject(errorMessage, errorObject);
 		}
 		else{
-			errorObject = Exception::Error(ConvertToV8String(errorMessage));
+			errorObject = Exception::Error(ConvertToV8String(errorMessage)); //get error object
 		}
 
-		auto thiz = Object::New(isolate);
-		auto func = handler.As<Function>();
-
-		// Notify the developer for the exception and let him do some additional job here
-		// TODO: Launching UI at this point may be erroneous, think how to prevent it
-		func->Call(thiz, 1, &errorObject);
+		CalllFuncWithError(isolate, handler, errorObject);
 
 		// check whether the developer marked the error as "Caught"
 		// As per discussion, it is safer to ALWAYS kill the application due to uncaught error(s)
@@ -189,6 +185,24 @@ void ExceptionUtil::OnUncaughtError(Handle<Message> message, Handle<Value> error
 	//NativeScriptRuntime::APP_FAIL(errorMessage.c_str());
 }
 
+void ExceptionUtil::SetMessageToErrorObject(const string &message, Handle<Value> errorObject){
+	errorObject.As<Object>()->Set(ConvertToV8String("message"), ConvertToV8String(message));
+}
+
+void ExceptionUtil::CalllFuncWithError(Isolate* isolate, Handle<Value> &handler, Handle<Value> errorObject){
+
+	if(!handler.IsEmpty() && handler->IsFunction())
+	{
+		auto func = handler.As<Function>();
+		auto thiz = Object::New(isolate);
+		func->Call(thiz, 1, &errorObject);
+	}
+	else
+	{
+		//throw exception, or fail in some way
+	}
+}
+
 string ExceptionUtil::GetErrorMessage(const Handle<Message>& message, const Handle<Value>& error){
 	stringstream ss;
 

build/project-template/AndroidManifest.xml

@@ -42,6 +42,8 @@ namespace tns
 		 */
 		static void OnUncaughtError(v8::Handle<v8::Message> message, v8::Handle<v8::Value> error);
 
+		static void CalllFuncWithError(v8::Isolate* isolate, v8::Handle<v8::Value> &handler, v8::Handle<v8::Value> errorObject);
+
 		static ExceptionUtil* GetInstance();
 
 	private:
@@ -55,6 +57,8 @@ namespace tns
 
 		static ExceptionUtil* instance;
 
+		static void SetMessageToErrorObject(const std::string &message, v8::Handle<v8::Value> errorObject);
+
 		bool initialized;
 
 		JavaVM *jvm;

build/project-template/project.properties

@@ -25,6 +25,10 @@ namespace tns {
 		return String::NewFromUtf8(Isolate::GetCurrent(), NATIVE_EXCEPTION.c_str());
 	}
 
+	Local<String> V8StringConstants::GetStackTrace(){
+		return String::NewFromUtf8(Isolate::GetCurrent(), STACK_TRACE.c_str());
+	}
+
 	Local<String> V8StringConstants::GetLongNumber(){
 		return String::NewFromUtf8(Isolate::GetCurrent(), LONG_NUMBER.c_str());
 	}
@@ -99,6 +103,7 @@ namespace tns {
 	const string V8StringConstants::EXTEND = "extend";
 	const string V8StringConstants::IS_PROTOTYPE_IMPLEMENTATION_OBJECT = "__isPrototypeImplementationObject";
 	const string V8StringConstants::NATIVE_EXCEPTION = "nativeException";
+	const string V8StringConstants::STACK_TRACE = "stackTrace";
 	const string V8StringConstants::LONG_NUMBER = "NativeScriptLongNumber";
 	const string V8StringConstants::PROTOTYPE = "prototype";
 	const string V8StringConstants::SUPER = "super";

build/project-template/res/values/strings.xml

@@ -33,6 +33,7 @@ namespace tns {
 			static v8::Local<v8::String> GetExtends();
 			static v8::Local<v8::String> GetIsPrototypeImplementationObject();
 			static v8::Local<v8::String> GetNativeException();
+			static v8::Local<v8::String> GetStackTrace();
 			static v8::Local<v8::String> GetLongNumber();
 			static v8::Local<v8::String> GetPrototype();
 			static v8::Local<v8::String> GetSuper();
@@ -57,6 +58,7 @@ namespace tns {
 			static const std::string EXTEND;
 			static const std::string IS_PROTOTYPE_IMPLEMENTATION_OBJECT;
 			static const std::string NATIVE_EXCEPTION;
+			static const std::string STACK_TRACE;
 			static const std::string LONG_NUMBER;
 			static const std::string PROTOTYPE;
 			static const std::string SUPER;

build/project-template/res/values/styles.xml

@@ -15,6 +15,7 @@
 #include "WeakRef.h"
 #include "NativeScriptAssert.h"
 #include "JsDebugger.h"
+#include "V8GlobalHelpers.h"
 #include <sstream>
 #include <android/log.h>
 #include <assert.h>
@@ -106,6 +107,7 @@ void PrepareV8Runtime(Isolate *isolate, JEnv& env, jstring filesPath, jstring pa
 	V8::SetCaptureStackTraceForUncaughtExceptions(true, 100, StackTrace::kOverview);
 	V8::AddMessageListener(ExceptionUtil::OnUncaughtError);
 
+	// says the New(); method will be deprecated soon and to use New(Isolate* isolate); instead
 	auto globalTemplate = ObjectTemplate::New();
 
 	globalTemplate->Set(ConvertToV8String("__startNativeScriptProfiler"), FunctionTemplate::New(isolate, NativeScriptRuntime::StartProfilerCallback));
@@ -517,3 +519,34 @@ extern "C" void Java_com_tns_Platform_adjustAmountOfExternalAllocatedMemoryNativ
 {
 	Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(usedMemory);
 }
+
+extern "C" void Java_com_tns_Platform_passUncaughtExceptionToJsNative(JNIEnv *env, jobject obj, jthrowable javaException, jstring javaStackTrace)
+{
+	Isolate* isolate = Isolate::GetCurrent();
+	HandleScope handleScope(isolate);
+
+	auto context = isolate->GetCurrentContext();
+	auto globalHandle = context->Global();
+	auto handler = globalHandle->Get(V8StringConstants::GetUncaughtError());
+
+	//set up v8 exception objects
+	auto message = "The application crashed because of an uncaught exception. You can look at the \"stackTrace\" or the \"nativeException\" for more information on the exception.";
+	auto errObj = Exception::Error(ConvertToV8String(message)).As<Object>();
+
+	jint javaObjectID = objectManager->GetOrCreateObjectId((jobject) javaException);
+	auto nativeExceptionObject = objectManager->GetJsObjectByJavaObject(javaObjectID);
+	auto stackTrace = ArgConverter::jstringToV8String(javaStackTrace);
+
+	if (nativeExceptionObject.IsEmpty())
+	{
+		string className = objectManager->GetClassName((jobject)javaException);
+		nativeExceptionObject = objectManager->CreateJSProxyInstance(javaObjectID, className);
+	}
+
+	//fill error object with information about the uncaught exception
+	errObj->Set(V8StringConstants::GetNativeException(), nativeExceptionObject);
+	errObj->Set(V8StringConstants::GetStackTrace(), stackTrace);
+
+	//send to JS
+	ExceptionUtil::GetInstance()->CalllFuncWithError(isolate, handler, errObj);
+}

src/assets/app/bootstrap.js

@@ -47,6 +47,8 @@ public class Platform
 
 	private static native void adjustAmountOfExternalAllocatedMemoryNative(long changeInBytes);
 
+	private static native void passUncaughtExceptionToJsNative(Throwable ex, String javaStackTrace);
+	
 	private static Context NativeScriptContext;
 
 	private static SparseArray<Object> strongInstances = new SparseArray<Object>();
@@ -162,6 +164,8 @@ public void uncaughtException(Thread thread, Throwable ex)
 						{
 							content = e.getMessage();
 						}
+						
+						passUncaughtExceptionToJsNative(ex, content);
 					}
 					finally
 					{
@@ -187,6 +191,8 @@ public void run()
 					{
 						h.uncaughtException(thread, ex);
 					}
+					
+					//TODO: should we kill application when an uncaught exception is thrown?!
 				}
 			};
 		}