MESSAGE("Build type: ${CMAKE_BUILD_TYPE}")
+
+# -----------------------------------------------------------------------------
+# Determine the feature configuration for optional API
+# -----------------------------------------------------------------------------
+
+IF(ENABLE_OPTIONAL_BT)
+ MESSAGE(STATUS "Bluetooth API Enabled")
+ ADD_DEFINITIONS( -DFEATURE_OPTIONAL_BT )
+ENDIF(ENABLE_OPTIONAL_BT)
+
+IF(ENABLE_OPTIONAL_CALL_HISTORY)
+ MESSAGE(STATUS "Callhistory API Enabled")
+ ADD_DEFINITIONS( -DFEATURE_OPTIONAL_CALL_HISTORY )
+ENDIF(ENABLE_OPTIONAL_CALL_HISTORY)
+
+IF(ENABLE_OPTIONAL_NBS)
+ MESSAGE(STATUS "Network Bearer Selection API Enabled")
+ ADD_DEFINITIONS( -DFEATURE_OPTIONAL_NBS )
+ENDIF(ENABLE_OPTIONAL_NBS)
+
+IF(ENABLE_OPTIONAL_NFC)
+ MESSAGE(STATUS "NFC API Enabled")
+ ADD_DEFINITIONS( -DFEATURE_OPTIONAL_NFC )
+ENDIF(ENABLE_OPTIONAL_NFC)
+
+IF(ENABLE_OPTIONAL_PUSH)
+ MESSAGE(STATUS "Push API Enabled")
+ ADD_DEFINITIONS( -DFEATURE_OPTIONAL_PUSH )
+ENDIF(ENABLE_OPTIONAL_PUSH)
+
+IF(ENABLE_OPTIONAL_SE)
+ MESSAGE(STATUS "Secure Element API Enabled")
+ ADD_DEFINITIONS( -DFEATURE_OPTIONAL_SE )
+ENDIF(ENABLE_OPTIONAL_SE)
+
# -----------------------------------------------------------------------------
# CFlags
# -----------------------------------------------------------------------------
Name: wrt-plugins-tizen
Summary: JavaScript plugins for WebRuntime
-Version: 0.4.28
-Release: 1
+Version: 0.4.29
+Release: 0
Group: Development/Libraries
License: Apache License, Version 2.0
Source0: %{name}-%{version}.tar.gz
export LDFLAGS+="-Wl,--rpath=%{PREFIX} -Wl,--as-needed"
-cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} -DDPL_LOG="ON" -DENABLE_TIME_TRACER="OFF"
+cmake \
+-DENABLE_OPTIONAL_BT=YES \
+-DENABLE_OPTIONAL_CALL_HISTORY=YES \
+-DENABLE_OPTIONAL_NBS=YES \
+-DENABLE_OPTIONAL_NFC=YES \
+-DENABLE_OPTIONAL_PUSH=YES \
+-DENABLE_OPTIONAL_SE=YES \
+. -DCMAKE_INSTALL_PREFIX=%{_prefix} -DDPL_LOG="ON" -DENABLE_TIME_TRACER="OFF"
make %{?jobs:-j%jobs}
#include <CommonsJavaScript/Validator.h>
#include <CommonsJavaScript/JSDOMExceptionFactory.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <Commons/Exception.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include "AlarmAbsolute.h"
return JSValueToObject(ctx, createJSObject(ctx, priv), exception);
} catch (const BasePlatformException& err) {
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(ctx, err);
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
return result;
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSDOMExceptionFactory.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <JSUtil.h>
#include <SecurityExceptions.h>
#include <Commons/Exception.h>
#include <Commons/Regex.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <JSApplicationControl.h>
#include <ApplicationControl.h>
#include <ApplicationConverter.h>
return JSValueMakeUndefined(ctx);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(ctx);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return result;
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return jsResult;
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
#include <CommonsJavaScript/Validator.h>
#include <CommonsJavaScript/JSDOMExceptionFactory.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <Commons/Exception.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include "plugin_config.h"
return JSValueToObject(ctx, createJSObject(ctx, delay, -1), exception);
}
} catch (const BasePlatformException& err) {
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(ctx, err);
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
return DeviceAPI::Common::JSUtil::toJSValueRef(ctx, result);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
return JSValueMakeNull(ctx);
}
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
} catch (...) {
DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
LoggerI("JSAlarmRelative delay = " << delay);
return DeviceAPI::Common::JSUtil::toJSValueRef(ctx, delay);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
} catch (...) {
DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
return DeviceAPI::Common::JSUtil::toJSValueRef(ctx, period);
}
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
} catch (...) {
DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
//
#include <CommonsJavaScript/JSCallbackManager.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <TimeTracer.h>
#include "ApplicationController.h"
#include "ApplicationConverter.h"
{
case ExceptionCodes::InvalidArgumentException:
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "given app id is not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "given app id is not found");
break;
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "platform exception");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "platform exception");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR,"unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
break;
}
return;
} Catch(Exception) {
LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
callbackManager->callOnError(error);
return;
switch (event->getExceptionCode())
{
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR,"given package is not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
break;
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR,"platform exception");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::INVALID_VALUES_ERROR, "invalid value");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "invalid value");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR,"unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
break;
}
return;
} Catch(Exception) {
LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
callbackManager->callOnError(error);
return;
switch (event->getExceptionCode())
{
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR,"given package is not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
break;
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR,"platform exception");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR,"unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
break;
}
return;
} Catch(Exception) {
LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
callbackManager->callOnError(error);
return;
switch (event->getExceptionCode())
{
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR,"given package is not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
break;
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR,"platform exception");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR,"unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
break;
}
return;
} Catch(Exception) {
LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
callbackManager->callOnError(error);
return;
switch (event->getExceptionCode())
{
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR,"given package is not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
break;
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR,"platform exception");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR,"unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
break;
}
return;
} Catch(Exception) {
LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
callbackManager->callOnError(error);
return;
switch (event->getExceptionCode())
{
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR,"given package is not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
break;
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR,"platform exception");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR,"unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
break;
}
return;
} Catch(Exception) {
LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
callbackManager->callOnError(error);
return;
#include <CommonsJavaScript/ScopedJSStringRef.h>
#include <Commons/RegexUtils.h>
#include <Commons/Exception.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include "ApplicationConverter.h"
#include "JSApplication.h"
#include <Commons/Exception.h>
#include <CommonsJavaScript/ScopedJSStringRef.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <JSUtil.h>
-//#include <JSTizenExceptionFactory.h>
-//#include <JSTizenException.h>
-//#include <SecurityExceptions.h>
+#include <JSWebAPIErrorFactory.h>
#include "ApplicationController.h"
#include "ApplicationConverter.h"
}
} Catch(WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- JSTizenExceptionFactory::postException(context, exception,JSTizenException::INVALID_VALUES_ERROR, "Invalid value error");
+ JSWebAPIErrorFactory::postException(context, exception,JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid value error");
}
return NULL;
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return converter->toJSValueRef(event->getRequestedAppControl());
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
#include <memory>
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/Converter.h>
-#include <JSWebAPIException.h>
//#include <Commons/Exception.h>
-//#include <JSWebAPIexception.h>
-//#include <JSTizenExceptionFactory.h>
-//#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "ApplicationCert.h"
#include "JSApplicationCert.h"
return converter.toJSValueRef(privateData->getValue());
}
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
#include <memory>
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/Converter.h>
-#include <JSWebAPIException.h>
-//#include <Commons/Exception.h>
-//#include <JSTizenExceptionFactory.h>
-//#include <JSTizenException.h>
#include "ApplicationContext.h"
+#include <JSWebAPIErrorFactory.h>
#include "JSApplicationContext.h"
#include <Export.h>
#include <Logger.h>
}
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
#include <CommonsJavaScript/PrivateObject.h>
#include <CommonsJavaScript/JSUtils.h>
#include <SecurityExceptions.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <Export.h>
//#include <Commons/Exception.h>
-//#include <JSTizenExceptionFactory.h>
-//#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "plugin_config.h"
appsvc->setAppControlDataArray(appControlDataArray);
}
} catch (const BasePlatformException& err) {
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(context, err);
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSApplicationControlPriv *priv = new JSApplicationControlPriv(context, appsvc);
JSApplicationControlPriv *priv = static_cast<JSApplicationControlPriv*>(JSObjectGetPrivate(object));
if (!priv) {
DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
try {
}
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
/* do not return undefined object to find method */
return NULL;
}
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return false;
#include <CommonsJavaScript/JSDOMExceptionFactory.h>
#include <ArgumentValidator.h>
-#include <JSWebAPIException.h>
-//#include <JSTizenExceptionFactory.h>
-//#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <JSUtil.h>
#include <Export.h>
#include "JSApplicationControlData.h"
return obj;
} catch (BasePlatformException &err) {
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(context, err);
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return converter.toJSValueRef(privateData->getValue());
}
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
return true;
}
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return false;
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/Converter.h>
#include <Commons/Exception.h>
-#include <JSWebAPIException.h>
-//#include <JSTizenExceptionFactory.h>
-//#include <JSTizenException.h>
#include "ApplicationInformation.h"
+#include <JSWebAPIErrorFactory.h>
#include "JSApplicationInformation.h"
#include "AppManagerWrapper.h"
#include <Export.h>
}
}
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
#include <CommonsJavaScript/Utils.h>
#include <CommonsJavaScript/ScopedJSStringRef.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <JSUtil.h>
#include <SecurityExceptions.h>
//#include <Commons/Exception.h>
-//#include <JSTizenExceptionFactory.h>
-//#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "ApplicationFactory.h"
#include "plugin_config.h"
return JSApplication::makeObject(context, event->getApp());
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getCurrentApplication().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.launch().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.kill().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.removeAppInfoEventListener().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
TIME_TRACER_ITEM_END("launchAppControlReply", 0);
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.launchAppControl().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.findAppControl().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
} catch (const BasePlatformException &err) {
LoggerE("BasePlatformException");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
LoggerE("etc...");
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppsContext().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return converter->toJSValueRefFromApplicationContext(event->getAppContext());
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppContext().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppsInfo().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return converter->toJSValueRefFromApplicationInformation(event->getAppInfo());
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppInfo().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return converter->toJSValueRef(id);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.addAppInfoEventListener().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.removeAppInfoEventListener().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return converter->toJSValueRefFromeApplicationCerts(event->getAppCerts());
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppCerts().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return converter->toJSValueRef(event->getSharedURI());
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
#include <CommonsJavaScript/JSUtils.h>
#include <SecurityExceptions.h>
#include <Commons/Exception.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "plugin_config.h"
#include "ApplicationConverter.h"
namespace DeviceAPI {
namespace Application {
+using WrtDeviceApis::Commons::NotFoundException;
+
JSClassRef JSRequestedApplicationControl::m_jsClassRef = NULL;
JSClassDefinition JSRequestedApplicationControl::m_classInfo = {
{
JSRequestedApplicationControlPriv *priv = static_cast<JSRequestedApplicationControlPriv*>(JSObjectGetPrivate(object));
if (!priv) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mistmatch error.");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mistmatch error.");
}
Try {
providerMgr->replyResult(resultArray);
} Catch (ConversionException) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception,JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
} Catch (NotFoundException) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception,JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
} Catch (NullPointerException) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception,JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
} Catch (Exception) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception,JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
return JSValueMakeUndefined(context);
providerMgr->replyFailure();
} Catch (NotFoundException) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception,JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
} Catch (NullPointerException) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception,JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
} Catch (Exception) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception,JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
return JSValueMakeUndefined(context);
#include <pcrecpp.h>
#include <Logger.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <system_info.h>
#include <JSUtil.h>
if(callback) {
JSContextRef context = callback->getContext();
ServiceNotAvailableException error("Bluetooth device is busy");
- callback->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(context, error));
+ callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
}
}
else {
if(callback) {
JSContextRef context = callback->getContext();
UnknownException error("Unknown error");
- callback->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(context, error));
+ callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
}
}
}
if(callback) {
JSContextRef context = callback->getContext();
UnknownException error("Unknown error");
- callback->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(context, error));
+ callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
}
}
JSContextRef context = callback->getContext();
UnknownException error("Unknown error");
- callback->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(context, error));
+ callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
}
/*
if(callback) {
JSContextRef context = callback->getContext();
UnknownException error("Unknown error");
- callback->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(context, error));
+ callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
}
}
if(callback) {
JSContextRef context = callback->getContext();
UnknownException error("Unknown error");
- callback->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(context, error));
+ callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
}
}
JSContextRef context = callback->getContext();
NotFoundException error("Not found");
if(callback)
- callback->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(context, error));
+ callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
// Update mConnReqMap
object->mConnReqMap.erase(iter);
LoggerE("Unknown exception");
userData->invokeCallback(
"error",
- JSWebAPIError::makeJSWebAPIError(userData->getContext(), UnknownException("Unknown exception"))
+ JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), UnknownException("Unknown exception"))
);
}
} else { // Not enabled
LoggerE("Bluetooth device is turned off");
userData->invokeCallback(
"error",
- JSWebAPIError::makeJSWebAPIError(userData->getContext(), ServiceNotAvailableException("Bluetooth device is turned off"))
+ JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), ServiceNotAvailableException("Bluetooth device is turned off"))
);
}
}
{
if(!isValidAddress(address)) {
LoggerE("Wrong address");
- userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), NotFoundException("Wrong address")));
+ userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), NotFoundException("Wrong address")));
return;
}
userData->invokeCallback(
"error",
- JSWebAPIError::makeJSWebAPIError(userData->getContext(), NotFoundException("There is no device with the given address"))
+ JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), NotFoundException("There is no device with the given address"))
);
}
LoggerE("Bluetooth device is turned off");
userData->invokeCallback(
"error",
- JSWebAPIError::makeJSWebAPIError(userData->getContext(), ServiceNotAvailableException("Bluetooth device is turned off"))
+ JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), ServiceNotAvailableException("Bluetooth device is turned off"))
);
}
}
{
if(!isValidUUID(uuid)) {
LoggerE("Wrong UUID");
- userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), InvalidValuesException("Wrong UUID")));
+ userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), InvalidValuesException("Wrong UUID")));
return;
}
bool isRegistered;
if(bt_adapter_is_service_used(uuid.c_str(), &isRegistered) == BT_ERROR_NONE && isRegistered == true) {
LoggerD("Already registered");
- userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), InvalidValuesException("Already registered")));
+ userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), InvalidValuesException("Already registered")));
return;
}
case BT_ERROR_INVALID_PARAMETER:
{
LoggerD("Invalid value");
- userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), InvalidValuesException("Invalid value")));
+ userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), InvalidValuesException("Invalid value")));
break;
}
default:
{
LoggerD("Unknown exception");
- userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), UnknownException("Unknown exception")));
+ userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), UnknownException("Unknown exception")));
}
}
case BT_ERROR_INVALID_PARAMETER:
{
LoggerD("Invalid value");
- userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), InvalidValuesException("Invalid value")));
+ userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), InvalidValuesException("Invalid value")));
break;
}
default:
{
LoggerD("Unknown exception");
- userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), UnknownException("Unknown exception")));
+ userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), UnknownException("Unknown exception")));
}
}
} else { // Not enabled
LoggerE("Bluetooth device is turned off");
userData->invokeCallback(
"error",
- JSWebAPIError::makeJSWebAPIError(userData->getContext(), ServiceNotAvailableException("Bluetooth device is turned off"))
+ JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), ServiceNotAvailableException("Bluetooth device is turned off"))
);
}
}
#include <Ecore.h>
#include <JSUtil.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include "BluetoothCallbackUtil.h"
#include "BluetoothAdapter.h"
case BluetoothCallbackUserData::BT_CB_ERROR:
{
LoggerD("BT_CB_ERROR");
- data->mUserData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(data->mUserData->getContext(), *(data->mError)));
+ data->mUserData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(data->mUserData->getContext(), *(data->mError)));
break;
}
case BluetoothCallbackUserData::BT_CB_DEVICE:
SET(DESTINATION_NAME ${bluetooth_dest})
SET(TARGET_IMPL_NAME ${bluetooth_impl})
+IF(ENABLE_OPTIONAL_BT)
PKG_SEARCH_MODULE(bluetooth REQUIRED capi-network-bluetooth)
PKG_SEARCH_MODULE(system-info REQUIRED capi-system-info)
INSTALL(TARGETS ${TARGET_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.xml DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
+ENDIF(ENABLE_OPTIONAL_BT)
INSTALL(
DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${DESTINATION_HEADER_PREFIX}/bluetooth
FILES_MATCHING PATTERN "*.h" PATTERN "CMakeFiles" EXCLUDE
#include <SecurityExceptions.h>
#include <JSUtil.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothAdapter.setName().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothAdapter.setPowered().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothAdapter.setVisible().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothAdapter.discoverDevices().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothAdapter.stopDiscovery().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothAdapter.getKnownDevices().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothAdapter.getDevice().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothAdapter.createBonding().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothAdapter.destroyBonding().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothAdapter.registerRFCOMMServiceByUUID().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
#include <SecurityExceptions.h>
#include <JSUtil.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
#include <PlatformException.h>
return JSUtil::toJSValueRef(context, priv->mClass->hasService(service));
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothClass.hasService().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
#include <SecurityExceptions.h>
#include <JSUtil.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
#include <PlatformException.h>
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothDevice.connectToServiceByUUID().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
#include <SecurityExceptions.h>
#include <JSUtil.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
#include <PlatformException.h>
return JSBluetoothAdapter::createJSObject(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothManager.getDefaultAdapter().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
#include <SecurityExceptions.h>
#include <JSUtil.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
#include <PlatformException.h>
return priv->setOnConnect(context, object);
}
} catch (const BasePlatformException &err) {
- JSWebAPIException::throwException(context, exception, err);
+ JSWebAPIErrorFactory::postException(context, exception, err);
}
return false;
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothServiceHandler.unregister().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
#include <SecurityExceptions.h>
#include <JSUtil.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
#include <PlatformException.h>
return priv->setOnError(context, object);
}
} catch (const BasePlatformException &err) {
- JSWebAPIException::throwException(context, exception, err);
+ JSWebAPIErrorFactory::postException(context, exception, err);
}
return false;
return JSUtil::toJSValueRef(context, priv->writeData(buffer, size));
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothSocket.writeData().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSUtil::toJSValueRef_(context, data);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothSocket.readData().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in BluetoothSocket.close().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
#include "JSBookmarkItem.h"
#include <queue>
#include <Ecore.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <PlatformException.h>
#include <favorites.h>
#include <Logger.h>
-using namespace WrtDeviceApis::CommonsJavaScript;
using namespace DeviceAPI::Common;
namespace DeviceAPI {
// limitations under the License.
//
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
#include <CommonsJavaScript/Converter.h>
#include <PlatformException.h>
-#include <JSWebAPIException.h>
#include "JSBookmarkFolder.h"
#include "BookmarkManager.h"
#include "BookmarkData.h"
} else
throw TypeMismatchException("Can't create BookmarkFolder");
} catch(const BasePlatformException& err){
- JSObjectRef error = JSWebAPIException::makeJSWebAPIException(ctx, err);
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
return convert.toJSValueRef(priv->m_title);
}
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}catch(const WrtDeviceApis::Commons::ConversionException& err){
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "converting fail");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "converting fail");
}
return JSValueMakeUndefined(context);
}
#include "JSBookmarkItem.h"
#include "JSBookmarkFolder.h"
#include "BookmarkData.h"
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <CommonsJavaScript/Converter.h>
#include <ArgumentValidator.h>
#include <PlatformException.h>
-#include <JSWebAPIException.h>
#include <Logger.h>
using namespace DeviceAPI::Common;
} else
throw TypeMismatchException("Can't create BookmarkItem");
}catch(const BasePlatformException& err){
- JSObjectRef error = JSWebAPIException::makeJSWebAPIException(ctx, err);
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
return convert.toJSValueRef(priv->m_url);
}
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}catch(const WrtDeviceApis::Commons::ConversionException& err){
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "converting fail");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "converting fail");
}
return JSValueMakeUndefined(context);
}
// limitations under the License.
//
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <CommonsJavaScript/Converter.h>
#include <GlobalContextManager.h>
#include "plugin_config.h"
#include <ArgumentValidator.h>
#include <PlatformException.h>
-#include <JSWebAPIException.h>
#include <CommonsJavaScript/Converter.h>
#include <TimeTracer.h>
return converter.toJSValueRef(bookmarksArray);
}catch( const BasePlatformException& err){
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
}
LoggerD("bookmark parent id:" << bookmark->m_parentId);
}catch( const BasePlatformException& err){
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(ctx);
BookmarkManager::getInstance()->remove(searchData);
}catch( const BasePlatformException& err){
- return JSWebAPIException::throwException(ctx, exception, err);
+ return JSWebAPIErrorFactory::postException(ctx, exception, err);
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(ctx);
JSCalendarAttendee.cpp
JSCalendarRecurrenceRule.cpp
JSCalendarAlarm.cpp
- CalendarAsyncCallbackManager.cpp
CalendarListenerManager.cpp
Calendar.cpp
CalendarManager.cpp
+++ /dev/null
-//
-// Tizen Web Device API
-// Copyright (c) 2012 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-
-#include "CalendarAsyncCallbackManager.h"
-
-namespace DeviceAPI {
-namespace Calendar {
-
-SINGLETON_IMPLEMENTATION(CalendarAsyncCallbackManager)
-
-} // Calendar
-} // DeviceAPI
#include "CalendarResponseDispatcher.h"
#include <CommonsJavaScript/JSCallbackManager.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include "CalendarConverter.h"
#include "JSCalendarEventId.h"
#include "CalendarMultiCallback.h"
#include "EventId.h"
-#include "CalendarAsyncCallbackManager.h"
+
#include <Logger.h>
+#include <GlobalContextManager.h>
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
+using namespace DeviceAPI::Common;
namespace DeviceAPI {
namespace Calendar {
{
JSCallbackManagerPtr cbm = DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
if (!cbm) {
- LoggerE("no callback manager");
- return;
+ LoggerE("no callback manager");
+ return;
+ }
+
+ if( !GlobalContextManager::getInstance()->isAliveGlobalContext(cbm->getContext())){
+ LoggerW("Global context invalidated.");
+ return;
}
Try
{
- CalendarAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(cbm);
-
if (event->getResult()) {
CalendarConverter converter(cbm->getContext());
const std::vector<ICalendarPtr> &results = event->getCalendars();
{
LoggerE("error during processing answer");
}
- JSValueRef errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ JSValueRef errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
cbm->callOnError(errorObject);
}
Try
{
if (!cbm) {
- LoggerD("no callback manager");
- return;
+ LoggerD("no callback manager");
+ return;
}
- CalendarAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(cbm);
+ if( !GlobalContextManager::getInstance()->isAliveGlobalContext(cbm->getContext())){
+ LoggerW("Global context invalidated.");
+ return;
+ }
if (event->getResult()) {
LoggerD("result success");
{
LoggerE("cannot convert event");
}
- JSValueRef errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ JSValueRef errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
cbm->callOnError(errorObject);
}
return;
}
- CalendarAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(cbm);
+ if( !GlobalContextManager::getInstance()->isAliveGlobalContext(cbm->getContext())){
+ LoggerW("Global context invalidated.");
+ return;
+ }
if (event->getResult()) {
cbm->callOnSuccess();
} else {
- JSValueRef errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ JSValueRef errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
cbm->callOnError(errorObject);
}
}
return;
}
- CalendarAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(cbm);
+ if( !GlobalContextManager::getInstance()->isAliveGlobalContext(cbm->getContext())){
+ LoggerW("Global context invalidated.");
+ return;
+ }
if (event->getResult()) {
cbm->callOnSuccess();
JSValueRef errorObject;
if (event->getExceptionCode() ==
ExceptionCodes::NotFoundException) {
- errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::NOT_FOUND_ERROR);
+ errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::NOT_FOUND_ERROR);
} else {
- errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
}
cbm->callOnError(errorObject);
}
{
JSCallbackManagerPtr cbm = DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
if (!cbm) {
- LoggerE("no callback manager");
- return;
+ LoggerE("no callback manager");
+ return;
}
+
+ if( !GlobalContextManager::getInstance()->isAliveGlobalContext(cbm->getContext())){
+ LoggerW("Global context invalidated.");
+ return;
+ }
+
Try
{
- CalendarAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(cbm);
-
if (event->getResult()) {
CalendarConverter converter(cbm->getContext());
} else {
JSValueRef errorObject;
if (event->getExceptionCode() == ExceptionCodes::InvalidArgumentException) {
- errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::INVALID_VALUES_ERROR);
+ errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::INVALID_VALUES_ERROR);
} else if (event->getExceptionCode() == ExceptionCodes::NotFoundException) {
- errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
} else {
- errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
}
cbm->callOnError(errorObject);
return;
Catch(Exception)
{
LoggerE("error during processing answer");
- JSValueRef errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ JSValueRef errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
cbm->callOnError(errorObject);
}
}
return;
}
- CalendarAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(cbm);
+ if( !GlobalContextManager::getInstance()->isAliveGlobalContext(cbm->getContext())){
+ LoggerW("Global context invalidated.");
+ return;
+ }
if (event->getResult()) {
CalendarConverter converter(cbm->getContext());
} else {
JSValueRef errorObject;
if (event->getExceptionCode()==ExceptionCodes::InvalidArgumentException) {
- errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::INVALID_VALUES_ERROR);
+ errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::INVALID_VALUES_ERROR);
} else if (event->getExceptionCode()==ExceptionCodes::NotFoundException) {
- errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::NOT_FOUND_ERROR);
+ errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::NOT_FOUND_ERROR);
} else {
- errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
}
cbm->callOnError(errorObject);
return;
Catch(Exception)
{
LoggerE("error during processing answer");
- JSValueRef errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ JSValueRef errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
cbm->callOnError(errorObject);
}
}
// limitations under the License.
//
+
#include "ICalendar.h"
#include "EventId.h"
#include "CalendarFactory.h"
#include <CommonsJavaScript/Utils.h>
#include <CommonsJavaScript/Validator.h>
#include <CommonsJavaScript/ScopedJSStringRef.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <TimeUtilConverter.h>
#include <TimeTracer.h>
#include <Logger.h>
#include <Export.h>
+#include <GlobalContextManager.h>
#include "JSCalendarManager.h"
#include "CalendarConverter.h"
#include "CalendarMultiCallback.h"
#include "CalendarFilterConverter.h"
-#include "CalendarAsyncCallbackManager.h"
#include "CalendarListenerManager.h"
using namespace WrtDeviceApis::Commons;
namespace DeviceAPI {
namespace Calendar {
+using WrtDeviceApis::Commons::UnknownException;
+using WrtDeviceApis::Commons::NotFoundException;
+
JSClassDefinition JSCalendar::m_classInfo = {
0,
kJSClassAttributeNone,
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
ICalendarPtr calendar = getCalendar(context, thisObject, NULL);
- JSContextRef globalContext = privateObject->getContext();
+ JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
CalendarConverter converter(context);
if (argumentCount<1) {
dplEvent->setForAsynchronousCall(&CalendarResponseDispatcher::getInstance());
calendar->addEvents(dplEvent);
- CalendarAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, globalContext);
-
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
ThrowMsg(ConversionException, "Object is null.");
}
- JSContextRef globalContext = privateObject->getContext();
+ JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
ICalendarPtr calendar = getCalendar(context, thisObject, exception);
dplEvent->setForAsynchronousCall(&CalendarResponseDispatcher::getInstance());
calendar->updateEvents(dplEvent);
- CalendarAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, globalContext);
-
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
}
ICalendarPtr calendar = getCalendar(context, thisObject, exception);
- JSContextRef globalContext = privateObject->getContext();
+ JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
CalendarConverter converter(context);
dplEvent->setForAsynchronousCall(&CalendarResponseDispatcher::getInstance());
calendar->deleteEvents(dplEvent);
- CalendarAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, globalContext);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
ICalendarPtr calendar = getCalendar(context, thisObject, exception);
- JSContextRef globalContext = privateObject->getContext();
+ JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
Validator validator(context, exception);
CalendarConverter converter(context);
calendar->findEvents(dplEvent);
- CalendarAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, globalContext);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
}
ICalendarPtr calendar = getCalendar(context, thisObject, exception);
- JSContextRef globalContext = privateObject->getContext();
+ JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
EventIdPtr itemId;
CalendarConverter converter(context);
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
}
ICalendarPtr calendar = getCalendar(context, thisObject, exception);
- JSContextRef globalContext = privateObject->getContext();
+ JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
CalendarConverter converter(context);
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
ICalendarPtr calendar = getCalendar(context, thisObject, exception);
- JSContextRef globalContext = privateObject->getContext();
+ JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
long watchId = -1;
CalendarConverter converter(context);
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
#include "JSCalendarAlarm.h"
#include "CalendarConverter.h"
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <CommonsJavaScript/Converter.h>
#include <TimeUtilConverter.h>
#include <JSTZDate.h>
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
//
#include "JSCalendarAttendee.h"
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <CommonsJavaScript/Converter.h>
#include "CalendarConverter.h"
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
#include "CalendarResponseDispatcher.h"
#include <TimeUtilConverter.h>
#include <JSTZDate.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
-#include "CalendarAsyncCallbackManager.h"
#include <GlobalContextManager.h>
#include <TimeTracer.h>
#include <Logger.h>
namespace DeviceAPI {
namespace Calendar {
+using WrtDeviceApis::Commons::UnknownException;
+using WrtDeviceApis::Commons::NotFoundException;
+
JSClassDefinition JSCalendarEvent::m_classInfo = {
0,
kJSClassAttributeNone,
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
ThrowMsg(ConversionException, "Parameter conversion failed.");
}
- JSContextRef globalContext = privateObject->getContext();
+ JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
CalendarConverter converter(context);
std::time_t startDate = 0;
dplEvent->setEndDate(endDate);
m_calendar->expandEventRecurrence(dplEvent);
- CalendarAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, globalContext);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
event = getPrivateObject(object);
if (event->getIsDetached()) {
LoggerW("Can't set the recurrenceRule of a detached event!");
- DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::NOT_SUPPORTED_ERROR);
+ DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR);
}
if (JSValueIsNull(context, value)) {
#include "JSCalendarEventId.h"
#include "CalendarConverter.h"
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <CommonsJavaScript/Converter.h>
#include <TimeUtilConverter.h>
#include <JSTZDate.h>
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
#include <CommonsJavaScript/PrivateObject.h>
#include <CommonsJavaScript/Converter.h>
#include <CommonsJavaScript/JSUtils.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <TimeUtilConverter.h>
#include <JSTZDate.h>
namespace DeviceAPI {
namespace Calendar {
+using WrtDeviceApis::Commons::UnknownException;
+using WrtDeviceApis::Commons::NotFoundException;
+
#define TIZEN_CALENDAR_ITEM_PROPERTIES_ATTRIBUTENAME "CalendarItemProperties"
JSClassDefinition JSCalendarItemProperties::m_classInfo = {
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
if (!item) {
ThrowMsg(ConversionException, "Parameter conversion failed.");
}
- JSContextRef globalContext = privateObject->getContext();
+ JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
// Call the copy constructor.
CalendarEventPtr clonedItem( new CalendarEvent(*item));
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
long length = converter.getDurationLength(value);
int unit = converter.getDurationUnit(value);
if (length < 0) {
- DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::INVALID_VALUES_ERROR);
+ DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::INVALID_VALUES_ERROR);
return false;
}
if( SECONDS_UNIT==unit ) {
} else if ( MSECS_UNIT==unit ) {
event->setEndTime(event->getStartTime() + length/1000);
} else {
- DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::INVALID_VALUES_ERROR);
+ DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::INVALID_VALUES_ERROR);
return false;
}
#include <CommonsJavaScript/PrivateObject.h>
#include <CommonsJavaScript/Utils.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <TimeTracer.h>
#include <Export.h>
+#include <Logger.h>
+#include <GlobalContextManager.h>
#include "JSCalendarManager.h"
#include "JSCalendar.h"
#include "CalendarResponseDispatcher.h"
#include "plugin_config.h"
-#include "CalendarAsyncCallbackManager.h"
-
-
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
using namespace DeviceAPI::Common;
namespace DeviceAPI {
namespace Calendar {
+using WrtDeviceApis::Commons::UnknownException;
+using WrtDeviceApis::Commons::NotFoundException;
+
JSClassDefinition JSCalendarManager::m_classInfo = {
0,
kJSClassAttributeNone,
CalendarConverter converter(context);
- JSContextRef globalContext = privateObject->getContext();
+ JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
JSCallbackManagerPtr cbm = JSCallbackManager::createObject(globalContext);
dplEvent->setForAsynchronousCall(&CalendarResponseDispatcher::getInstance());
privateObject->getObject()->getCalendars(dplEvent);
- CalendarAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, globalContext);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
}
// Global context should be passed to the calendar object.
- JSContextRef globalContext = privateObject->getContext();
+ JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
CalendarConverter converter(globalContext);
CalendarEvent::CalendarType calendarType = CalendarEvent::UNDEFINED_TYPE;
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
}
// Global context should be passed to the calendar object.
- JSContextRef globalContext = privateObject->getContext();
+ JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
CalendarConverter converter(globalContext);
CalendarEvent::CalendarType calendarType = CalendarEvent::UNDEFINED_TYPE;
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
}
// Global context should be passed to the calendar object.
- JSContextRef globalContext = privateObject->getContext();
+ JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
CalendarConverter converter(globalContext);
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
//
#include "JSCalendarRecurrenceRule.h"
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <CommonsJavaScript/Converter.h>
#include "CalendarConverter.h"
#include <TimeUtilConverter.h>
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
#include <CommonsJavaScript/PrivateObject.h>
#include <CommonsJavaScript/Converter.h>
#include <CommonsJavaScript/JSUtils.h>
-#include <JSTizenExceptionFactory.h>
#include "EventId.h"
#include "ICalendar.h"
#include "CalendarFactory.h"
#include "JSCalendarEventId.h"
#include <TimeUtilConverter.h>
#include <JSTZDate.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <GlobalContextManager.h>
#include <Logger.h>
#include <Export.h>
namespace DeviceAPI {
namespace Calendar {
+using WrtDeviceApis::Commons::UnknownException;
+
JSClassDefinition JSCalendarTask::m_classInfo = {
0,
kJSClassAttributeNone,
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
#include "JSCalendarEventId.h"
#include "JSCalendarAlarm.h"
-#include "CalendarAsyncCallbackManager.h"
#include "CalendarListenerManager.h"
#include <TimeTracer.h>
{
LoggerD("[Tizen\\Calendar] on_frame_unload_callback (" << context << ")");
- CalendarAsyncCallbackManagerSingleton::Instance().unregisterContext(static_cast<JSContextRef>(context));
CalendarListenerManagerSingleton::Instance().unregisterContext(static_cast<JSContextRef>(context));
DeviceAPI::Common::GlobalContextManager::getInstance()->removeGlobalContext(static_cast<JSContextRef>(context));
}
SET(DESTINATION_NAME ${callhistory_dest})
SET(TARGET_IMPL_NAME ${callhistory_impl})
+IF(ENABLE_OPTIONAL_CALL_HISTORY)
PKG_CHECK_MODULES(platform_pkgs_callhistory REQUIRED contacts-service2 glib-2.0 libpcrecpp)
INCLUDE_DIRECTORIES(
INSTALL(TARGETS ${TARGET_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.xml DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
+ENDIF(ENABLE_OPTIONAL_CALL_HISTORY)
INSTALL(
DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${DESTINATION_HEADER_PREFIX}/callhistory
FILES_MATCHING PATTERN "*.h" PATTERN "CMakeFiles" EXCLUDE
#include "EventCallHistoryListener.h"
#include "CallHistoryFactory.h"
#include "ICallHistory.h"
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
#include <SecurityExceptions.h>
#include <JSUtil.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
#include <TimeTracer.h>
#include <Logger.h>
TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
- bool bSuccess = false;
- bool bError = false;
-
if (argumentCount < 1) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
JSCallHistoryPriv *priv = static_cast<JSCallHistoryPriv*> (JSObjectGetPrivate(thisObject));
if (!priv) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
JSContextRef gContext = priv->getContext();
ArgumentValidator validator(context, argumentCount, arguments);
JSObjectRef successCB = validator.toFunction(0);
- if(successCB)
- bSuccess = true;
JSObjectRef errCB = validator.toFunction(1, true);
- if(errCB)
- bError = true;
unsigned long limit = validator.toULong(4, true);
unsigned long offset = validator.toULong(5, true);
- if (argumentCount >= 1) {
- if (JSValueIsNull(context, arguments[0]) || JSValueIsUndefined(context, arguments[0])) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : success callback ");
- } else if (!JSObjectIsFunction(context, converter.toJSObjectRef(arguments[0]))) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : success callback ");
- }
- cbm->setOnSuccess(arguments[0]);
- }
+ if(successCB != NULL)
+ cbm->setOnSuccess(successCB);
- if (argumentCount >= 2) {
- if (!JSValueIsNull(context, arguments[1]) && !JSValueIsUndefined(context, arguments[1])) {
- if (!JSObjectIsFunction(context, converter.toJSObjectRef(arguments[1]))) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : error callback ");
- }
- cbm->setOnError(arguments[1]);
- }
- }
+ if(errCB != NULL)
+ cbm->setOnError(errCB);
if (argumentCount >= 3) {
if (!JSValueIsNull(context, arguments[2]) && !JSValueIsUndefined(context, arguments[2])) {
if (!JSValueIsObject(context, arguments[2])) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : filter");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : filter");
}
}
}
event->setForAsynchronousCall(&ResponseDispatcher::getInstance());
if (argumentCount >= 3) {
+ if(JSValueIsUndefined(context, arguments[2])) {
+ throw DeviceAPI::Common::TypeMismatchException("Filter is undefined");
+ }
+
if(!JSValueIsNull(context, arguments[2])){
FilterPtr filter = filterConverter->toFilter(arguments[2]);
}else{
event ->setFilter(filter);
}
- }else if(JSValueIsUndefined(context, arguments[2])) {
- throw DeviceAPI::Common::TypeMismatchException("Filter is undefined");
}
}
if (argumentCount >= 4) {
+ if(JSValueIsUndefined(context, arguments[3])) {
+ throw DeviceAPI::Common::TypeMismatchException("Sortmode is undefined");
+ }
+
if (!JSValueIsNull(context, arguments[3])) {
DeviceAPI::Tizen::SortModePtr sortMode = filterConverter->toSortMode(arguments[3]);
}else{
event->setSortMode(filterConverter->toSortMode(arguments[3]));
}
- }else if(JSValueIsUndefined(context, arguments[3])) {
- throw DeviceAPI::Common::TypeMismatchException("Sortmode is undefined");
}
}
callHistory->find(event);
CallHistoryAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, gContext);
} catch(const BasePlatformException& err){
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::PlatformException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
JSObjectRef entryObj = validator.toObject(0);
if (argumentCount < 1) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
JSCallHistoryPriv *priv = static_cast<JSCallHistoryPriv*> (JSObjectGetPrivate(thisObject));
if (!priv) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
Converter converter(context);
if (!JSValueIsObjectOfClass(context, arguments[0], JSCallHistoryEntry::getClassRef())) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : CallHistoryEntry");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : CallHistoryEntry");
}
ICallHistoryPtr callHistory(priv->getObject());
callHistory->remove(entry->getEntryId());
}
} catch(const BasePlatformException& err){
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::PlatformException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage());
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
if (argumentCount < 1) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
JSCallHistoryPriv *priv = static_cast<JSCallHistoryPriv*> (JSObjectGetPrivate(thisObject));
if (!priv) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
JSContextRef gContext = priv->getContext();
JSObjectRef errCB = validator.toFunction(2, true);
if(successCB != NULL)
- cbm->setOnSuccess(arguments[1]);
+ cbm->setOnSuccess(successCB);
if(errCB != NULL)
- cbm->setOnError(arguments[2]);
+ cbm->setOnError(errCB);
cbm->setObject(thisObject);
callHistory->removeBatch(event);
CallHistoryAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, gContext);
} else {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, "Invalid values error : Entry array is empty"));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid values error : Entry array is empty"));
}
} catch(const BasePlatformException& err){
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::PlatformException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
JSCallHistoryPriv *priv = static_cast<JSCallHistoryPriv*> (JSObjectGetPrivate(thisObject));
if (!priv) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
JSContextRef gContext = priv->getContext();
callHistory->removeAll(event);
CallHistoryAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, gContext);
} catch(const BasePlatformException& err){
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::PlatformException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
-JSValueRef JSCallHistory::deleteRecording(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
- const JSValueRef arguments[], JSValueRef* exception) {
-
- return JSValueMakeUndefined(context);
-}
-
JSValueRef JSCallHistory::addChangeListener(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
const JSValueRef arguments[], JSValueRef* exception) {
JSObjectRef observerObj = validator.toCallbackObject(0, false,"onadded","onchanged","onremoved",NULL);
if (argumentCount < 1) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
JSCallHistoryPriv *priv = static_cast<JSCallHistoryPriv*> (JSObjectGetPrivate(thisObject));
if (!priv) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
JSContextRef gContext = priv->getContext();
return JSUtil::toJSValueRef(context, id);
} catch(const BasePlatformException& err){
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::PlatformException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage());
}
}
JSCallHistoryPriv *priv = static_cast<JSCallHistoryPriv*> (JSObjectGetPrivate(thisObject));
if (!priv) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
JSContextRef gContext = priv->getContext();
ICallHistoryPtr callHistory(priv->getObject());
callHistory->removeListener(handle);
} else {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid values error : handle");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid values error : handle");
}
CallHistoryListenerCancellerPtr canceller = CallHistoryListenerCancellerPtr(new CallHistoryListenerCanceller(gContext, thisObject, handle));
DeviceAPI::Common::IListenerItemPtr listenerItem = DPL::StaticPointerCast<DeviceAPI::Common::IListenerItem>(canceller);
CallHistoryListenerManagerSingleton::Instance().unregisterListener(listenerItem);
} catch(const BasePlatformException& err){
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::PlatformException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage());
}
return JSValueMakeUndefined(context);
JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
JSValueRef* exception);
- static JSValueRef deleteRecording(JSContextRef context, JSObjectRef object,
- JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
- JSValueRef* exception);
-
static JSValueRef addChangeListener(JSContextRef context, JSObjectRef object,
JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
JSValueRef* exception);
#include "CallHistoryFactory.h"
#include "ICallHistoryEntry.h"
#include "CallHistoryDefine.h"
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include "JSCallHistoryEntry.h"
#include "JSRemoteParty.h"
{
JSCallHistoryEntryPriv *priv = static_cast<JSCallHistoryEntryPriv*>(JSObjectGetPrivate(object));
if (!priv) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
try {
return convert.toJSValueRef(entryInfo->getDuration());
}
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage());
}
return NULL;
}
{
JSCallHistoryEntryPriv *priv = static_cast<JSCallHistoryEntryPriv*>(JSObjectGetPrivate(object));
if (!priv) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
Converter converter(context);
}
}
} catch (const WrtDeviceApis::Commons::Exception& ex) {
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
}
return false;
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSDOMExceptionFactory.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "CallHistoryDefine.h"
#include "RemoteParty.h"
#include "JSRemoteParty.h"
{
JSRemotePartyPriv *priv = static_cast<JSRemotePartyPriv*>(JSObjectGetPrivate(object));
if (!priv) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
try {
return convert.toJSValueRef(remoteParty->getPersonId());
}
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage());
}
return NULL;
}
#include <Commons/IEvent.h>
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "JSCallHistory.h"
#include "Converter.h"
#include "CallHistoryAsyncCallbackManager.h"
try {
data->callOnSuccess(converter.toJSValueRef(event->getResult(), data->getContext()));
} catch(WrtDeviceApis::Commons::ConversionException) {
- data->callOnError(JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::UNKNOWN_ERROR, "Unknown error"));
+ data->callOnError(JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error"));
} catch(WrtDeviceApis::Commons::Exception) {
- data->callOnError(JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::UNKNOWN_ERROR, "Unknown error"));
+ data->callOnError(JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error"));
}
} else {
JSObjectRef jsException = NULL;
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
} else {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
}
data->callOnError(jsException);
}
} else {
JSObjectRef jsException = NULL;
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
} else {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
}
data->callOnError(jsException);
}
} else {
JSObjectRef jsException = NULL;
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
} else {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
}
data->callOnError(jsException);
}
SET(SRCS
- JSTizenException.cpp
- TizenExceptionData.cpp
- JSTizenExceptionFactory.cpp
- JSWebAPIError.cpp
- JSWebAPIException.cpp
CallbackUserData.cpp
GlobalContextManager.cpp
ArgumentValidator.cpp
JSUtil.cpp
PlatformException.cpp
MultiCallbackUserData.cpp
+ JSStringRefWrapper.cpp
JSWebAPIErrorFactory.cpp
- JSWebAPIError2.cpp
+ JSWebAPIError.cpp
+ JSWebAPIException.cpp
WebAPIError.cpp
PropertyBag.cpp
JSArray.cpp
--- /dev/null
+//
+// Tizen Web Device API
+// Copyright (c) 2012 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "JSStringRefWrapper.h"
+
+namespace DeviceAPI {
+namespace Common {
+
+JSStringRefWrapper::JSStringRefWrapper(JSStringRefWrapper &obj) : m_ref(NULL)
+{
+ JSStringRef ref = obj.m_ref;
+ if(ref)
+ {
+ const JSChar* chars = JSStringGetCharactersPtr(ref);
+ size_t numChars = JSStringGetLength(ref);
+
+ m_ref = JSStringCreateWithCharacters(chars, numChars);
+ }
+}
+
+JSStringRefWrapper::JSStringRefWrapper(JSStringRef ref) : m_ref(ref)
+{
+}
+
+JSStringRefWrapper::JSStringRefWrapper(const std::string str)
+{
+ m_ref = JSStringCreateWithUTF8CString(str.c_str());
+}
+
+JSStringRefWrapper::JSStringRefWrapper(const char * str)
+{
+ m_ref = JSStringCreateWithUTF8CString(str);
+}
+
+JSStringRefWrapper::~JSStringRefWrapper()
+{
+ if (m_ref != NULL)
+ JSStringRelease(m_ref);
+}
+
+JSStringRefWrapper & JSStringRefWrapper::operator=(const JSStringRefWrapper &obj)
+{
+ JSStringRef ref = obj.m_ref;
+
+ if (m_ref != NULL)
+ JSStringRelease(m_ref);
+
+ if(ref)
+ {
+ const JSChar* chars = JSStringGetCharactersPtr(ref);
+ size_t numChars = JSStringGetLength(ref);
+
+ m_ref = JSStringCreateWithCharacters(chars, numChars);
+ }
+ else
+ {
+ m_ref = NULL;
+ }
+
+ return *this;
+}
+
+JSStringRef JSStringRefWrapper::get() const
+{
+ return m_ref;
+}
+
+} // Common
+} // DeviceAPI
// limitations under the License.
//
+#ifndef _JS_STRING_REF_WRAPPER_H_
+#define _JS_STRING_REF_WRAPPER_H_
-#ifndef _TIZEN_CALENDAR_ASYNC_CALLBACK_MANAGER_H_
-#define _TIZEN_CALENDAR_ASYNC_CALLBACK_MANAGER_H_
-
-#include <AsyncCallbackManager.h>
+#include <string>
+#include <JavaScriptCore/JavaScript.h>
namespace DeviceAPI {
-namespace Calendar {
+namespace Common {
-class CalendarAsyncCallbackManager : public DeviceAPI::Common::AsyncCallbackManager
+class JSStringRefWrapper
{
-private:
- CalendarAsyncCallbackManager()
- {
- }
-
public:
- virtual ~CalendarAsyncCallbackManager()
- {
- }
+ JSStringRefWrapper(JSStringRefWrapper &obj);
+ JSStringRefWrapper(JSStringRef ref);
+ JSStringRefWrapper(const std::string str);
+ JSStringRefWrapper(const char * str);
+ virtual ~JSStringRefWrapper();
- friend class CalendarAsyncCallbackManagerSingleton;
-};
+ JSStringRefWrapper & operator=(const JSStringRefWrapper &obj);
-SINGLETON_DEFINITION(CalendarAsyncCallbackManager)
+ JSStringRef get() const;
+
+private:
+ JSStringRef m_ref;
+};
-} // Calendar
+} // Common
} // DeviceAPI
-#endif // _TIZEN_CALENDAR_ASYNC_CALLBACK_MANAGER_H_
+#endif // _JS_STRING_REF_WRAPPER_H_
+++ /dev/null
-//
-// Tizen Web Device API
-// Copyright (c) 2012 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "JSTizenException.h"
-#include <CommonsJavaScript/Converter.h>
-#include "Logger.h"
-
-namespace DeviceAPI {
-namespace Common {
-
- const std::string JSTizenException::UNKNOWN_ERROR = "UnknownError";
- const std::string JSTizenException::TYPE_MISMATCH_ERROR = "TypeMismatchError";
- const std::string JSTizenException::INVALID_VALUES_ERROR = "InvalidValuesError";
- const std::string JSTizenException::TIMEOUT_ERROR = "TimeoutError";
- const std::string JSTizenException::IO_ERROR = "IOError";
- const std::string JSTizenException::NOT_SUPPORTED_ERROR = "NotSupportedError";
- const std::string JSTizenException::PERMISSION_DENIED_ERROR = "SecurityError";
- const std::string JSTizenException::NOT_FOUND_ERROR = "NotFoundError";
- const std::string JSTizenException::SERVICE_NOT_AVAILABLE = "ServiceNotAvailableError";
- const std::string JSTizenException::NETWORK_ERROR = "NetworkError";
- const std::string JSTizenException::INVALID_ACCESS_ERROR = "InvalidAccessError";
-
- namespace{
- #define PLUGIN_NAME "TizenException"
- #define PROPERTY_NAME "name"
- #define PROPERTY_MESSAGE "message"
-
- const std::string PROPERTY_ERROR[] = {
- DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR,
- DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR,
- DeviceAPI::Common::JSTizenException::INVALID_VALUES_ERROR,
- DeviceAPI::Common::JSTizenException::TIMEOUT_ERROR,
- DeviceAPI::Common::JSTizenException::IO_ERROR,
- DeviceAPI::Common::JSTizenException::NOT_SUPPORTED_ERROR,
- DeviceAPI::Common::JSTizenException::PERMISSION_DENIED_ERROR,
- DeviceAPI::Common::JSTizenException::NOT_FOUND_ERROR,
- DeviceAPI::Common::JSTizenException::NETWORK_ERROR,
- DeviceAPI::Common::JSTizenException::INVALID_ACCESS_ERROR,
- };
- }
-
- JSClassRef JSTizenException::m_classRef = NULL;
-
- JSClassDefinition JSTizenException::m_classInfo = {
- 0,
- kJSClassAttributeNone,
- PLUGIN_NAME,
- 0,
- m_properties,
- NULL, //__function,
- initialize,
- finalize,
- hasProperty,
- NULL,
- NULL, //SetProperty,
- NULL, //DeleteProperty,
- NULL,
- NULL, //CallAsFunction,
- NULL, //CallAsConstructor,
- hasInstance,
- NULL, //ConvertToType,
- };
-
- JSStaticValue JSTizenException::m_properties[] = {
- { PROPERTY_NAME, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_MESSAGE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { 0, 0, 0, 0 }
- };
-
- const JSClassDefinition* JSTizenException::getClassInfo() {
- return &m_classInfo;
- }
-
- JSClassRef JSTizenException::getClassRef() {
- if (!m_classRef) {
- m_classRef = JSClassCreate(&m_classInfo);
- }
- return m_classRef;
- }
-
- void JSTizenException::initialize(JSContextRef /*context*/, JSObjectRef /*object*/) {
- }
-
- void JSTizenException::finalize(JSObjectRef object) {
- PrivateObject* privateObject = static_cast<PrivateObject*> (JSObjectGetPrivate(object));
- if (privateObject) {
- JSObjectSetPrivate(object, NULL);
- delete privateObject;
- }
- }
-
- bool JSTizenException::hasProperty(JSContextRef /*context*/, JSObjectRef /*object*/, JSStringRef propertyName) {
- const size_t size = sizeof(PROPERTY_ERROR) / sizeof(PROPERTY_ERROR[0]);
- for (size_t i = 0; i < size; ++i) {
- if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_ERROR[i].c_str())) {
- return true;
- }
- }
- return false;
- }
-
- JSValueRef JSTizenException::getStaticProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* /*exception*/) {
- PrivateObject* privateObject = static_cast<PrivateObject*> (JSObjectGetPrivate(object));
- if (!privateObject) {
- LoggerE("Private object is not set.");
- return JSValueMakeUndefined(context);
- }
-
-// WrtDeviceApis::CommonsJavaScript::Converter converter(context);
-// try {
-// if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NAME)) {
-// return converter.toJSValueRef(privateObject->getObject()->getName());
-// } else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_MESSAGE)) {
-// return converter.toJSValueRef(privateObject->getObject()->getMessage());
-// }
-// } catch (const WrtDeviceApis::Commons::ConversionException& ex) {
-// LoggerE("Exception: " << ex.GetMessage());
-// }
-
- return JSValueMakeUndefined(context);
- }
-
- bool JSTizenException::hasInstance(JSContextRef context, JSObjectRef /*constructor*/, JSValueRef possibleInstance, JSValueRef* /*exception*/) {
- return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
- }
-
-} // Common
-}// DeviceAPI
\ No newline at end of file
+++ /dev/null
-//
-// Tizen Web Device API
-// Copyright (c) 2012 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef JSTIZENEXCEPTION_H_
-#define JSTIZENEXCEPTION_H_
-
-#include <JavaScriptCore/JavaScript.h>
-#include <CommonsJavaScript/PrivateObject.h>
-
-#include "TizenExceptionData.h"
-
-namespace DeviceAPI {
-namespace Common {
-
- /**
- * @deprecated
- * TizenException is deprecated. use JSWebAPIError instead.
- */
- class JSTizenException {
- public:
- typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<TizenExceptionDataPtr>::Type PrivateObject;
-
- public:
- static const std::string UNKNOWN_ERROR;
- static const std::string TYPE_MISMATCH_ERROR;
- static const std::string INVALID_VALUES_ERROR;
- static const std::string TIMEOUT_ERROR;
- static const std::string IO_ERROR;
- static const std::string NOT_SUPPORTED_ERROR;
- static const std::string PERMISSION_DENIED_ERROR;
- static const std::string NOT_FOUND_ERROR;
- static const std::string SERVICE_NOT_AVAILABLE;
- static const std::string NETWORK_ERROR;
- static const std::string INVALID_ACCESS_ERROR;
- public:
- static JSClassRef getClassRef();
-
- static const JSClassDefinition* getClassInfo();
-
- private:
- /**
- * The callback invoked when an object is first created.
- */
- static void initialize(JSContextRef context, JSObjectRef object);
-
- /**
- * The callback invoked when an object is finalized.
- */
- static void finalize(JSObjectRef object);
-
- /**
- * The callback invoked when getting a property's value.
- */
- static bool hasProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName);
-
- /**
- * The callback invoked when getting a property's value.
- */
- static JSValueRef getStaticProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception);
-
- /**
- * The callback invoked when an object is used as the target of an 'instanceof' expression.
- */
- static bool hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef possibleInstance, JSValueRef* exception);
-
- /**
- * This structure contains properties and callbacks that define a type of object.
- */
- static JSClassDefinition m_classInfo;
-
- /**
- * This structure describes a statically declared value property.
- */
- static JSStaticValue m_properties[];
-
- static JSClassRef m_classRef;
- };
-
-}// Common
-}// DeviceAPI
-
-#endif /* JSTIZENEXCEPTION_H_ */
+++ /dev/null
-//
-// Tizen Web Device API
-// Copyright (c) 2012 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "JSTizenExceptionFactory.h"
-#include <dpl/assert.h>
-#include <CommonsJavaScript/JSUtils.h>
-#include "TizenExceptionData.h"
-#include "JSWebAPIError.h"
-#include "JSWebAPIException.h"
-#include "Logger.h"
-
-namespace DeviceAPI {
-namespace Common {
-
- JSTizenExceptionFactory::JSTizenExceptionFactory() {
- }
-
- JSTizenExceptionFactory::~JSTizenExceptionFactory() {
- }
-
- JSObjectRef JSTizenExceptionFactory::makeErrorObject(JSContextRef context, const std::string& name, const std::string& message) {
-
- int code = JSWebAPIError::convertToWebAPIErrorCode(name);
-
- JSWebAPIError::PrivateObject::ObjectType data(new TizenExceptionData(code, name, message));
- return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(context, JSWebAPIError::getClassRef(), data);
- }
-
- JSValueRef JSTizenExceptionFactory::postException(JSContextRef context, JSValueRef* exception, const std::string& name, const std::string& message) {
- Assert(exception && "Exception object can't be NULL.");
-
- int code = JSWebAPIException::convertToWebAPIExceptionCode(name);
-
- JSWebAPIError::PrivateObject::ObjectType data(new TizenExceptionData(code, name, message));
- *exception = WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(context, JSWebAPIException::getClassRef(), data);
- return JSValueMakeUndefined(context);
- }
-}// Common
-}// DeviceAP
\ No newline at end of file
+++ /dev/null
-//
-// Tizen Web Device API
-// Copyright (c) 2012 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef JSTIZENEXCEPTIONFACTORY_H_
-#define JSTIZENEXCEPTIONFACTORY_H_
-
-
-#include <string>
-#include <dpl/noncopyable.h>
-#include <JavaScriptCore/JavaScript.h>
-
-namespace DeviceAPI {
-namespace Common {
-
- class JSTizenExceptionFactory : public DPL::Noncopyable {
- public:
- JSTizenExceptionFactory();
- virtual ~JSTizenExceptionFactory();
-
- public:
- static JSObjectRef makeErrorObject(JSContextRef context, const std::string& name, const std::string& message=std::string());
- static JSValueRef postException (JSContextRef context, JSValueRef* exception, const std::string& name, const std::string& message=std::string());
- };
-
-}// Common
-}// DeviceAPI
-
-
-#endif /* JSTIZENEXCEPTIONFACTORY_H_ */
//
#include "JSWebAPIError.h"
-#include <CommonsJavaScript/Converter.h>
-#include <CommonsJavaScript/JSUtils.h>
+
#include <string>
+#include <map>
+#include "JSUtil.h"
#include "Logger.h"
namespace DeviceAPI {
namespace Common {
-namespace{
+#define CLASS_NAME "WebAPIError"
+#define PROPERTY_CODE "code"
+#define PROPERTY_NAME "name"
+#define PROPERTY_TYPE "type"
+#define PROPERTY_MESSAGE "message"
- #define PLUGIN_NAME "WebAPIError"
- #define PROPERTY_CODE "code"
- #define PROPERTY_NAME "name"
- #define PROPERTY_TYPE "type"
- #define PROPERTY_MESSAGE "message"
+#define PROPERTY_INDEX_SIZE_ERR "INDEX_SIZE_ERR"
+#define PROPERTY_DOMSTRING_SIZE_ERR "DOMSTRING_SIZE_ERR"
+#define PROPERTY_HIERARCHY_REQUEST_ERR "HIERARCHY_REQUEST_ERR"
+#define PROPERTY_WRONG_DOCUMENT_ERR "WRONG_DOCUMENT_ERR"
+#define PROPERTY_INVALID_CHARACTER_ERR "INVALID_CHARACTER_ERR"
+#define PROPERTY_NO_DATA_ALLOWED_ERR "NO_DATA_ALLOWED_ERR"
+#define PROPERTY_NO_MODIFICATION_ALLOWED_ERR "NO_MODIFICATION_ALLOWED_ERR"
+#define PROPERTY_NOT_FOUND_ERR "NOT_FOUND_ERR"
+#define PROPERTY_NOT_SUPPORTED_ERR "NOT_SUPPORTED_ERR"
+#define PROPERTY_INUSE_ATTRIBUTE_ERR "INUSE_ATTRIBUTE_ERR"
+#define PROPERTY_INVALID_STATE_ERR "INVALID_STATE_ERR"
+#define PROPERTY_SYNTAX_ERR "SYNTAX_ERR"
+#define PROPERTY_INVALID_MODIFICATION_ERR "INVALID_MODIFICATION_ERR"
+#define PROPERTY_NAMESPACE_ERR "NAMESPACE_ERR"
+#define PROPERTY_INVALID_ACCESS_ERR "INVALID_ACCESS_ERR"
+#define PROPERTY_VALIDATION_ERR "VALIDATION_ERR"
+#define PROPERTY_TYPE_MISMATCH_ERR "TYPE_MISMATCH_ERR"
+#define PROPERTY_SECURITY_ERR "SECURITY_ERR"
+#define PROPERTY_NETWORK_ERR "NETWORK_ERR"
+#define PROPERTY_ABORT_ERR "ABORT_ERR"
+#define PROPERTY_URL_MISMATCH_ERR "URL_MISMATCH_ERR"
+#define PROPERTY_QUOTA_EXCEEDED_ERR "QUOTA_EXCEEDED_ERR"
+#define PROPERTY_TIMEOUT_ERR "TIMEOUT_ERR"
+#define PROPERTY_INVALID_NODE_TYPE_ERR "INVALID_NODE_TYPE_ERR"
+#define PROPERTY_DATA_CLONE_ERR "DATA_CLONE_ERR"
- #define PROPERTY_UNKNOWN_ERR "UNKNOWN_ERR"
- #define PROPERTY_INDEX_SIZE_ERR "INDEX_SIZE_ERR"
- #define PROPERTY_DOMSTRING_SIZE_ERR "DOMSTRING_SIZE_ERR"
- #define PROPERTY_HIERARCHY_REQUEST_ERR "HIERARCHY_REQUEST_ERR"
- #define PROPERTY_WRONG_DOCUMENT_ERR "WRONG_DOCUMENT_ERR"
- #define PROPERTY_INVALID_CHARACTER_ERR "INVALID_CHARACTER_ERR"
- #define PROPERTY_NO_DATA_ALLOWED_ERR "NO_DATA_ALLOWED_ERR"
- #define PROPERTY_NO_MODIFICATION_ALLOWED_ERR "NO_MODIFICATION_ALLOWED_ERR"
- #define PROPERTY_NOT_FOUND_ERR "NOT_FOUND_ERR"
- #define PROPERTY_NOT_SUPPORTED_ERR "NOT_SUPPORTED_ERR"
- #define PROPERTY_INUSE_ATTRIBUTE_ERR "INUSE_ATTRIBUTE_ERR"
- #define PROPERTY_INVALID_STATE_ERR "INVALID_STATE_ERR"
- #define PROPERTY_SYNTAX_ERR "SYNTAX_ERR"
- #define PROPERTY_INVALID_MODIFICATION_ERR "INVALID_MODIFICATION_ERR"
- #define PROPERTY_NAMESPACE_ERR "NAMESPACE_ERR"
- #define PROPERTY_INVALID_ACCESS_ERR "INVALID_ACCESS_ERR"
- #define PROPERTY_VALIDATION_ERR "VALIDATION_ERR"
- #define PROPERTY_TYPE_MISMATCH_ERR "TYPE_MISMATCH_ERR"
- #define PROPERTY_SECURITY_ERR "SECURITY_ERR"
- #define PROPERTY_NETWORK_ERR "NETWORK_ERR"
- #define PROPERTY_ABORT_ERR "ABORT_ERR"
- #define PROPERTY_URL_MISMATCH_ERR "URL_MISMATCH_ERR"
- #define PROPERTY_QUOTA_EXCEEDED_ERR "QUOTA_EXCEEDED_ERR"
- #define PROPERTY_TIMEOUT_ERR "TIMEOUT_ERR"
- #define PROPERTY_INVALID_NODE_TYPE_ERR "INVALID_NODE_TYPE_ERR"
- #define PROPERTY_DATA_CLONE_ERR "DATA_CLONE_ERR"
- #define PROPERTY_INVALID_VALUES_ERR "INVALID_VALUES_ERR"
- #define PROPERTY_IO_ERR "IO_ERR"
- #define PROPERTY_OUT_OF_MEMORY_ERR "OUT_OF_MEMORY_ERR"
- #define PROPERTY_NOT_CONNECTED_SERVICE_ERR "NOT_CONNECTED_SERVICE_ERR"
- #define PROPERTY_FAIL_TO_REQUEST_ERR "FAIL_TO_REQUEST_ERR"
- #define PROPERTY_INVALID_RESPONSE_ERR "INVALID_RESPONSE_ERR"
- #define PROPERTY_NO_AVAILABLE_NETWORK_ERR "NO_AVAILABLE_NETWORK_ERR"
- #define PROPERTY_INVALID_DEVICE_ERR "INVALID_DEVICE_ERR"
- #define PROPERTY_NOT_SUPPORTED_FUNCTION_ERR "NOT_SUPPORTED_FUNCTION_ERR"
- #define PROPERTY_NO_PERMISSION_ERR "NO_PERMISSION_ERR"
- #define PROPERTY_INVALID_ITEM_ERR "INVALID_ITEM_ERR"
- #define PROPERTY_FAIL_TO_PLAY_ERR "FAIL_TO_PLAY_ERR"
- #define PROPERTY_SERVICE_NOT_AVAILABLE "SERVICE_NOT_AVAILABLE"
- #define PROPERTY_AVPLAY_NETWORK_DISCONNECTED_ERR "AVPLAY_NETWORK_DISCONNECTED_ERR"
- #define PROPERTY_AVPLAY_UNSUPPORTED_VIDEO_FORMAT_ERR "AVPLAY_UNSUPPORTED_VIDEO_FORMAT_ERR"
- #define PROPERTY_AVPLAY_UNSUPPORTED_AUDIO_FORMAT_ERR "AVPLAY_UNSUPPORTED_AUDIO_FORMAT_ERR"
- #define PROPERTY_AVPLAY_UNSUPPORTED_VIDEO_RESOLUTION_ERR "AVPLAY_UNSUPPORTED_VIDEO_RESOLUTION_ERR"
- #define PROPERTY_AVPLAY_UNSUPPORTED_VIDEO_FRAMERATE_ERR "AVPLAY_UNSUPPORTED_VIDEO_FRAMERATE_ERR"
- #define PROPERTY_AVPLAY_CURRUPTED_STREAM_ERR "AVPLAY_CURRUPTED_STREAM_ERR"
- }
+typedef std::map<std::string, int> DeviceAPIErrorCodeMap;
- JSClassRef JSWebAPIError::m_classRef = NULL;
+static DeviceAPIErrorCodeMap errorCodes = {
+ { PROPERTY_INDEX_SIZE_ERR, 1 },
+ { PROPERTY_DOMSTRING_SIZE_ERR, 2 },
+ { PROPERTY_HIERARCHY_REQUEST_ERR, 3 },
+ { PROPERTY_WRONG_DOCUMENT_ERR, 4 },
+ { PROPERTY_INVALID_CHARACTER_ERR, 5 },
+ { PROPERTY_NO_DATA_ALLOWED_ERR, 6 },
+ { PROPERTY_NO_MODIFICATION_ALLOWED_ERR, 7 },
+ { PROPERTY_NOT_FOUND_ERR, 8 },
+ { PROPERTY_NOT_SUPPORTED_ERR, 9 },
+ { PROPERTY_INUSE_ATTRIBUTE_ERR, 10 },
+ { PROPERTY_INVALID_STATE_ERR, 11 },
+ { PROPERTY_SYNTAX_ERR, 12 },
+ { PROPERTY_INVALID_MODIFICATION_ERR, 13 },
+ { PROPERTY_NAMESPACE_ERR, 14 },
+ { PROPERTY_INVALID_ACCESS_ERR, 15 },
+ { PROPERTY_VALIDATION_ERR, 16 },
+ { PROPERTY_TYPE_MISMATCH_ERR, 17 },
+ { PROPERTY_SECURITY_ERR, 18 },
+ { PROPERTY_NETWORK_ERR, 19 },
+ { PROPERTY_ABORT_ERR, 20 },
+ { PROPERTY_URL_MISMATCH_ERR, 21 },
+ { PROPERTY_QUOTA_EXCEEDED_ERR, 22 },
+ { PROPERTY_TIMEOUT_ERR, 23 },
+ { PROPERTY_INVALID_NODE_TYPE_ERR, 24 },
+ { PROPERTY_DATA_CLONE_ERR, 25 }
+};
- JSClassDefinition JSWebAPIError::m_classInfo = {
- 0,
- kJSClassAttributeNone,
- PLUGIN_NAME,
- 0,
- m_properties,
- m_function, //__function,
- initialize,
- finalize,
- NULL,
- NULL,
- NULL, //SetProperty,
- NULL, //DeleteProperty,
- NULL,
- NULL, //CallAsFunction,
- NULL, //CallAsConstructor,
- hasInstance,
- NULL, //ConvertToType,
- };
+JSClassRef JSWebAPIError::m_classRef = NULL;
- JSStaticFunction JSWebAPIError::m_function[] = {
- { "toString", toString, kJSPropertyAttributeNone },
- { 0, 0, 0 }
- };
+JSClassDefinition JSWebAPIError::m_classInfo =
+{
+ 0,
+ kJSClassAttributeNone,
+ CLASS_NAME,
+ 0,
+ m_properties,
+ m_function,
+ initialize,
+ finalize,
+ NULL, // hasProperty,
+ NULL, // getProperty,
+ NULL, // setProperty,
+ NULL, // deleteProperty,
+ NULL, // getPropertyNames,
+ NULL, // callAsFunction,
+ NULL, // callAsConstructor,
+ hasInstance,
+ NULL, // convertToType,
+};
+JSStaticFunction JSWebAPIError::m_function[] =
+{
+ { "toString", toString, kJSPropertyAttributeNone },
+ { 0, 0, 0 }
+};
- JSStaticValue JSWebAPIError::m_properties[] = {
- { PROPERTY_CODE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NAME, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_TYPE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_MESSAGE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+JSStaticValue JSWebAPIError::m_properties[] = {
+ { PROPERTY_CODE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_NAME, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_TYPE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_MESSAGE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_UNKNOWN_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INDEX_SIZE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_DOMSTRING_SIZE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_HIERARCHY_REQUEST_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_WRONG_DOCUMENT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_CHARACTER_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NO_DATA_ALLOWED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NO_MODIFICATION_ALLOWED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NOT_FOUND_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NOT_SUPPORTED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INUSE_ATTRIBUTE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_STATE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_SYNTAX_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_MODIFICATION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NAMESPACE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_ACCESS_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_VALIDATION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_TYPE_MISMATCH_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_SECURITY_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NETWORK_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_ABORT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_URL_MISMATCH_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_QUOTA_EXCEEDED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_TIMEOUT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_NODE_TYPE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_DATA_CLONE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_VALUES_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_IO_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_OUT_OF_MEMORY_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NOT_CONNECTED_SERVICE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_FAIL_TO_REQUEST_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_RESPONSE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NO_AVAILABLE_NETWORK_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_DEVICE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NOT_SUPPORTED_FUNCTION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NO_PERMISSION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_ITEM_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_FAIL_TO_PLAY_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_SERVICE_NOT_AVAILABLE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_AVPLAY_NETWORK_DISCONNECTED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_AVPLAY_UNSUPPORTED_VIDEO_FORMAT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_AVPLAY_UNSUPPORTED_AUDIO_FORMAT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_AVPLAY_UNSUPPORTED_VIDEO_RESOLUTION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_AVPLAY_UNSUPPORTED_VIDEO_FRAMERATE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_AVPLAY_CURRUPTED_STREAM_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { 0, 0, 0, 0 }
- };
+ { PROPERTY_INDEX_SIZE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_DOMSTRING_SIZE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_HIERARCHY_REQUEST_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_WRONG_DOCUMENT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_INVALID_CHARACTER_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_NO_DATA_ALLOWED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_NO_MODIFICATION_ALLOWED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_NOT_FOUND_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_NOT_SUPPORTED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_INUSE_ATTRIBUTE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_INVALID_STATE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_SYNTAX_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_INVALID_MODIFICATION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_NAMESPACE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_INVALID_ACCESS_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_VALIDATION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_TYPE_MISMATCH_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_SECURITY_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_NETWORK_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_ABORT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_URL_MISMATCH_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_QUOTA_EXCEEDED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_TIMEOUT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_INVALID_NODE_TYPE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { PROPERTY_DATA_CLONE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
+ { 0, 0, 0, 0 }
+};
- const JSClassDefinition* JSWebAPIError::getClassInfo() {
- return &m_classInfo;
- }
+const JSClassDefinition* JSWebAPIError::getClassInfo()
+{
+ return &m_classInfo;
+}
- JSClassRef JSWebAPIError::getClassRef() {
- if (!m_classRef) {
- m_classRef = JSClassCreate(&m_classInfo);
- }
- return m_classRef;
- }
+JSClassRef JSWebAPIError::getClassRef()
+{
+ if (!m_classRef)
+ {
+ m_classRef = JSClassCreate(&m_classInfo);
+ }
+ return m_classRef;
+}
- void JSWebAPIError::initialize(JSContextRef /*context*/, JSObjectRef /*object*/) {
- }
+bool JSWebAPIError::isObjectOfClass(JSContextRef context, JSValueRef value)
+{
+ return JSValueIsObjectOfClass(context, value, getClassRef());
+}
- void JSWebAPIError::finalize(JSObjectRef object) {
- PrivateObject* privateObject = static_cast<PrivateObject*> (JSObjectGetPrivate(object));
- if (privateObject) {
- JSObjectSetPrivate(object, NULL);
- delete privateObject;
- }
- }
+JSObjectRef JSWebAPIError::createJSObject(JSContextRef context, WebAPIError* webapiError)
+{
+ JSObjectRef jsObjectRef = JSObjectMake(context, getClassRef(), static_cast<void*>(webapiError));
+ if (NULL == jsObjectRef) {
+ LoggerE("object creation error");
+ return NULL;
+ }
+ return jsObjectRef;
+}
- JSValueRef JSWebAPIError::getStaticProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* /*exception*/) {
- PrivateObject* privateObject = static_cast<PrivateObject*> (JSObjectGetPrivate(object));
- if (!privateObject) {
- LoggerE("Private object is not set.");
- return JSValueMakeUndefined(context);
- }
+WebAPIError* JSWebAPIError::getPriv(JSContextRef context, JSObjectRef object)
+{
+ if(!JSValueIsObjectOfClass(context, object, getClassRef()))
+ return NULL;
- WrtDeviceApis::CommonsJavaScript::Converter converter(context);
- try {
- if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_CODE)) {
- LoggerD("propertyName PROPERTY_CODE");
- return converter.toJSValueRef(privateObject->getObject()->getCode());
- } else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NAME)) {
- return converter.toJSValueRef(privateObject->getObject()->getName());
- } else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_TYPE)) {
- return converter.toJSValueRef(privateObject->getObject()->getName());
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_MESSAGE)) {
- return converter.toJSValueRef(privateObject->getObject()->getMessage());
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_UNKNOWN_ERR)) {
- return converter.toJSValueRef(UNKNOWN_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INDEX_SIZE_ERR)) {
- return converter.toJSValueRef(INDEX_SIZE_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_DOMSTRING_SIZE_ERR)) {
- return converter.toJSValueRef(DOMSTRING_SIZE_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_HIERARCHY_REQUEST_ERR)) {
- return converter.toJSValueRef(HIERARCHY_REQUEST_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_WRONG_DOCUMENT_ERR)) {
- return converter.toJSValueRef(WRONG_DOCUMENT_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INVALID_CHARACTER_ERR)) {
- return converter.toJSValueRef(INVALID_CHARACTER_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NO_DATA_ALLOWED_ERR)) {
- return converter.toJSValueRef(NO_DATA_ALLOWED_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NO_MODIFICATION_ALLOWED_ERR)) {
- return converter.toJSValueRef(NO_MODIFICATION_ALLOWED_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NOT_FOUND_ERR)) {
- return converter.toJSValueRef(NOT_FOUND_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NOT_SUPPORTED_ERR)) {
- return converter.toJSValueRef(NOT_SUPPORTED_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INUSE_ATTRIBUTE_ERR)) {
- return converter.toJSValueRef(INUSE_ATTRIBUTE_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INVALID_STATE_ERR)) {
- return converter.toJSValueRef(INVALID_STATE_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_SYNTAX_ERR)) {
- return converter.toJSValueRef(SYNTAX_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INVALID_MODIFICATION_ERR)) {
- return converter.toJSValueRef(INVALID_MODIFICATION_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NAMESPACE_ERR)) {
- return converter.toJSValueRef(NAMESPACE_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INVALID_ACCESS_ERR)) {
- return converter.toJSValueRef(INVALID_ACCESS_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_VALIDATION_ERR)) {
- return converter.toJSValueRef(VALIDATION_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_TYPE_MISMATCH_ERR)) {
- return converter.toJSValueRef(TYPE_MISMATCH_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_SECURITY_ERR)) {
- return converter.toJSValueRef(SECURITY_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NETWORK_ERR)) {
- return converter.toJSValueRef(NETWORK_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_ABORT_ERR)) {
- return converter.toJSValueRef(ABORT_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_URL_MISMATCH_ERR)) {
- return converter.toJSValueRef(URL_MISMATCH_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_QUOTA_EXCEEDED_ERR)) {
- return converter.toJSValueRef(QUOTA_EXCEEDED_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_TIMEOUT_ERR)) {
- return converter.toJSValueRef(TIMEOUT_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INVALID_NODE_TYPE_ERR)) {
- return converter.toJSValueRef(INVALID_NODE_TYPE_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_DATA_CLONE_ERR)) {
- return converter.toJSValueRef(DATA_CLONE_ERR);
- }else{
- LoggerD("propertyName not supported");
- return converter.toJSValueRef(UNKNOWN_ERR);
- }
- } catch (const WrtDeviceApis::Commons::ConversionException& ex) {
- LoggerE("Exception: " << ex.GetMessage());
- }
+ return static_cast<WebAPIError*>(JSObjectGetPrivate(object));
+}
- return JSValueMakeUndefined(context);
- }
+void JSWebAPIError::initialize(JSContextRef /*context*/, JSObjectRef /*object*/)
+{
+}
- JSValueRef JSWebAPIError::toString(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception){
- PrivateObject* privateObject = static_cast<PrivateObject*> (JSObjectGetPrivate(thisObject));
- if (!privateObject) {
- return NULL;
- }
+void JSWebAPIError::finalize(JSObjectRef object)
+{
+ WebAPIError* webapiErrObj = static_cast<WebAPIError*>(JSObjectGetPrivate(object));
+ if(webapiErrObj)
+ {
+ JSObjectSetPrivate(object, NULL);
+ delete webapiErrObj;
+ }
+}
- WrtDeviceApis::CommonsJavaScript::Converter converter(context);
- std::string name = privateObject->getObject()->getName();
- std::string message = privateObject->getObject()->getMessage();
- std::string result = name + ": "+message;
- return converter.toJSValueRef(result);
- }
+JSValueRef JSWebAPIError::getStaticProperty(JSContextRef context,
+ JSObjectRef object,
+ JSStringRef propertyName,
+ JSValueRef* /*exception*/)
+{
+ WebAPIError* webapiErrObj = getPriv(context, object);
+ if(!webapiErrObj)
+ {
+ LoggerE("Private object is not set.");
+ return JSValueMakeUndefined(context);
+ }
- bool JSWebAPIError::hasInstance(JSContextRef context, JSObjectRef /*constructor*/, JSValueRef possibleInstance, JSValueRef* /*exception*/) {
- return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
+ try
+ {
+ std::string propertyNameStr = JSUtil::JSStringToString(context, propertyName);
+
+ if (propertyNameStr == PROPERTY_CODE)
+ {
+ return JSUtil::toJSValueRef(context, static_cast<long>(webapiErrObj->getCode()));
+ }
+ else if (propertyNameStr == PROPERTY_NAME)
+ {
+ return JSUtil::toJSValueRef(context, webapiErrObj->getName());
+ }
+ else if (propertyNameStr == PROPERTY_TYPE)
+ {
+ return JSUtil::toJSValueRef(context, webapiErrObj->getName());
}
+ else if (propertyNameStr == PROPERTY_MESSAGE)
+ {
+ return JSUtil::toJSValueRef(context, webapiErrObj->getMessage());
+ }
+ else // Error codes
+ {
+ DeviceAPIErrorCodeMap::iterator iter = errorCodes.find(propertyNameStr);
+ if(iter != errorCodes.end())
+ return JSUtil::toJSValueRef(context, static_cast<long>(iter->second));
+ }
+ }
+ catch(const BasePlatformException & err)
+ {
+ LoggerE("Exception: " << err.getMessage());
+ }
- int JSWebAPIError::convertToWebAPIErrorCode(const std::string& errorName){
- LoggerD("<<< errorName:[" << errorName << "]");
+ return JSValueMakeUndefined(context);
+}
- int retErrorCode = -1;
+JSValueRef JSWebAPIError::toString(JSContextRef context,
+ JSObjectRef object,
+ JSObjectRef thisObject,
+ size_t argumentCount,
+ const JSValueRef arguments[],
+ JSValueRef* exception)
+{
+ WebAPIError* webapiErrObj = getPriv(context, thisObject);
+ if(!webapiErrObj)
+ {
+ LoggerE("Private object is not set.");
+ return NULL;
+ }
- if(errorName.compare(JSTizenException::UNKNOWN_ERROR) == 0){
- retErrorCode = UNKNOWN_ERR;
- }else if(errorName.compare(JSTizenException::NOT_FOUND_ERROR) == 0){
- retErrorCode = NOT_FOUND_ERR;
- }else if(errorName.compare(JSTizenException::NOT_SUPPORTED_ERROR) == 0){
- retErrorCode = NOT_SUPPORTED_ERR;
- }else if(errorName.compare(JSTizenException::TYPE_MISMATCH_ERROR) == 0){
- retErrorCode = TYPE_MISMATCH_ERR;
- }else if(errorName.compare(JSTizenException::PERMISSION_DENIED_ERROR) == 0){
- retErrorCode = SECURITY_ERR;
- }else if(errorName.compare(JSTizenException::TIMEOUT_ERROR) == 0){
- retErrorCode = TIMEOUT_ERR;
- }else if(errorName.compare(JSTizenException::INVALID_VALUES_ERROR) == 0){
- retErrorCode = 0;
- }else if(errorName.compare(JSTizenException::IO_ERROR) == 0){
- retErrorCode = 0;
- }else if(errorName.compare(JSTizenException::SERVICE_NOT_AVAILABLE) == 0){
- retErrorCode = 0;
- }else if(errorName.compare(JSTizenException::NETWORK_ERROR) == 0){
- retErrorCode = NETWORK_ERR;
- }else{
- retErrorCode = UNKNOWN_ERR;
- }
+ std::string name = webapiErrObj->getName();
+ std::string message = webapiErrObj->getMessage();
- LoggerD(">>> retERrorCode:" << retErrorCode );
- return retErrorCode;
- }
+ std::string result = name + ": " + message;
- JSObjectRef JSWebAPIError::makeJSWebAPIError(JSContextRef context, const BasePlatformException& error){
- JSWebAPIError::PrivateObject::ObjectType data(new TizenExceptionData(error.getCode(), error.getName(), error.getMessage()));
- return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(context, JSWebAPIError::getClassRef(), data);
- }
- JSValueRef JSWebAPIError::throwException(JSContextRef context, JSValueRef* exception, const BasePlatformException& error){
- Assert(exception && "Exception object can't be NULL.");
+ return JSUtil::toJSValueRef(context, result);
+}
- *exception = makeJSWebAPIError(context, error);
- return JSValueMakeUndefined(context);
- }
+bool JSWebAPIError::hasInstance(JSContextRef context,
+ JSObjectRef /*constructor*/,
+ JSValueRef possibleInstance,
+ JSValueRef* /*exception*/)
+{
+ return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
+}
-}// Common
-}// DeviceAPI
+} // Common
+} // DeviceAPI
// limitations under the License.
//
-#ifndef JSWEBAPIERROR_H_
-#define JSWEBAPIERROR_H_
+// TODO This object will replace JSWebAPIError.
+// The numeric suffix ('2') will be removed after replacing JSWebAPIError.
+
+#ifndef _JS_WEBAPI_ERROR2_H_
+#define _JS_WEBAPI_ERROR2_H_
#include <JavaScriptCore/JavaScript.h>
-#include <CommonsJavaScript/PrivateObject.h>
+#include "JSWebAPIErrorFactory.h"
-#include "JSTizenException.h"
-#include "PlatformException.h"
+#include "WebAPIError.h"
namespace DeviceAPI {
namespace Common {
- class JSWebAPIError {
- public:
- typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<TizenExceptionDataPtr>::Type PrivateObject;
-
- static JSClassRef getClassRef();
- static const JSClassDefinition* getClassInfo();
-
- static int convertToWebAPIErrorCode(const std::string& errorName);
-
- static JSObjectRef makeJSWebAPIError(JSContextRef context, const BasePlatformException& error);
- static JSValueRef throwException(JSContextRef context, JSValueRef* exception, const BasePlatformException& error);
-
- private:
- /**
- * The callback invoked when an object is first created.
- */
- static void initialize(JSContextRef context, JSObjectRef object);
-
- /**
- * The callback invoked when an object is finalized.
- */
- static void finalize(JSObjectRef object);
-
- /**
- * The callback invoked when getting a property's value.
- */
- static JSValueRef getStaticProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception);
-
- /**
- * The callback invoked when an object is used as the target of an 'instanceof' expression.
- */
- static bool hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef possibleInstance, JSValueRef* exception);
-
-
- static JSValueRef toString(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);
-
-
- /**
- * This structure contains properties and callbacks that define a type of object.
- */
- static JSClassDefinition m_classInfo;
-
- /**
- * This structure describes a statically declared value property.
- */
- static JSStaticValue m_properties[];
-
- static JSClassRef m_classRef;
-
- static JSStaticFunction m_function[];
-
- public:
- enum{
- UNKNOWN_ERR = 0,
- INDEX_SIZE_ERR = 1,
- DOMSTRING_SIZE_ERR = 2,
- HIERARCHY_REQUEST_ERR = 3,
- WRONG_DOCUMENT_ERR = 4,
- INVALID_CHARACTER_ERR = 5,
- NO_DATA_ALLOWED_ERR = 6,
- NO_MODIFICATION_ALLOWED_ERR = 7,
- NOT_FOUND_ERR = 8,
- NOT_SUPPORTED_ERR = 9,
- INUSE_ATTRIBUTE_ERR = 10,
- INVALID_STATE_ERR = 11,
- SYNTAX_ERR = 12,
- INVALID_MODIFICATION_ERR = 13,
- NAMESPACE_ERR = 14,
- INVALID_ACCESS_ERR = 15,
- VALIDATION_ERR = 16,
- TYPE_MISMATCH_ERR = 17,
- SECURITY_ERR = 18,
- NETWORK_ERR = 19,
- ABORT_ERR = 20,
- URL_MISMATCH_ERR = 21,
- QUOTA_EXCEEDED_ERR = 22,
- TIMEOUT_ERR = 23,
- INVALID_NODE_TYPE_ERR = 24,
- DATA_CLONE_ERR = 25,
-
- }; //WebAPIError
- };
-
-}// Common
-}// DeviceAPI
-#endif /* JSWEBAPIERROR_H_ */
+class JSWebAPIErrorFactory;
+
+class JSWebAPIError
+{
+public:
+ static JSClassRef getClassRef();
+
+ static const JSClassDefinition* getClassInfo();
+
+ static bool isObjectOfClass(JSContextRef context, JSValueRef value);
+
+private:
+ static JSObjectRef createJSObject(JSContextRef context, WebAPIError* webapiError);
+
+ static WebAPIError* getPriv(JSContextRef context, JSObjectRef object);
+
+ static void initialize(JSContextRef context, JSObjectRef object);
+
+ static void finalize(JSObjectRef object);
+
+ static JSValueRef getStaticProperty(JSContextRef context,
+ JSObjectRef object,
+ JSStringRef propertyName,
+ JSValueRef* exception);
+
+ static bool hasInstance(JSContextRef context,
+ JSObjectRef constructor,
+ JSValueRef possibleInstance,
+ JSValueRef* exception);
+
+ static JSValueRef toString(JSContextRef context,
+ JSObjectRef object,
+ JSObjectRef thisObject,
+ size_t argumentCount,
+ const JSValueRef arguments[],
+ JSValueRef* exception);
+
+ static JSClassDefinition m_classInfo;
+
+ static JSStaticValue m_properties[];
+
+ static JSClassRef m_classRef;
+
+ static JSStaticFunction m_function[];
+
+ friend class JSWebAPIErrorFactory;
+};
+
+} // Common
+} // DeviceAPI
+
+#endif // _JS_WEBAPI_ERROR2_H_
+++ /dev/null
-//
-// Tizen Web Device API
-// Copyright (c) 2012 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "JSWebAPIError2.h"
-#include <string>
-#include <map>
-#include <CommonsJavaScript/JSUtils.h>
-#include "JSUtil.h"
-#include "Logger.h"
-
-namespace DeviceAPI {
-namespace Common {
-
-#define PLUGIN_NAME "WebAPIError"
-#define PROPERTY_CODE "code"
-#define PROPERTY_NAME "name"
-#define PROPERTY_TYPE "type"
-#define PROPERTY_MESSAGE "message"
-
-#define PROPERTY_INDEX_SIZE_ERR "INDEX_SIZE_ERR"
-#define PROPERTY_DOMSTRING_SIZE_ERR "DOMSTRING_SIZE_ERR"
-#define PROPERTY_HIERARCHY_REQUEST_ERR "HIERARCHY_REQUEST_ERR"
-#define PROPERTY_WRONG_DOCUMENT_ERR "WRONG_DOCUMENT_ERR"
-#define PROPERTY_INVALID_CHARACTER_ERR "INVALID_CHARACTER_ERR"
-#define PROPERTY_NO_DATA_ALLOWED_ERR "NO_DATA_ALLOWED_ERR"
-#define PROPERTY_NO_MODIFICATION_ALLOWED_ERR "NO_MODIFICATION_ALLOWED_ERR"
-#define PROPERTY_NOT_FOUND_ERR "NOT_FOUND_ERR"
-#define PROPERTY_NOT_SUPPORTED_ERR "NOT_SUPPORTED_ERR"
-#define PROPERTY_INUSE_ATTRIBUTE_ERR "INUSE_ATTRIBUTE_ERR"
-#define PROPERTY_INVALID_STATE_ERR "INVALID_STATE_ERR"
-#define PROPERTY_SYNTAX_ERR "SYNTAX_ERR"
-#define PROPERTY_INVALID_MODIFICATION_ERR "INVALID_MODIFICATION_ERR"
-#define PROPERTY_NAMESPACE_ERR "NAMESPACE_ERR"
-#define PROPERTY_INVALID_ACCESS_ERR "INVALID_ACCESS_ERR"
-#define PROPERTY_VALIDATION_ERR "VALIDATION_ERR"
-#define PROPERTY_TYPE_MISMATCH_ERR "TYPE_MISMATCH_ERR"
-#define PROPERTY_SECURITY_ERR "SECURITY_ERR"
-#define PROPERTY_NETWORK_ERR "NETWORK_ERR"
-#define PROPERTY_ABORT_ERR "ABORT_ERR"
-#define PROPERTY_URL_MISMATCH_ERR "URL_MISMATCH_ERR"
-#define PROPERTY_QUOTA_EXCEEDED_ERR "QUOTA_EXCEEDED_ERR"
-#define PROPERTY_TIMEOUT_ERR "TIMEOUT_ERR"
-#define PROPERTY_INVALID_NODE_TYPE_ERR "INVALID_NODE_TYPE_ERR"
-#define PROPERTY_DATA_CLONE_ERR "DATA_CLONE_ERR"
-
-typedef std::map<std::string, int> DeviceAPIErrorCodeMap;
-
-static DeviceAPIErrorCodeMap errorCodes = {
- { PROPERTY_INDEX_SIZE_ERR, 1 },
- { PROPERTY_DOMSTRING_SIZE_ERR, 2 },
- { PROPERTY_HIERARCHY_REQUEST_ERR, 3 },
- { PROPERTY_WRONG_DOCUMENT_ERR, 4 },
- { PROPERTY_INVALID_CHARACTER_ERR, 5 },
- { PROPERTY_NO_DATA_ALLOWED_ERR, 6 },
- { PROPERTY_NO_MODIFICATION_ALLOWED_ERR, 7 },
- { PROPERTY_NOT_FOUND_ERR, 8 },
- { PROPERTY_NOT_SUPPORTED_ERR, 9 },
- { PROPERTY_INUSE_ATTRIBUTE_ERR, 10 },
- { PROPERTY_INVALID_STATE_ERR, 11 },
- { PROPERTY_SYNTAX_ERR, 12 },
- { PROPERTY_INVALID_MODIFICATION_ERR, 13 },
- { PROPERTY_NAMESPACE_ERR, 14 },
- { PROPERTY_INVALID_ACCESS_ERR, 15 },
- { PROPERTY_VALIDATION_ERR, 16 },
- { PROPERTY_TYPE_MISMATCH_ERR, 17 },
- { PROPERTY_SECURITY_ERR, 18 },
- { PROPERTY_NETWORK_ERR, 19 },
- { PROPERTY_ABORT_ERR, 20 },
- { PROPERTY_URL_MISMATCH_ERR, 21 },
- { PROPERTY_QUOTA_EXCEEDED_ERR, 22 },
- { PROPERTY_TIMEOUT_ERR, 23 },
- { PROPERTY_INVALID_NODE_TYPE_ERR, 24 },
- { PROPERTY_DATA_CLONE_ERR, 25 }
-};
-
-JSClassRef JSWebAPIError2::m_classRef = NULL;
-
-JSClassDefinition JSWebAPIError2::m_classInfo =
-{
- 0,
- kJSClassAttributeNone,
- PLUGIN_NAME,
- 0,
- m_properties,
- m_function, //__function,
- initialize,
- finalize,
- NULL,
- NULL,
- NULL, //SetProperty,
- NULL, //DeleteProperty,
- NULL,
- NULL, //CallAsFunction,
- NULL, //CallAsConstructor,
- hasInstance,
- NULL, //ConvertToType,
-};
-
-JSStaticFunction JSWebAPIError2::m_function[] =
-{
- { "toString", toString, kJSPropertyAttributeNone },
- { 0, 0, 0 }
-};
-
-JSStaticValue JSWebAPIError2::m_properties[] = {
- { PROPERTY_CODE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NAME, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_TYPE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_MESSAGE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
-
- { PROPERTY_INDEX_SIZE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_DOMSTRING_SIZE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_HIERARCHY_REQUEST_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_WRONG_DOCUMENT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_CHARACTER_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NO_DATA_ALLOWED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NO_MODIFICATION_ALLOWED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NOT_FOUND_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NOT_SUPPORTED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INUSE_ATTRIBUTE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_STATE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_SYNTAX_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_MODIFICATION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NAMESPACE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_ACCESS_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_VALIDATION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_TYPE_MISMATCH_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_SECURITY_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NETWORK_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_ABORT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_URL_MISMATCH_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_QUOTA_EXCEEDED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_TIMEOUT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_NODE_TYPE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_DATA_CLONE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { 0, 0, 0, 0 }
-};
-
-const JSClassDefinition* JSWebAPIError2::getClassInfo()
-{
- return &m_classInfo;
-}
-
-JSClassRef JSWebAPIError2::getClassRef()
-{
- if (!m_classRef)
- {
- m_classRef = JSClassCreate(&m_classInfo);
- }
- return m_classRef;
-}
-
-JSObjectRef JSWebAPIError2::createJSObject(JSContextRef context,
- WebAPIErrorPtr webapiError)
-{
- PrivateObject *priv = new PrivateObject(context, webapiError);
- JSObjectRef jsObjectRef = JSObjectMake(context, getClassRef(), static_cast<void*>(priv));
- if (NULL == jsObjectRef) {
- LoggerE("object creation error");
- return NULL;
- }
- return jsObjectRef;
-}
-
-void JSWebAPIError2::initialize(JSContextRef /*context*/, JSObjectRef /*object*/)
-{
-}
-
-void JSWebAPIError2::finalize(JSObjectRef object)
-{
- PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(object));
- if (privateObject)
- {
- JSObjectSetPrivate(object, NULL);
- delete privateObject;
- }
-}
-
-JSValueRef JSWebAPIError2::getStaticProperty(JSContextRef context,
- JSObjectRef object,
- JSStringRef propertyName,
- JSValueRef* /*exception*/)
-{
- PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(object));
- if (!privateObject)
- {
- LoggerE("Private object is not set.");
- return JSValueMakeUndefined(context);
- }
-
- try
- {
- std::string propertyNameStr = JSUtil::JSStringToString(context, propertyName);
-
- if (propertyNameStr == PROPERTY_CODE)
- {
- return JSUtil::toJSValueRef(context, static_cast<long>(privateObject->getObject()->getCode()));
- }
- else if (propertyNameStr == PROPERTY_NAME)
- {
- return JSUtil::toJSValueRef(context, privateObject->getObject()->getName());
- }
- else if (propertyNameStr == PROPERTY_TYPE)
- {
- return JSUtil::toJSValueRef(context, privateObject->getObject()->getName());
- }
- else if (propertyNameStr == PROPERTY_MESSAGE)
- {
- return JSUtil::toJSValueRef(context, privateObject->getObject()->getMessage());
- }
- else // Error codes
- {
- DeviceAPIErrorCodeMap::iterator iter = errorCodes.find(propertyNameStr);
- if(iter != errorCodes.end())
- return JSUtil::toJSValueRef(context, static_cast<long>(iter->second));
- }
- }
- catch (const WrtDeviceApis::Commons::ConversionException& ex)
- {
- LoggerE("Exception: " << ex.GetMessage());
- }
-
- return JSValueMakeUndefined(context);
-}
-
-JSValueRef JSWebAPIError2::toString(JSContextRef context,
- JSObjectRef object,
- JSObjectRef thisObject,
- size_t argumentCount,
- const JSValueRef arguments[],
- JSValueRef* exception)
-{
- PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
- if (!privateObject)
- {
- LoggerE("Private object is not set.");
- return NULL;
- }
-
- std::string name = privateObject->getObject()->getName();
- std::string message = privateObject->getObject()->getMessage();
-
- std::string result = name + ": " + message;
-
- return JSUtil::toJSValueRef(context, result);
-}
-
-bool JSWebAPIError2::hasInstance(JSContextRef context,
- JSObjectRef /*constructor*/,
- JSValueRef possibleInstance,
- JSValueRef* /*exception*/)
-{
- return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
-}
-
-} // Common
-} // DeviceAPI
+++ /dev/null
-//
-// Tizen Web Device API
-// Copyright (c) 2012 Samsung Electronics Co., Ltd.
-//
-// 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 This object will replace JSWebAPIError.
-// The numeric suffix ('2') will be removed after replacing JSWebAPIError.
-
-#ifndef _JS_WEBAPI_ERROR2_H_
-#define _JS_WEBAPI_ERROR2_H_
-
-#include <JavaScriptCore/JavaScript.h>
-#include <CommonsJavaScript/PrivateObject.h>
-
-#include "WebAPIError.h"
-
-namespace DeviceAPI {
-namespace Common {
-
-class JSWebAPIError2
-{
-public:
- typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<WebAPIErrorPtr>::Type PrivateObject;
-
- static JSClassRef getClassRef();
-
- static const JSClassDefinition* getClassInfo();
-
- static JSObjectRef createJSObject(JSContextRef context, WebAPIErrorPtr webapiError);
-
-private:
- /**
- * The callback invoked when an object is first created.
- */
- static void initialize(JSContextRef context, JSObjectRef object);
-
- /**
- * The callback invoked when an object is finalized.
- */
- static void finalize(JSObjectRef object);
-
- /**
- * The callback invoked when getting a property's value.
- */
- static JSValueRef getStaticProperty(JSContextRef context,
- JSObjectRef object,
- JSStringRef propertyName,
- JSValueRef* exception);
-
- /**
- * The callback invoked when an object is used as the target of an 'instanceof' expression.
- */
- static bool hasInstance(JSContextRef context,
- JSObjectRef constructor,
- JSValueRef possibleInstance,
- JSValueRef* exception);
-
- static JSValueRef toString(JSContextRef context,
- JSObjectRef object,
- JSObjectRef thisObject,
- size_t argumentCount,
- const JSValueRef arguments[],
- JSValueRef* exception);
-
- /**
- * This structure contains properties and callbacks that define a type of object.
- */
- static JSClassDefinition m_classInfo;
-
- /**
- * This structure describes a statically declared value property.
- */
- static JSStaticValue m_properties[];
-
- static JSClassRef m_classRef;
-
- static JSStaticFunction m_function[];
-};
-
-} // Common
-} // DeviceAPI
-
-#endif // _JS_WEBAPI_ERROR2_H_
#include "JSWebAPIErrorFactory.h"
#include <map>
#include <dpl/assert.h>
-#include <CommonsJavaScript/JSUtils.h>
-#include <CommonsJavaScript/ScopedJSStringRef.h>
-#include "JSWebAPIError2.h"
+#include "JSStringRefWrapper.h"
+#include "JSWebAPIException.h"
+#include "JSWebAPIError.h"
#include "Logger.h"
#define INDEX_SIZE_ERROR_NAME_STR "IndexSizeError"
const std::string& name,
const std::string& message)
{
- return createException(context, name, message);
+ return createErrorObject(context, name, message, false);
}
JSObjectRef JSWebAPIErrorFactory::makeErrorObject(JSContextRef context,
const BasePlatformException& error)
{
- return createException(context, error.getName(), error.getMessage());
+ return createErrorObject(context, error.getName(), error.getMessage(), false);
}
-JSValueRef JSWebAPIErrorFactory::postException(JSContextRef context,
+JSObjectRef JSWebAPIErrorFactory::postException(JSContextRef context,
JSValueRef* exception,
const std::string& name,
const std::string& message)
{
Assert(exception && "Exception object can't be NULL.");
- *exception = createException(context, name, message);
+ JSObjectRef exceptionObj = createErrorObject(context, name, message, true);
- return JSValueMakeUndefined(context);
+ *exception = exceptionObj;
+
+ return exceptionObj;
}
-JSValueRef JSWebAPIErrorFactory::postException(JSContextRef context,
+JSObjectRef JSWebAPIErrorFactory::postException(JSContextRef context,
JSValueRef* exception,
const BasePlatformException& error)
{
return postException(context, exception, error.getName(), error.getMessage());
}
-JSObjectRef JSWebAPIErrorFactory::createException(JSContextRef context,
+JSObjectRef JSWebAPIErrorFactory::createErrorObject(JSContextRef context,
const std::string& name,
- const std::string& message)
+ const std::string& message,
+ const bool isException)
{
- JSObjectRef errorObject = NULL;
+ JSObjectRef jsErrorObject = NULL;
DeviceAPIErrorProperties *properties;
else
properties = &s_customErrorProperties;
+ if(properties->type == ERROR_TYPE_ECMA)
+ return createECMAErrorObject(context, properties->name, message);
+
+ WebAPIError *errorObject = NULL;
switch(properties->type)
{
case ERROR_TYPE_DOM:
case ERROR_TYPE_TIZEN:
- errorObject = JSWebAPIError2::createJSObject(context,
- WebAPIErrorPtr(new WebAPIError(properties->code, properties->name, message)));
- break;
- case ERROR_TYPE_ECMA:
- errorObject = createECMAException(context, properties->name, message);
+ errorObject = new WebAPIError(properties->code, properties->name, message);
break;
case ERROR_TYPE_CUSTOM:
- errorObject = JSWebAPIError2::createJSObject(context,
- WebAPIErrorPtr(new WebAPIError(0, name, message)));
+ errorObject = new WebAPIError(0, name, message);
break;
+ case ERROR_TYPE_ECMA: // Cannot happen
default:
- errorObject = JSWebAPIError2::createJSObject(context,
- WebAPIErrorPtr(new WebAPIError(0, "Error", message)));
+ errorObject = new WebAPIError(0, "Error", message);
break;
}
- return errorObject;
+ if(isException)
+ jsErrorObject = JSWebAPIException::createJSObject(context, errorObject);
+ else
+ jsErrorObject = JSWebAPIError::createJSObject(context, errorObject);
+
+ return jsErrorObject;
}
-JSObjectRef JSWebAPIErrorFactory::createECMAException(JSContextRef context,
+JSObjectRef JSWebAPIErrorFactory::createECMAErrorObject(JSContextRef context,
const std::string& name,
const std::string& message)
{
jsCodeStr += "\"" + message + "\"";
jsCodeStr += ");";
- WrtDeviceApis::CommonsJavaScript::ScopedJSStringRef jsCode(
- JSStringCreateWithUTF8CString(jsCodeStr.c_str()));
+ JSStringRefWrapper jsCode(jsCodeStr);
JSValueRef errValue = JSEvaluateScript(context, jsCode.get(), NULL, NULL, 0, NULL);
#define _JS_WEBAPI_ERROR_FACTORY_H_
#include <string>
-#include <dpl/noncopyable.h>
#include <JavaScriptCore/JavaScript.h>
#include "PlatformException.h"
namespace DeviceAPI {
namespace Common {
-class JSWebAPIErrorFactory: public DPL::Noncopyable
+class JSWebAPIErrorFactory
{
public:
JSWebAPIErrorFactory();
static JSObjectRef makeErrorObject(JSContextRef context,
const BasePlatformException& error);
- static JSValueRef postException(JSContextRef context,
+ static JSObjectRef postException(JSContextRef context,
JSValueRef* exception,
const std::string& name,
const std::string& message = std::string());
- static JSValueRef postException(JSContextRef context,
+ static JSObjectRef postException(JSContextRef context,
JSValueRef* exception,
const BasePlatformException& error);
static const std::string SERVICE_NOT_AVAILABLE_ERROR;
private:
- static JSObjectRef createException(JSContextRef context,
+ static JSObjectRef createErrorObject(JSContextRef context,
const std::string& name,
- const std::string& message);
+ const std::string& message,
+ const bool isException);
- static JSObjectRef createECMAException(JSContextRef context,
+ static JSObjectRef createECMAErrorObject(JSContextRef context,
const std::string& name,
const std::string& message);
};
//
#include "JSWebAPIException.h"
-#include <CommonsJavaScript/Converter.h>
-#include <CommonsJavaScript/JSUtils.h>
#include <string>
+#include <map>
+#include "JSUtil.h"
+#include "JSWebAPIError.h"
#include "Logger.h"
namespace DeviceAPI {
namespace Common {
-namespace{
-
- #define PLUGIN_NAME "WebAPIException"
- #define PROPERTY_CODE "code"
- #define PROPERTY_NAME "name"
- #define PROPERTY_TYPE "type"
- #define PROPERTY_MESSAGE "message"
-
- #define PROPERTY_UNKNOWN_ERR "UNKNOWN_ERR"
- #define PROPERTY_INDEX_SIZE_ERR "INDEX_SIZE_ERR"
- #define PROPERTY_DOMSTRING_SIZE_ERR "DOMSTRING_SIZE_ERR"
- #define PROPERTY_HIERARCHY_REQUEST_ERR "HIERARCHY_REQUEST_ERR"
- #define PROPERTY_WRONG_DOCUMENT_ERR "WRONG_DOCUMENT_ERR"
- #define PROPERTY_INVALID_CHARACTER_ERR "INVALID_CHARACTER_ERR"
- #define PROPERTY_NO_DATA_ALLOWED_ERR "NO_DATA_ALLOWED_ERR"
- #define PROPERTY_NO_MODIFICATION_ALLOWED_ERR "NO_MODIFICATION_ALLOWED_ERR"
- #define PROPERTY_NOT_FOUND_ERR "NOT_FOUND_ERR"
- #define PROPERTY_NOT_SUPPORTED_ERR "NOT_SUPPORTED_ERR"
- #define PROPERTY_INUSE_ATTRIBUTE_ERR "INUSE_ATTRIBUTE_ERR"
- #define PROPERTY_INVALID_STATE_ERR "INVALID_STATE_ERR"
- #define PROPERTY_SYNTAX_ERR "SYNTAX_ERR"
- #define PROPERTY_INVALID_MODIFICATION_ERR "INVALID_MODIFICATION_ERR"
- #define PROPERTY_NAMESPACE_ERR "NAMESPACE_ERR"
- #define PROPERTY_INVALID_ACCESS_ERR "INVALID_ACCESS_ERR"
- #define PROPERTY_VALIDATION_ERR "VALIDATION_ERR"
- #define PROPERTY_TYPE_MISMATCH_ERR "TYPE_MISMATCH_ERR"
- #define PROPERTY_SECURITY_ERR "SECURITY_ERR"
- #define PROPERTY_NETWORK_ERR "NETWORK_ERR"
- #define PROPERTY_ABORT_ERR "ABORT_ERR"
- #define PROPERTY_URL_MISMATCH_ERR "URL_MISMATCH_ERR"
- #define PROPERTY_QUOTA_EXCEEDED_ERR "QUOTA_EXCEEDED_ERR"
- #define PROPERTY_TIMEOUT_ERR "TIMEOUT_ERR"
- #define PROPERTY_INVALID_NODE_TYPE_ERR "INVALID_NODE_TYPE_ERR"
- #define PROPERTY_DATA_CLONE_ERR "DATA_CLONE_ERR"
- #define PROPERTY_INVALID_VALUES_ERR "INVALID_VALUES_ERR"
- #define PROPERTY_IO_ERR "IO_ERR"
- #define PROPERTY_OUT_OF_MEMORY_ERR "OUT_OF_MEMORY_ERR"
- #define PROPERTY_NOT_CONNECTED_SERVICE_ERR "NOT_CONNECTED_SERVICE_ERR"
- #define PROPERTY_FAIL_TO_REQUEST_ERR "FAIL_TO_REQUEST_ERR"
- #define PROPERTY_INVALID_RESPONSE_ERR "INVALID_RESPONSE_ERR"
- #define PROPERTY_NO_AVAILABLE_NETWORK_ERR "NO_AVAILABLE_NETWORK_ERR"
- #define PROPERTY_INVALID_DEVICE_ERR "INVALID_DEVICE_ERR"
- #define PROPERTY_NOT_SUPPORTED_FUNCTION_ERR "NOT_SUPPORTED_FUNCTION_ERR"
- #define PROPERTY_NO_PERMISSION_ERR "NO_PERMISSION_ERR"
- #define PROPERTY_INVALID_ITEM_ERR "INVALID_ITEM_ERR"
- #define PROPERTY_FAIL_TO_PLAY_ERR "FAIL_TO_PLAY_ERR"
- #define PROPERTY_SERVICE_NOT_AVAILABLE "SERVICE_NOT_AVAILABLE"
- #define PROPERTY_AVPLAY_NETWORK_DISCONNECTED_ERR "AVPLAY_NETWORK_DISCONNECTED_ERR"
- #define PROPERTY_AVPLAY_UNSUPPORTED_VIDEO_FORMAT_ERR "AVPLAY_UNSUPPORTED_VIDEO_FORMAT_ERR"
- #define PROPERTY_AVPLAY_UNSUPPORTED_AUDIO_FORMAT_ERR "AVPLAY_UNSUPPORTED_AUDIO_FORMAT_ERR"
- #define PROPERTY_AVPLAY_UNSUPPORTED_VIDEO_RESOLUTION_ERR "AVPLAY_UNSUPPORTED_VIDEO_RESOLUTION_ERR"
- #define PROPERTY_AVPLAY_UNSUPPORTED_VIDEO_FRAMERATE_ERR "AVPLAY_UNSUPPORTED_VIDEO_FRAMERATE_ERR"
- #define PROPERTY_AVPLAY_CURRUPTED_STREAM_ERR "AVPLAY_CURRUPTED_STREAM_ERR"
- }
-
- JSClassRef JSWebAPIException::m_classRef = NULL;
-
- JSClassDefinition JSWebAPIException::m_classInfo = {
- 0,
- kJSClassAttributeNone,
- PLUGIN_NAME,
- 0,
- m_properties,
- m_function, //__function,
- initialize,
- finalize,
- NULL,
- NULL,
- NULL, //SetProperty,
- NULL, //DeleteProperty,
- NULL,
- NULL, //CallAsFunction,
- NULL, //CallAsConstructor,
- hasInstance,
- NULL, //ConvertToType,
- };
-
- JSStaticFunction JSWebAPIException::m_function[] = {
- { "toString", toString, kJSPropertyAttributeNone },
- { 0, 0, 0 }
- };
-
-
- JSStaticValue JSWebAPIException::m_properties[] = {
- { PROPERTY_CODE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NAME, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_TYPE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_MESSAGE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
-
- { PROPERTY_UNKNOWN_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INDEX_SIZE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_DOMSTRING_SIZE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_HIERARCHY_REQUEST_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_WRONG_DOCUMENT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_CHARACTER_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NO_DATA_ALLOWED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NO_MODIFICATION_ALLOWED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NOT_FOUND_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NOT_SUPPORTED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INUSE_ATTRIBUTE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_STATE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_SYNTAX_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_MODIFICATION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NAMESPACE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_ACCESS_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_VALIDATION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_TYPE_MISMATCH_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_SECURITY_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NETWORK_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_ABORT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_URL_MISMATCH_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_QUOTA_EXCEEDED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_TIMEOUT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_NODE_TYPE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_DATA_CLONE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_VALUES_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_IO_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_OUT_OF_MEMORY_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NOT_CONNECTED_SERVICE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_FAIL_TO_REQUEST_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_RESPONSE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NO_AVAILABLE_NETWORK_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_DEVICE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NOT_SUPPORTED_FUNCTION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_NO_PERMISSION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_INVALID_ITEM_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_FAIL_TO_PLAY_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_SERVICE_NOT_AVAILABLE, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_AVPLAY_NETWORK_DISCONNECTED_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_AVPLAY_UNSUPPORTED_VIDEO_FORMAT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_AVPLAY_UNSUPPORTED_AUDIO_FORMAT_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_AVPLAY_UNSUPPORTED_VIDEO_RESOLUTION_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_AVPLAY_UNSUPPORTED_VIDEO_FRAMERATE_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { PROPERTY_AVPLAY_CURRUPTED_STREAM_ERR, getStaticProperty, NULL, kJSPropertyAttributeReadOnly },
- { 0, 0, 0, 0 }
- };
-
- const JSClassDefinition* JSWebAPIException::getClassInfo() {
- return &m_classInfo;
- }
-
- JSClassRef JSWebAPIException::getClassRef() {
- if (!m_classRef) {
- m_classRef = JSClassCreate(&m_classInfo);
- }
- return m_classRef;
- }
-
- void JSWebAPIException::initialize(JSContextRef /*context*/, JSObjectRef /*object*/) {
- }
-
- void JSWebAPIException::finalize(JSObjectRef object) {
- PrivateObject* privateObject = static_cast<PrivateObject*> (JSObjectGetPrivate(object));
- if (privateObject) {
- JSObjectSetPrivate(object, NULL);
- delete privateObject;
- }
- }
-
- JSValueRef JSWebAPIException::getStaticProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* /*exception*/) {
- PrivateObject* privateObject = static_cast<PrivateObject*> (JSObjectGetPrivate(object));
- if (!privateObject) {
- LoggerE("Private object is not set.");
- return JSValueMakeUndefined(context);
- }
-
- WrtDeviceApis::CommonsJavaScript::Converter converter(context);
- try {
- if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_CODE)) {
- LoggerD("propertyName PROPERTY_CODE");
- return converter.toJSValueRef(privateObject->getObject()->getCode());
- } else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NAME)) {
- return converter.toJSValueRef(privateObject->getObject()->getName());
- } else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_TYPE)) {
- return converter.toJSValueRef(privateObject->getObject()->getName());
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_MESSAGE)) {
- return converter.toJSValueRef(privateObject->getObject()->getMessage());
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_UNKNOWN_ERR)) {
- return converter.toJSValueRef(UNKNOWN_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INDEX_SIZE_ERR)) {
- return converter.toJSValueRef(INDEX_SIZE_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_DOMSTRING_SIZE_ERR)) {
- return converter.toJSValueRef(DOMSTRING_SIZE_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_HIERARCHY_REQUEST_ERR)) {
- return converter.toJSValueRef(HIERARCHY_REQUEST_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_WRONG_DOCUMENT_ERR)) {
- return converter.toJSValueRef(WRONG_DOCUMENT_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INVALID_CHARACTER_ERR)) {
- return converter.toJSValueRef(INVALID_CHARACTER_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NO_DATA_ALLOWED_ERR)) {
- return converter.toJSValueRef(NO_DATA_ALLOWED_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NO_MODIFICATION_ALLOWED_ERR)) {
- return converter.toJSValueRef(NO_MODIFICATION_ALLOWED_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NOT_FOUND_ERR)) {
- return converter.toJSValueRef(NOT_FOUND_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NOT_SUPPORTED_ERR)) {
- return converter.toJSValueRef(NOT_SUPPORTED_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INUSE_ATTRIBUTE_ERR)) {
- return converter.toJSValueRef(INUSE_ATTRIBUTE_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INVALID_STATE_ERR)) {
- return converter.toJSValueRef(INVALID_STATE_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_SYNTAX_ERR)) {
- return converter.toJSValueRef(SYNTAX_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INVALID_MODIFICATION_ERR)) {
- return converter.toJSValueRef(INVALID_MODIFICATION_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NAMESPACE_ERR)) {
- return converter.toJSValueRef(NAMESPACE_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INVALID_ACCESS_ERR)) {
- return converter.toJSValueRef(INVALID_ACCESS_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_VALIDATION_ERR)) {
- return converter.toJSValueRef(VALIDATION_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_TYPE_MISMATCH_ERR)) {
- return converter.toJSValueRef(TYPE_MISMATCH_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_SECURITY_ERR)) {
- return converter.toJSValueRef(SECURITY_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_NETWORK_ERR)) {
- return converter.toJSValueRef(NETWORK_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_ABORT_ERR)) {
- return converter.toJSValueRef(ABORT_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_URL_MISMATCH_ERR)) {
- return converter.toJSValueRef(URL_MISMATCH_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_QUOTA_EXCEEDED_ERR)) {
- return converter.toJSValueRef(QUOTA_EXCEEDED_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_TIMEOUT_ERR)) {
- return converter.toJSValueRef(TIMEOUT_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_INVALID_NODE_TYPE_ERR)) {
- return converter.toJSValueRef(INVALID_NODE_TYPE_ERR);
- }else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_DATA_CLONE_ERR)) {
- return converter.toJSValueRef(DATA_CLONE_ERR);
- }else{
- LoggerD("propertyName not supported");
- return converter.toJSValueRef(UNKNOWN_ERR);
- }
- } catch (const WrtDeviceApis::Commons::ConversionException& ex) {
- LoggerE("Exception: " << ex.GetMessage());
- }
-
- return JSValueMakeUndefined(context);
- }
-
- JSValueRef JSWebAPIException::toString(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception){
- PrivateObject* privateObject = static_cast<PrivateObject*> (JSObjectGetPrivate(thisObject));
- if (!privateObject) {
- return NULL;
- }
-
- WrtDeviceApis::CommonsJavaScript::Converter converter(context);
- std::string name = privateObject->getObject()->getName();
- std::string message = privateObject->getObject()->getMessage();
- std::string result = name + ": "+message;
- return converter.toJSValueRef(result);
- }
-
- bool JSWebAPIException::hasInstance(JSContextRef context, JSObjectRef /*constructor*/, JSValueRef possibleInstance, JSValueRef* /*exception*/) {
- return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
- }
-
- int JSWebAPIException::convertToWebAPIExceptionCode(const std::string& errorName){
- LoggerD("<<< errorName:[" << errorName << "]");
-
- int retErrorCode = -1;
-
- if(errorName.compare(JSTizenException::UNKNOWN_ERROR) == 0){
- retErrorCode = UNKNOWN_ERR;
- }else if(errorName.compare(JSTizenException::NOT_FOUND_ERROR) == 0){
- retErrorCode = NOT_FOUND_ERR;
- }else if(errorName.compare(JSTizenException::NOT_SUPPORTED_ERROR) == 0){
- retErrorCode = NOT_SUPPORTED_ERR;
- }else if(errorName.compare(JSTizenException::TYPE_MISMATCH_ERROR) == 0){
- retErrorCode = TYPE_MISMATCH_ERR;
- }else if(errorName.compare(JSTizenException::PERMISSION_DENIED_ERROR) == 0){
- retErrorCode = SECURITY_ERR;
- }else if(errorName.compare(JSTizenException::TIMEOUT_ERROR) == 0){
- retErrorCode = TIMEOUT_ERR;
- }else if(errorName.compare(JSTizenException::INVALID_VALUES_ERROR) == 0){
- retErrorCode = 0;
- }else if(errorName.compare(JSTizenException::IO_ERROR) == 0){
- retErrorCode = 0;
- }else if(errorName.compare(JSTizenException::SERVICE_NOT_AVAILABLE) == 0){
- retErrorCode = 0;
- }else if(errorName.compare(JSTizenException::NETWORK_ERROR) == 0){
- retErrorCode = NETWORK_ERR;
- }else{
- retErrorCode = UNKNOWN_ERR;
- }
-
- LoggerD(">>> retERrorCode:" << retErrorCode );
- return retErrorCode;
- }
-
- JSObjectRef JSWebAPIException::makeJSWebAPIException(JSContextRef context, const BasePlatformException& error){
- JSWebAPIException::PrivateObject::ObjectType data(new TizenExceptionData(error.getCode(), error.getName(), error.getMessage()));
- return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(context, JSWebAPIException::getClassRef(), data);
- }
- JSValueRef JSWebAPIException::throwException(JSContextRef context, JSValueRef* exception, const BasePlatformException& error){
- Assert(exception && "Exception object can't be NULL.");
-
- *exception = makeJSWebAPIException(context, error);
- return JSValueMakeUndefined(context);
- }
-
-}// Common
-}// DeviceAPI
+#define CLASS_NAME "WebAPIException"
+
+JSClassRef JSWebAPIException::m_classRef = NULL;
+
+JSClassDefinition JSWebAPIException::m_classInfo =
+{
+ 0,
+ kJSClassAttributeNone,
+ CLASS_NAME,
+ JSWebAPIError::getClassRef(),
+ m_properties,
+ m_function,
+ initialize,
+ finalize,
+ NULL, // hasProperty,
+ NULL, // getProperty,
+ NULL, // setProperty,
+ NULL, // deleteProperty,
+ NULL, // getPropertyNames,
+ NULL, // callAsFunction,
+ NULL, // callAsConstructor,
+ hasInstance,
+ NULL, // convertToType,
+};
+
+JSStaticFunction JSWebAPIException::m_function[] =
+{
+ { "toString", toString, kJSPropertyAttributeNone },
+ { 0, 0, 0 }
+};
+
+JSStaticValue JSWebAPIException::m_properties[] = {
+ { 0, 0, 0, 0 }
+};
+
+const JSClassDefinition* JSWebAPIException::getClassInfo()
+{
+ return &m_classInfo;
+}
+
+JSClassRef JSWebAPIException::getClassRef()
+{
+ if (!m_classRef)
+ {
+ m_classRef = JSClassCreate(&m_classInfo);
+ }
+ return m_classRef;
+}
+
+bool JSWebAPIException::isObjectOfClass(JSContextRef context, JSValueRef value)
+{
+ return JSValueIsObjectOfClass(context, value, getClassRef());
+}
+
+JSObjectRef JSWebAPIException::createJSObject(JSContextRef context, WebAPIError* webapiError)
+{
+ JSObjectRef jsObjectRef = JSObjectMake(context, getClassRef(), static_cast<void*>(webapiError));
+ if (NULL == jsObjectRef) {
+ LoggerE("object creation error");
+ return NULL;
+ }
+ return jsObjectRef;
+}
+
+WebAPIError* JSWebAPIException::getPriv(JSContextRef context, JSObjectRef object)
+{
+ if(!JSValueIsObjectOfClass(context, object, getClassRef()))
+ return NULL;
+
+ return static_cast<WebAPIError*>(JSObjectGetPrivate(object));
+}
+
+void JSWebAPIException::initialize(JSContextRef /*context*/, JSObjectRef /*object*/)
+{
+}
+
+void JSWebAPIException::finalize(JSObjectRef /*object*/)
+{
+}
+
+JSValueRef JSWebAPIException::toString(JSContextRef context,
+ JSObjectRef object,
+ JSObjectRef thisObject,
+ size_t argumentCount,
+ const JSValueRef arguments[],
+ JSValueRef* exception)
+{
+ WebAPIError* webapiErrObj = getPriv(context, thisObject);
+ if(!webapiErrObj)
+ {
+ LoggerE("Private object is not set.");
+ return NULL;
+ }
+
+ std::string name = webapiErrObj->getName();
+ std::string message = webapiErrObj->getMessage();
+
+ std::string result = name + ": " + message;
+
+ return JSUtil::toJSValueRef(context, result);
+}
+
+bool JSWebAPIException::hasInstance(JSContextRef context,
+ JSObjectRef /*constructor*/,
+ JSValueRef possibleInstance,
+ JSValueRef* /*exception*/)
+{
+ return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
+}
+
+} // Common
+} // DeviceAPI
// limitations under the License.
//
-#ifndef JSWEBAPIEXCEPTION_H_
-#define JSWEBAPIEXCEPTION_H_
+// TODO This object will replace JSWebAPIError.
+// The numeric suffix ('2') will be removed after replacing JSWebAPIError.
+
+#ifndef _JS_WEBAPI_EXCEPTION2_H_
+#define _JS_WEBAPI_EXCEPTION2_H_
#include <JavaScriptCore/JavaScript.h>
-#include <CommonsJavaScript/PrivateObject.h>
+#include "JSWebAPIErrorFactory.h"
-#include "JSTizenException.h"
-#include "PlatformException.h"
+#include "WebAPIError.h"
namespace DeviceAPI {
namespace Common {
- class JSWebAPIException {
- public:
- typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<TizenExceptionDataPtr>::Type PrivateObject;
-
- static JSClassRef getClassRef();
- static const JSClassDefinition* getClassInfo();
-
- static int convertToWebAPIExceptionCode(const std::string& errorName);
-
- static JSObjectRef makeJSWebAPIException(JSContextRef context, const BasePlatformException& error);
- static JSValueRef throwException(JSContextRef context, JSValueRef* exception, const BasePlatformException& error);
-
- private:
- /**
- * The callback invoked when an object is first created.
- */
- static void initialize(JSContextRef context, JSObjectRef object);
-
- /**
- * The callback invoked when an object is finalized.
- */
- static void finalize(JSObjectRef object);
-
- /**
- * The callback invoked when getting a property's value.
- */
- static JSValueRef getStaticProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception);
-
- /**
- * The callback invoked when an object is used as the target of an 'instanceof' expression.
- */
- static bool hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef possibleInstance, JSValueRef* exception);
-
-
- static JSValueRef toString(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);
-
-
- /**
- * This structure contains properties and callbacks that define a type of object.
- */
- static JSClassDefinition m_classInfo;
-
- /**
- * This structure describes a statically declared value property.
- */
- static JSStaticValue m_properties[];
-
- static JSClassRef m_classRef;
-
- static JSStaticFunction m_function[];
-
- public:
- enum{
- UNKNOWN_ERR = 0,
- INDEX_SIZE_ERR = 1,
- DOMSTRING_SIZE_ERR = 2,
- HIERARCHY_REQUEST_ERR = 3,
- WRONG_DOCUMENT_ERR = 4,
- INVALID_CHARACTER_ERR = 5,
- NO_DATA_ALLOWED_ERR = 6,
- NO_MODIFICATION_ALLOWED_ERR = 7,
- NOT_FOUND_ERR = 8,
- NOT_SUPPORTED_ERR = 9,
- INUSE_ATTRIBUTE_ERR = 10,
- INVALID_STATE_ERR = 11,
- SYNTAX_ERR = 12,
- INVALID_MODIFICATION_ERR = 13,
- NAMESPACE_ERR = 14,
- INVALID_ACCESS_ERR = 15,
- VALIDATION_ERR = 16,
- TYPE_MISMATCH_ERR = 17,
- SECURITY_ERR = 18,
- NETWORK_ERR = 19,
- ABORT_ERR = 20,
- URL_MISMATCH_ERR = 21,
- QUOTA_EXCEEDED_ERR = 22,
- TIMEOUT_ERR = 23,
- INVALID_NODE_TYPE_ERR = 24,
- DATA_CLONE_ERR = 25,
-
- }; //WebAPIException
- };
-
-}// Common
-}// DeviceAPI
-#endif /* JSWEBAPIEXCEPTION_H_ */
+class JSWebAPIErrorFactory;
+
+class JSWebAPIException
+{
+public:
+ static JSClassRef getClassRef();
+
+ static const JSClassDefinition* getClassInfo();
+
+ static bool isObjectOfClass(JSContextRef context, JSValueRef value);
+
+private:
+ static JSObjectRef createJSObject(JSContextRef context, WebAPIError* webapiError);
+
+ static WebAPIError* getPriv(JSContextRef context, JSObjectRef object);
+
+ static void initialize(JSContextRef context, JSObjectRef object);
+
+ static void finalize(JSObjectRef object);
+
+ static bool hasInstance(JSContextRef context,
+ JSObjectRef constructor,
+ JSValueRef possibleInstance,
+ JSValueRef* exception);
+
+ static JSValueRef toString(JSContextRef context,
+ JSObjectRef object,
+ JSObjectRef thisObject,
+ size_t argumentCount,
+ const JSValueRef arguments[],
+ JSValueRef* exception);
+
+ static JSClassDefinition m_classInfo;
+
+ static JSStaticValue m_properties[];
+
+ static JSClassRef m_classRef;
+
+ static JSStaticFunction m_function[];
+
+ friend class JSWebAPIErrorFactory;
+};
+
+} // Common
+} // DeviceAPI
+
+#endif // _JS_WEBAPI_EXCEPTION2_H_
#include "PlatformException.h"
#include "JSUtil.h"
-#include "JSWebAPIException.h"
+#include "JSWebAPIErrorFactory.h"
#include <CommonsJavaScript/Converter.h>
using namespace WrtDeviceApis::CommonsJavaScript;
namespace DeviceAPI {
namespace Common{
-BasePlatformException::BasePlatformException(int code, const char* name, const char* message):mCode(code),mName(name),mMessage(message){
+BasePlatformException::BasePlatformException(const char* name, const char* message):mName(name),mMessage(message){
}
BasePlatformException::BasePlatformException(JSContextRef context, JSValueRef value){
return;
JSValueRef message = JSUtil::getProperty(context, object, "message");
- JSValueRef code = JSUtil::getProperty(context, object, "code");
JSValueRef name = JSUtil::getProperty(context, object, "name");
try{
mMessage = convert.toString(message);
if( !JSValueIsUndefined(context, name ))
mName = convert.toString(name);
- if( !JSValueIsUndefined(context, code ))
- mCode = convert.toInt(code);
}catch( const ConversionException& err){
}
}
-int BasePlatformException::getCode() const{
- return mCode;
+BasePlatformException::~BasePlatformException() {
}
std::string BasePlatformException::getName() const{
}
-TypeMismatchException::TypeMismatchException(const char* message):BasePlatformException(JSWebAPIException::TYPE_MISMATCH_ERR,"TypeMismatchError", message){
+TypeMismatchException::TypeMismatchException(const char* message):BasePlatformException("TypeMismatchError", message){
}
TypeMismatchException::TypeMismatchException(JSContextRef ctx, JSValueRef exception):BasePlatformException(ctx,exception){
- mCode = JSWebAPIException::TYPE_MISMATCH_ERR;
mName = "TypeMismatchError";
}
-InvalidValuesException::InvalidValuesException(const char* message):BasePlatformException(0,"InvalidValuesError", message){
+InvalidValuesException::InvalidValuesException(const char* message):BasePlatformException("InvalidValuesError", message){
}
InvalidValuesException::InvalidValuesException(JSContextRef ctx, JSValueRef exception):BasePlatformException(ctx,exception){
- mCode = 0;
mName = "InvalidValuesError";
}
-IOException::IOException(const char* message):BasePlatformException(0,"IOError", message){
+IOException::IOException(const char* message):BasePlatformException("IOError", message){
}
IOException::IOException(JSContextRef ctx, JSValueRef exception):BasePlatformException(ctx,exception){
- mCode = 0;
mName = "IOError";
}
-UnknownException::UnknownException(const char* message):BasePlatformException(0,"UnknownError", message){
+UnknownException::UnknownException(const char* message):BasePlatformException("UnknownError", message){
}
UnknownException::UnknownException(JSContextRef ctx, JSValueRef exception):BasePlatformException(ctx,exception){
- mCode = 0;
mName = "UnknownError";
}
-ServiceNotAvailableException::ServiceNotAvailableException(const char* message):BasePlatformException(0,"ServiceNotAvailableError", message){
+ServiceNotAvailableException::ServiceNotAvailableException(const char* message):BasePlatformException("ServiceNotAvailableError", message){
}
ServiceNotAvailableException::ServiceNotAvailableException(JSContextRef ctx, JSValueRef exception):BasePlatformException(ctx,exception){
- mCode = 0;
mName = "ServiceNotAvailableError";
}
-SecurityException::SecurityException(const char* message):BasePlatformException(JSWebAPIException::SECURITY_ERR,"SecurityError", message){
+SecurityException::SecurityException(const char* message):BasePlatformException("SecurityError", message){
}
SecurityException::SecurityException(JSContextRef ctx, JSValueRef exception):BasePlatformException(ctx,exception){
- mCode = JSWebAPIException::SECURITY_ERR;
mName = "SecurityError";
}
-NotSupportedException::NotSupportedException(const char* message):BasePlatformException(JSWebAPIException::NOT_SUPPORTED_ERR,"NotSupportedError", message){
+NotSupportedException::NotSupportedException(const char* message):BasePlatformException("NotSupportedError", message){
}
NotSupportedException::NotSupportedException(JSContextRef ctx, JSValueRef exception):BasePlatformException(ctx,exception){
- mCode = JSWebAPIException::NOT_SUPPORTED_ERR;
mName = "NotSupportedError";
}
-NotFoundException::NotFoundException(const char* message):BasePlatformException(JSWebAPIException::NOT_FOUND_ERR,"NotFoundError", message){
+NotFoundException::NotFoundException(const char* message):BasePlatformException("NotFoundError", message){
}
NotFoundException::NotFoundException(JSContextRef ctx, JSValueRef exception):BasePlatformException(ctx,exception){
- mCode = JSWebAPIException::NOT_FOUND_ERR;
mName = "NotFoundError";
}
-InvalidAccessException::InvalidAccessException(const char* message):BasePlatformException(JSWebAPIException::INVALID_ACCESS_ERR,"InvalidAccessError", message){
+InvalidAccessException::InvalidAccessException(const char* message):BasePlatformException("InvalidAccessError", message){
}
InvalidAccessException::InvalidAccessException(JSContextRef ctx, JSValueRef exception):BasePlatformException(ctx,exception){
- mCode = JSWebAPIException::INVALID_ACCESS_ERR;
mName = "InvalidAccessError";
}
-QuotaExceededException::QuotaExceededException(const char* message):BasePlatformException(JSWebAPIException::QUOTA_EXCEEDED_ERR,"QuotaExceededError", message){
+QuotaExceededException::QuotaExceededException(const char* message):BasePlatformException("QuotaExceededError", message){
}
QuotaExceededException::QuotaExceededException(JSContextRef ctx, JSValueRef exception):BasePlatformException(ctx,exception){
- mCode = JSWebAPIException::QUOTA_EXCEEDED_ERR;
mName = "QuotaExceededError";
}
class BasePlatformException{
public:
- BasePlatformException(int code, const char* name, const char* message);
+ BasePlatformException(const char* name, const char* message);
BasePlatformException(JSContextRef ctx, JSValueRef exception);
+ virtual ~BasePlatformException();
- virtual int getCode() const;
virtual std::string getName() const;
virtual std::string getMessage() const;
protected:
- int mCode;
std::string mName;
std::string mMessage;
};
#define TIZENAPIS_COMMONS_JS_SECURITYEXCEPTIONS_H_
#include <JavaScriptCore/JavaScript.h>
-#include "JSTizenExceptionFactory.h"
+#include "JSWebAPIErrorFactory.h"
namespace DeviceAPI {
namespace Common {
do { \
switch (status) { \
case AceSecurityStatus::InternalError: \
- return JSTizenExceptionFactory::postException(context, exception, \
- JSTizenException::UNKNOWN_ERROR); \
+ return JSWebAPIErrorFactory::postException(context, exception, \
+ JSWebAPIErrorFactory::UNKNOWN_ERROR); \
break; \
case AceSecurityStatus::AccessDenied: \
- return JSTizenExceptionFactory::postException(context, exception, \
- JSTizenException::PERMISSION_DENIED_ERROR); \
+ return JSWebAPIErrorFactory::postException(context, exception, \
+ JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR); \
break; \
default: \
break; \
do { \
switch (status) { \
case AceSecurityStatus::InternalError: \
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, \
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, \
"SECURITY_ERROR", "internal error")); \
return JSValueMakeNull(context); \
case AceSecurityStatus::AccessDenied: \
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, \
- JSTizenException::PERMISSION_DENIED_ERROR, "PERMISSION_DENIED_ERROR")); \
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, \
+ JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "PERMISSION_DENIED_ERROR")); \
return JSValueMakeNull(context); \
default: \
break; \
+++ /dev/null
-//
-// Tizen Web Device API
-// Copyright (c) 2012 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-#include "TizenExceptionData.h"
-
-namespace DeviceAPI {
-namespace Common {
-
- TizenExceptionData::TizenExceptionData(int code, const std::string& name, const std::string& message) :
- m_code(code), m_name(name), m_message(message) {
- }
-
- TizenExceptionData::~TizenExceptionData() {
- }
-
- int TizenExceptionData::getCode() const {
- return m_code;
- }
-
- std::string TizenExceptionData::getName() const {
- return m_name;
- }
-
- std::string TizenExceptionData::getMessage() const {
- return m_message;
- }
-}// Common
-}// DeviceAPI
+++ /dev/null
-//
-// Tizen Web Device API
-// Copyright (c) 2012 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef TIZENEXCEPTIONDATA_H_
-#define TIZENEXCEPTIONDATA_H_
-
-#include <string>
-#include <dpl/shared_ptr.h>
-
-namespace DeviceAPI {
-namespace Common {
-
-class TizenExceptionData {
- public:
- TizenExceptionData(int code, const std::string& name, const std::string& message = std::string());
- virtual ~TizenExceptionData();
-
- int getCode() const;
- std::string getName() const;
- std::string getMessage() const;
-
- private :
- int m_code;
- std::string m_name;
- std::string m_message;
-};
-
-typedef DPL::SharedPtr<TizenExceptionData> TizenExceptionDataPtr;
-
-}// Common
-}// DeviceAPI
-
-#endif /* TIZENEXCEPTIONDATA_H_ */
std::string m_name;
std::string m_message;
};
-typedef DPL::SharedPtr<WebAPIError> WebAPIErrorPtr;
} // Common
} // DeviceAPI
*/
#include <CommonsJavaScript/JSCallbackManager.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "AddressBookController.h"
#include "ContactConverter.h"
#include "JSAddressBookChangeCallbackManager.h"
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Invalid value error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Invalid value error");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
return;
} Catch(Exception) {
LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
callbackManager->callOnError(error);
return;
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "record not found");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Invalid value error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Invalid value error");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "record not found");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Invalid value error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Invalid value error");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
callbackManager->callOnError(error);
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_SUPPORTED_ERROR, "Not support such a filter");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Not support such a filter");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Invalid value error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Invalid value error");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
return;
} Catch(Exception) {
LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
callbackManager->callOnError(error);
return;
JSContextRef gContext = cbm->getContext();
if (event->getExceptionCode() == ExceptionCodes::NotFoundException)
- errorObject = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "Not found error");
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "Not found error");
else
- errorObject = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
cbm->callOnError(errorObject);
}
#include "ContactPhoneNumber.h"
#include "ContactEmailAddress.h"
#include <ArgumentValidator.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <JSUtil.h>
#include <Export.h>
*/
#include <CommonsJavaScript/JSCallbackManager.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "ContactConverter.h"
#include "ContactManagerController.h"
#include "ContactAsyncCallbackManager.h"
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Invalid value error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Invalid value error");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
return;
} Catch(Exception) {
LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
callbackManager->callOnError(error);
return;
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "record not found");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Invalid value error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Invalid value error");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "record not found");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Invalid value error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Invalid value error");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
callbackManager->callOnError(error);
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_SUPPORTED_ERROR, "Not support such a filter");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Not support such a filter");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Invalid value error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Invalid value error");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
return;
} Catch(Exception) {
LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
callbackManager->callOnError(error);
return;
JSContextRef gContext = cbm->getContext();
if (event->getExceptionCode() == ExceptionCodes::NotFoundException)
- errorObject = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "Not found error");
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "Not found error");
else
- errorObject = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
cbm->callOnError(errorObject);
}
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSPendingOperation.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
#include <SecurityExceptions.h>
#include <FilterConverter.h>
#include "ContactFactory.h"
#include "ContactListenerManager.h"
#include "ContactFilterConverter.h"
#include <ArgumentValidator.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <JSUtil.h>
#include <TimeTracer.h>
#include <Logger.h>
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_GET);
ArgumentValidator validator(context, argumentCount, arguments);
id = validator.toString(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
EventAddressBookGetPtr dplEvent(new EventAddressBookGet());
addressBook->get(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult() || !dplEvent->getContactIsSet())
case ExceptionCodes::InvalidArgumentException:
LoggerE("Not Found error : " << id);
oss << "No Contact id '" << id << "'";
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
result = converter->toJSValueRef(contact);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD);
ArgumentValidator validator(context, argumentCount, arguments);
validator.toObject(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
ContactPtr contact(NULL);
contact = converter->toContact(arguments[0]);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "1st argument must be a 'Contact object'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument must be a 'Contact object'");
}
EventAddressBookAddPtr dplEvent(new EventAddressBookAdd());
addressBook->add(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult())
switch (dplEvent->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
case ExceptionCodes::InvalidArgumentException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "There is Invalid input value");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "There is Invalid input value");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_BATCH);
js3rdParamIsFunction = true;
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(context);
dplEvent->setContacts(converter->toContactArray(arguments[0]));
} Catch(ConversionException) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "1st argument must be an array of 'Contact object'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument must be an array of 'Contact object'");
}
// set event handler's data
ContactAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE);
validator.toObject(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
ContactPtr contact(NULL);
contact = converter->toContact(arguments[0]);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "1st argument is not a 'Contact object'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument is not a 'Contact object'");
}
EventAddressBookUpdatePtr dplEvent(new EventAddressBookUpdate());
addressBook->update(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult())
case ExceptionCodes::NotFoundException:
case ExceptionCodes::InvalidArgumentException:
oss << "No Contact id '" << contact->getId() << "'";
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE_BATCH);
js3rdParamIsFunction = true;
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(context);
dplEvent->setContacts(converter->toContactArray(arguments[0]));
} Catch(ConversionException) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "3rd argument must be an array of 'Contact object'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "3rd argument must be an array of 'Contact object'");
}
// set event handler's data
ContactAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
addressBook = controller->getObject();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE);
try {
contactId = validator.toString(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
EventAddressBookRemovePtr dplEvent(new EventAddressBookRemove());
addressBook->remove(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult())
case ExceptionCodes::InvalidArgumentException:
LoggerE("Not Found error : " << contactId);
oss << "No Contact id '" << contactId << "'";
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_BATCH);
js3rdParamIsFunction = true;
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(context);
dplEvent->setContactIds(converter->toStringArray(arguments[0]));
} Catch(ConversionException) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "3rd argument must be an array of 'Contact id'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "3rd argument must be an array of 'Contact id'");
}
// set event handler's data
ContactAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_FIND);
js4thParamIsObject = true;
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
dplEvent->setFilter(filterConverter->toFilter(arguments[2]));
} Catch(Exception) {
LoggerE("Error on 3rd parameter conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "3rd argument must be an 'Filter object' or 'null'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "3rd argument must be an 'Filter object' or 'null'");
}
Try {
dplEvent->setSortMode(filterConverter->toSortMode(arguments[3]));
} Catch(Exception) {
LoggerE("Error on 4th parameter conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "4th argument must be an 'SortMode object' or 'null'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "4th argument must be an 'SortMode object' or 'null'");
}
// set event handler's data
ContactAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_CHANGE_LISTENER);
if(errorObj)
js2ndParamIsFunction = true;
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(context);
} Catch(ConversionException) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
JSAddressBookChangeCallbackManagerPtr callbackManager = JSAddressBookChangeCallbackManager::createObject(gContext);
addressBook->addChangeListener(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult() || !dplEvent->getIdIsSet())
{
case ExceptionCodes::InvalidArgumentException:
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
// result = converter->toJSValueRefLong(watchId);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return result;
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_CHANGE_LISTENER);
ArgumentValidator validator(context, argumentCount, arguments);
watchId = validator.toLong(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
EventAddressBookRemoveChangeListenerPtr dplEvent(new EventAddressBookRemoveChangeListener());
addressBook->removeChangeListener(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
ContactsChangeListenerCancellerPtr canceller = ContactsChangeListenerCancellerPtr(new ContactsChangeListenerCanceller(gContext, thisObject, watchId));
{
case ExceptionCodes::InvalidArgumentException:
case ExceptionCodes::NotFoundException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, "Watch id not found");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "Watch id not found");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_GET_GROUP);
ArgumentValidator validator(context, argumentCount, arguments);
id = validator.toString(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
EventAddressBookGetGroupPtr dplEvent(new EventAddressBookGetGroup());
addressBook->getGroup(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult() || !dplEvent->getContactGroupIsSet())
case ExceptionCodes::InvalidArgumentException:
LoggerE("Not Found error : " << id);
oss << "No Contact id '" << id << "'";
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_FOUND_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
result = converter->toJSValueRef(group);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return result;
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_GROUP);
validator.toObject(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
ContactGroupPtr group(NULL);
group = converter->toContactGroup(arguments[0]);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "1st argument must be a 'ContactGroup object'");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument must be a 'ContactGroup object'");
}
EventAddressBookAddGroupPtr dplEvent(new EventAddressBookAddGroup());
addressBook->addGroup(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult())
switch (dplEvent->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE_GROUP);
validator.toObject(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
ContactGroupPtr contact(NULL);
contact = converter->toContactGroup(arguments[0]);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "1st argument is not a 'ContactGroup object'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument is not a 'ContactGroup object'");
}
EventAddressBookUpdateGroupPtr dplEvent(new EventAddressBookUpdateGroup());
addressBook->updateGroup(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult())
case ExceptionCodes::NotFoundException:
case ExceptionCodes::InvalidArgumentException:
oss << "No Contact id '" << contact->getId() << "'";
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_FOUND_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
addressBook = controller->getObject();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_GROUP);
ArgumentValidator validator(context, argumentCount, arguments);
groupId = validator.toString(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
EventAddressBookRemoveGroupPtr dplEvent(new EventAddressBookRemoveGroup());
addressBook->removeGroup(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult())
case ExceptionCodes::InvalidArgumentException:
LoggerE("Not Found error : " << groupId);
oss << "No Contact id '" << groupId << "'";
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_FOUND_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_GET_GROUPS);
addressBook->getGroups(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult() || !dplEvent->getContactGroupsIsSet())
case ExceptionCodes::InvalidArgumentException:
LoggerE("Not Found error : " << id);
oss << "No Contact id '" << id << "'";
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_FOUND_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
result = converter->toJSValueRef(groups);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return result;
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
#include <SecurityExceptions.h>
#include "ContactFactory.h"
#include "plugin_config.h"
#include "JSContact.h"
#include "Contact.h"
#include <ArgumentValidator.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <TimeTracer.h>
#include <Logger.h>
#include <Export.h>
else
{
LoggerE("Argument type mismatch : 1nd argument must be ContactInit object or string");
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "2nd argument must be 'ContactTextFormat'");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "2nd argument must be 'ContactTextFormat'");
return NULL;
}
}
} Catch(ConversionException) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "1st argument must be 'ContactInit object'");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument must be 'ContactInit object'");
return NULL;
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
return NULL;
}
}
} Catch(ConversionException) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "2nd argument must be 'ContactTextFormat'");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "2nd argument must be 'ContactTextFormat'");
return NULL;
} Catch(InvalidArgumentException) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, "1st argument must be vCard string");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "1st argument must be vCard string");
return NULL;
} Catch(UnsupportedException) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_SUPPORTED_ERROR, "Only support vCard 3.0");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Only support vCard 3.0");
return NULL;
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
return NULL;
}
}
contact = ContactFactory::getInstance().createContact();
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
return NULL;
}
}
jsobject = createJSObject(gContext, contact);
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
return NULL;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
// AceSecurityStatus status = CONTACT_CHECK_ACCESS(
try {
format = validator.toString(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
std::string vCard;
vCard = contact->convertToString(format);
} Catch(ConversionException) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "1st argument must be 'ContactTextFormat string'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument must be 'ContactTextFormat string'");
} Catch(UnsupportedException) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, "Only support vCard 3.0");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Only support vCard 3.0");
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(context);
result = converter->toJSValueRef(vCard);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return result;
}
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
// AceSecurityStatus status = CONTACT_CHECK_ACCESS(
clonedContact = contact->clone();
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
JSValueRef result;
result = createJSObject(gContext, clonedContact);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return result;
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "ContactConverter.h"
#include "JSContactAddress.h"
#include <Logger.h>
} Catch(Exception ) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "1st argument must be a 'ContactAddressInit object'");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument must be a 'ContactAddressInit object'");
return NULL;
}
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "1st argument must be a 'ContactAddressInit object'");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument must be a 'ContactAddressInit object'");
return NULL;
}
jsobject = createJSObject(gContext, contactEmailAddress);
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
return NULL;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "ContactConverter.h"
#include "JSContactAnniversary.h"
#include <Logger.h>
contactAnniversary->setLabel(label);
}
} catch (const TypeMismatchException& err ) {
- JSWebAPIError::throwException(context, exception, err);
+ JSWebAPIErrorFactory::postException(context, exception, err);
return NULL;
} catch(const BasePlatformException& err) {
- JSWebAPIError::throwException(context, exception, err);
+ JSWebAPIErrorFactory::postException(context, exception, err);
return NULL;
} catch(const ConversionException& err) {
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
return NULL;
} catch(const NullPointerException& err) {
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
return NULL;
}
contactAnniversary->setDate(date);
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "1st argument must be a 'Date object'");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument must be a 'Date object'");
return NULL;
}
jsobject = createJSObject(gContext, contactAnniversary);
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong arguments");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong arguments");
return NULL;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "ContactConverter.h"
#include "JSContactEmailAddress.h"
#include <Logger.h>
isDefault = Argvalidator.toBool(2, false);
} catch (const TypeMismatchException& err ) {
- JSWebAPIError::throwException(context, exception, err);
+ JSWebAPIErrorFactory::postException(context, exception, err);
return NULL;
} catch(const BasePlatformException& err) {
- JSWebAPIError::throwException(context, exception, err);
+ JSWebAPIErrorFactory::postException(context, exception, err);
return NULL;
} catch(const ConversionException& err) {
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
return NULL;
} catch(const NullPointerException& err) {
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
return NULL;
}
jsobject = createJSObject(gContext, contactEmailAddress);
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong arguments");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong arguments");
return NULL;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
#include "JSContactGroup.h"
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "ContactConverter.h"
#include <Logger.h>
#include <Export.h>
contactGroup->setPhotoURI(Argvalidator.toString(2, true));
} catch (const TypeMismatchException& err ) {
- JSWebAPIError::throwException(context, exception, err);
+ JSWebAPIErrorFactory::postException(context, exception, err);
return NULL;
} catch(const BasePlatformException& err) {
- JSWebAPIError::throwException(context, exception, err);
+ JSWebAPIErrorFactory::postException(context, exception, err);
return NULL;
} catch(const ConversionException& err) {
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
return NULL;
} catch(const NullPointerException& err) {
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
return NULL;
}
jsobject = createJSObject(gContext, contactGroup);
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
return NULL;
}
LoggerW("trying to set incorrect value");
}
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
return false;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
#include <CommonsJavaScript/Converter.h>
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSPendingOperation.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
#include <SecurityExceptions.h>
#include <FilterConverter.h>
#include "ContactFactory.h"
#include "JSContactManagerChangeCallbackManager.h"
#include "ContactFilterConverter.h"
#include <ArgumentValidator.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <TimeTracer.h>
#include <Logger.h>
#include <Export.h>
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_ADDRESS_BOOKS);
if(errorObj)
js2ndParamIsFunction = true;
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
ContactAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
static_cast<ContactManagerController*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_DEFAULT_ADDRESS_BOOK);
gContext = priv->getContext();
} Catch(Exception) {
LoggerE("contact manager or context is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(gContext);
contactManager->getDefaultAddressBook(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult() || !dplEvent->getDefaultAddressBookIsSet())
case ExceptionCodes::InvalidArgumentException:
LoggerE("Not Found error");
oss << "No default address book";
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
resultValue = converter->toJSValueRef(defaultAddressBook);
} Catch(Exception){
LoggerE("Conversion error.");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
static_cast<ContactManagerController*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_UNIFIED_ADDRESS_BOOK);
gContext = priv->getContext();
} Catch(Exception) {
LoggerE("contact manager or context is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(gContext);
contactManager->getUnifiedAddressBook(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult() || !dplEvent->getUnifiedAddressBookIsSet())
case ExceptionCodes::InvalidArgumentException:
LoggerE("Not Found error");
oss << "No default address book";
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
resultValue = converter->toJSValueRef(unifiedAddressBook);
} Catch(Exception){
LoggerE("Conversion error.");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
static_cast<ContactManagerController*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_ADDRESS_BOOK);
gContext = priv->getContext();
} Catch(Exception) {
LoggerE("contact manager or context is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(gContext);
ArgumentValidator validator(context, argumentCount, arguments);
addressBookId = validator.toString(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
EventContactManagerGetAddressBookPtr dplEvent(new EventContactManagerGetAddressBook());
contactManager->getAddressBook(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult() || !dplEvent->getAddressBookIsSet())
case ExceptionCodes::InvalidArgumentException:
LoggerE("Not Found error : " << addressBookId);
oss << "No Contact id '" << addressBookId << "'";
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
resultValue = converter->toJSValueRef(addressBook);
} Catch(Exception){
LoggerE("Conversion error.");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
addressBook = controller->getObject();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_GET);
if (argumentCount < 1) {
/* 1st Argument must be string. */
LoggerE("1st argument must not be undefined.");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, "No Contact id 'undefined'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "No Contact id 'undefined'");
}
std::string id;
ArgumentValidator validator(context, argumentCount, arguments);
id = validator.toString(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
EventContactManagerGetPtr dplEvent(new EventContactManagerGet());
addressBook->get(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult() || !dplEvent->getPersonIsSet())
case ExceptionCodes::InvalidArgumentException:
LoggerE("Not Found error : " << id);
oss << "No Person id '" << id << "'";
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
result = converter->toJSValueRef(person);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
addressBook = controller->getObject();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_UPDATE);
ArgumentValidator validator(context, argumentCount, arguments);
validator.toObject(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
PersonPtr person(NULL);
person = converter->toPerson(arguments[0]);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "1st argument is not a 'Contact object'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument is not a 'Contact object'");
}
EventContactManagerUpdatePtr dplEvent(new EventContactManagerUpdate());
addressBook->update(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult())
case ExceptionCodes::NotFoundException:
case ExceptionCodes::InvalidArgumentException:
oss << "No Contact id '" << person->getId() << "'";
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_UPDATE_BATCH);
if(errorObj)
js3rdParamIsFunction = true;
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(context);
dplEvent->setPersons(converter->toPersonArray(arguments[0]));
} Catch(ConversionException) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "3rd argument must be a 'function' or a 'null'");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "3rd argument must be a 'function' or a 'null'");
}
// set event handler's data
ContactAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
addressBook = controller->getObject();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE);
ArgumentValidator validator(context, argumentCount, arguments);
personId = validator.toString(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
EventContactManagerRemovePtr dplEvent(new EventContactManagerRemove());
addressBook->remove(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult())
case ExceptionCodes::InvalidArgumentException:
LoggerE("Not Found error : " << personId);
oss << "No Contact id '" << personId << "'";
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_FOUND_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE_BATCH);
if(errorObj)
js3rdParamIsFunction = true;
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(context);
dplEvent->setPersonIds(converter->toStringArray(arguments[0]));
} Catch(ConversionException) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "3rd argument must be an array of 'Contact id'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "3rd argument must be an array of 'Contact id'");
}
// set event handler's data
ContactAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_FIND);
js4thParamIsObject = true;
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
dplEvent->setFilter(filterConverter->toFilter(arguments[2]));
} Catch(Exception) {
LoggerE("Error on 3rd parameter conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "3rd argument must be an 'Filter object' or 'null'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "3rd argument must be an 'Filter object' or 'null'");
}
Try {
dplEvent->setSortMode(filterConverter->toSortMode(arguments[3]));
} Catch(Exception) {
LoggerE("Error on 4th parameter conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "4th argument must be an 'SortMode object' or 'null'");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "4th argument must be an 'SortMode object' or 'null'");
}
// set event handler's data
ContactAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_ADD_CHANGE_LISTENER);
js2ndParamIsFunction = true;
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(context);
} Catch(ConversionException) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
JSContactManagerChangeCallbackManagerPtr callbackManager = JSContactManagerChangeCallbackManager::createObject(gContext);
addressBook->addChangeListener(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult() || !dplEvent->getIdIsSet())
{
case ExceptionCodes::InvalidArgumentException:
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
result = converter->toJSValueRefLong(watchId);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return result;
gContext = controller->getContext();
} Catch(Exception) {
LoggerE("No private object");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE_CHANGE_LISTENER);
ArgumentValidator validator(context, argumentCount, arguments);
watchId = validator.toLong(0, false, 0);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
EventContactManagerRemoveChangeListenerPtr dplEvent(new EventContactManagerRemoveChangeListener());
addressBook->removeChangeListener(dplEvent);
} Catch(Exception) {
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
PersonsChangeListenerCancellerPtr canceller = PersonsChangeListenerCancellerPtr(new PersonsChangeListenerCanceller(gContext, thisObject, watchId));
{
case ExceptionCodes::InvalidArgumentException:
case ExceptionCodes::NotFoundException:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, "Watch id not found");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "Watch id not found");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "ContactConverter.h"
#include "JSContactName.h"
#include <Logger.h>
} Catch(Exception ) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "1st argument must be 'object'");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument must be 'object'");
return NULL;
}
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
return NULL;
}
jsobject = createJSObject(gContext, contactName);
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
return NULL;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
#include "JSContactOrganization.h"
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "ContactConverter.h"
#include <Logger.h>
#include <Export.h>
} Catch(Exception ) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "1st argument must be a 'object'");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument must be a 'object'");
return NULL;
}
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
return NULL;
}
jsobject = createJSObject(gContext, contactOrganization);
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
return NULL;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "ContactConverter.h"
#include "JSContactPhoneNumber.h"
#include <Logger.h>
isDefault = Argvalidator.toBool(2, false);
} catch (const TypeMismatchException& err ) {
- JSWebAPIError::throwException(context, exception, err);
+ JSWebAPIErrorFactory::postException(context, exception, err);
return NULL;
} catch(const BasePlatformException& err) {
- JSWebAPIError::throwException(context, exception, err);
+ JSWebAPIErrorFactory::postException(context, exception, err);
return NULL;
} catch(const ConversionException& err) {
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
return NULL;
} catch(const NullPointerException& err) {
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
return NULL;
}
jsobject = createJSObject(gContext, contactPhoneNumber);
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong arguments");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong arguments");
return NULL;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "ContactConverter.h"
#include "JSContactRef.h"
#include <Logger.h>
} Catch(Exception ) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, "Wrong arguments");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Wrong arguments");
return NULL;
}
addressBookId = converter->toString(arguments[0]);
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong arguments");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong arguments");
return NULL;
}
contactId = converter->toString(arguments[1]);
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong arguments");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong arguments");
return NULL;
}
jsobject = createJSObject(gContext, contactRef);
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong arguments");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong arguments");
return NULL;
}
LoggerW("trying to set incorrect value");
}
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
return false;
}
LoggerW("trying to set incorrect value");
}
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
return false;
}
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "ContactConverter.h"
#include "JSContactWebSite.h"
#include <Logger.h>
}
} catch (const TypeMismatchException& err ) {
- JSWebAPIError::throwException(context, exception, err);
+ JSWebAPIErrorFactory::postException(context, exception, err);
return NULL;
} catch(const BasePlatformException& err) {
- JSWebAPIError::throwException(context, exception, err);
+ JSWebAPIErrorFactory::postException(context, exception, err);
return NULL;
} catch(const ConversionException& err) {
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
return NULL;
} catch(const NullPointerException& err) {
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
return NULL;
}
jsobject = createJSObject(gContext, contactWebSite);
} Catch(Exception) {
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong arguments");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong arguments");
return NULL;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
}
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
#include <SecurityExceptions.h>
#include "ContactFactory.h"
#include "plugin_config.h"
#include "ContactConverter.h"
#include "JSPerson.h"
#include <ArgumentValidator.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <TimeTracer.h>
#include <Logger.h>
#include <Export.h>
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("trying to set incorrect value");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
return true;
Catch(Exception)
{
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_PERSON_LINK);
try {
personId = validator.toString(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
EventPersonLinkPtr dplEvent(new EventPersonLink());
Catch(ConversionException)
{
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "1st argument must be 'PersonId'");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument must be 'PersonId'");
}
Catch(Exception)
{
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult())
{
case ExceptionCodes::NotFoundException:
oss << "Person id (" << personId << ") is not exists.";
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, oss.str());
break;
case ExceptionCodes::InvalidArgumentException:
oss << "Person id (" << personId << ") is wrong.";
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
Catch(Exception)
{
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "Wrong object");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_PERSON_UNLINK);
try {
contactId = validator.toString(0, false);
} catch (const TypeMismatchException& err ) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const BasePlatformException& err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch(const ConversionException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
} catch(const NullPointerException& err) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "");
}
EventPersonUnlinkPtr dplEvent(new EventPersonUnlink());
Catch(ConversionException)
{
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "1st argument must be 'ContactId'");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument must be 'ContactId'");
}
Catch(Exception)
{
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
if (!dplEvent->getResult())
{
case ExceptionCodes::InvalidArgumentException:
oss << "No Contact id is wrong : '" << contactId << "'";
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, oss.str());
break;
case ExceptionCodes::NotFoundException:
oss << "No Contact id '" << contactId << "'";
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, oss.str());
break;
case ExceptionCodes::OutOfRangeException:
oss << "Contact (id:'" << contactId << "') is not a member of person";
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, oss.str());
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, oss.str());
break;
case ExceptionCodes::PlatformException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
default:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
}
}
Catch(Exception)
{
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Internal error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return result;
//
#include <CommonsJavaScript/JSCallbackManager.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include "ContentController.h"
#include "ContentConverter.h"
#include "ContentAsyncCallbackManager.h"
}
else
{
- JSValueRef errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ JSValueRef errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
cbm->callOnError(errorObject);
}
return;
}
else
{
- JSValueRef errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ JSValueRef errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
cbm->callOnError(errorObject);
}
return;
}
else
{
- JSValueRef errorObject = DeviceAPI::Common::JSTizenExceptionFactory::makeErrorObject(
- cbm->getContext(), DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ JSValueRef errorObject = DeviceAPI::Common::JSWebAPIErrorFactory::makeErrorObject(
+ cbm->getContext(), DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
cbm->callOnError(errorObject);
}
return;
#include <pthread.h>
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <JSUtil.h>
#include "ContentListener.h"
#include "ContentConverter.h"
}
}
+ if (MEDIA_CONTENT_ERROR_NONE == media_info_get_title(info, &tmpStr) )
+ {
+ if (tmpStr)
+ {
+ newMedia->setTitle(tmpStr);
+ free(tmpStr);
+ tmpStr = NULL;
+ }
+ }
+
if ( MEDIA_CONTENT_ERROR_NONE == media_info_get_file_path(info, &tmpStr) )
{
if (tmpStr)
{
struct tm *result = (struct tm *)calloc(1, sizeof(struct tm));
if (strptime(tmpStr, "%Y:%m:%d %H:%M:%S", result) == NULL) {
- LogError( "Couldn't convert supplied date.");
+ LoggerE( "Couldn't convert supplied date.");
}
newImage->setReleasedDate(result);
tmpStr = NULL;
}
}
- if ( MEDIA_CONTENT_ERROR_NONE == image_meta_get_title(img, &tmpStr) )
- {
- if( tmpStr )
- {
- newImage->setTitle(tmpStr);
- free(tmpStr);
- tmpStr = NULL;
- }
- }
-
if ( MEDIA_CONTENT_ERROR_NONE == image_meta_get_width(img, &tmpInt) )
{
newImage->setImageWidth(tmpInt);
{
struct tm *result=(struct tm *)calloc(1, sizeof(struct tm));
if (strptime(tmpStr, "%Y:%m:%d %H:%M:%S", result) == NULL) {
- LogError( "Couldn't convert supplied date.");
+ LoggerE( "Couldn't convert supplied date.");
}
newVideo->setReleasedDate(result);
}
}
- if ( MEDIA_CONTENT_ERROR_NONE == video_meta_get_title(video, &tmpStr) )
- {
- if( tmpStr )
- {
- newVideo->setTitle(tmpStr);
- free(tmpStr);
- tmpStr = NULL;
- }
- }
-
if ( MEDIA_CONTENT_ERROR_NONE == video_meta_get_artist(video, &tmpStr) )
{
if ( tmpStr)
{
struct tm *result = (struct tm *)calloc(1, sizeof(struct tm));
if (strptime(tmpStr, "%Y:%m:%d %H:%M:%S", result) == NULL) {
- LogError( "Couldn't convert supplied date.");
+ LoggerE( "Couldn't convert supplied date.");
}
newAudio->setReleasedDate(result);
}
}
- if ( MEDIA_CONTENT_ERROR_NONE == audio_meta_get_title(audio, &tmpStr) )
- {
- if (tmpStr)
- {
- newAudio->setTitle(tmpStr);
- free(tmpStr);
- tmpStr = NULL;
- }
- }
-
if ( MEDIA_CONTENT_ERROR_NONE == audio_meta_get_album(audio, &tmpStr) )
{
if (tmpStr)
if ( MEDIA_CONTENT_ERROR_NONE !=
media_folder_foreach_folder_from_db (NULL, mediaFolderCallback, eFolder.Get()))
{
- LogError("error ( media_folder_foreach_folder_from_db ) : ");
+ LoggerE("error ( media_folder_foreach_folder_from_db ) : ");
eFolder->setResult(false);
}
else
else
{
- LogError("error ( media filter create ) : ");
+ LoggerE("error ( media filter create ) : ");
eBrowse->setResult(false);
}
}
if ( MEDIA_CONTENT_ERROR_NONE !=
media_folder_foreach_media_from_db (folderID.c_str(), filter, mediaItemCallback, eBrowse.Get()))
{
- LogError("error ( media_folder_foreach_folder_from_db ) : " << ret);
+ LoggerE("error ( media_folder_foreach_folder_from_db ) : " << ret);
eBrowse->setResult(false);
}
else
if ( MEDIA_CONTENT_ERROR_NONE !=
media_info_foreach_media_from_db (filter, mediaItemCallback, eBrowse.Get()))
{
- LogError("error ( media_folder_foreach_folder_from_db ) : " << ret);
+ LoggerE("error ( media_folder_foreach_folder_from_db ) : " << ret);
eBrowse->setResult(false);
}
else
{
if ( MEDIA_CONTENT_ERROR_NONE != media_filter_destroy(filter))
{
- LogError("media_filter_create Error: " << ret);
+ LoggerE("media_filter_create Error: " << ret);
}
}
}
catch(const Exception &ex){
- LogError("Exception: " << ex.DumpToString());
+ LoggerE("Exception: " << ex.DumpToString());
eBrowse->setResult(false);
return;
}
}
catch (const Exception &ex)
{
- LogError("Exception: " << ex.DumpToString());
+ LoggerE("Exception: " << ex.DumpToString());
eMedia->setResult(false);
}
}
}
catch (const Exception &ex)
{
- LogError("Exception: " << ex.DumpToString());
+ LoggerE("Exception: " << ex.DumpToString());
eItems->setResult(false);
}
}
#include <CommonsJavaScript/PrivateObject.h>
#include <CommonsJavaScript/Converter.h>
#include <CommonsJavaScript/JSUtils.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include "JSAudio.h"
#include "JSAudioLyrics.h"
Catch(Exception)
{
LoggerW("trying to set incorrect value");
- DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR);
+ DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
return false;
}
else
{
- DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR);
+ DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
return false;
}
}
Catch(Exception)
{
LoggerW("trying to set incorrect value");
- return DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR);
+ return DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
return false;
}
Catch(Exception)
{
- return DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR);
+ return DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
return false;
Catch(Exception)
{
LoggerW("trying to set incorrect value");
- return DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR);
+ return DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
return false;
Catch(Exception)
{
LoggerW("trying to set incorrect value");
- DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR);
+ DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
return false;
#include <CommonsJavaScript/PrivateObject.h>
#include <CommonsJavaScript/Converter.h>
#include <CommonsJavaScript/JSUtils.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include "JSContent.h"
#include <Logger.h>
Catch(Exception)
{
LoggerW("trying to set incorrect value");
- DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR);
+ DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
return false;
Catch(Exception)
{
LoggerW("trying to set incorrect value");
- DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR);
+ DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
return false;
Catch(Exception)
{
LoggerW("trying to set incorrect value");
- DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR);
+ DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
return false;
#include <CommonsJavaScript/JSPendingOperation.h>
#include <CommonsJavaScript/PrivateObject.h>
#include <CommonsJavaScript/ScopedJSStringRef.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
#include <SecurityExceptions.h>
#include <CallbackUserData.h>
#include <MultiCallbackUserData.h>
#include <GlobalContextManager.h>
#include <FilterConverter.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
#include <TimeTracer.h>
#include "ContentImage.h"
#include "ContentFilterConverter.h"
#include "ContentUtility.h"
-#include "JSWebAPIException.h"
#include <Logger.h>
using namespace DeviceAPI::Common;
privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
cbm->setOnError(errorCallbackObj);
}
}catch(const BasePlatformException &err){
- return JSWebAPIException::throwException(context,exception,err);
+ return JSWebAPIErrorFactory::postException(context,exception,err);
}
catch(...){
DeviceAPI::Common::UnknownException err("Unknown Error in ContentManager.getDirectories().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
Try
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
if(!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
AceSecurityStatus status = CONTENT_CHECK_ACCESS(CONTENT_FUNCTION_API_FIND_ITEMS);
}
}
}catch(const BasePlatformException &err){
- return JSWebAPIException::throwException(context,exception,err);
+ return JSWebAPIErrorFactory::postException(context,exception,err);
}
catch(...){
DeviceAPI::Common::UnknownException err("Unknown Error in find().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
Try
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
if(!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
cbm->setOnError(errorCallbackObj);
}
}catch(const BasePlatformException &err){
- return JSWebAPIException::throwException(context,exception,err);
+ return JSWebAPIErrorFactory::postException(context,exception,err);
}
catch(...){
DeviceAPI::Common::UnknownException err("Unknown Error in updateBatch().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
Try
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
AceSecurityStatus status = CONTENT_CHECK_ACCESS(CONTENT_FUNCTION_API_UPDATE_ITEM);
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
}
else{
DeviceAPI::Common::UnknownException err(err_msg.c_str());
- JSObjectRef errorObject = JSWebAPIError::makeJSWebAPIError(cb->getContext(),err);
+ JSObjectRef errorObject = JSWebAPIErrorFactory::makeErrorObject(cb->getContext(),err);
cb->callErrorCallback(errorObject);
}
delete cb;
privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
if(!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
AceSecurityStatus status = CONTENT_CHECK_ACCESS(CONTENT_FUNCTION_API_SCAN_FILE);
callback->setErrorCallback(errorCallbackObj);
}
}catch(const BasePlatformException &err){
- return JSWebAPIException::throwException(context,exception,err);
+ return JSWebAPIErrorFactory::postException(context,exception,err);
}
catch(...){
DeviceAPI::Common::UnknownException err("Unknown Error in scanFile().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
Try
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
if(!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
AceSecurityStatus status = CONTENT_CHECK_ACCESS(CONTENT_FUNCTION_API_SET_CHANGE_LISTENER);
throw DeviceAPI::Common::UnknownException( "Unknown exception is occured by platfrom");
}
}catch(const BasePlatformException &err){
- return JSWebAPIException::throwException(context,exception,err);
+ return JSWebAPIErrorFactory::postException(context,exception,err);
}
catch(...){
DeviceAPI::Common::UnknownException err("Unknown Error in setChangeListener().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
if(!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
AceSecurityStatus status = CONTENT_CHECK_ACCESS(CONTENT_FUNCTION_API_SET_CHANGE_LISTENER);
throw DeviceAPI::Common::UnknownException( "Unknown exception is occured by platfrom");
}
}catch(const BasePlatformException &err){
- return JSWebAPIException::throwException(context,exception,err);
+ return JSWebAPIErrorFactory::postException(context,exception,err);
}
catch(...){
DeviceAPI::Common::UnknownException err("Unknown Error in unsetChangeListener().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
#include <CommonsJavaScript/JSDOMExceptionFactory.h>
#include <JSSimpleCoordinates.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include "JSUtil.h"
Catch(Exception)
{
LoggerW("trying to get incorrect value");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR);
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
return false;
Catch(Exception)
{
LoggerW("trying to get incorrect value");
- DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR);
+ DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
return false;
#include <CommonsJavaScript/Converter.h>
#include <CommonsJavaScript/JSUtils.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <JSSimpleCoordinates.h>
#include "ContentConverter.h"
Catch(Exception)
{
LoggerW("trying to get incorrect value");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR);
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
return false;
}
}
}
else{
- DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR);
+ DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
video->setVideoArtist(artists, true);
return true;
Catch(Exception)
{
LoggerW("trying to set incorrect value");
- DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR);
+ DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
return false;
}
Catch(Exception)
{
LoggerW("trying to set incorrect value");
- DeviceAPI::Common::JSTizenExceptionFactory::postException(context, exception, DeviceAPI::Common::JSTizenException::TYPE_MISMATCH_ERROR);
+ DeviceAPI::Common::JSWebAPIErrorFactory::postException(context, exception, DeviceAPI::Common::JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR);
}
return false;
}
#include "DataControlAsyncCallbackManager.h"
#include "JSSelectObjectArrayValues.h"
#include <CommonsJavaScript/JSUtils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <Logger.h>
using namespace DeviceAPI::Common;
errorMsg = "permission denied error";
err[0] = converter.toJSValueRef(reqid);
- err[1] = JSTizenExceptionFactory::makeErrorObject(globalContext,
- JSTizenException::PERMISSION_DENIED_ERROR, errorMsg);
+ err[1] = JSWebAPIErrorFactory::makeErrorObject(globalContext,
+ JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, errorMsg);
break;
case ExceptionCodes::UnsupportedException:
errorMsg = "unsupport error";
err[0] = converter.toJSValueRef(reqid);
- err[1] = JSTizenExceptionFactory::makeErrorObject(globalContext,
- JSTizenException::NOT_SUPPORTED_ERROR, errorMsg);
+ err[1] = JSWebAPIErrorFactory::makeErrorObject(globalContext,
+ JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, errorMsg);
break;
case ExceptionCodes::NotFoundException:
errorMsg = "not found error";
err[0] = converter.toJSValueRef(reqid);
- err[1] = JSTizenExceptionFactory::makeErrorObject(globalContext,
- JSTizenException::NOT_FOUND_ERROR, errorMsg);
+ err[1] = JSWebAPIErrorFactory::makeErrorObject(globalContext,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, errorMsg);
break;
case ExceptionCodes::AlreadyInUseException:
errorMsg = "service not available";
err[0] = converter.toJSValueRef(reqid);
- err[1] = JSTizenExceptionFactory::makeErrorObject(globalContext,
- JSTizenException::SERVICE_NOT_AVAILABLE, errorMsg);
+ err[1] = JSWebAPIErrorFactory::makeErrorObject(globalContext,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, errorMsg);
break;
case ExceptionCodes::EventCancelledException:
errorMsg = "unknown error";
err[0] = converter.toJSValueRef(reqid);
- err[1] = JSTizenExceptionFactory::makeErrorObject(globalContext,
- JSTizenException::UNKNOWN_ERROR, errorMsg);
+ err[1] = JSWebAPIErrorFactory::makeErrorObject(globalContext,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, errorMsg);
break;
}
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <Commons/Exception.h>
#include <TimeTracer.h>
#include "DataControlListener.h"
#include "plugin_config.h"
#include <ArgumentValidator.h>
-#include <JSWebAPIError.h>
-#include <JSWebAPIException.h>
#include <JSUtil.h>
}
catch (const BasePlatformException &err)
{
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (...)
{
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSValueRef reserveArguments[3];
Catch (WrtDeviceApis::Commons::ConversionException)
{
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
Catch (WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("InvalidArgumentException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "type mismatch error");
}
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerE("UnsupportException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Unsupport Exception");
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("UnkownException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
}
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <Commons/Exception.h>
#include <TimeTracer.h>
#include <ArgumentValidator.h>
-#include <JSWebAPIError.h>
-#include <JSWebAPIException.h>
#include <JSUtil.h>
#include "DataControlFactory.h"
#include "JSMappedDataControlConsumer.h"
}
catch (const BasePlatformException &err)
{
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (...)
{
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
if (priv == NULL)
{
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
Catch (WrtDeviceApis::Commons::ConversionException)
{
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
Catch (WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("InvalidArgumentException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "type mismatch error");
}
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerE("UnsupportException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Unsupport Exception");
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("UnkownException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
catch (const BasePlatformException &err)
{
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (...)
{
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
if (priv == NULL)
{
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
Catch (WrtDeviceApis::Commons::ConversionException)
{
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
Catch (WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("InvalidArgumentException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "type mismatch error");
}
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerE("UnsupportException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Unsupport Exception");
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("UnkownException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
if (priv == NULL)
{
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
// argument validation with new validator
}
catch (const BasePlatformException &err)
{
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (...)
{
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSContextRef globalContext = priv->getContext();
Catch (WrtDeviceApis::Commons::ConversionException)
{
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
Catch (WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("InvalidArgumentException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "type mismatch error");
}
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerE("UnsupportException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Unsupport Exception");
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("UnkownException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
catch (const BasePlatformException &err)
{
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (...)
{
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
if (priv == NULL)
{
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
Catch (WrtDeviceApis::Commons::ConversionException)
{
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
Catch (WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("InvalidArgumentException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "type mismatch error");
}
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerE("UnsupportException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Unsupport Exception");
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("UnkownException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <Commons/Exception.h>
#include <TimeTracer.h>
#include <ArgumentValidator.h>
-#include <JSWebAPIError.h>
-#include <JSWebAPIException.h>
#include <JSUtil.h>
#include "DataControlFactory.h"
#include "JSSQLDataControlConsumer.h"
}
catch (const BasePlatformException &err)
{
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (...)
{
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
if (priv == NULL)
{
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
Catch (WrtDeviceApis::Commons::ConversionException)
{
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
Catch (WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("InvalidArgumentException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "type mismatch error");
}
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerE("UnsupportException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Unsupport Exception");
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("UnkownException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
catch (const BasePlatformException &err)
{
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (...)
{
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
DataControlConverter converter(context);
if (priv == NULL)
{
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
Catch (WrtDeviceApis::Commons::ConversionException)
{
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
Catch (WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("InvalidArgumentException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "type mismatch error");
}
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerE("UnsupportException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Unsupport Exception");
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("UnkownException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
catch (const BasePlatformException &err)
{
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (...)
{
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
if (priv == NULL)
{
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
JSContextRef globalContext = priv->getContext();
Catch (WrtDeviceApis::Commons::ConversionException)
{
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
Catch (WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("InvalidArgumentException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "type mismatch error");
}
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerE("UnsupportException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Unsupport Exception");
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("UnkownException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
catch (const BasePlatformException &err)
{
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (...)
{
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
DataControlConverter converter(context);
if (priv == NULL)
{
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
JSCallbackManagerPtr cbm = JSCallbackManager::createObject(priv->getContext(), NULL, NULL);
Catch (WrtDeviceApis::Commons::ConversionException)
{
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
}
Catch (WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("InvalidArgumentException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "type mismatch error");
}
Catch(WrtDeviceApis::Commons::UnsupportedException)
{
LoggerE("UnsupportException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_SUPPORTED_ERROR, "Unsupport Exception");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Unsupport Exception");
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("UnkownException");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
#include <algorithm>
#include <CommonsJavaScript/ScopedJSStringRef.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "DataControlFactory.h"
#include "RowData.h"
#include "DataControlConverter.h"
}
else
{
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}
}
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("error occured");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}*/
return false;
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("error occured");
- JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
+ JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
}*/
return false;
}
return SYNC_AGENT_SYNC_INTERVAL_1_WEEK;
} else if(SyncInfo::INTERVAL_1_MONTH==syncInterval) {
return SYNC_AGENT_SYNC_INTERVAL_1_MONTH;
+ } else if(SyncInfo::INTERVAL_UNDEFINED==syncInterval) {
+ return SYNC_AGENT_SYNC_INTERVAL_NONE;
} else {
- LoggerW("Error while converting a sync interval.");
+ LoggerW("Error while converting a JS sync interval.");
}
return SYNC_AGENT_SYNC_INTERVAL_1_WEEK;
return SyncInfo::INTERVAL_1_WEEK;
} else if(SYNC_AGENT_SYNC_INTERVAL_1_MONTH==syncInterval) {
return SyncInfo::INTERVAL_1_MONTH;
+ } else if(SYNC_AGENT_SYNC_INTERVAL_NONE==syncInterval) {
+ return SyncInfo::INTERVAL_UNDEFINED;
} else {
- LoggerW("Error while converting a sync interval.");
+ LoggerW("Error while converting a platform sync interval.");
}
return SyncInfo::INTERVAL_UNDEFINED;
password = categories->at(i)->getPassword();
enable = categories->at(i)->getEnable();
- LoggerD("serviceType: "<<serviceType<<", tgtURI: "<<tgtURI<<", id: "<<id<<" for index: "<<i);
+ LoggerD("serviceType: "<<serviceType<<", tgtURI: "<<tgtURI<<" for index: "<<i);
ret = sync_agent_ds_set_sync_service_info(profile_h, serviceType, enable, srcURI, (char*)(tgtURI.c_str()),
0==id.size() ? NULL : (char*)(id.c_str()), 0==password.size() ? NULL : (char*)(password.c_str()));
password = categories->at(i)->getPassword();
enable = categories->at(i)->getEnable();
- LoggerD("serviceType: "<<serviceType<<", tgtURI: "<<tgtURI<<", id: "<<id<<" for index: "<<i);
+ LoggerD("serviceType: "<<serviceType<<", tgtURI: "<<tgtURI<<" for index: "<<i);
ret = sync_agent_ds_set_sync_service_info(profile_h, serviceType, enable, srcURI, (char*)(tgtURI.c_str()),
0==id.size() ? NULL : (char*)(id.c_str()), 0==password.size() ? NULL : (char*)(password.c_str()));
#include "DataSyncMultiCallback.h"
#include <CommonsJavaScript/JSCallbackManager.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <Logger.h>
#include <GlobalContextManager.h>
LoggerD("Sync failed with: "<<event->getExceptionCode());
JSValueRef errorObject;
if (ExceptionCodes::PlatformException==event->getExceptionCode()) {
- //errorObject = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NETWORK_ERROR, event->getErrorMessage());
- errorObject = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NETWORK_ERROR);
+ //errorObject = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::NETWORK_ERROR, event->getErrorMessage());
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::NETWORK_ERROR);
} else {
- errorObject = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR);
}
JSValueRef objParam[2] = {profileId, errorObject};
multiCallbacks->getOnFailed()->callOnSuccess(objParam, 2);
#include <CommonsJavaScript/Utils.h>
#include <CommonsJavaScript/Validator.h>
#include <CommonsJavaScript/ScopedJSStringRef.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include "OnDataSyncStateChanged.h"
namespace DeviceAPI {
namespace DataSync {
+using WrtDeviceApis::Commons::UnknownException;
+using WrtDeviceApis::Commons::NotFoundException;
+
JSClassDefinition JSDataSyncManager::m_classInfo = {
0,
kJSClassAttributeNone,
Catch(OutOfRangeException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, "QuotaExceededError", _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::QUOTA_EXCEEDED_ERROR, _rethrown_exception.GetMessage());
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
LoggerD("Set the emitter.");
dplEvent->setEmitter(emitter);
- } else if (JSValueIsNull(context, arguments[1]) || JSValueIsUndefined(context, arguments[1]) ) {
+ } else if (JSValueIsNull(context, arguments[1]) ) {
LoggerD("Null or undefined listener.");
} else {
ThrowMsg(ConversionException, "Wrong second parameter type.");
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
return JSValueMakeUndefined(context);
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
return JSValueMakeUndefined(context);
Catch (NotFoundException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
}
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
#include "JSSyncInfo.h"
#include "DataSyncConverter.h"
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <CommonsJavaScript/Converter.h>
#include <Logger.h>
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
} else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_TYPE)) {
return converter.toJSValueRef(converter.toTizenValue(syncInfo->getSyncType()));
} else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_INTERVAL)) {
- return converter.toJSValueRef(converter.toTizenValue(syncInfo->getSyncInterval()));
+ if( SyncInfo::INTERVAL_UNDEFINED==syncInfo->getSyncInterval() ) {
+ return JSValueMakeUndefined(context);
+ } else {
+ return converter.toJSValueRef(converter.toTizenValue(syncInfo->getSyncInterval()));
+ }
} else {
LoggerD("Wrong property name.");
}
#include "JSSyncServiceInfo.h"
#include "DataSyncConverter.h"
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <CommonsJavaScript/Converter.h>
#include <CommonsJavaScript/JSUtils.h>
#include <Logger.h>
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
#include "JSSyncServiceInfo.h"
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <CommonsJavaScript/Converter.h>
#include "DataSyncConverter.h"
#include <Logger.h>
Catch(UnsupportedException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
}
Catch(InvalidArgumentException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
}
Catch(ConversionException)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
Catch(Exception)
{
LoggerW("Exception: "<<_rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
}
#include "JSSyncStatistics.h"
#include "DataSyncConverter.h"
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <CommonsJavaScript/Converter.h>
#include <Logger.h>
// limitations under the License.
//
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <PlatformException.h>
#include <JSUtil.h>
#include "DownloadCallback.h"
-using namespace WrtDeviceApis::Commons;
-using namespace WrtDeviceApis::CommonsJavaScript;
-
using namespace DeviceAPI::Common;
namespace DeviceAPI {
JSValueRef objParam[2] = {
JSUtil::toJSValueRef(context, downloadId),
- JSWebAPIError::makeJSWebAPIError(context, error)
+ JSWebAPIErrorFactory::makeErrorObject(context, error)
};
mCallbackUserData->invokeCallback("onfailed", 2, objParam);
}
#include <SecurityExceptions.h>
#include <JSUtil.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
return JSUtil::toJSValueRef(context, downloadId);
} catch (const BasePlatformException &err) {
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in tizen.download.start().");
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in tizen.download.setListener().");
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in tizen.download.cancel().");
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in tizen.download.pause().");
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in tizen.download.resume().");
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSUtil::toJSValueRef(context, ret);
} catch (const BasePlatformException &err) {
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in tizen.download.resume().");
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return obj;
} catch (const BasePlatformException &err) {
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in tizen.download.resume().");
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSUtil::toJSValueRef(context, ret);
} catch (const BasePlatformException &err) {
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in tizen.download.resume().");
LOGE("%s : %s", err.getName().c_str(), err.getMessage().c_str());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
#include <Logger.h>
#include <JSUtil.h>
-#include <JSWebAPIError.h>
#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
#include <CommonsJavaScript/Validator.h>
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/Utils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <ArgumentValidator.h>
-#include <JSWebAPIError.h>
-#include <JSWebAPIException.h>
#include <JSUtil.h>
#include <Export.h>
static_cast<PrivateObject*>(JSObjectGetPrivate(object));
if (!privateObject) {
LoggerE("Private object is not set.");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
JSContextRef globalContext = privateObject->getContext();
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("Private object is not set.");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
Converter converter(context);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return converter.toJSValueRef(privateObject->getObject()->getNode()->toUri(widgetId));
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage());
}
}
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
LoggerD("OK");
validator.toObject(2, true);
}
catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSContextRef globalContext = privateObject->getContext();
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
// argument validation with new validator
validator.toFunction(2, true);
}
catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSContextRef globalContext = privateObject->getContext();
}
if ((AM_READ != mode) && (PERM_READ == privateObject->getObject()->getNode()->getPermissions())) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
}
std::string path = privateObject->getObject()->getNode()->getPath()->getFullPath();
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
validator.toFunction(1, true);
}
catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
if (NT_FILE != privateObject->getObject()->getNode()->getType()) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::IO_ERROR, "IO error"));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::IO_ERROR, "IO error"));
return JSValueMakeUndefined(context);
}
privateObject->getObject()->getNode()->read(event);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
JSContextRef globalContext = privateObject->getContext();
validator.toFunction(4, true);
}
catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
bool overwrite = converter.toBool(reserveArguments[2]);;
if (NT_DIRECTORY != privateObject->getObject()->getNode()->getType()) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::IO_ERROR, "IO error"));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::IO_ERROR, "IO error"));
return JSValueMakeUndefined(context);
}
IManager::getInstance().copy(event);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::NotFoundException &ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_FOUND_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
JSContextRef globalContext = privateObject->getContext();
validator.toFunction(4, true);
}
catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
size_t index = 0;
}
if ((privateObject->getObject()->getNode()->getPermissions() & PERM_WRITE) == 0) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
}
Converter converter(context);
cbm->setObject(thisObject);
if (NT_DIRECTORY != privateObject->getObject()->getNode()->getType()) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::IO_ERROR, "io error"));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::IO_ERROR, "io error"));
return JSValueMakeUndefined(context);
}
IManager::getInstance().move(event);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::NotFoundException &ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_FOUND_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage()));
}
catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_CREATE_DIR);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(privateObject->getContext(), getClassRef(), privData);
} catch (const WrtDeviceApis::Commons::PlatformException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::IO_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::IO_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage());
}
}
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_CREATE_FILE);
INodePtr node = privateObject->getObject()->getNode()->createChild(path, NT_FILE);
return JSUtils::makeObject(privateObject->getContext(), getClassRef(), node);*/
} catch (const WrtDeviceApis::Commons::PlatformException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::IO_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::IO_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage());
}
}
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_RESOLVE);
TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
if (privateObject->getObject()->getNode()->getType() != NT_DIRECTORY) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::IO_ERROR, "IO error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::IO_ERROR, "IO error");
}
Converter converter(context);
return JSUtils::makeObject(privateObject->getContext(), getClassRef(), node);
*/
} catch (const WrtDeviceApis::Commons::PlatformException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::IO_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::IO_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::NotFoundException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage());
}
}
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_DELETE_DIR);
TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
if (argc < 2) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
JSContextRef globalContext = privateObject->getContext();
validator.toFunction(3, true);
}
catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
size_t index = 0;
cbm->setObject(thisObject);
if ((privateObject->getObject()->getNode()->getPermissions() & PERM_WRITE) == 0) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
}
if (privateObject->getObject()->getNode()->getType() != NT_DIRECTORY) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::IO_ERROR, "IO error"));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::IO_ERROR, "IO error"));
return JSValueMakeUndefined(context);
}
bool recursive = converter.toBool(reserveArguments[1]);
if (*privateObject->getObject()->getNode()->getPath() != path->getPath()) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_FOUND_ERROR, "not found error"));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "not found error"));
return JSValueMakeUndefined(context);
}
IManager::getInstance().remove(eventRemove);
}
} catch (const WrtDeviceApis::Commons::PlatformException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::IO_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::IO_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::NotFoundException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_FOUND_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
// argument validation with new validator
try {
validator.toFunction(2, true);
}
catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSContextRef globalContext = privateObject->getContext();
if ((privateObject->getObject()->getNode()->getPermissions() & PERM_WRITE) == 0) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
}
JSValueRef onSuccess = NULL;
cbm->setObject(thisObject);
if (privateObject->getObject()->getNode()->getType() != NT_DIRECTORY) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::IO_ERROR, "IO error"));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::IO_ERROR, "IO error"));
return JSValueMakeUndefined(context);
}
if(eventResolve->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException){
LoggerD("POST IO NOT_FOUND_ERROR");
ThrowMsg(WrtDeviceApis::Commons::NotFoundException, "Not found error");
-
}
LoggerD("POST IO ERROR");
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::IO_ERROR, "IO error"));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::IO_ERROR, "IO error"));
return JSValueMakeUndefined(context);
}
}
} catch (const WrtDeviceApis::Commons::PlatformException& ex) {
LoggerD("Platform Exception !!!!!!!! post io error");
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::IO_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::IO_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::NotFoundException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_FOUND_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
LoggerD(">>>");
#include <Commons/Base64.h>
#include <CommonsJavaScript/JSUtils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <TimeTracer.h>
#include <Export.h>
{
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(object));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
}
return converter.toJSValueRef(static_cast<unsigned long>(pos));
} else if (JSStringIsEqualToUTF8CString(propertyName, PROPERTY_BYTES_AVAILABLE)) {
- unsigned long long bytes = stream->getSize() - stream->getPosition();
- return converter.toJSValueRef(static_cast<unsigned long long>(bytes));
+ long position = stream->getPosition();
+ long bytes = stream->getSize() - position;
+
+ return converter.toJSValueRefLong(static_cast<long>(bytes));
}
} catch (const WrtDeviceApis::Commons::ConversionException& ex) {
LoggerW("trying to get incorrect value");
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
Try {
privateObject->getObject()->close();
} Catch (WrtDeviceApis::Commons::PlatformException) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
TIME_TRACER_ITEM_BEGIN("read(UTF8)", 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
Converter converter(context);
return converter.toJSValueRef(outStr);
}
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::PlatformException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::IO_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::IO_ERROR, ex.GetMessage());
}
}
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_READ_BYTES);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return converter.toJSValueRef(data.Get(), privateObject->getObject()->getCount());
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::PlatformException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::IO_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::IO_ERROR, ex.GetMessage());
}
}
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_READ_BASE64);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return converter.toJSValueRef(base64);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::PlatformException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::IO_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::IO_ERROR, ex.GetMessage());
}
}
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_WRITE);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::PlatformException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::IO_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::IO_ERROR, ex.GetMessage());
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_WRITE_BYTES);
stream->write(*it);
}
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::PlatformException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::IO_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::IO_ERROR, ex.GetMessage());
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_WRITE_BASE64);
privateObject->getObject()->write(base64);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::PlatformException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::IO_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::IO_ERROR, ex.GetMessage());
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
#include <CommonsJavaScript/Utils.h>
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <Commons/WrtAccess/WrtAccess.h>
#include <WidgetDB/WidgetDBMgr.h>
#include <WidgetDB/IWidgetDB.h>
#include <TimeTracer.h>
#include <ArgumentValidator.h>
-#include <JSWebAPIError.h>
#include <JSWebAPIException.h>
#include <JSUtil.h>
#include <Export.h>
try {
return converter->toJSValueRef(IManager::getInstance().getMaxPathLength());
} catch (const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::IO_ERROR, "IO error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::IO_ERROR, "IO error");
}
}
validator.toFunction(2, true);
}
catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
if (argc < 2) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
IManager::getInstance().getStorage(event);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
validator.toFunction(1, true);
}
catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
if (argc < 1) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
IManager::getInstance().listStorages(event);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
catch (const BasePlatformException &err) {
LogDebug("Exception");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
if (argc < 1) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "TYPE_MISMATCH_ERROR");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "TYPE_MISMATCH_ERROR");
}
return converter->toJSValueRefLong(id);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
validator.toLong(0, false);
}
catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
if (argc < 1) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
}
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch (const WrtDeviceApis::Commons::NotFoundException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage());
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
validator.toString(3, true);
}
catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
if (argc < 2) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
LogDebug("resolve");
std::string perms = converter->toString(reserveArguments[3]);
LoggerD("perms:[" << perms << "]");
if (("r" != perms) && ("rw" != perms) && ("w" != perms) && ("a" != perms)) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Invalid permission");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Invalid permission");
} else if ("r" == perms) {
permissions = PERM_READ;
}
}
if (permissions & PERM_WRITE && virtualPath == "wgt-package") {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::PERMISSION_DENIED_ERROR, "permission denied");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "permission denied");
}
PermissionsAccessInfo perms(permissions, virtualPath);
IManager::getInstance().getNode(event);
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::NotFoundException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_FOUND_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage()));
} catch (const WrtDeviceApis::Commons::UnsupportedException& ex) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, ex.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::InvalidArgumentException& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage()));
} catch(const WrtDeviceApis::Commons::Exception& ex) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, ex.GetMessage()));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, ex.GetMessage()));
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
#include "PathUtils.h"
#include <Logger.h>
-
namespace DeviceAPI {
namespace Filesystem {
namespace PathUtils {
#include <Commons/Exception.h>
#include <Commons/IEvent.h>
#include <CommonsJavaScript/JSUtils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "JSFile.h"
#include "JSFilestream.h"
#include "EventGetNodeData.h"
} else {
JSObjectRef jsException;
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getCallbackManager()->getContext(), JSTizenException::NOT_FOUND_ERROR, "NotFoundError");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getCallbackManager()->getContext(), JSWebAPIErrorFactory::NOT_FOUND_ERROR, "NotFoundError");
} else {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getCallbackManager()->getContext(), JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getCallbackManager()->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
}
data->getCallbackManager()->callOnError(jsException);
}
data->callOnSuccess(result);
}
Catch(WrtDeviceApis::Commons::ConversionException) {
- data->callOnError(JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error"));
+ data->callOnError(JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::IO_ERROR, "IO error"));
}
} else {
JSObjectRef jsException = NULL;
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
} else {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::IO_ERROR, "IO error");
}
data->callOnError(jsException);
}
JSObjectRef jsException;
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::NOT_FOUND_ERROR, "NotFoundError");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::NOT_FOUND_ERROR, "NotFoundError");
}
else {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::IO_ERROR, "IO error");
}
data->callOnError(jsException);
}
} else {
JSObjectRef jsException = NULL;
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
}
else if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::NOT_FOUND_ERROR, "NotFoundError");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::NOT_FOUND_ERROR, "NotFoundError");
}
else {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::IO_ERROR, "IO error");
}
data->callOnError(jsException);
}
} else {
JSObjectRef jsException = NULL;
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
}
else if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::NOT_FOUND_ERROR, "NotFoundError");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::NOT_FOUND_ERROR, "NotFoundError");
}
else {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::IO_ERROR, "IO error");
}
data->callOnError(jsException);
}
} else {
JSObjectRef jsException = NULL;
if (event->getExceptionCode() ==WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
}
else if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::NOT_FOUND_ERROR, "NotFoundError");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::NOT_FOUND_ERROR, "NotFoundError");
}
else {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::IO_ERROR, "IO error");
}
data->callOnError(jsException);
}
}
}
Catch(WrtDeviceApis::Commons::ConversionException) {
- data->callOnError(JSTizenExceptionFactory::makeErrorObject(
- data->getContext(), JSTizenException::IO_ERROR, "IO error"));
+ data->callOnError(JSWebAPIErrorFactory::makeErrorObject(
+ data->getContext(), JSWebAPIErrorFactory::IO_ERROR, "IO error"));
}
} else {
JSObjectRef jsException = NULL;
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
}
else if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::NOT_FOUND_ERROR, "NotFoundError");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::NOT_FOUND_ERROR, "NotFoundError");
}
else {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::IO_ERROR, "IO error");
}
data->callOnError(jsException);
}
JSValueRef result = converter.toJSValueRef(event->getResult(), data->getContext());
data->callOnSuccess(result);
} Catch (WrtDeviceApis::Commons::ConversionException) {
- data->callOnError(JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error"));
+ data->callOnError(JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::IO_ERROR, "IO error"));
}
} else {
JSObjectRef jsException = NULL;
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
}
else if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::NotFoundException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::NOT_FOUND_ERROR, "Not found error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::NOT_FOUND_ERROR, "Not found error");
}
else {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::IO_ERROR, "IO error");
}
data->callOnError(jsException);
}
JSValueRef result = converter.toJSValueRef(event->getResult(), data->getContext());
data->callOnSuccess(result);
} Catch (WrtDeviceApis::Commons::ConversionException) {
- data->callOnError(JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error"));
+ data->callOnError(JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::IO_ERROR, "IO error"));
}
} else {
JSObjectRef jsException = NULL;
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::SecurityException) {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::PERMISSION_DENIED_ERROR, "Permission denied error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "Permission denied error");
} else {
- jsException = JSTizenExceptionFactory::makeErrorObject(data->getContext(), JSTizenException::IO_ERROR, "IO error");
+ jsException = JSWebAPIErrorFactory::makeErrorObject(data->getContext(), JSWebAPIErrorFactory::IO_ERROR, "IO error");
}
data->callOnError(jsException);
}
if (!m_stream.seekg(0, std::_S_end)) {
return 0;
}
-
- pos = m_stream.tellg();
-
- if (pos == -1) {
- return 0;
- }
unsigned long long result = m_stream.tellg();
m_stream.seekg(pos, std::_S_beg);
#include <CommonsJavaScript/Converter.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/JSUtils.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
+#include <JSWebAPIErrorFactory.h>
#include <TimeTracer.h>
#include "EventLocalMessagePortAddMessagePortListener.h"
#include "EventLocalMessagePortRemoveMessagePortListener.h"
catch(BasePlatformException &e)
{
LoggerE("No private object");
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
JSValueRef listener = NULL;
}
catch(BasePlatformException &e)
{
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
Catch(Exception)
{
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Plugin's internal error"));
}
switch (dplEvent->getExceptionCode())
{
case ExceptionCodes::InvalidArgumentException:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Plugin's internal error."));
break;
case ExceptionCodes::PlatformException:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("The method cannot proceed due to a severe system error."));
break;
default:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Internal error"));
break;
}
catch(BasePlatformException &e)
{
LoggerE("Error on conversion : " << e.getMessage());
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Internal error"));
}
catch(BasePlatformException &e)
{
LoggerE("No private object");
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
long watchId = 0;
}
catch(BasePlatformException &e)
{
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
EventLocalMessagePortRemoveMessagePortListenerPtr dplEvent(new EventLocalMessagePortRemoveMessagePortListener());
Catch(Exception)
{
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Internal error"));
}
switch (dplEvent->getExceptionCode())
{
case ExceptionCodes::InvalidArgumentException:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
InvalidValuesException(oss.str().c_str()));
break;
case ExceptionCodes::NotFoundException:
oss << "No watchId (" << watchId << ") has been registered.";
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
NotFoundException(oss.str().c_str()));
break;
case ExceptionCodes::PlatformException:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("The method cannot proceed due to a severe system error."));
break;
default:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Internal error."));
break;
}
#include "JSMessagePortManager.h"
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/Validator.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
+#include <JSWebAPIErrorFactory.h>
#include <TimeTracer.h>
#include "IMessagePortManager.h"
#include "MessagePortFactory.h"
catch(BasePlatformException &e)
{
LoggerE("No private object");
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
string localMessagePortName;
}
catch(BasePlatformException &e)
{
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
if(localMessagePortName.empty())
{
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
InvalidValuesException("Local message port name is empty"));
}
Catch(Exception)
{
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Plugin's internal error"));
}
{
case ExceptionCodes::InvalidArgumentException:
oss << "Invalid local message port name ('" << localMessagePortName << "')";
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
InvalidValuesException(oss.str().c_str()));
break;
case ExceptionCodes::PlatformException:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("The method cannot proceed due to a severe system error."));
break;
default:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Internal error"));
break;
}
catch(BasePlatformException &e)
{
LoggerE("Error on conversion : " << e.getMessage());
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Internal error"));
}
catch(BasePlatformException &e)
{
LoggerE("No private object");
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
string localMessagePortName;
}
catch(BasePlatformException &e)
{
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
if(localMessagePortName.empty())
{
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
InvalidValuesException("Local message port name is empty"));
}
Catch(Exception)
{
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Plugin's internal error"));
}
{
case ExceptionCodes::InvalidArgumentException:
oss << "Invalid local message port name ('" << localMessagePortName << "')";
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
InvalidValuesException(oss.str().c_str()));
break;
case ExceptionCodes::PlatformException:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("The method cannot proceed due to a severe system error."));
break;
default:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Internal error"));
break;
}
catch(BasePlatformException &e)
{
LoggerE("Error on conversion : " << e.getMessage());
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Internal error"));
}
catch(BasePlatformException &e)
{
LoggerE("No private object");
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
string appId;
}
catch(BasePlatformException &e)
{
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
if(appId.empty())
{
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
InvalidValuesException("Application id is empty"));
}
if(remoteMessagePortName.empty())
{
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
InvalidValuesException("Remote message port name is empty"));
}
Catch(Exception)
{
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Plugin's internal error"));
}
{
case ExceptionCodes::InvalidArgumentException:
oss << "Invalid values for appId '" << appId << "' or port name '" << remoteMessagePortName << "'";
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
InvalidValuesException(oss.str().c_str()));
break;
case ExceptionCodes::NotFoundException:
oss << "No port name '" << remoteMessagePortName << "' on app '" << appId << "'";
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
NotFoundException(oss.str().c_str()));
break;
case ExceptionCodes::PlatformException:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("The method cannot proceed due to a severe system error."));
break;
default:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Internal error"));
break;
}
catch(BasePlatformException &e)
{
LoggerE("Error on conversion : " << e.getMessage());
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Internal error"));
}
catch(BasePlatformException &e)
{
LoggerE("No private object");
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
string appId;
}
catch(BasePlatformException &e)
{
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
if(appId.empty())
{
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
InvalidValuesException("Application id is empty"));
}
if(remoteMessagePortName.empty())
{
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
InvalidValuesException("Remote message port name is empty"));
}
Catch(Exception)
{
LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Plugin's internal error"));
}
{
case ExceptionCodes::InvalidArgumentException:
oss << "Invalid values for appId '" << appId << "' or port name '" << remoteMessagePortName << "'";
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
InvalidValuesException(oss.str().c_str()));
break;
case ExceptionCodes::NotFoundException:
oss << "No port name '" << remoteMessagePortName << "' on app '" << appId << "'";
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
NotFoundException(oss.str().c_str()));
break;
case ExceptionCodes::PlatformWrongStateException:
oss << "Have no permission to access app '" << appId << "'";
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
InvalidAccessException(oss.str().c_str()));
break;
case ExceptionCodes::PlatformException:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("The method cannot proceed due to a severe system error."));
break;
default:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Internal error"));
break;
}
catch(BasePlatformException &e)
{
LoggerE("Error on conversion : " << e.getMessage());
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Internal error"));
}
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSPendingOperation.h>
-#include <JSWebAPIException.h>
+#include <JSWebAPIErrorFactory.h>
#include <TimeTracer.h>
#include "EventRemoteMessagePortSendMessage.h"
#include "JSLocalMessagePort.h"
}
catch(BasePlatformException &e)
{
- LogError("No private object");
- return JSWebAPIException::throwException(context, exception, e);
+ LoggerE("No private object");
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
MessagePortDataItemMapPtr data(NULL);
}
catch(BasePlatformException &e)
{
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
try
}
catch(BasePlatformException &e)
{
- return JSWebAPIException::throwException(context, exception, e);
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
EventRemoteMessagePortSendMessagePtr dplEvent(new EventRemoteMessagePortSendMessage());
}
Catch(Exception)
{
- LogError("Error on platform : " << _rethrown_exception.GetMessage());
- return JSWebAPIException::throwException(context, exception,
+ LoggerE("Error on platform : " << _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Plugin's internal error."));
}
switch (dplEvent->getExceptionCode())
{
case ExceptionCodes::ConversionException:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
TypeMismatchException("Wrong LocalMessagePort object."));
break;
case ExceptionCodes::InvalidArgumentException:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
InvalidValuesException("The data argument is wrong."));
break;
case ExceptionCodes::NotFoundException:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("The target application's port is not found."));
break;
case ExceptionCodes::PlatformException:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("The method cannot proceed due to a severe system error."));
break;
case ExceptionCodes::OutOfRangeException:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
QuotaExceededException("The size of message has exceeded the maximum limit."));
break;
default:
- return JSWebAPIException::throwException(context, exception,
+ return JSWebAPIErrorFactory::postException(context, exception,
UnknownException("Internal error"));
break;
}
}
Catch(InvalidArgumentException)
{
- LogError("Error [InvalidArguments] : " << _rethrown_exception.GetMessage());
+ LoggerE("Error [InvalidArguments] : " << _rethrown_exception.GetMessage());
event->setExceptionCode(ExceptionCodes::InvalidArgumentException);
event->setResult(false);
}
Catch(ConversionException)
{
- LogError("Error [ConversionException] : " << _rethrown_exception.GetMessage());
+ LoggerE("Error [ConversionException] : " << _rethrown_exception.GetMessage());
event->setExceptionCode(ExceptionCodes::ConversionException);
event->setResult(false);
}
Catch(NotFoundException)
{
- LogError("Error [NotFound] : " << _rethrown_exception.GetMessage());
+ LoggerE("Error [NotFound] : " << _rethrown_exception.GetMessage());
event->setExceptionCode(ExceptionCodes::NotFoundException);
event->setResult(false);
}
Catch(OutOfRangeException)
{
- LogError("Error [OutOfRange] : " << _rethrown_exception.GetMessage());
+ LoggerE("Error [OutOfRange] : " << _rethrown_exception.GetMessage());
event->setExceptionCode(ExceptionCodes::OutOfRangeException);
event->setResult(false);
}
Catch(PlatformException)
{
- LogError("Error [PlatformException] : " << _rethrown_exception.GetMessage());
+ LoggerE("Error [PlatformException] : " << _rethrown_exception.GetMessage());
event->setExceptionCode(ExceptionCodes::PlatformException);
event->setResult(false);
}
Catch(Exception)
{
- LogError("Error [Unknown] : " << _rethrown_exception.GetMessage());
+ LoggerE("Error [Unknown] : " << _rethrown_exception.GetMessage());
event->setExceptionCode(ExceptionCodes::UnknownException);
event->setResult(false);
}
<api-feature>
<name>http://tizen.org/privilege/messageport</name>
- <device-capability>messageport</device-capability>
</api-feature>
</plugin-properties>
m_isInlineAttachment = att->inline_content_status;
//m_mimeType = std::string(att->attachment_mime_type);
LoggerD(" showname = " << m_attachShortName << " isDownloaded = " << m_isDownloaded << " attachmentID = " << m_attachmentID << "Mime= " << m_mimeType);
- LoggerD("save name is = " << att->attachment_path << "isInlineAttachment = " << m_isInlineAttachment);
+// LoggerD("save name is = " << att->attachment_path << "isInlineAttachment = " << m_isInlineAttachment);
if ( att->attachment_path)
{
PKG_CHECK_MODULES(platform_pkgs_messaging REQUIRED msg-service email-service dbus-1)
+ADD_DEFINITIONS("-fvisibility=hidden")
+
INCLUDE_DIRECTORIES(
${TOP}/Tizen
${TOP}/Common
#include "JSConversation.h"
#include "JSMessageFolder.h"
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <Logger.h>
#if 0 // MESSAGING ATTACHMENT IS BLOCKED
// See the License for the specific language governing permissions and
// limitations under the License.
//
-
+
#include <unistd.h>
#include <cstdio>
#include <cstddef>
//exception
ThrowMsg(WrtDeviceApis::Commons::PlatformException, " message id is invalid");
}
-
+
reload();
} catch (const WrtDeviceApis::Commons::PlatformException& ex) {
LoggerE("Exception: " << ex.DumpToString());
}
Email::Email(const std::string& id, int accountId) :
- IMessage(EMAIL, id)
+ IMessage(EMAIL, id)
{
LOG_ENTER
//exception
ThrowMsg(WrtDeviceApis::Commons::PlatformException, " message id is invalid");
}
-
+
LoggerD("Account ID = " << accountId);
m_accountId = accountId;
reload();
-
+
} catch (const WrtDeviceApis::Commons::PlatformException& ex) {
LoggerE("Exception: " << ex.DumpToString());
}
if (getIdRef().empty()) {
create(account);
}
-
+
reload();
}
catch (const WrtDeviceApis::Commons::PlatformException& ex) {
}
void Email::downloadBodyCancel( int handle)
-{
+{
return MailSync::getInstance().cancelDownloadBody(handle);
}
}
void Email::downloadAttachmentCancel( int handle)
-{
+{
LOG_ENTER
return MailSync::getInstance().cancelDownloadAttachment(handle);
LOG_EXIT
return m_mail->account_id;
else
return -1;
-
+
LOG_EXIT
}
int Email::getUID()
{
LOG_ENTER
-
+
if (m_mail)
return m_mail->mail_id;
else
}
bool Email::hasAttachment()
-{
+{
std::size_t attachmentSize = getAttachmentsCount();
if ( attachmentSize > 0)
return true;
{
/*
Assert(m_mail && "mail is NULL.");
-
+
update();
int accountId = m_mail->account_id;
"Couldn't move mail to folder: " << newFolder << ". [" <<
error << "]");
}
-
+
error = email_free_mailbox(&mailbox, 1); //free
if (EMF_ERROR_NONE != error) {
LoggerE("Failed to destroy mailbox: " << error);
void Email::copyToFolder(const string& newFolder)
{
LOG_ENTER
-/*
+/*
Assert(m_mail && "mail is NULL.");
update();
ScopedMail mail(EmailService::cloneMail(m_mail.Get())); //clone
mail->mailbox_name = (NULL != newFolder.c_str() ? strdup(newFolder.c_str()) : NULL);
mail->account_id = accountId;
-
+
//Attachment
email_attachment_data_t* attachment = NULL;
int attachmentCount = 0;
ThrowMsg( WrtDeviceApis::Commons::PlatformException,
"Couldn't get attachment list: " << newFolder << ". [" << error << "]");
}
-
+
int mailId = EmailService::addMail( mail.Get(), attachment );
if (0 == mailId) {
ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Cloned mail didn't get new id.");
}
-*/
+*/
LOG_EXIT
}
m_accountId = account.getIntId();
//MailSender::getInstance();
-
+
LoggerD("account ID : " << m_accountId);
ScopedMail mail(EmailService::createMailData(account));
-
+
setEmailAccount(account); //save account
mail->mailbox_type = EMAIL_MAILBOX_TYPE_DRAFT;
-
+
setId(convertId(EmailService::addMail(mail.Get(), NULL)));
setFolderType(DRAFTBOX);
setMessageStatus(MESSAGE_STATUS_DRAFT);
-
+
LOG_EXIT
}
//m_mailbox.Reset(EmailService::getMailboxByMailId(m_accountId, getIntId()) );
//setFolderType(EmailConverter::toFolderType(m_mailbox->mailbox_type));
-
+
setFolderType(EmailConverter::toFolderType(m_mail->mailbox_type));
setMessageStatus(EmailConverter::toMessageStatus(m_mail->mailbox_type));
struct tm timeinfo;
memset(&timeinfo, 0, sizeof(timeinfo));
memcpy(t, &timeinfo, sizeof(struct tm));
- setDateTime(timeinfo);
+ setDateTime(timeinfo);
#else
memset(buf, 0x00, sizeof(buf));
targetBuf += snprintf(buf, sizeof(buf), "%.2s", targetBuf);
timeinfo.tm_sec = atoi(buf);
-
+
setDateTime(timeinfo);
}
#endif
-
+
#if 0
time_t rawtime;
time(&rawtime);
ThrowMsg(WrtDeviceApis::Commons::PlatformException,
"Cannot read plain body size");
}
-
+
fseek(file.Get(), 0, SEEK_SET);
DPL::ScopedPtr<char> data(new char[size + 1]);
memset(data.Get(), 0, size + 1);
- TEMP_FAILURE_RETRY(fread(data.Get(), 1, size, file.Get()) &&
+ TEMP_FAILURE_RETRY(fread(data.Get(), 1, size-2, file.Get()) &&
ferror(file.Get()) == 0 ? -1 : 0);
setBody(data.Get());
}
ThrowMsg(WrtDeviceApis::Commons::PlatformException,
"Cannot read html body size");
}
-
+
fseek(file.Get(), 0, SEEK_SET);
DPL::ScopedPtr<char> data(new char[size + 1]);
memset(data.Get(), 0, size + 1);
//email_attachment_info_t* attachment = NULL;
email_attachment_data_t* attachment = NULL;
int attachmentCount = 0;
-
+
int error = email_get_attachment_data_list( m_mail->mail_id, &attachment, &attachmentCount); //get Attachment list
if (EMAIL_ERROR_NONE != error) {
ThrowMsg( WrtDeviceApis::Commons::PlatformException, "Couldn't get attachment list: ");
}
-
+
if ( attachment && attachmentCount > 0)
{
LoggerD("reading attachments , attahcment count = " << attachmentCount);
IAttachmentPtr tmpAtt(new Attachment());
if (attachment[i].attachment_path)
tmpAtt->init(attachment[i].attachment_path, false);
-
+
if (tmpAtt)
{
LoggerD("attachment[i].inline_content_status : " << attachment[i].inline_content_status);
}
LoggerD(" append Attachment complete");
-
+
}
catch ( const WrtDeviceApis::Commons::Exception& ex )
{
LoggerE("Error while trying to append attachment " << attachment[i].attachment_path << ": " << ex.DumpToString());
}
-
+
}
}
-
+
if (attachment)
{
error = email_free_attachment_data(&attachment, attachmentCount);
void Email::updateBody()
{
LOG_ENTER
-
+
int error = 0;
bool locationChecker = false;
-
+
if (isBodyValid()) { return; }
-
+
if (!m_mail) {
LoggerD("m_mail is NULL");
ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Mail is NULL.");
ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Plain Body File Open Error");
}
-
// For Html Body
locationChecker = EmailUtils::isFrameworkEmailData(m_mail->file_path_html);
if((locationChecker == true) || (!m_mail->file_path_html)) // html file is not exist or exist on email frame work then create tmp html file
if (!m_mail) {
ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Mail not allocated.");
}
-
+
m_mail->subject = String::strdup(getSubjectRef());
setSubjectValidity(true);
error = email_free_attachment_data(&attachment, attachmentCount);
if (EMAIL_ERROR_NONE != error) {
LoggerW("email_free_attachment_data [" << error << "]");
- }
+ }
}
LOG_EXIT
MailSender::getInstance(); //start email service
LoggerD("getUID: " << getUID());
if ( getUID() > 0 && m_accountId > 0)
- {
+ {
update();
}
else
- {
+ {
DPL::Mutex::ScopedLock mx(&m_updateMutex);
-
+
EmailAccountInfo account = getEmailAccount();
m_accountId = account.getIntId(); //set account ID
LoggerD("account ID : " << m_accountId);
m_mail.Reset(EmailService::createMailData(account));
-
+
updateSubject();
updateBody();
updateRecipients();
updatePriority();
updateReadStatus();
-
+
email_mailbox_t* mailbox;
int error = email_get_mailbox_by_mailbox_type(m_accountId, EMAIL_MAILBOX_TYPE_OUTBOX, &mailbox );
if (EMAIL_ERROR_NONE != error) {
ThrowMsg(WrtDeviceApis::Commons::PlatformException,
"Couldn't add message to mailbox. [" << error << "]");
}
-
+
LoggerD("m_mail->mail_id =" << m_mail->mail_id);
-
+
setId(convertId(m_mail->mail_id));
setFolderType(OUTBOX);
setMessageStatus(MESSAGE_STATUS_SENDING);
updateAttachments(); //update Attachment.
-
+
error = email_free_mailbox(&mailbox, 1);
if (EMAIL_ERROR_NONE != error) {
LoggerE("Failed to destroy mailbox: " << error);
if (m_mail->file_path_plain)
free(m_mail->file_path_plain);
m_mail->file_path_plain = strdup(result->file_path_plain);
-
+
if ( m_mail->file_path_html)
{
free(m_mail->file_path_html);
{
m_mail->file_path_html = strdup(result->file_path_html);
}
-
+
error = email_free_mail_data(&result, 1);
if (EMAIL_ERROR_NONE != error) {
ThrowMsg(WrtDeviceApis::Commons::PlatformException,
"Couldn't find message " << m_mail->mail_id << ". [" << error << "]");
- }
+ }
}
LOG_EXIT
LOG_ENTER
MailSender::getInstance(); //start email service
-
+
LoggerD("getUID: " << getUID());
if ( getUID() > 0 && m_accountId > 0)
- {
+ {
update();
}
else
- {
+ {
DPL::Mutex::ScopedLock mx(&m_updateMutex);
-
+
EmailAccountInfo account = getEmailAccount();
m_accountId = account.getIntId(); //set account ID
LoggerD("account ID : " << m_accountId);
m_mail.Reset(EmailService::createMailData(account));
-
+
updateSubject();
updateBody();
updateRecipients();
updatePriority();
updateReadStatus();
-
+
email_mailbox_t* mailbox;
int error = email_get_mailbox_by_mailbox_type(m_accountId, EMAIL_MAILBOX_TYPE_DRAFT, &mailbox );
if (EMAIL_ERROR_NONE != error) {
ThrowMsg(WrtDeviceApis::Commons::PlatformException,
"Couldn't add message to mailbox. [" << error << "]");
}
-
+
LoggerD("message id =" << m_mail->mail_id);
-
+
setId(convertId(m_mail->mail_id));
setFolderType(DRAFTBOX);
setMessageStatus(MESSAGE_STATUS_DRAFT);
updateAttachments(); //update Attachment.
-
+
error = email_free_mailbox(&mailbox, 1);
if (EMAIL_ERROR_NONE != error) {
LoggerE("Failed to destroy mailbox: " << error);
int mail_id_array[1];
email_mail_attribute_type attribute_type;
email_mail_attribute_value_t attribute_value;
-
+
mail_id_array[0] = m_mail->mail_id;
attribute_type = EMAIL_MAIL_ATTRIBUTE_BODY_DOWNLOAD_STATUS;
attribute_value.integer_type_value = 1;
-
+
email_update_mail_attribute(m_accountId, mail_id_array, 1, EMAIL_MAIL_ATTRIBUTE_BODY_DOWNLOAD_STATUS, attribute_value);
}
if (m_mail->file_path_plain)
free(m_mail->file_path_plain);
m_mail->file_path_plain = strdup(result->file_path_plain);
-
+
if ( m_mail->file_path_html)
{
free(m_mail->file_path_html);
{
m_mail->file_path_html = strdup(result->file_path_html);
}
-
+
error = email_free_mail_data(&result, 1);
if (EMAIL_ERROR_NONE != error) {
ThrowMsg(WrtDeviceApis::Commons::PlatformException,
"Couldn't find message " << m_mail->mail_id << ". [" << error << "]");
- }
+ }
}
}
email_attachment_data_t* attachment = NULL;
- int attachmentCount = 0;
+ int attachmentCount = 0;
email_mailbox_t* mailBox = NULL;
int error = 0;
ThrowMsg( WrtDeviceApis::Commons::PlatformException, "Couldn't get attachment list: ");
}
error = email_get_mailbox_by_mailbox_id(m_mail->mailbox_id, &mailBox);
-
+
if (EMAIL_ERROR_NONE != error) {
ThrowMsg(WrtDeviceApis::Commons::PlatformException,
"Couldn't get mailbox. [" << error << "]");
- }
-
+ }
+
if ( attachmentCount > 0 )
{
LoggerD("attachmentCount=" << attachmentCount);
}
}
-
+
//set Attachment
std::size_t attachmentSize = getAttachmentsCount();
std::size_t inlineAttachmentSize = getInlineAttachmentsCount();
-
+
LoggerD("update attachments, attachmentSize=" << attachmentSize);
if (attachmentSize > 0)
{
cp_cmd << " \"" << att->getFullPath() << "\"";
cp_cmd << " \"" << buf << "\"";
- attachment_info = EmailService::alloc<email_attachment_data_t>();
+ attachment_info = EmailService::alloc<email_attachment_data_t>();
attachment_info->attachment_name = String::strdup(att->getShortName());
attachment_info->attachment_path = String::strdup( buf );
attachment_info->save_status = true;
LoggerD("error :" << error);
ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Error while adding attachment. [" << error << "]");
}
- else
- {
+ else
+ {
LoggerD(" attachment id : " << attachment_info->attachment_id);
LoggerD(" attachment inline : " << attachment_info->inline_content_status);
LoggerD(" setNth(i+1) : " << i+1);
att->setMessage(SharedFromThis());
att->setNth(i+1);
}
-
+
if (attachment_info)
EmailService::freeAttachment(attachment_info);
- }
-
+ }
+
}
LoggerD("update attachments, inlineAttachmentSize=" << inlineAttachmentSize);
- if (inlineAttachmentSize > 0)
+ if (inlineAttachmentSize > 0)
{
email_attachment_data_t* attachment_info = NULL;
- for (std::size_t i = 0; i < inlineAttachmentSize; ++i)
+ for (std::size_t i = 0; i < inlineAttachmentSize; ++i)
{
IAttachmentPtr att = getInlineAttachment(i);
if (!att) {
cp_cmd << " \"" << att->getFullPath() << "\"";
cp_cmd << " \"" << buf << "\"";
- attachment_info = EmailService::alloc<email_attachment_data_t>();
+ attachment_info = EmailService::alloc<email_attachment_data_t>();
attachment_info->attachment_name = String::strdup(att->getShortName());
attachment_info->attachment_path = String::strdup( buf );
attachment_info->save_status = true;
ThrowMsg(WrtDeviceApis::Commons::PlatformException,
"Error while adding attachment. [" << error << "]");
}
- else
- {
- LoggerD(" attachment id : " << attachment_info->attachment_id);
+ else
+ {
+ LoggerD(" attachment id : " << attachment_info->attachment_id);
LoggerD(" attachment inline : " << attachment_info->inline_content_status);
LoggerD(" setNth(i+(int)attachmentSize+1) : " << i+(int)attachmentSize+1);
att->setDownloaded(true);
// att->setNth(i+1);
att->setNth(i + (int)attachmentSize + 1);
}
-
+
if (attachment_info)
EmailService::freeAttachment(attachment_info);
- }
-
+ }
+
}
-
-
- }
+
+
+ }
Catch(WrtDeviceApis::Commons::PlatformException) {
- if (attachment)
+ if (attachment)
{
int error = email_free_attachment_data(&attachment, attachmentCount);
if (EMAIL_ERROR_NONE != error) {
#include "JSConversation.h"
#include "ConverterMessage.h"
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <Logger.h>
#include "MessagingListener.h"
#include "ReqReceiverMessage.h"
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <CommonsJavaScript/ScopedJSStringRef.h>
// ==== new common headers
#include <GlobalContextManager.h>
#include <PlatformException.h>
-#include <JSWebAPIError.h>
-#include <JSWebAPIException.h>
#include <JSUtil.h>
+#include <Export.h>
#include <ArgumentValidator.h>
// ====
{ 0, 0, 0, 0 }
};
+JSClassRef JSMessage::jsInit(JSContextRef context)
+{
+ LoggerI("enter");
+ return JSClassCreate(&m_classInfo);
+}
+
+const JSClassDefinition* JSMessage::getClassInfo()
+{
+ LoggerI("enter");
+ return &(m_classInfo);
+}
+
+JSClassRef DLL_EXPORT JSMessage::getClassRef()
+{
+ LoggerI("enter");
+ if (!m_jsClassRef) {
+ m_jsClassRef = JSClassCreate(&m_classInfo);
+ }
+ return m_jsClassRef;
+}
JSValueRef JSMessage::createJSObject(JSContextRef context,
EmailAccountInfo& account,
const IMessagePtr& msg,
EventUpdateMessageAnswerReceiver* listener)
{
- JSClassRef jsClassRef = JSClassCreate(getClassInfo());
JSMessagePrivateObject* priv = new JSMessagePrivateObject(context, msg);
priv->setUpdateMsgReceiver(listener);
- JSObjectRef jsValueRef = JSObjectMake(context, jsClassRef, static_cast<void*>(priv));
- JSClassRelease(jsClassRef);
+ JSObjectRef jsValueRef = JSObjectMake(context, JSMessage::getClassRef(), static_cast<void*>(priv));
if (NULL == jsValueRef) {
LoggerE("object creation error");
return JSValueMakeUndefined(context);
const IMessagePtr& msg)
{
LoggerD("createJSObject");
- JSClassRef jsClassRef = JSClassCreate(getClassInfo());
- LoggerD("jsClassRef success");
JSMessagePrivateObject* priv = new JSMessagePrivateObject(context, msg);
LoggerD("priv success");
- JSObjectRef jsValueRef = JSObjectMake(context, jsClassRef, static_cast<void*>(priv));
+ JSObjectRef jsValueRef = JSObjectMake(context, JSMessage::getClassRef(), static_cast<void*>(priv));
LoggerD("JSObjectMake success");
- JSClassRelease(jsClassRef);
if (NULL == jsValueRef) {
LoggerE("object creation error");
return JSValueMakeUndefined(context);
return true;
}
-JSObjectRef JSMessage::constructor(JSContextRef context,
+JSObjectRef DLL_EXPORT JSMessage::constructor(JSContextRef context,
JSObjectRef constructor,
size_t argumentCount,
const JSValueRef arguments[],
}
catch(BasePlatformException &bex) {
LoggerE("Message creation failed: " << bex.getMessage());
- JSObjectRef error = JSWebAPIException::makeJSWebAPIException(context, bex);
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, bex);
}
catch(...) {
DeviceAPI::Common::UnknownException err("UnknownError in Message constructor.");
- JSObjectRef error = JSWebAPIException::makeJSWebAPIException(context, err);
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
- return NULL;
+
+ return JSWebAPIErrorFactory::postException(context, exception,
+ DeviceAPI::Common::UnknownException("UnknownError in Message constructor."));
}
JSValueRef JSMessage::convertToType(JSContextRef context,
static_cast<JSMessagePrivateObject*>(JSObjectGetPrivate(object));
if (!priv) {
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
}
}
Catch(WrtDeviceApis::Commons::NullPointerException) {
LoggerE("Error on pointer, null value");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
}
vector<string> attachments;
}
Catch(WrtDeviceApis::Commons::ConversionException) {
LoggerE("Error on conversion");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
}
Catch(WrtDeviceApis::Commons::NullPointerException) {
LoggerE("Error on pointer, null value");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
LoggerE("Invalid argument");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
}
return false;
}
/*
* This method initializes object in the JS Engine.
*/
- static JSClassRef jsInit(JSContextRef context)
- {
- LoggerI("enter");
- return JSClassCreate(&m_classInfo);
- }
-
- static const JSClassDefinition* getClassInfo()
- {
- LoggerI("enter");
- return &(m_classInfo);
- }
-
- static JSClassRef getClassRef()
- {
- LoggerI("enter");
- if (!m_jsClassRef) {
- m_jsClassRef = JSClassCreate(&m_classInfo);
- }
- return m_jsClassRef;
- }
+ static JSClassRef jsInit(JSContextRef context);
+
+ static const JSClassDefinition* getClassInfo();
+
+ static JSClassRef getClassRef();
static JSObjectRef constructor(JSContextRef ctx,
JSObjectRef constructor,
#include <EventGetNodeData.h>
#include <FilesystemUtils.h>
#include <IManager.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
#include "AttachmentFactory.h"
#include "MessagingErrorMsg.h"
#include "Attachment.h"
-#include <JSWebAPIError.h>
-#include <JSWebAPIException.h>
+#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
+#include <Export.h>
#include <Logger.h>
#if 0
return &(m_classInfo);
}
-JSClassRef JSMessageAttachment::getClassRef()
+JSClassRef DLL_EXPORT JSMessageAttachment::getClassRef()
{
if (!m_jsClassRef) {
m_jsClassRef = JSClassCreate(&m_classInfo);
Catch(WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("invalid value conversion");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("Unkown Exception");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
}
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("invalid value conversion");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("Unkown Exception");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
}
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("invalid value conversion");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("Unkown Exception");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
}
// return JSValueMakeUndefined(context);
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("invalid value conversion");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("Unkown Exception");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
}
// return JSValueMakeUndefined(context);
}
else
{
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
}
/* // MESSAGING ATTACHMENT IS BLOCKED
WrtDeviceApis::Commons::ExceptionCodes::Enumeration code = event->getExceptionCode();
if (code != WrtDeviceApis::Commons::ExceptionCodes::None) {
LoggerE("Attachment location not resolved. Exception code: " << code);
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
}
DeviceAPI::Filesystem::INodePtr node = event->getResult();
if (!node) {
LoggerE("Resolved attachment location is empty.");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("invalid value conversion");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
}
Catch(WrtDeviceApis::Commons::Exception)
{
LoggerE("Unkown Exception");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
}
return JSValueMakeUndefined(context);
*/
return thisPrivate;
}
-JSObjectRef JSMessageAttachment::constructor(JSContextRef context,
+JSObjectRef DLL_EXPORT JSMessageAttachment::constructor(JSContextRef context,
JSObjectRef constructor,
size_t argumentCount,
const JSValueRef arguments[],
}
}catch(BasePlatformException & e) {
LoggerE("Message creation failed: " << e.getMessage());
- JSObjectRef error = JSWebAPIException::makeJSWebAPIException(context, e);
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
catch(...) {
DeviceAPI::Common::UnknownException err("UnknownError in Message constructor.");
- JSObjectRef error = JSWebAPIException::makeJSWebAPIException(context, err);
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
- return NULL;
+
+ return JSWebAPIErrorFactory::postException(context, exception,
+ DeviceAPI::Common::UnknownException("UnknownError in Message constructor."));
}
JSValueRef JSMessageAttachment::getProperty(JSContextRef context,
#include <CommonsJavaScript/JSUtils.h>
#include "ConverterMessage.h"
#include "JSMessageBody.h"
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
#include "MessagingErrorMsg.h"
#include "JSMessageAttachment.h"
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
#include <JSUtil.h>
#include <Logger.h>
#include "IMessageFolder.h"
#include "IMessagingTypes.h"
-#include <JSWebAPIError.h>
#include <Logger.h>
-
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
#include <SecurityExceptions.h>
#include "MessagingErrorMsg.h"
#include <Commons/StringUtils.h>
#include "ReqReceiverMessage.h"
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
#include <SecurityExceptions.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
#include <JSUtil.h>
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
}
Catch(WrtDeviceApis::Commons::ConversionException) {
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, JSMESSAGING_EXCEPTION_MSG_TYPE_MISMATCH);
}
// LoggerI(">>>");
else
{
LoggerD(" Private Object is NULL ");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_FOUND_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_FOUND);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_FOUND);
}
}
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSContextRef globalContext = priv->getContext();
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSContextRef globalContext = priv->getContext(); //create global Context
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSContextRef globalContext = priv->getContext(); //create global Context
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSContextRef globalContext = priv->getContext(); //get global Context
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSContextRef globalContext = priv->getContext(); //get global Context
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
#if 0
}
Catch (WrtDeviceApis::Commons::InvalidArgumentException){
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
}
Catch (WrtDeviceApis::Commons::NotFoundException){
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_FOUND_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_FOUND);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_FOUND);
}
Catch (WrtDeviceApis::Commons::UnsupportedException){
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_SUPPORTED_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_SUPPORTED);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_SUPPORTED);
}
Catch (WrtDeviceApis::Commons::Exception){
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
}
}
else
{
LoggerD(" Private Object is NULL ");
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_FOUND_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_FOUND);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_FOUND);
}
LoggerD(">>>");
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
try {
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
-#include <JSWebAPIError.h>
#include <ArgumentValidator.h>
+#include <Export.h>
#include "JSMessagingServiceManager.h"
#include "MessagingController.h"
{ 0, 0, 0 }
};
- const JSClassRef JSMessagingServiceManager::getClassRef() {
+ const JSClassRef DLL_EXPORT JSMessagingServiceManager::getClassRef() {
if (!m_jsClassRef) {
m_jsClassRef = JSClassCreate(&m_classInfo);
}
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSContextRef gContext = priv->getContext();
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
#include <CommonsJavaScript/JSDOMExceptionFactory.h>
#include <CommonsJavaScript/SecurityExceptions.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
-#include <JSWebAPIError.h>
#include <ArgumentValidator.h>
#include <JSUtil.h>
Catch (WrtDeviceApis::Commons::Exception)
{
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
}
LoggerD(">>>");
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
if (!callbackManager) {
LoggerE("callbackManager is NULL.");
DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::ConversionException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
if (!callbackManager) {
LoggerE("callbackManager is NULL.");
DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::ConversionException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
if (!callbackManager) {
LoggerE("callbackManager is NULL.");
DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::ConversionException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
if (!callbackManager) {
LoggerE("callbackManager is NULL.");
DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::ConversionException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
if (!callbackManager) {
LoggerE("callbackManager is NULL.");
DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::ConversionException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
if (!callbackManager) {
LoggerE("callbackManager is NULL.");
DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::ConversionException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
if (!callbackManager) {
LoggerE("callbackManager is NULL.");
DeviceAPI::Common::UnknownException err("callbackManager is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::ConversionException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::NullPointerException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::ConversionException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::UnsupportedException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::AlreadyInUseException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::ConversionException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::UnsupportedException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::AlreadyInUseException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::ConversionException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::UnsupportedException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::AlreadyInUseException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
if (!priv) {
LoggerE("Private object is NULL.");
DeviceAPI::Common::UnknownException err("Private object is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
DeviceAPI::Common::UnknownException err("objectPriv is NULL.");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager(NULL);
}
catch(const BasePlatformException& err) {
LoggerE(err.getMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::ConversionException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::TypeMismatchException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::InvalidArgumentException& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::InvalidValuesException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
catch (const WrtDeviceApis::Commons::Exception& exc) {
LoggerE(exc.GetMessage().c_str());
DeviceAPI::Common::UnknownException err(exc.GetMessage().c_str());
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
if (err == EMAIL_ERROR_NONE) {
LoggerD("attachment Name : " << attachment_data->attachment_name);
LoggerD("attachment ID : " << attachment_data->attachment_id);
- LoggerD("attachment attachment_mime_type : " << attachment_data->attachment_mime_type);
+
attachment->init(attachment_data->attachment_path, false);
if(attachment_data->attachment_mime_type)
{
+ LoggerD("attachment attachment_mime_type : " << attachment_data->attachment_mime_type);
attachment->setMimeType(attachment_data->attachment_mime_type);
}
LoggerD("attachment getMimeTypes : " << attachment->getMimeType());
//
#include "MessageAsyncCallbackManager.h"
-#include <dpl/singleton_impl.h>
-
-using namespace DPL;
-
-IMPLEMENT_SINGLETON(DeviceAPI::Messaging::MessageAsyncCallbackManager)
namespace DeviceAPI {
namespace Messaging {
+SINGLETON_IMPLEMENTATION(MessageAsyncCallbackManager)
+
} // Tizen1_0
} // TizenApis
#ifndef _TIZEN_MESSAGING_ASYNC_CALLBACK_MANAGER_H_
#define _TIZEN_MESSAGING_ASYNC_CALLBACK_MANAGER_H_
-#include <dpl/singleton.h>
#include <AsyncCallbackManager.h>
namespace DeviceAPI {
class MessageAsyncCallbackManager : public DeviceAPI::Common::AsyncCallbackManager
{
-public:
+private:
MessageAsyncCallbackManager()
{
}
+public:
virtual ~MessageAsyncCallbackManager()
{
}
- friend class DPL::Singleton<MessageAsyncCallbackManager>;
+ friend class MessageAsyncCallbackManagerSingleton;
};
-typedef DPL::Singleton<MessageAsyncCallbackManager> MessageAsyncCallbackManagerSingleton;
+SINGLETON_DEFINITION(MessageAsyncCallbackManager)
} // Tizen1_0
} // TizenApis
-#endif // _TIZEN_MESSAGING_ASYNC_CALLBACK_MANAGER_H_
\ No newline at end of file
+#endif // _TIZEN_MESSAGING_ASYNC_CALLBACK_MANAGER_H_
//
#include "MessageListenerManager.h"
-#include <dpl/singleton_impl.h>
-
-using namespace DPL;
-
-IMPLEMENT_SINGLETON(DeviceAPI::Messaging::MessageListenerManager)
namespace DeviceAPI {
namespace Messaging {
+SINGLETON_IMPLEMENTATION(MessageListenerManager)
+
} // Tizen1_0
} // TizenApis
#include <map>
#include <JavaScriptCore/JavaScript.h>
#include <dpl/shared_ptr.h>
-#include <dpl/singleton.h>
#include <IListenerManager.h>
#include "JSMessagingStorage.h"
#include <Logger.h>
class MessageListenerManager : public DeviceAPI::Common::IListenerController
{
-public:
+private:
MessageListenerManager()
{
}
+public:
virtual ~MessageListenerManager()
{
}
+
+ friend class MessageListenerManagerSingleton;
};
-typedef DPL::Singleton<MessageListenerManager> MessageListenerManagerSingleton;
+SINGLETON_DEFINITION(MessageListenerManager)
class MessageListenerCanceller : public DeviceAPI::Common::IListenerItem
{
MessageQueryGenerator::~MessageQueryGenerator() {
}
- void MessageQueryGenerator::reset(QueryGeneratorMode mode){
+ void MessageQueryGenerator::reset(QueryGeneratorMode mode, int limit, int offset){
m_query.clear();
m_queryVector.clear();
- m_limit = 0;
- m_offset = 0;
+ m_limit = limit;
+ m_offset = offset;
m_mode = mode;
m_query.append(getQueryPrefix());
retClause = emfAttributeName + "=" + convertMessageTypeToString(valueString);
break;
} else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_BODY)==0) {
- retClause = emfAttributeName + " ='" + valueString + "'";
+ retClause = emfAttributeName + " LIKE '" + valueString + "'";
+ break;
+ } else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_SUBJECT)==0) {
+ retClause = emfAttributeName + " LIKE '" + valueString + "'";
break;
}
if(m_sortMode != NULL)
{
+ LoggerD("m_sortMode exist");
std::string platformAttrName = convertToEmfAttrName(m_sortMode->getAttributeName());
std::string sortModeString;
if(m_sortMode->getOrder() == ASCENDING_SORT_ORDER){
if(m_limit != 0){
buffer << " LIMIT " << m_offset << "," << m_limit;
}
+ else
+ {
+ buffer << " LIMIT " << m_offset << ", -1";
+ }
m_orderLimit.append(buffer.str());
return m_serviceType;
}
- void reset(QueryGeneratorMode mode);
+ void reset(QueryGeneratorMode mode, int limit, int offset);
protected:
virtual void setEmailAttributeMap();
switch(type){
case EMAIL:{
LoggerD("type is EMAIL:[" << conversationType <<"]");
- queryGenerator->reset(MessageQueryGenerator::MODE_EMAIL);
+ queryGenerator->reset(MessageQueryGenerator::MODE_EMAIL, limit, offset);
filter->travel(filterVisitor, 0);
filterSql = queryGenerator->getQuery();
+ orderLimitSql = queryGenerator->getOrderLimit();
+ filterSql.append(orderLimitSql);
// LOGD("filterSql:[%s]", filterSql.c_str());
result = queryEmailConversation(filterSql);
break;
case SMS:{
LoggerD("type is SMS:[" << conversationType <<"]");
- queryGenerator->reset(MessageQueryGenerator::MODE_SMS);
+ queryGenerator->reset(MessageQueryGenerator::MODE_SMS, limit, offset);
IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
filter->travel(filterVisitor, 0);
filterSql = queryGenerator->getQuery();
case MMS:{
LoggerD("type is MMS:[" << conversationType <<"]");
- queryGenerator->reset(MessageQueryGenerator::MODE_MMS);
+ queryGenerator->reset(MessageQueryGenerator::MODE_MMS, limit, offset);
IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
filter->travel(filterVisitor, 0);
filterSql = queryGenerator->getQuery();
#include <Commons/Exception.h>
#include <CommonsJavaScript/JSDOMExceptionFactory.h>
#include <JavaScriptCore/JavaScript.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include "MessagingErrorMsg.h"
WrtDeviceApis::Commons::ExceptionCodes::Enumeration exception = event->getExceptionCode();
switch(exception) {
case WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException:
- errorObject = JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
break;
case WrtDeviceApis::Commons::ExceptionCodes::PlatformException:
- errorObject = JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::IO_ERROR, JSMESSAGING_EXCEPTION_MSG_IO);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::IO_ERROR, JSMESSAGING_EXCEPTION_MSG_IO);
break;
case WrtDeviceApis::Commons::ExceptionCodes::PlatformWrongStateException:
- errorObject = JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::NOT_SUPPORTED_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_SUPPORTED);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, JSMESSAGING_EXCEPTION_MSG_NOT_SUPPORTED);
break;
default:
- errorObject = JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
break;
}
callbackManager->callOnError(errorObject);
if(msg)
callbackManager->callOnSuccess(msg);
else
- callbackManager->callOnError( JSTizenExceptionFactory::makeErrorObject(globalContext,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError( JSWebAPIErrorFactory::makeErrorObject(globalContext,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
else
{
if ( attachment)
callbackManager->callOnSuccess(attachment);
else
- callbackManager->callOnError( JSTizenExceptionFactory::makeErrorObject(globalContext,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError( JSWebAPIErrorFactory::makeErrorObject(globalContext,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
else
{
switch (event->getExceptionCode()) {
case WrtDeviceApis::Commons::ExceptionCodes::PlatformException:
case WrtDeviceApis::Commons::ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(globalContext,
- JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
+ error = JSWebAPIErrorFactory::makeErrorObject(globalContext,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(globalContext,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ error = JSWebAPIErrorFactory::makeErrorObject(globalContext,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
break;
}
}
switch (event->getExceptionCode()) {
case WrtDeviceApis::Commons::ExceptionCodes::PlatformException:
case WrtDeviceApis::Commons::ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
+ error = JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT);
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
+ error = JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN);
break;
}
}
#include "StorageChangesConversationGenerator.h"
#include "StorageChangesFolderGenerator.h"
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include "MessagingErrorMsg.h"
}
Catch(WrtDeviceApis::Commons::PlatformException) {
LoggerE("platform error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::ConversionException) {
LoggerE("conversion error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
LoggerE("InvalidArgument error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT));
}
Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("unknown error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
}
}
Catch(WrtDeviceApis::Commons::PlatformException) {
LoggerE("platform error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::ConversionException) {
LoggerE("conversion error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("conversion error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT));
}
Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("unknown error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
}
Catch(WrtDeviceApis::Commons::PlatformException) {
LoggerE("platform error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::ConversionException) {
LoggerE("conversion error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("unknown error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
}
Catch(WrtDeviceApis::Commons::PlatformException) {
LoggerE("platform error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::ConversionException) {
LoggerE("conversion error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("unknown error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
}
Catch(WrtDeviceApis::Commons::PlatformException) {
LoggerE("platform error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::ConversionException) {
LoggerE("conversion error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("conversion error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
}
Catch(WrtDeviceApis::Commons::PlatformException)
{
LoggerE("platform error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::ConversionException)
{
LoggerE("conversion error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("conversion error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT));
}
Catch(WrtDeviceApis::Commons::UnknownException)
{
LoggerE("unknown error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
}
Catch(WrtDeviceApis::Commons::PlatformException)
{
LoggerE("platform error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::ConversionException)
{
LoggerE("conversion error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::UnknownException)
{
LoggerE("unknown error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
}
Catch(WrtDeviceApis::Commons::PlatformException)
{
LoggerE("platform error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::ConversionException)
{
LoggerE("conversion error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException)
{
LoggerE("conversion error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, JSMESSAGING_EXCEPTION_MSG_INVALID_ARGUMENT));
}
Catch(WrtDeviceApis::Commons::UnknownException)
{
LoggerE("unknown error");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context,
- JSTizenException::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, JSMESSAGING_EXCEPTION_MSG_UNKNOWN));
}
}
msg_set_int_value(m_messageData, MSG_MESSAGE_ID_INT, msgId);
setId(convertId(msgId));
- readExistingMessage();
+ readAllData();
msg_release_struct(&sendOpt);
void Mms::readAllData()
{
- readExistingMessage();
+ LoggerD("entered");
+
+ if (getIdRef().empty() || (EMPTY_ID == getIdRef()))
+ {
+ ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Empty id.");
+ }
+
+ msg_release_struct(&m_messageData);
+ m_messageData = NULL;
+ msg_struct_t sendOpt = NULL;
+
+ Try {
+
+ m_messageData = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
+ sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
+
+ // trying to get message from platform
+ if (MSG_SUCCESS != msg_get_message(MsgGetCommonHandle(), convertId(getIdRef()), m_messageData, sendOpt))
+ {
+ LoggerE("get message error");
+ Throw(WrtDeviceApis::Commons::PlatformException);
+ }
+ LoggerD("message found with msgId=" << getIdRef());
+
+ // read all mms dat to abstraction layer
+ readConversationId(m_messageData);
+// readRecipientList(m_messageData);
+ readPriority(m_messageData);
+ readSubject(m_messageData);
+ readBodyAndAttachments(m_messageData);
+ readFolder(m_messageData);
+ readDateTime(m_messageData);
+ readReadStatus(m_messageData);
+ readMessageStatus(m_messageData);
+
+ msg_release_struct(&sendOpt);
+ }
+ Catch(WrtDeviceApis::Commons::PlatformException) {
+ LoggerE("exception");
+ // nothing to do
+ msg_release_struct(&sendOpt);
+ }
+
}
void Mms::moveToFolder(const FolderType newFolder)
void Sms::readAllData()
{
- readExistingMessage();
+ if (getIdRef().empty() || (EMPTY_ID == getIdRef())) {
+ ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Empty id.");
+ }
+
+ // release old data
+ if (m_messageData) {
+ // release platform message if it was created previously
+ msg_release_struct(&m_messageData);
+ m_messageData = NULL;
+ }
+ msg_struct_t sendOpt = NULL;
+
+ Try {
+ // create new platform structure
+ m_messageData = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
+ sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
+
+ msg_message_id_t l_id = convertId(getIdRef());
+ LoggerD("reading message id=" << l_id);
+ // trying to get message from platform
+ if (MSG_SUCCESS == msg_get_message(MsgGetCommonHandle(), l_id, m_messageData, sendOpt))
+ {
+ LoggerD("message found with msgId=" << getIdRef());
+
+ // read all mms dat to abstraction layer
+ readConversationId(m_messageData);
+// readRecipientList(m_messageData);
+ readBody(m_messageData);
+ readFolder(m_messageData);
+ readDateTime(m_messageData);
+ readReadStatus(m_messageData);
+ readSize(m_messageData);
+ readMessageStatus(m_messageData);
+
+ } else {
+ LoggerE("message not found with msgId=" << getIdRef());
+ setId("");
+ Throw(WrtDeviceApis::Commons::PlatformException);
+ }
+
+ msg_release_struct(&sendOpt);
+ }
+ Catch(WrtDeviceApis::Commons::PlatformException) {
+ LoggerE("exception");
+ // nothing to do
+ msg_release_struct(&sendOpt);
+ }
+
}
void Sms::moveToFolder(const FolderType newFolder)
setId(convertId(msgId));
- readExistingMessage();
+ readAllData();
msg_release_struct(&sendOpt);
}
using namespace WrtDeviceApis::Commons;
-const char* MessagingExportedNames[] =
+#pragma GCC visibility push(default)
+
+const char* MessagingExportedNames[] =
{
"getMessageServices",
"createMessage",
static WrtDeviceApis::Commons::FunctionMapping createMessagingFunctions();
static WrtDeviceApis::Commons::FunctionMapping MessagingFunctions = createMessagingFunctions();
+
DEFINE_FUNCTION_GETTER(Messaging, MessagingFunctions);
+#pragma GCC visibility pop
+
static WrtDeviceApis::Commons::FunctionMapping createMessagingFunctions()
{
/**
SET(DESTINATION_NAME ${nfc_dest})
SET(TARGET_IMPL_NAME ${nfc_impl})
+IF(ENABLE_OPTIONAL_NFC)
PKG_CHECK_MODULES(platform_pkgs_nfc REQUIRED capi-network-nfc)
INCLUDE_DIRECTORIES(
INSTALL(TARGETS ${TARGET_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.xml DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
+ENDIF(ENABLE_OPTIONAL_NFC)
INSTALL(
DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${DESTINATION_HEADER_PREFIX}/nfc
FILES_MATCHING PATTERN "*.h" PATTERN "CMakeFiles" EXCLUDE
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <GlobalContextManager.h>
#include <ArgumentValidator.h>
#include <JSUtil.h>
-#include <JSWebAPIException.h>
#include <PlatformException.h>
#include "JSNFCManager.h"
NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
INFCAdapterPtr nfcAdapter(privateObject->getObject());
return JSValueMakeUndefined(context);
} Catch (BasePlatformException) {
LoggerE(_rethrown_exception.getName() << ": " << _rethrown_exception.getMessage());
- return JSWebAPIException::throwException(context, exception, _rethrown_exception);
+ return JSWebAPIErrorFactory::postException(context, exception, _rethrown_exception);
} Catch (ConversionException) {
LoggerE("JSNFCAdapter::setTagListener : ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSNFCAdapter::setPeerListener (JSContextRef context, JSObjectRef object,
NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
INFCAdapterPtr nfcAdapter(privateObject->getObject());
return JSValueMakeUndefined(context);
} Catch (BasePlatformException) {
LoggerE(_rethrown_exception.getName() << ": " << _rethrown_exception.getMessage());
- return JSWebAPIException::throwException(context, exception, _rethrown_exception);
+ return JSWebAPIErrorFactory::postException(context, exception, _rethrown_exception);
} Catch (ConversionException) {
LoggerE("JSNFCAdapter::setPeerListener : ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSNFCAdapter::unsetTagListener(JSContextRef context, JSObjectRef object, JSObjectRef thisObject,
size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) {
NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
Try {
return JSValueMakeUndefined(context);
} Catch (NullPointerException) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSNFCAdapter::unsetPeerListener(JSContextRef context, JSObjectRef object, JSObjectRef thisObject,
NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
Try {
return JSValueMakeUndefined(context);
} Catch (NullPointerException) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSNFCAdapter::getCachedMessage (JSContextRef context, JSObjectRef object,
NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSNFCAdapter::setPowered (JSContextRef context, JSObjectRef object,
NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
INFCAdapterPtr nfcAdapter(privateObject->getObject());
return JSValueMakeUndefined(context);
} Catch (BasePlatformException) {
LoggerE(_rethrown_exception.getName() << ": " << _rethrown_exception.getMessage());
- return JSWebAPIException::throwException(context, exception, _rethrown_exception);
+ return JSWebAPIErrorFactory::postException(context, exception, _rethrown_exception);
} Catch (ConversionException) {
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available"));
return JSValueMakeUndefined(context);
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error"));
return JSValueMakeUndefined(context);
}
#include <Commons/Exception.h>
#include <CommonsJavaScript/PrivateObject.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <GlobalContextManager.h>
#include <ArgumentValidator.h>
-#include <JSWebAPIException.h>
#include <PlatformException.h>
#include "JSNFCManager.h"
return JSNFCAdapter::createJSObject(GlobalContextManager::getInstance()->getGlobalContext(context));
} Catch (UnsupportedException) {
LoggerE("UnsupportedException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, "Not Supported");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Not Supported");
} Catch (ConversionException) {
LoggerE("ConversionException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (NullPointerException) {
LoggerE("NullPointerException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("InvalidArgumentException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSNFCManager::setExclusiveMode (JSContextRef context, JSObjectRef object,
return JSValueMakeUndefined(context);
} Catch (BasePlatformException) {
LoggerE(_rethrown_exception.getName() << ": " << _rethrown_exception.getMessage());
- return JSWebAPIException::throwException(context, exception, _rethrown_exception);
+ return JSWebAPIErrorFactory::postException(context, exception, _rethrown_exception);
} Catch (ConversionException) {
LoggerE("ConversionException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (NullPointerException) {
LoggerE("NullPointerException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
}
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
-#include <JSWebAPIException.h>
#include <PlatformException.h>
#include "JSNFCTag.h"
NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
INFCTagPtr nfcTag(privateObject->getObject());
return JSValueMakeUndefined(context);
} Catch (BasePlatformException) {
LoggerE(_rethrown_exception.getName() << ": " << _rethrown_exception.getMessage());
- return JSWebAPIException::throwException(context, exception, _rethrown_exception);
+ return JSWebAPIErrorFactory::postException(context, exception, _rethrown_exception);
} Catch (ConversionException) {
LoggerE("readNDEF : ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (UnsupportedException) {
LoggerE("UnsupportedException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, "Not Support NDEF");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Not Support NDEF");
} Catch (InvalidArgumentException) {
LoggerE("readNDEF InvalidArgumentException");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values"));
return JSValueMakeUndefined(context);
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available"));
return JSValueMakeUndefined(context);
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error"));
return JSValueMakeUndefined(context);
}
NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
INFCTagPtr nfcTag(privateObject->getObject());
return JSValueMakeUndefined(context);
} Catch (BasePlatformException) {
LoggerE(_rethrown_exception.getName() << ": " << _rethrown_exception.getMessage());
- return JSWebAPIException::throwException(context, exception, _rethrown_exception);
+ return JSWebAPIErrorFactory::postException(context, exception, _rethrown_exception);
} Catch (ConversionException) {
LoggerE("writeNDEF : ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (UnsupportedException) {
LoggerE("UnsupportedException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, "Not Support NDEF");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Not Support NDEF");
} Catch (InvalidArgumentException) {
LoggerE("writeNDEF InvalidArgumentException");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values"));
return JSValueMakeUndefined(context);
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available"));
return JSValueMakeUndefined(context);
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error"));
return JSValueMakeUndefined(context);
}
NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
INFCTagPtr nfcTag(privateObject->getObject());
return JSValueMakeUndefined(context);
} Catch (BasePlatformException) {
LoggerE(_rethrown_exception.getName() << ": " << _rethrown_exception.getMessage());
- return JSWebAPIException::throwException(context, exception, _rethrown_exception);
+ return JSWebAPIErrorFactory::postException(context, exception, _rethrown_exception);
} Catch (ConversionException) {
LoggerE("transceive : ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("transceive InvalidArgumentException");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values"));
return JSValueMakeUndefined(context);
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available"));
return JSValueMakeUndefined(context);
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error"));
return JSValueMakeUndefined(context);
}
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
-#include <JSWebAPIException.h>
#include <PlatformException.h>
#include "JSNFCTarget.h"
NFCTargetPrivObject* privateObject = static_cast<NFCTargetPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
INFCTargetPtr nfcTarget(privateObject->getObject());
return JSValueMakeUndefined(context);
} Catch (BasePlatformException) {
LoggerE(_rethrown_exception.getName() << ": " << _rethrown_exception.getMessage());
- return JSWebAPIException::throwException(context, exception, _rethrown_exception);
+ return JSWebAPIErrorFactory::postException(context, exception, _rethrown_exception);
} Catch (ConversionException) {
LoggerE("setReceiveNDEFListener : ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSNFCTarget::unsetReceiveNDEFListener(JSContextRef context,
NFCTargetPrivObject* privateObject = static_cast<NFCTargetPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
INFCTargetPtr nfcTarget(privateObject->getObject());
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSNFCTarget::sendNDEF(JSContextRef context,
NFCTargetPrivObject* privateObject = static_cast<NFCTargetPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
INFCTargetPtr nfcTarget(privateObject->getObject());
return JSValueMakeUndefined(context);
} Catch (BasePlatformException) {
LoggerE(_rethrown_exception.getName() << ": " << _rethrown_exception.getMessage());
- return JSWebAPIException::throwException(context, exception, _rethrown_exception);
+ return JSWebAPIErrorFactory::postException(context, exception, _rethrown_exception);
} Catch (ConversionException) {
LoggerE("sendNDEF : ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("sendNDEF InvalidArgumentException");
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values"));
return JSValueMakeUndefined(context);
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available"));
return JSValueMakeUndefined(context);
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error"));
return JSValueMakeUndefined(context);
}
#include <Commons/Exception.h>
#include <CommonsJavaScript/PrivateObject.h>
#include <CommonsJavaScript/JSUtils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
-#include <JSWebAPIException.h>
#include <PlatformException.h>
#include "NFCFactory.h"
} else
throw TypeMismatchException("Parameter Type Mismatch");
} Catch(BasePlatformException){
- JSObjectRef error = JSWebAPIException::makeJSWebAPIException(ctx, _rethrown_exception);
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, _rethrown_exception);
} Catch(ConversionException) {
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSNdefMessage::getProperty(JSContextRef context, JSObjectRef object,
NdefMessagePrivObject* privateObject = static_cast<NdefMessagePrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
INdefMessagePtr ndefMessage(privateObject->getObject());
return convert.toJSValueRef(newMessage->toByte());
} Catch (ConversionException) {
LoggerE("ConversionException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
}
#include <string>
#include <CommonsJavaScript/JSUtils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
-#include <JSWebAPIException.h>
#include <PlatformException.h>
#include "NFCFactory.h"
} else
throw TypeMismatchException("Parameter Type Mismatch");
} Catch (BasePlatformException) {
- JSObjectRef error = JSWebAPIException::makeJSWebAPIException(ctx, _rethrown_exception);
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, _rethrown_exception);
} Catch(ConversionException) {
LoggerE("ConversionException: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("InvalidArgumentException: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSNdefRecord::getProperty(JSContextRef context, JSObjectRef object,
#include <string>
#include <CommonsJavaScript/JSUtils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
-#include <JSWebAPIException.h>
#include <PlatformException.h>
#include "NFCFactory.h"
JSStringRelease(ctorName);
return result;
} Catch (BasePlatformException) {
- JSObjectRef error = JSWebAPIException::makeJSWebAPIException(ctx, _rethrown_exception);
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, _rethrown_exception);
} Catch(ConversionException) {
LoggerE("ConversionException: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("InvalidArgumentException: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSNdefRecordMedia::getProperty(JSContextRef context, JSObjectRef object,
#include <string>
#include <CommonsJavaScript/JSUtils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
-#include <JSWebAPIException.h>
#include <PlatformException.h>
#include "NFCFactory.h"
return result;
} Catch (BasePlatformException) {
- JSObjectRef error = JSWebAPIException::makeJSWebAPIException(ctx, _rethrown_exception);
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, _rethrown_exception);
} Catch(ConversionException) {
LoggerE("ConversionException: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("InvalidArgumentException: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSNdefRecordText::getProperty(JSContextRef context, JSObjectRef object,
JSStringRef propertyName, JSValueRef* exception) {
#include <string>
#include <CommonsJavaScript/JSUtils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <CommonsJavaScript/Converter.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
-#include <JSWebAPIException.h>
#include <PlatformException.h>
#include "NFCFactory.h"
JSStringRelease(ctorName);
return result;
} Catch (BasePlatformException) {
- JSObjectRef error = JSWebAPIException::makeJSWebAPIException(ctx, _rethrown_exception);
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, _rethrown_exception);
} Catch(ConversionException) {
LoggerE("ConversionException: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("InvalidArgumentException: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::SERVICE_NOT_AVAILABLE, "Service Not Available");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR, "Service Not Available");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("PlatformException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSNdefRecordURI::getProperty(JSContextRef context, JSObjectRef object,
JSStringRef propertyName, JSValueRef* exception) {
#include <dpl/scoped_ptr.h>
#include <Commons/Exception.h>
-#include <JSTizenException.h>
#include <nfc.h>
+#include <JSWebAPIErrorFactory.h>
#include "NFCDefaultAdapter.h"
#include "NFCAdapter.h"
#include "NFCUtil.h"
}
if (m_EventNFCChangedSetPoweredPtr.Get() !=NULL) {
event->setResult(false);
- event->setError(DeviceAPI::Common::JSTizenException::SERVICE_NOT_AVAILABLE);
+ event->setError(DeviceAPI::Common::JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR);
event->setErrorMessage("Progressing Identical Operation");
return;
}
} Catch(PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
event->setResult(false);
- event->setError(DeviceAPI::Common::JSTizenException::SERVICE_NOT_AVAILABLE);
+ event->setError(DeviceAPI::Common::JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR);
event->setErrorMessage("Progressing Identical Operation");
EventRequestReceiver<EventNFCChangedSetPowered>::ManualAnswer(event);
} Catch(WrtDeviceApis::Commons::Exception) {
#include <dpl/scoped_ptr.h>
#include <dpl/singleton_impl.h>
#include <Commons/Exception.h>
-#include <JSTizenException.h>
#include <nfc.h>
#include "NFCDefaultAdapter.h"
#include "NFCUtil.h"
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/ScopedJSStringRef.h>
#include <Commons/IEvent.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "NFCStaticController.h"
#include "EventNFCChangedPrivateData.h"
LoggerE("Conversion exception while processing EventNFCChanged");
} Catch (PlatformException) {
LoggerE("PlatformException:Platform can't create NFCTag" << _rethrown_exception.GetMessage());
- } Catch (UnknownException) {
+ } Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException:Platform can't create NFCTag" << _rethrown_exception.GetMessage());
} Catch (NullPointerException) {
LoggerE("NullPointer exception while processing EventNFCChanged");
JSValueRef errorObject;
if (error != "") {
if (errorMessage != "")
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), error, errorMessage);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), error, errorMessage);
else
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), error, error);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), error, error);
} else
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error");
cbm->callOnError(errorObject);
} Catch (PlatformException) {
LoggerE("PlatformException" << _rethrown_exception.GetMessage());
- JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::SERVICE_NOT_AVAILABLE,"Service Not Available");
+ JSValueRef errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR,"Service Not Available");
cbm->callOnError(errorObject);
- } Catch (UnknownException) {
+ } Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException" << _rethrown_exception.GetMessage());
- JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
+ JSValueRef errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error");
cbm->callOnError(errorObject);
} Catch (Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
+ JSValueRef errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error");
cbm->callOnError(errorObject);
}
}
//
#include <Commons/Exception.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "NFCTag.h"
#include "NFCUtil.h"
if (m_EventTagActionFormatPtr.Get() != NULL) {
event->setResult(false);
- event->setError(DeviceAPI::Common::JSTizenException::SERVICE_NOT_AVAILABLE);
+ event->setError(DeviceAPI::Common::JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR);
event->setErrorMessage("Progressing Identical Operation");
EventRequestReceiver<EventTagActionFormat>::ManualAnswer(event);
return;
//
#include <Commons/Exception.h>
-#include <JSTizenException.h>
#include <nfc.h>
+#include <JSWebAPIErrorFactory.h>
#include "NFCUtil.h"
#include <Logger.h>
case NFC_ERROR_INVALID_PARAMETER:
case NFC_ERROR_INVALID_NDEF_MESSAGE:
case NFC_ERROR_INVALID_RECORD_TYPE:
- return DeviceAPI::Common::JSTizenException::INVALID_VALUES_ERROR;
+ return DeviceAPI::Common::JSWebAPIErrorFactory::INVALID_VALUES_ERROR;
case NFC_ERROR_NO_DEVICE:
case NFC_ERROR_OUT_OF_MEMORY:
case NFC_ERROR_OPERATION_FAILED:
case NFC_ERROR_DEVICE_BUSY:
- return DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR;
+ return DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR;
case NFC_ERROR_NOT_ACTIVATED:
- return DeviceAPI::Common::JSTizenException::SERVICE_NOT_AVAILABLE;
+ return DeviceAPI::Common::JSWebAPIErrorFactory::SERVICE_NOT_AVAILABLE_ERROR;
case NFC_ERROR_NOT_SUPPORTED:
- return DeviceAPI::Common::JSTizenException::NOT_SUPPORTED_ERROR;
+ return DeviceAPI::Common::JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR;
case NFC_ERROR_TIMED_OUT:
- return DeviceAPI::Common::JSTizenException::TIMEOUT_ERROR;
+ return DeviceAPI::Common::JSWebAPIErrorFactory::TIMEOUT_ERROR;
}
- return DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR;
+ return DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR;
}
std::string NFCUtil::getNFCErrorMessage(const int errorCode) {
#include <vector>
#include <CommonsJavaScript/JSCallbackManager.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "ResponseDispatcher.h"
#include "NFCConverter.h"
#include "JSNdefMessage.h"
JSValueRef errorObject;
if (error != "") {
if (errorMessage != "")
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), error, errorMessage);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), error, errorMessage);
else
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), error, error);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), error, error);
} else
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error");
cbm->callOnError(errorObject);
} Catch (PlatformException) {
LoggerE("Platform can't create NdefMessage" << _rethrown_exception.GetMessage());
- JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
+ JSValueRef errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error");
cbm->callOnError(errorObject);
} Catch (Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
+ JSValueRef errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error");
cbm->callOnError(errorObject);
}
}
JSValueRef errorObject;
if (error != "") {
if (errorMessage != "")
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), error, errorMessage);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), error, errorMessage);
else
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), error, error);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), error, error);
} else
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error");
cbm->callOnError(errorObject);
}
JSValueRef errorObject;
if (error != "") {
if (errorMessage != "")
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), error, errorMessage);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), error, errorMessage);
else
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), error, error);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), error, error);
} else
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error");
cbm->callOnError(errorObject);
} Catch (ConversionException) {
LoggerE("Conversion exception while processing EventTagActionTransceive");
- JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
+ JSValueRef errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error");
cbm->callOnError(errorObject);
} Catch (Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
+ JSValueRef errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error");
cbm->callOnError(errorObject);
}
}
JSValueRef errorObject;
if (error != "") {
if (errorMessage != "")
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), error, errorMessage);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), error, errorMessage);
else
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), error, error);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), error, error);
} else
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error");
cbm->callOnError(errorObject);
}
JSValueRef errorObject;
if (error != "") {
if (errorMessage != "")
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), error, errorMessage);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), error, errorMessage);
else
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), error, error);
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), error, error);
} else
- errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
+ errorObject = JSWebAPIErrorFactory::makeErrorObject(cbm->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error");
cbm->callOnError(errorObject);
}
SET(TARGET_NAME ${networkbearerselection_target})
SET(DESTINATION_NAME ${networkbearerselection_dest})
+IF(ENABLE_OPTIONAL_NBS)
PKG_CHECK_MODULES(platform_pkgs_networkbearerselection REQUIRED capi-network-connection)
INCLUDE_DIRECTORIES(
INSTALL(TARGETS ${TARGET_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.xml DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
+ENDIF(ENABLE_OPTIONAL_NBS)
INSTALL(
DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${DESTINATION_HEADER_PREFIX}/networkbearerselection
FILES_MATCHING PATTERN "*.h" PATTERN "CMakeFiles" EXCLUDE
#include "EventNetworkBearerSelection.h"
#include "EventNetworkBearerRelease.h"
#include "OnNetworkBearerSelectionStateChanged.h"
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include "JSNetworkBearerSelection.h"
#include "JSNetworkBearerSelectionCallbackManager.h"
if (!priv) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Wrong Object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Wrong Object");
}
if (argumentCount < 3) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
if (argumentCount == 4) {
if (check.isCallback(arguments[3])) {
LoggerD("arguments 3 is callback");
- } else if (!JSValueIsNull(context, arguments[3]) && !JSValueIsUndefined(context, arguments[3])) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ } else if (!JSValueIsNull(context, arguments[3])) {
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
}
AceSecurityStatus status = NETWORKBEARERSELECTION_CHECK_ACCESS(NETWORKBEARERSELECTION_FUNCTION_API_REQUEST_ROUTE_TO_HOST);
TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
- JSValueRef onsuccess;
- JSValueRef onpaused;
- JSValueRef onresumed;
- JSValueRef ondisconnected;
+ JSValueRef onsuccess = NULL;
+ JSValueRef onpaused = NULL;
+ JSValueRef onresumed = NULL;
+ JSValueRef ondisconnected = NULL;
Try {
JSObjectRef callbackObject = converter.toJSObjectRef(arguments[2]);
ThrowMsg(ConversionException, "2nd argument's onsuccess attribute is not a 'function'");
}
+ if( onsuccess == NULL && onpaused == NULL && onresumed == NULL && ondisconnected == NULL ) {
+ ThrowMsg(ConversionException, "2nd argument is not a callback'");
+ }
+
} Catch(ConversionException) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
}
JSNetworkBearerSelectionCallbackManagerPtr callbackManager = JSNetworkBearerSelectionCallbackManager::createObject(priv->getContext());
std::string networkType = converter.toString(arguments[0]);
std::string domainName = converter.toString(arguments[1]);
if (strcmp(networkType.c_str(), "CELLULAR") != 0) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
callbackManager->setOnSuccess(onsuccess);
NetworkBearerSelections->requestRouteToHost(dplEvent);
} else {
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NETWORK_ERROR, "Network error"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::NETWORK_ERROR, "Network error"));
}
}
Catch(WrtDeviceApis::Commons::Exception) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
}
return JSValueMakeUndefined(context);
}
if (!priv) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Wrong Object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Wrong Object");
}
if (argumentCount < 3) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
if (!check.isCallback(arguments[2])) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
AceSecurityStatus status = NETWORKBEARERSELECTION_CHECK_ACCESS(NETWORKBEARERSELECTION_FUNCTION_API_RELEASE_ROUTE_TO_HOST);
std::string networkType = converter.toString(arguments[0]);
std::string domainName = converter.toString(arguments[1]);
if (strcmp(networkType.c_str(), "CELLULAR") != 0) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
if (argumentCount > 3) {
if (check.isCallback(arguments[3])) {
onErrorForCbm = arguments[3];
- } else if (!JSValueIsNull(context, arguments[3]) && !JSValueIsUndefined(context, arguments[3])) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ } else if (!JSValueIsNull(context, arguments[3])) {
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
}
JSCallbackManagerPtr callbackManager(JSCallbackManager::createObject(priv->getContext(), onSuccessForCbm, onErrorForCbm, true, true));
}
Catch(WrtDeviceApis::Commons::Exception) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
}
return JSValueMakeUndefined(context);
static void connection_state_changed_callback(connection_profile_state_e state, void* user_data)
{
+ LoggerD("enter");
if(user_data != NULL) {
LoggerD("Callback registration Succeeded");
NewtorkBearerSelectionPendingEvent *pendingEvent = (NewtorkBearerSelectionPendingEvent *)user_data;
static void connection_opened_callback(connection_error_e result, void* user_data)
{
+ LoggerD("enter");
if (result == CONNECTION_ERROR_NONE) {
LoggerD("Connection open Succeeded");
if(user_data != NULL) {
static void connection_closed_callback(connection_error_e result, void* user_data)
{
+ LoggerD("enter");
if (result == CONNECTION_ERROR_NONE) {
LoggerD("Connection close Succeeded");
if (user_data != NULL) {
}
}
+static void connection_closed_callback2(connection_error_e result, void* user_data)
+{
+ LoggerD("enter");
+ if (result == CONNECTION_ERROR_NONE) {
+ LoggerD("Connection close Succeeded");
+ }
+}
+
+
static void connection_removed_callback(connection_error_e result, void* user_data)
{
+ LoggerD("enter");
if (user_data != NULL) {
if (result == CONNECTION_ERROR_NONE) {
LoggerD("Connection close Succeeded");
}
NetworkBearerSelection::NetworkBearerSelection() : m_connectionHandle(NULL),
- m_profileHandle(NULL)
+ m_profileHandle(NULL),
+ m_connectionState(NETWORK_UNKNOWN)
{
int ret = connection_create(&m_connectionHandle);
void NetworkBearerSelection::OnRequestReceived(const EventNetworkBearerSelectionPtr &event)
{
- if (checkProfileHandle() == false) {
+ LoggerD("m_connectionState : " << m_connectionState);
+
+ if (m_connectionState == NETWORK_CONNECTED) {
reLaunchConnection(event);
return;
}
int ret = connection_get_profile_iterator(m_connectionHandle, CONNECTION_ITERATOR_TYPE_REGISTERED, &profileIter);
if (ret != CONNECTION_ERROR_NONE) {
LoggerD("Fail to get profile iterator");
+ makeCallback(event, CONNECTION_STATE_PLATFORM_ERROR);
return;
}
while (connection_profile_iterator_has_next(profileIter)) {
if (connection_profile_iterator_next(profileIter, &m_profileHandle) != CONNECTION_ERROR_NONE) {
LoggerD("Fail to get profile handle");
+ makeCallback(event, CONNECTION_STATE_PLATFORM_ERROR);
return;
}
}
if (connection_open_profile(m_connectionHandle, m_profileHandle, connection_opened_callback, pendingEvent) != CONNECTION_ERROR_NONE) {
LoggerD("Connection open Failed");
+ makeCallback(event, CONNECTION_STATE_PLATFORM_ERROR);
delete pendingEvent;
pendingEvent = NULL;
}
}
NewtorkBearerReleasePendingEvent *pendingEvent = new NewtorkBearerReleasePendingEvent((void *)this, event);
-
+
if (connection_close_profile(m_connectionHandle, m_profileHandle, connection_closed_callback, pendingEvent) != CONNECTION_ERROR_NONE) {
LoggerD("connection close failed");
delete pendingEvent;
LoggerD("enter");
if (connection_profile_unset_state_changed_cb(m_profileHandle) != CONNECTION_ERROR_NONE) {
- LoggerD("unset callback is failed");
+ LoggerD("unset callback is failed");
+ makeCallback(event, CONNECTION_STATE_PLATFORM_ERROR);
return;
}
if (connection_close_profile(m_connectionHandle, m_profileHandle, connection_removed_callback, pendingEvent) != CONNECTION_ERROR_NONE) {
LoggerD("connection close failed");
+ makeCallback(event, CONNECTION_STATE_PLATFORM_ERROR);
delete pendingEvent;
pendingEvent = NULL;
}
int ret = connection_get_profile_iterator(m_connectionHandle, CONNECTION_ITERATOR_TYPE_REGISTERED, &profileIter);
if (ret != CONNECTION_ERROR_NONE) {
LoggerD("Fail to get profile iterator");
+ makeCallback(event, CONNECTION_STATE_PLATFORM_ERROR);
return;
}
while (connection_profile_iterator_has_next(profileIter)) {
if (connection_profile_iterator_next(profileIter, &m_profileHandle) != CONNECTION_ERROR_NONE) {
LoggerD("Fail to get profile handle");
+ makeCallback(event, CONNECTION_STATE_PLATFORM_ERROR);
return;
}
}
if (connection_open_profile(m_connectionHandle, m_profileHandle, connection_opened_callback, pendingEvent) != CONNECTION_ERROR_NONE) {
LoggerD("Connection open Failed");
+ makeCallback(event, CONNECTION_STATE_PLATFORM_ERROR);
delete pendingEvent;
pendingEvent = NULL;
}
char *interfaceName = NULL;
char *hostAddr = NULL;
struct hostent *host_entry;
- int ndx = 0;
- int ret = 0;
if (connection_profile_get_network_interface_name(m_profileHandle, &interfaceName) != CONNECTION_ERROR_NONE) {
LoggerD("Fail to get interface name!");
+ makeCallback(event, CONNECTION_STATE_PLATFORM_ERROR);
}
else {
LoggerD("Interface name : " << interfaceName);
if(!host_entry) {
LoggerD("gethostbyname is failed");
- makeCallback(event, CONNECTION_STATE_ERROR);
+ makeCallback(event, CONNECTION_STATE_INVALID_VALUES_ERROR);
+
+ if (connection_close_profile(m_connectionHandle, m_profileHandle, connection_closed_callback2, NULL) != CONNECTION_ERROR_NONE) {
+ LoggerD("connection close failed");
+ makeCallback(event, CONNECTION_STATE_PLATFORM_ERROR);
+ }
+ m_profileHandle = NULL;
return;
}
{
LoggerD("enter");
m_profileHandle = NULL;
-
+ m_connectionState = NETWORK_DISCONNECTED;
EventRequestReceiver<EventNetworkBearerRelease>::ManualAnswer(event);
}
void NetworkBearerSelection::makeCallback(const EventNetworkBearerSelectionPtr &event, connectionStateType state)
{
- LoggerD("enter");
+ LoggerD("state : " << state);
OnNetworkBearerSelectionStateChangedEmitterPtr emitter = event->getEmitter();
OnNetworkBearerSelectionStateChangedPtr listener(new OnNetworkBearerSelectionStateChanged());
m_domainName = event->getDomainName();
-
listener->setConnectionStateType(state);
- if (state == CONNECTION_STATE_ERROR) {
+ if (state == CONNECTION_STATE_INVALID_VALUES_ERROR) {
+ m_connectionState = NETWORK_CONNECTION_FAILED;
listener->setExceptionCode(ExceptionCodes::InvalidArgumentException);
+ } else if (state == CONNECTION_STATE_PLATFORM_ERROR) {
+ m_connectionState = NETWORK_CONNECTION_FAILED;
+ listener->setExceptionCode(ExceptionCodes::PlatformException);
+ } else if (state == CONNECTION_STATE_DISCONNECTED) {
+ m_connectionState = NETWORK_DISCONNECTED;
+ } else if (state == CONNECTION_STATE_CONNECTED) {
+ m_connectionState = NETWORK_CONNECTED;
}
-
emitter->emit(listener);
}
namespace DeviceAPI {
namespace NetworkBearerSelection {
+enum {
+ NETWORK_UNKNOWN = 0,
+ NETWORK_CONNECTED = 1,
+ NETWORK_DISCONNECTED = 2,
+ NETWORK_CONNECTION_FAILED = 3
+};
+
class NetworkBearerSelection : public INetworkBearerSelection
{
friend class NetworkBearerSelectionFactory;
connection_h m_connectionHandle;
connection_profile_h m_profileHandle;
std::string m_domainName;
+ long m_connectionState;
};
class NewtorkBearerSelectionPendingEvent
#include "NetworkBearerSelectionResponseDispatcher.h"
#include "JSNetworkBearerSelectionCallbackManager.h"
#include <CommonsJavaScript/JSCallbackManager.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <Logger.h>
using namespace DeviceAPI::Common;
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "record not found");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::INVALID_VALUES_ERROR, "DomainName is not setted");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "DomainName is not setted");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
} else if (event->getConnectionStateType() == CONNECTION_STATE_DISCONNECTED) {
LoggerD("disconnect callback");
callbackManager->callOnDisconnected();
- } else if (event->getConnectionStateType() == CONNECTION_STATE_ERROR) {
+ } else if (event->getConnectionStateType() == CONNECTION_STATE_INVALID_VALUES_ERROR || event->getConnectionStateType() == CONNECTION_STATE_PLATFORM_ERROR) {
JSContextRef gContext = callbackManager->getContext();
JSValueRef error = NULL;
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "record not found");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::INVALID_VALUES_ERROR, "Invalid values error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid values error");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
enum connectionStateType {
CONNECTION_STATE_DISCONNECTED = 0,
CONNECTION_STATE_CONNECTED = 1,
- CONNECTION_STATE_ERROR = 2
+ CONNECTION_STATE_INVALID_VALUES_ERROR = 2,
+ CONNECTION_STATE_PLATFORM_ERROR = 3
};
class OnNetworkBearerSelectionStateChanged : public WrtDeviceApis::Commons::ListenerEvent<OnNetworkBearerSelectionStateChanged>
static WrtDeviceApis::Commons::FunctionMapping NetworkBearerSelectionFunctions =
createNetworkBearerSelectionFunctions();
+#pragma GCC visibility push(default)
+
DEFINE_FUNCTION_GETTER(NetworkBearerSelection, NetworkBearerSelectionFunctions);
+#pragma GCC visibility pop
+
static WrtDeviceApis::Commons::FunctionMapping createNetworkBearerSelectionFunctions()
{
using namespace WrtDeviceApis::Commons;
#include <SecurityExceptions.h>
#include <JSUtil.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
#include <MultiCallbackUserData.h>
if (priv) {
JSObjectSetPrivate(object, static_cast<void*>(priv));
}
+ else {
+ throw TypeMismatchException("NotificationDetailInfo object is invaild.");
+ }
// mainText
JSUtil::setProperty(context, object, NOTIFICATION_DETAIL_INFO_MAIN_TEXT,
#include <SecurityExceptions.h>
#include <JSUtil.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
#include <MultiCallbackUserData.h>
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in NotificationManager.post().");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in NotificationManager.update().");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in NotificationManager.remove().");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in NotificationManager.removeAll().");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return obj;
} catch (const BasePlatformException &err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in NotificationManager.get().");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return jsResult;
} catch (const BasePlatformException &err) {
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in NotificationManager.getAll().");
- return JSWebAPIError::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
#include <SecurityExceptions.h>
#include <JSUtil.h>
-#include <JSWebAPIError.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
#include <MultiCallbackUserData.h>
#include <PlatformException.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <FilesystemUtils.h>
#include "plugin_config.h"
catch ( const BasePlatformException& err)
{
LoggerW(" notification convertion is failed. " << err.getName().c_str() << ":" << err.getMessage().c_str());
- JSObjectRef error = JSWebAPIError::makeJSWebAPIError(context, err);
+ JSObjectRef error = JSWebAPIErrorFactory::makeErrorObject(context, err);
*exception = error;
return error;
}
throw TypeMismatchException("value is not notification type");
}
- setProgressType(NOTI_PROGRESS_TYPE_PERCENTAGE); //default
+ //setProgressType(NOTI_PROGRESS_TYPE_PERCENTAGE); //default
LoggerI("Notification Type : " << type);
if (NOTIFICATION_TYPE_ONGOING == type)
{ //ongoing no ticker.
LoggerI("ongoing type");
- notification_set_display_applist(noti, NOTIFICATION_DISPLAY_APP_NOTIFICATION_TRAY |NOTIFICATION_DISPLAY_APP_INDICATOR );
+ if ( NOTIFICATION_ERROR_NONE != notification_set_display_applist(noti, NOTIFICATION_DISPLAY_APP_NOTIFICATION_TRAY |NOTIFICATION_DISPLAY_APP_INDICATOR ))
+ {
+ throw UnknownException("can't set notification display applist");
+ }
}
+
}
else
{
LoggerI(" notification type =" << type);
setNotiType(type);
- setProgressType(NOTI_PROGRESS_TYPE_PERCENTAGE); //default.
+ //setProgressType(NOTI_PROGRESS_TYPE_PERCENTAGE); //default.
+ //read Progress type value.
+ char *strProgressType = NULL;
+ if (NOTIFICATION_ERROR_NONE == notification_get_image(notification, NOTIFICATION_IMAGE_TYPE_LIST_5, &strProgressType))
+ {
+ if ( strProgressType )
+ {
+ std::string notiProgressType(strProgressType);
+ if( notiProgressType.compare(TIZEN_NOTIFICATION_PROGRESS_TYPE_BYTE) == 0)
+ m_progressType = NOTI_PROGRESS_TYPE_SIZE;
+ }
+ }
setNotificationHandle((void*)notification);
loadThumbnails();
loadDetailInfos();
+#if 0
if ( type == NOTI_TYPE_PROGRESS)
{
notification_update_progress(notification, NOTIFICATION_PRIV_ID_NONE, getProgressValue());
}
-
+#endif
//service
bundle *bSvc = NULL;
LoggerI(" notification type =" << type);
setNotiType(type);
- setProgressType(NOTI_PROGRESS_TYPE_PERCENTAGE); //default.
+ //setProgressType(NOTI_PROGRESS_TYPE_PERCENTAGE); //default.
+ //read Progress type value.
+ char *strProgressType = NULL;
+ if (NOTIFICATION_ERROR_NONE == notification_get_image(notification, NOTIFICATION_IMAGE_TYPE_LIST_5, &strProgressType))
+ {
+ if ( strProgressType )
+ {
+ std::string notiProgressType(strProgressType);
+ if( notiProgressType.compare(TIZEN_NOTIFICATION_PROGRESS_TYPE_BYTE) == 0)
+ m_progressType = NOTI_PROGRESS_TYPE_SIZE;
+ }
+ }
+
setNotificationHandle((void*)notification);
loadThumbnails();
loadDetailInfos();
-
+#if 0
if ( type == NOTI_TYPE_PROGRESS)
{
notification_update_progress(notification, NOTIFICATION_PRIV_ID_NONE, getProgressValue());
}
-
+#endif
//service
bundle *bSvc = NULL;
if (m_notiHandle)
{
-#if 0
LoggerI(" service = " << m_service);
if (m_service != NULL)
{
service_destroy(m_service);
m_service = NULL;
}
-#endif
+
if (notification_free(m_notiHandle) != NOTIFICATION_ERROR_NONE)
{
throw UnknownException("notification free failed...");
std::string StatusNotification::getApplicationId()
{
std::string retString;
- service_h service = NULL;
char* appIdStr = NULL;
-
+#if 0
+ service_h service = NULL;
+
if (m_service != NULL)
{
int retcode;
}
}
}
-
- if (service != NULL)
+#endif
+ if (m_service != NULL)
{
- if (service_get_app_id(service, &appIdStr) != SERVICE_ERROR_NONE)
+ if (service_get_app_id(m_service, &appIdStr) != SERVICE_ERROR_NONE)
{
throw UnknownException ("get a appId error");
}
}
}
+NotificationProgressType StatusNotification::getProgressType()
+{
+ return m_progressType;
+}
+
+void StatusNotification::setProgressType(NotificationProgressType type)
+{
+
+ if (m_notiHandle)
+ {
+ LoggerI(" NotificationProgressType = " << type);
+
+ std::string progressType;
+
+ if ( type == NOTI_PROGRESS_TYPE_PERCENTAGE)
+ {
+ progressType = TIZEN_NOTIFICATION_PROGRESS_TYPE_PERCENTAGE;
+ }
+ else if ( type == NOTI_PROGRESS_TYPE_SIZE)
+ {
+ progressType = TIZEN_NOTIFICATION_PROGRESS_TYPE_BYTE;
+ }
+ else
+ {
+ throw TypeMismatchException("Invalid Progress Type.");
+ }
+
+ if (notification_set_image(m_notiHandle,NOTIFICATION_IMAGE_TYPE_LIST_5, progressType.c_str()) != NOTIFICATION_ERROR_NONE)
+ {
+ throw UnknownException("set notification sound error");
+ }
+
+ m_progressType = type;
+ }
+ else
+ {
+ LoggerD("noti Handle is NULL");
+ throw UnknownException("notification handle is null");
+ }
+
+}
+
std::string StatusNotification::getSubIconPath()
{
LoggerI("Handle = " << m_notiHandle);
StatusNotification(int privID); //private ID of Notification.
~StatusNotification();
-
+
+#if 0
NotificationProgressType getProgressType()
{
return m_progressType;
}
-
- std::string getEnumProgressType();
-
void setProgressType( NotificationProgressType type)
{
m_progressType = type;
}
+#endif
+
+ std::string getEnumProgressType();
+
+
void setUpdatedFlag(bool value)
{
if (value)
bool getDefaultVibration() ;
void setDefaultVibration(const bool& vibration) ;
-
- double getProgressValue() ;
- void setProgressValue(const double & progressValue) ;
+
+ NotificationProgressType getProgressType();
+ void setProgressType(NotificationProgressType type);
+
+ double getProgressValue() ;
+ void setProgressValue(const double & progressValue);
std::string getSubIconPath() ;
void setSubIconPath(const std::string& subIconPath) ;
protected:
- //NotificationType m_notiType;
NotificationType m_notiType;
service_h m_service;
notification_h m_notiHandle;
// limitations under the License.
//
-#include <JSWebAPIException.h>
#include <CommonsJavaScript/Converter.h>
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/Utils.h>
#include <JSUtil.h>
+#include <JSWebAPIErrorFactory.h>
#include "JSPackageInformation.h"
#include "PackageInformation.h"
#include <Logger.h>
return JSUtil::toJSValueRef(context, privateData->m_appIds);
}
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::TypeMismatchException err("TypeMismatchException occured");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
return JSValueMakeUndefined(context);
// limitations under the License.
//
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <ArgumentValidator.h>
#include <PlatformException.h>
-#include <JSWebAPIException.h>
#include <CommonsJavaScript/Converter.h>
//#include <CommonsJavaScript/JSUtils.h>
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSPackageInformation::createJSObject(context, pkgInfo);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSValueMakeUndefined(context);
} catch(const BasePlatformException& err) {
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
string id = converter.toString(checkedArguments[0]);
string storage = converter.toString(checkedArguments[1]);
if ((storage.compare("EXTERNAL") != 0) && (storage.compare("INTERNAL") != 0)) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong second parameter type");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong second parameter type");
}
JSObjectRef eventCBObj = converter.toJSObjectRef(arguments[2]);
if (!JSObjectIsFunction(context, converter.toJSObjectRef(onprogress)) ||
!JSObjectIsFunction(context, converter.toJSObjectRef(oncomplete))) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong third parameter type");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong third parameter type");
}
CallbackUserData *onprogressCb = new CallbackUserData(GlobalContextManager::getInstance()->getGlobalContext(context));
} Catch (NotFoundException) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
} Catch (ConversionException) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
} Catch (Exception) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
return JSValueMakeUndefined(context);
// Should I change first parameter to "undefined" or throw exception???
if (argumentCount < 1) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "wrong parameter");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "wrong parameter");
}
Try {
return converter.toJSValueRef(PackageManager::getInstance()->isInstalled(id));
} Catch (NotFoundException) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
} Catch (ConversionException) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
} Catch (Exception) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
return false;
return converter.toJSValueRef(PackageManager::getInstance()->getPackageIdFromAppId(id));
} Catch (NotFoundException) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
} Catch (ConversionException) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
} Catch (Exception) {
LoggerE("Exception: "<<_rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
}
return JSValueMakeUndefined(context);
#include <glib.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <GlobalContextManager.h>
#include <PlatformException.h>
JSObjectRef jsResult = JSCreateArrayObject(context, 0, NULL);
if (jsResult == NULL) {
- JSValueRef error = JSTizenExceptionFactory::makeErrorObject(callback->getContext(), JSTizenException::UNKNOWN_ERROR, "platform exception");
+ JSValueRef error = JSWebAPIErrorFactory::makeErrorObject(callback->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR, "platform exception");
callback->callErrorCallback(error);
return false;
}
for (size_t i = 0; i < pkgInfoList.size(); ++i) {
JSValueRef tmpVal = JSPackageInformation::createJSObject(context, &pkgInfoList[i]);
if (!JSSetArrayElement(context, jsResult, i, tmpVal)) {
- JSValueRef error = JSTizenExceptionFactory::makeErrorObject(callback->getContext(), JSTizenException::UNKNOWN_ERROR, "platform exception");
+ JSValueRef error = JSWebAPIErrorFactory::makeErrorObject(callback->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR, "platform exception");
callback->callErrorCallback(error);
return false;
}
callback->callSuccessCallback(jsResult);
} else {
- JSValueRef error = JSTizenExceptionFactory::makeErrorObject(callback->getContext(), JSTizenException::UNKNOWN_ERROR, "platform exception");
+ JSValueRef error = JSWebAPIErrorFactory::makeErrorObject(callback->getContext(), JSWebAPIErrorFactory::UNKNOWN_ERROR, "platform exception");
callback->callErrorCallback(error);
}
case PACAKGE_MANAGER_EVENT_STATE_FAILED: {
JSValueRef jsError = NULL;
if (error == PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE) {
- jsError = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::NOT_FOUND_ERROR,"given package is not found");
+ jsError = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
} else {
- jsError = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"platform exception");
+ jsError = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
}
if (callback->getOnError()) {
break;
}
default:
- JSValueRef error = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"platform exception");
+ JSValueRef error = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
if (callback->getOnError()) {
callback->getOnError()->callSuccessCallback(error);
}
if (ret != PACKAGE_MANAGER_ERROR_NONE) {
if (errCallback) {
JSValueRef error =
- JSTizenExceptionFactory::makeErrorObject(globalCtx, JSTizenException::UNKNOWN_ERROR, "Platform Error");
+ JSWebAPIErrorFactory::makeErrorObject(globalCtx, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Platform Error");
errCallback->callSuccessCallback(error);
}
delete callback;
if (ret != PACKAGE_MANAGER_ERROR_NONE) {
if (errCallback) {
JSValueRef error =
- JSTizenExceptionFactory::makeErrorObject(globalCtx, JSTizenException::NOT_FOUND_ERROR, "Not proper file");
+ JSWebAPIErrorFactory::makeErrorObject(globalCtx, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "Not proper file");
errCallback->callSuccessCallback(error);
}
delete callback;
if (ret != PACKAGE_MANAGER_ERROR_NONE) {
if (errCallback) {
JSValueRef error =
- JSTizenExceptionFactory::makeErrorObject(globalCtx, JSTizenException::UNKNOWN_ERROR, "Platform Error");
+ JSWebAPIErrorFactory::makeErrorObject(globalCtx, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Platform Error");
errCallback->callSuccessCallback(error);
}
delete callback;
if (ret != PACKAGE_MANAGER_ERROR_NONE) {
if (errCallback) {
JSValueRef error =
- JSTizenExceptionFactory::makeErrorObject(globalCtx, JSTizenException::UNKNOWN_ERROR, "Platform Error");
+ JSWebAPIErrorFactory::makeErrorObject(globalCtx, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Platform Error");
errCallback->callSuccessCallback(error);
}
//clean-up callback object
if (ret != PACKAGE_MANAGER_ERROR_NONE) {
if (errCallback) {
JSValueRef error =
- JSTizenExceptionFactory::makeErrorObject(globalCtx, JSTizenException::NOT_FOUND_ERROR, "Not proper file");
+ JSWebAPIErrorFactory::makeErrorObject(globalCtx, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "Not proper file");
// TODO: how can I handle about uninstallable package???
errCallback->callSuccessCallback(error);
}
if (ret != PACKAGE_MANAGER_ERROR_NONE) {
if (errCallback) {
JSValueRef error =
- JSTizenExceptionFactory::makeErrorObject(globalCtx, JSTizenException::UNKNOWN_ERROR, "Platform Error");
+ JSWebAPIErrorFactory::makeErrorObject(globalCtx, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Platform Error");
errCallback->callSuccessCallback(error);
}
//clean-up callback object
#include <CallbackUserData.h>
#include <GlobalContextManager.h>
#include <JSUtil.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <TimeTracer.h>
#include <Logger.h>
using namespace WrtDeviceApis::Commons;
-using namespace WrtDeviceApis::CommonsJavaScript;
using namespace DeviceAPI::Common;
using namespace std;
PowerState state(state_str.c_str());
PowerManager::getInstance()->request( resource , state );
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
PowerManager::getInstance()->release( resource );
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
PowerManager::getInstance()->addScreenStateChangedCallback(callback);
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}catch( const std::bad_alloc& oom){
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Out of memory");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Out of memory");
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSUtil::toJSValueRef(context, brightness);
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
LOGE(" value = %f", value);
PowerManager::getInstance()->setScreenBrightness(value);
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSUtil::toJSValueRef(context,state);
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
try{
PowerManager::getInstance()->restoreScreenBrightness();
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);}
try{
PowerManager::getInstance()->setScreenState(true);
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
try{
PowerManager::getInstance()->setScreenState(false);
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
SET(DESTINATION_NAME ${push_dest})
SET(TARGET_IMPL_NAME ${push_impl})
+IF(ENABLE_OPTIONAL_PUSH)
PKG_CHECK_MODULES(platform_pkgs_push REQUIRED push capi-appfw-application)
INCLUDE_DIRECTORIES(
INSTALL(TARGETS ${TARGET_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.xml DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
+ENDIF(ENABLE_OPTIONAL_PUSH)
INSTALL(
DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${DESTINATION_HEADER_PREFIX}/push
FILES_MATCHING PATTERN "*.h" PATTERN "CMakeFiles" EXCLUDE
#include <SecurityExceptions.h>
#include <JSUtil.h>
-#include <JSWebAPIException.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
#include <MultiCallbackUserData.h>
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ LOGE("%s: %s", err.getName().c_str(), err.getMessage().c_str());
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in PushManager.registerService().");
- LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ LOGE("%s: %s", err.getName().c_str(), err.getMessage().c_str());
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ LOGE("%s: %s", err.getName().c_str(), err.getMessage().c_str());
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in PushManager.unregisterService().");
- LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ LOGE("%s: %s", err.getName().c_str(), err.getMessage().c_str());
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ LOGE("%s: %s", err.getName().c_str(), err.getMessage().c_str());
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in PushManager.connectService().");
- LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ LOGE("%s: %s", err.getName().c_str(), err.getMessage().c_str());
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
} catch (const BasePlatformException &err) {
- LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ LOGE("%s: %s", err.getName().c_str(), err.getMessage().c_str());
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in PushManager.disconnectService().");
- LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ LOGE("%s: %s", err.getName().c_str(), err.getMessage().c_str());
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
return JSUtil::toJSValueRef(context, ret);
}
} catch (const BasePlatformException &err) {
- LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ LOGE("%s: %s", err.getName().c_str(), err.getMessage().c_str());
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("Unknown Error in PushManager.getRegistrationId().");
- LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ LOGE("%s: %s", err.getName().c_str(), err.getMessage().c_str());
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
}
#include <SecurityExceptions.h>
#include <JSUtil.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
#include <GlobalContextManager.h>
#include <MultiCallbackUserData.h>
//
#include <JSUtil.h>
-#include <JSWebAPIError.h>
+#include <JSWebAPIErrorFactory.h>
#include <PlatformException.h>
#include <app_manager.h>
}
if (!success) {
- LoggerE("Platform error %d <%s>", err, msg.c_str());
+ LOGE("Platform error %d <%s>", err, msg.c_str());
}
return msg;
static void push_connection_state_cb(push_state_e state, const char *err, void *user_data)
{
- LoggerI("Push connection state cb with state: "<< state <<", err: "<< err);
+ LOGD("Push connection state cb with state: %d, err: %s", state, err);
PushManager *thisPushManager = static_cast<PushManager*>(user_data);
if (!thisPushManager) {
- LoggerE("user_data of push_connection_state_cb() is NULL.");
+ LOGE("user_data of push_connection_state_cb() is NULL.");
} else {
thisPushManager->m_connectionState = state;
}
char *alertMessage = NULL;
long long int date = -1;
- LoggerI("Push notification cb");
+ LOGD("Push notification cb");
try {
PushManager *thisPushManager = static_cast<PushManager*>(user_data);
MultiCallbackUserDataPtr callback = thisPushManager->m_notificationCallback;
if (!callback) {
- LoggerW("notification callback is not set. ignored.");
+ LOGW("notification callback is not set. ignored.");
return;
}
ret = push_get_notification_time(noti, &date);
if (ret != PUSH_ERROR_NONE) {
- LoggerE("Platform error while getting notification date/time. " << _get_internal_error(ret));
+ LOGE("Platform error while getting notification date/time. %s", _get_internal_error(ret).c_str());
}
PushMessage *pushMessage = new PushMessage();
callback->invokeCallback("onsuccess", pushMessageObj);
} catch (const BasePlatformException &err) {
- LoggerE(err.getMessage());
+ LOGE("%s", err.getMessage().c_str());
}
}
int ret;
char *tmp = NULL;
- LoggerI("Push registration cb");
+ LOGD("Push registration cb");
try {
PushManager *thisPushManager = static_cast<PushManager*>(user_data);
}
} else {
UnknownException error(msg == NULL ? "Unknown" : msg);
- JSObjectRef errorObj = JSWebAPIError::makeJSWebAPIError(callback->getContext(), error);
+ JSObjectRef errorObj = JSWebAPIErrorFactory::makeErrorObject(callback->getContext(), error);
callback->invokeCallback("onerror", errorObj);
}
} catch (const BasePlatformException &err) {
- LoggerE(err.getMessage());
+ LOGE("%s", err.getMessage().c_str());
}
}
static void push_unregistration_result_cb(push_result_e result, const char *msg, void *user_data)
{
- LoggerI("Push unregistration cb");
+ LOGD("Push unregistration cb");
try {
PushManager *thisPushManager = static_cast<PushManager*>(user_data);
callback->invokeCallback("onsuccess");
} else {
UnknownException error(msg == NULL ? "Unknown" : msg);
- JSObjectRef errorObj = JSWebAPIError::makeJSWebAPIError(callback->getContext(), error);
+ JSObjectRef errorObj = JSWebAPIErrorFactory::makeErrorObject(callback->getContext(), error);
callback->invokeCallback("onerror", errorObj);
}
} catch (const BasePlatformException &err) {
- LoggerE(err.getMessage());
+ LOGE("%s", err.getMessage().c_str());
}
}
m_connectionState(PUSH_STATE_UNREGISTERED),
m_connectionHandle(NULL)
{
- LoggerI("Connecting to the push service...");
- LoggerI("Push App id: " << m_appId);
- LoggerI("Push Package id: " << m_pkgId);
+ LOGD("Connecting to the push service...");
int ret = push_connect(m_pkgId.c_str(), push_connection_state_cb, push_notify_cb, this, &m_connectionHandle);
if (PUSH_ERROR_NONE!=ret) {
- LoggerE("Error while connecting to the push service: "<< ret);
+ LOGE("Error while connecting to the push service: %d", ret);
return;
}
}
PushManager::~PushManager()
{
- LoggerI("Disconnecting to the push service...");
+ LOGD("Disconnecting to the push service...");
push_disconnect(m_connectionHandle);
}
PushManager *PushManager::getInstance() {
- LoggerI("Getting instance of PushManager...");
+ LOGD("Getting instance of PushManager...");
static PushManager instance;
return &instance;
}
int ret = app_manager_get_app_info(appId.c_str(), &handle);
if (ret != APP_MANAGER_ERROR_NONE) {
- LoggerE("WrtAccess initialization failed");
+ LOGE("WrtAccess initialization failed");
return;
}
ret = app_info_get_package(handle, &_pkg_id);
if ((ret != APP_MANAGER_ERROR_NONE) || (_pkg_id == NULL)) {
- LoggerD("Fail to get pkg_id by " << appId.c_str());
+ LOGW("Fail to get pkg_id by %s", appId.c_str());
}
ret = app_info_destroy(handle);
if (ret != APP_MANAGER_ERROR_NONE) {
- LoggerE("WrtAccess initialization failed");
+ LOGE("WrtAccess initialization failed");
return;
}
if (appControl->getUri().compare("") != 0) {
ret = service_set_uri(service, appControl->getUri().c_str());
if (ret != SERVICE_ERROR_NONE) {
- LoggerW("Platform error while setting uri to appControl. " << _get_internal_error(ret));
+ LOGW("Platform error while setting uri to appControl. %s", _get_internal_error(ret).c_str());
}
}
if (appControl->getMime().compare("") != 0) {
ret = service_set_mime(service, appControl->getMime().c_str());
if (ret != SERVICE_ERROR_NONE) {
- LoggerW("Platform error while setting mime to appControl. " << _get_internal_error(ret));
+ LOGW("Platform error while setting mime to appControl. %s", _get_internal_error(ret).c_str());
}
}
for (size_t i = 0; i < controlDataArray.size(); i++) {
key = controlDataArray.at(i)->getKey();
if (key.empty()) {
- LoggerW("Invalid key for " << i << " in ApplicationControl's data array.");
+ LOGW("Invalid key for %d in ApplicationControl's data array.", i);
} else {
std::vector<std::string> valueArray = controlDataArray.at(i)->getValue();
size_t size = valueArray.size();
if (size == 1) {
ret = service_add_extra_data(service, (const char*)key.c_str(), arr[0]);
if (ret != SERVICE_ERROR_NONE) {
- LoggerW("Platform error while adding extra data to appControl. " << _get_internal_error(ret));
+ LOGW("Platform error while adding extra data to appControl. %s", _get_internal_error(ret).c_str());
}
} else {
ret = service_add_extra_data_array(service, (const char*)key.c_str(), arr, size);
if (ret != SERVICE_ERROR_NONE) {
- LoggerW("Platform error while adding extra data array to appControl. " << _get_internal_error(ret));
+ LOGW("Platform error while adding extra data array to appControl. %s", _get_internal_error(ret).c_str());
}
}
ret = push_get_registration_id(m_connectionHandle, ®Id);
if (ret != PUSH_ERROR_NONE) {
- LoggerW("Platform error while getting registration id. " << _get_internal_error(ret));
+ LOGW("Platform error while getting registration id. %s", _get_internal_error(ret).c_str());
} else {
if (regId) {
str = regId;
void on_widget_start_callback(int widgetId)
{
- LoggerD("[Tizen\\Push] on_widget_start_callback (%d)", widgetId);
+ LOGD("[Tizen\\Push] on_widget_start_callback (%d)", widgetId);
TIME_TRACER_INIT();
try {
WrtDB::WidgetDAOReadOnly dao(widgetId);
PushManager::setAppId(DPL::ToUTF8String(dao.getTzAppId()));
WrtAccessSingleton::Instance().initialize(widgetId);
} catch (...) {
- LoggerE("WrtAccess initialization failed");
+ LOGE("WrtAccess initialization failed");
}
}
void on_widget_stop_callback(int widgetId)
{
- LoggerD("[Tizen\\Push] on_widget_stop_callback (%d)", widgetId);
+ LOGD("[Tizen\\Push] on_widget_stop_callback (%d)", widgetId);
TIME_TRACER_EXPORT_REPORT_TO(TIME_TRACER_EXPORT_FILE,"Push");
TIME_TRACER_RELEASE();
try {
WrtAccessSingleton::Instance().deinitialize(widgetId);
} catch (...) {
- LoggerE("WrtAccess deinitialization failed");
+ LOGE("WrtAccess deinitialization failed");
}
}
void on_frame_load_callback(const void * context)
{
- LoggerD("[Tizen\\Push] on_frame_load_callback (%p)", context);
+ LOGD("[Tizen\\Push] on_frame_load_callback (%p)", context);
GlobalContextManager::getInstance()->addGlobalContext(static_cast<JSContextRef>(context));
}
void on_frame_unload_callback(const void * context)
{
- LoggerD("[Tizen\\Push] on_frame_unload_callback (%p)", context);
+ LOGD("[Tizen\\Push] on_frame_unload_callback (%p)", context);
GlobalContextManager::getInstance()->removeGlobalContext(static_cast<JSContextRef>(context));
}
SET(DESTINATION_NAME ${secureelement_dest})
SET(TARGET_IMPL_NAME ${secureelement_impl})
+IF(ENABLE_OPTIONAL_SE)
PKG_CHECK_MODULES(platform_pkgs_secureelement REQUIRED smartcard-service smartcard-service-common)
INCLUDE_DIRECTORIES(
INSTALL(TARGETS ${TARGET_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.xml DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
+ENDIF(ENABLE_OPTIONAL_SE)
INSTALL(
DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${DESTINATION_HEADER_PREFIX}/secureelement
FILES_MATCHING PATTERN "*.h" PATTERN "CMakeFiles" EXCLUDE
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
-#include <JSWebAPIException.h>
#include <SecurityExceptions.h>
#include "SEFactory.h"
#include "SEResponseDispatcher.h"
SEChannelPrivObject* privateObject = static_cast<SEChannelPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
ISEChannelPtr seChannel(privateObject->getObject());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSSEChannel::transmit(JSContextRef context,
if ((argumentCount < 2) || JSValueIsNull(context, arguments[0]) || JSValueIsUndefined(context, arguments[0]) || !JSIsArrayValue(context, arguments[0])) {
/* 1st argument is mandatory. And 1st argument must be Array */
LoggerE("data TypeMismatchException!");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
}
} catch (const BasePlatformException &err) {
LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
SEChannelPrivObject* privateObject = static_cast<SEChannelPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
ISEChannelPtr seChannel(privateObject->getObject());
return JSValueMakeUndefined(context);
} Catch (ConversionException) {
LoggerE("ConversionException: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error"));
return JSValueMakeUndefined(context);
}
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <ArgumentValidator.h>
-#include <JSWebAPIException.h>
#include "SEFactory.h"
#include "SEResponseDispatcher.h"
#include "JSSEReader.h"
SEReaderPrivObject* privateObject = static_cast<SEReaderPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
ISEReaderPtr seReader(privateObject->getObject());
}
} catch (const BasePlatformException &err) {
LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
SEReaderPrivObject* privateObject = static_cast<SEReaderPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
ISEReaderPtr seReader(privateObject->getObject());
return JSValueMakeUndefined(context);
} Catch (ConversionException) {
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error"));
return JSValueMakeUndefined(context);
}
SEReaderPrivObject* privateObject = static_cast<SEReaderPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
ISEReaderPtr seReader(privateObject->getObject());
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <ArgumentValidator.h>
-#include <JSWebAPIException.h>
#include "SEFactory.h"
#include "SEResponseDispatcher.h"
#include "JSSEService.h"
}
} catch (const BasePlatformException &err) {
LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
SEServicePrivObject* privateObject = static_cast<SEServicePrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
ISEServicePtr seService(privateObject->getObject());
return JSValueMakeUndefined(context);
} Catch (ConversionException) {
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error"));
return JSValueMakeUndefined(context);
}
if (!argValidator.toObject(0))
throw TypeMismatchException("Parameter is not Object");
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
SEConverter convert(context);
} else {
/* 1st argument must be SEListener. */
LoggerE("SEListener must has onSEReady and onSENotReady");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
SEServicePrivObject* privateObject = static_cast<SEServicePrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
ISEServicePtr seService(privateObject->getObject());
return convert.toJSValueRef(static_cast<unsigned long>(emitter->getId()));
} Catch (ConversionException) {
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR,"Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error");
}
JSValueRef JSSEService::unregisterSEListener(JSContextRef context, JSObjectRef object, JSObjectRef thisObject,
ArgumentValidator validator(context, argumentCount, arguments);
value = validator.toULong(0);
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
SEServicePrivObject* privateObject = static_cast<SEServicePrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
Try {
return JSValueMakeUndefined(context);
} Catch (ConversionException) {
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (NullPointerException) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (WrtDeviceApis::Commons::NotFoundException) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Not Found ID");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Not Found ID");
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSSEService::shutdown(JSContextRef context,
SEServicePrivObject* privateObject = static_cast<SEServicePrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
ISEServicePtr seService(privateObject->getObject());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
}
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <ArgumentValidator.h>
-#include <JSWebAPIException.h>
#include "SEFactory.h"
#include "SEResponseDispatcher.h"
#include "JSSESession.h"
SESessionPrivObject* privateObject = static_cast<SESessionPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
ISESessionPtr seSession(privateObject->getObject());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSSESession::close(JSContextRef context,
SESessionPrivObject* privateObject = static_cast<SESessionPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
ISESessionPtr seSession(privateObject->getObject());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSSESession::closeChannels(JSContextRef context,
SESessionPrivObject* privateObject = static_cast<SESessionPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
ISESessionPtr seSession(privateObject->getObject());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSSESession::openBasicChannel(JSContextRef context,
if ((argumentCount < 2) || JSValueIsNull(context, arguments[0]) || JSValueIsUndefined(context, arguments[0]) || !JSIsArrayValue(context, arguments[0])) {
/* 1st argument is mandatory. And 1st argument must be Array. */
LoggerE("AID TypeMismatchException!");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
}
} catch (const BasePlatformException &err) {
LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
SESessionPrivObject* privateObject = static_cast<SESessionPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
ISESessionPtr seSession(privateObject->getObject());
std::vector<unsigned char> aid = convert.toVectorOfUChars(arguments[0]);
if ((aid.size() < 5) || (aid.size() > 16)) {
LoggerE("wrong aid length : " << aid.size());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Wrong AID length");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Wrong AID length");
}
EventSEOpenChannelPtr event(new EventSEOpenChannel(aid, true));
event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
return JSValueMakeUndefined(context);
} Catch (ConversionException) {
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error"));
return JSValueMakeUndefined(context);
}
if ((argumentCount < 2) || JSValueIsNull(context, arguments[0]) || JSValueIsUndefined(context, arguments[0]) || !JSIsArrayValue(context, arguments[0])) {
/* 1st argument is mandatory. And 1st argument must be Array. */
LoggerE("AID TypeMismatchException!");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
}
} catch (const BasePlatformException &err) {
LoggerE(err.getName() << ": " << err.getMessage());
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}
SESessionPrivObject* privateObject = static_cast<SESessionPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
ISESessionPtr seSession(privateObject->getObject());
std::vector<unsigned char> aid = convert.toVectorOfUChars(arguments[0]);
if ((aid.size() < 5) || (aid.size() > 16)) {
LoggerE("wrong aid length : " << aid.size());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Wrong AID length");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Wrong AID length");
}
EventSEOpenChannelPtr event(new EventSEOpenChannel(aid, false));
event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
return JSValueMakeUndefined(context);
} Catch (ConversionException) {
LoggerE("ConversionException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("UnknownException: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
+ callbackManager->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR,"Unknown Error"));
return JSValueMakeUndefined(context);
}
//
#include <Commons/Exception.h>
-#include <JSTizenException.h>
#include <ByteArray.h>
+#include <JSWebAPIErrorFactory.h>
#include "SEChannel.h"
#include "SEUtil.h"
#include <Logger.h>
} catch (const WrtDeviceApis::Commons::Exception& ex) {
LoggerE("Exception: " << ex.GetMessage());
event->setResult(false);
- event->setError(DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ event->setError(DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
event->setErrorMessage("Unknown Error");
EventRequestReceiver<EventSEChannelTransmit>::ManualAnswer(event);
}
#include <CommonsJavaScript/Validator.h>
#include <CommonsJavaScript/JSUtils.h>
#include "SEConverter.h"
-#include <JSWebAPIError.h>
-#include <TizenExceptionData.h>
+#include <JSWebAPIErrorFactory.h>
#include <Logger.h>
using namespace std;
}
JSValueRef SEConverter::makeSeErrorObject(std::string error, std::string message) {
- int code = JSWebAPIError::UNKNOWN_ERR;
- if (error.compare("InvalidStateError") == 0)
- code = JSWebAPIError::INVALID_STATE_ERR;
- else
- code = JSWebAPIError::convertToWebAPIErrorCode(error);
-
- JSWebAPIError::PrivateObject::ObjectType data(new TizenExceptionData(code, error, message));
- return JSUtils::makeObject(m_context, JSWebAPIError::getClassRef(), data);
+ return JSWebAPIErrorFactory::makeErrorObject(m_context, error, message);
}
}
//
#include <Commons/Exception.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "SEReader.h"
#include "SEUtil.h"
#include <Logger.h>
event->setErrorMessage(util.getErrorMessage(error));
} else if (session == NULL) {
event->setResult(false);
- event->setError(DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ event->setError(DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
event->setErrorMessage("Unknown Error");
} else {
event->setSession(session);
} catch (const WrtDeviceApis::Commons::Exception& ex) {
LoggerE("Exception: " << ex.GetMessage());
event->setResult(false);
- event->setError(DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ event->setError(DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
event->setErrorMessage("Unknown Error");
EventRequestReceiver<EventSEOpenSession>::ManualAnswer(event);
}
#include <vector>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/ScopedJSStringRef.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "JSSEReader.h"
#include "JSSESession.h"
#include "JSSEChannel.h"
#include <Ecore.h>
#include <Commons/Exception.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "SESession.h"
#include "SEUtil.h"
#include <Logger.h>
event->setErrorMessage(util.getErrorMessage(error));
} else if (channel == NULL) {
event->setResult(false);
- event->setError(DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ event->setError(DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
event->setErrorMessage("Unknown Error");
} else {
event->setChannel(channel);
} catch (const WrtDeviceApis::Commons::Exception& ex) {
LoggerE("Exception: " << ex.GetMessage());
event->setResult(false);
- event->setError(DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR);
+ event->setError(DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR);
event->setErrorMessage("Unknown Error");
EventRequestReceiver<EventSEOpenChannel>::ManualAnswer(event);
}
#include "SEUtil.h"
-#include <JSTizenException.h>
#include <smartcard-types.h>
+#include <JSWebAPIErrorFactory.h>
#include <Logger.h>
namespace DeviceAPI {
case SCARD_ERROR_IPC_FAILED:
case SCARD_ERROR_OPERATION_TIMEOUT:
case SCARD_ERROR_UNKNOWN:
- return DeviceAPI::Common::JSTizenException::IO_ERROR;
+ return DeviceAPI::Common::JSWebAPIErrorFactory::IO_ERROR;
case SCARD_ERROR_ILLEGAL_STATE:
case SCARD_ERROR_ILLEGAL_REFERENCE:
return "InvalidStateError";
case SCARD_ERROR_ILLEGAL_PARAM:
- return DeviceAPI::Common::JSTizenException::INVALID_VALUES_ERROR;
+ return DeviceAPI::Common::JSWebAPIErrorFactory::INVALID_VALUES_ERROR;
case SCARD_ERROR_SECURITY_NOT_ALLOWED:
- return DeviceAPI::Common::JSTizenException::PERMISSION_DENIED_ERROR;
+ return DeviceAPI::Common::JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR;
case SCARD_ERROR_IO_FAILED:
- return DeviceAPI::Common::JSTizenException::NOT_FOUND_ERROR;
+ return DeviceAPI::Common::JSWebAPIErrorFactory::NOT_FOUND_ERROR;
}
- return DeviceAPI::Common::JSTizenException::UNKNOWN_ERROR;
+ return DeviceAPI::Common::JSWebAPIErrorFactory::UNKNOWN_ERROR;
}
std::string SEUtil::getErrorMessage(const int errorCode) {
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
#include <SecurityExceptions.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "JSSecureStorageManager.h"
#include "plugin_config.h"
switch(ex.getCode())
{
case WrtDeviceApis::Commons::ExceptionCodes::NotFoundException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_FOUND_ERROR, "not found error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, "not found error");
case WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "invalid parameter error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "invalid parameter error");
case WrtDeviceApis::Commons::ExceptionCodes::ConversionException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
case WrtDeviceApis::Commons::ExceptionCodes::SecurityException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::PERMISSION_DENIED_ERROR, "permission denied error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "permission denied error");
case WrtDeviceApis::Commons::ExceptionCodes::Exception:
default:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
}
return JSValueMakeUndefined(context);
switch(ex.getCode())
{
case WrtDeviceApis::Commons::ExceptionCodes::NotFoundException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_FOUND_ERROR, "not found error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, "not found error");
case WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "invalid parameter error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "invalid parameter error");
case WrtDeviceApis::Commons::ExceptionCodes::ConversionException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
case WrtDeviceApis::Commons::ExceptionCodes::SecurityException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::PERMISSION_DENIED_ERROR, "permission denied error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "permission denied error");
case WrtDeviceApis::Commons::ExceptionCodes::Exception:
default:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
}
return JSValueMakeUndefined(context);
switch(ex.getCode())
{
case WrtDeviceApis::Commons::ExceptionCodes::NotFoundException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_FOUND_ERROR, "not found error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, "not found error");
case WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "invalid parameter error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "invalid parameter error");
case WrtDeviceApis::Commons::ExceptionCodes::ConversionException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
case WrtDeviceApis::Commons::ExceptionCodes::SecurityException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::PERMISSION_DENIED_ERROR, "permission denied error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "permission denied error");
case WrtDeviceApis::Commons::ExceptionCodes::Exception:
default:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
}
return JSValueMakeUndefined(context);
switch(ex.getCode())
{
case WrtDeviceApis::Commons::ExceptionCodes::NotFoundException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_FOUND_ERROR, "not found error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, "not found error");
case WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "invalid parameter error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "invalid parameter error");
case WrtDeviceApis::Commons::ExceptionCodes::ConversionException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
case WrtDeviceApis::Commons::ExceptionCodes::SecurityException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::PERMISSION_DENIED_ERROR, "permission denied error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "permission denied error");
case WrtDeviceApis::Commons::ExceptionCodes::Exception:
default:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
}
return JSValueMakeUndefined(context);
switch(ex.getCode())
{
case WrtDeviceApis::Commons::ExceptionCodes::NotFoundException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::NOT_FOUND_ERROR, "not found error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::NOT_FOUND_ERROR, "not found error");
case WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::INVALID_VALUES_ERROR, "invalid parameter error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "invalid parameter error");
case WrtDeviceApis::Commons::ExceptionCodes::ConversionException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::TYPE_MISMATCH_ERROR, "type mismatch error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "type mismatch error");
case WrtDeviceApis::Commons::ExceptionCodes::SecurityException:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::PERMISSION_DENIED_ERROR, "permission denied error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::PERMISSION_DENIED_ERROR, "permission denied error");
case WrtDeviceApis::Commons::ExceptionCodes::Exception:
default:
- return JSTizenExceptionFactory::postException(context, exception,
- JSTizenException::UNKNOWN_ERROR, "Unkown error");
+ return JSWebAPIErrorFactory::postException(context, exception,
+ JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unkown error");
}
}
return JSValueMakeUndefined(context);
#include "EventGetSetting.h"
#include "SystemSettingFactory.h"
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <TimeTracer.h>
#include "JSSystemSetting.h"
namespace DeviceAPI {
namespace SystemSetting {
+using WrtDeviceApis::Commons::UnknownException;
+
JSClassDefinition JSSystemSetting::m_classInfo = {
0,
kJSClassAttributeNone,
if (!priv) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Wrong Object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Wrong Object");
}
if (argumentCount < 3) {
LoggerD("Argument is too few");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
if (!check.isCallback(arguments[2])) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
AceSecurityStatus status = SYSTEMSETTING_CHECK_ACCESS(SYSTEMSETTING_FUNCTION_API_SET_PROPERTY);
if (check.isCallback(arguments[3])) {
onErrorForCbm = arguments[3];
} else if (!JSValueIsNull(context, arguments[3])) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
}
Catch(WrtDeviceApis::Commons::ConversionException) {
LoggerD("Exception");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
LoggerD("Exception");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "invalid value error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "invalid value error");
}
Catch(WrtDeviceApis::Commons::PlatformException) {
LoggerD("Exception");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "platform error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "platform error");
}
Catch(WrtDeviceApis::Commons::Exception) {
LoggerD("Exception");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
}
LoggerD("end");
if (!priv) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Wrong Object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Wrong Object");
}
if (argumentCount < 2) {
LoggerD("Argument is too few");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
if (!check.isCallback(arguments[1])) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
/*
if (check.isCallback(arguments[2])) {
onErrorForCbm = arguments[2];
} else if (!JSValueIsNull(context, arguments[2])) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
}
Catch(WrtDeviceApis::Commons::ConversionException) {
LoggerD("Exception");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
LoggerD("Exception");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "invalid value error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "invalid value error");
}
Catch(WrtDeviceApis::Commons::PlatformException) {
LoggerD("Exception");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "platform error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "platform error");
}
Catch(WrtDeviceApis::Commons::Exception) {
LoggerD("Exception");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
}
LoggerD("end");
#include "SystemSettingResponseDispatcher.h"
#include <CommonsJavaScript/JSCallbackManager.h>
-#include <JSTizenException.h>
-#include <JSTizenExceptionFactory.h>
+#include <JSWebAPIErrorFactory.h>
#include <FilesystemUtils.h>
#include "SystemSettingAsyncCallbackManager.h"
#include <Logger.h>
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "record not found");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::INVALID_VALUES_ERROR, "DomainName is not setted");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "DomainName is not setted");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
LoggerD("callOnError");
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "record not found");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::INVALID_VALUES_ERROR, "DomainName is not setted");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "DomainName is not setted");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "record not found");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::INVALID_VALUES_ERROR, "DomainName is not setted");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "DomainName is not setted");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
switch (event->getExceptionCode())
{
case ExceptionCodes::PlatformException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
break;
case ExceptionCodes::NotFoundException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "record not found");
break;
case ExceptionCodes::InvalidArgumentException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::INVALID_VALUES_ERROR, "DomainName is not setted");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "DomainName is not setted");
break;
case ExceptionCodes::ConversionException:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
break;
default:
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
break;
}
if (settingPath.size() == 0)
{
- error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
callbackManager->callOnError(error);
return;
}
//
#include <memory>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
+#include <system_info.h>
#include "JSCellularNetworkInfo.h"
#include "plugin_config.h"
#include <Logger.h>
} else if (JSStringIsEqualToUTF8CString(propertyName, CELLULARNETWORK_IMEI_PROPERTY)) {
AceSecurityStatus status = SYSTEMINFO_CHECK_ACCESS(SYSTEMINFO_FUNCTION_API_GET_PROPERTY_PARTNER_VALUE);
TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
+ char* imei = NULL;
+
+ if (system_info_get_value_string(SYSTEM_INFO_KEY_MOBILE_DEVICE_ID, &imei) == SYSTEM_INFO_ERROR_NONE) {
+ if (imei) {
+ LoggerD("imei : " << imei);
+ cellularNetworkInfo->imei = imei;
+ free(imei);
+ }
+ }
+
return convert.toJSValueRef(cellularNetworkInfo->imei);
}
}
#include <fstream>
#include <pcrecpp.h>
#include <memory>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <sensor.h>
#include <sensors.h>
//
#include <memory>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <sim.h>
#include "JSSIMInfo.h"
#include "SysteminfoFactory.h"
#include "EventGetSysteminfo.h"
#include "EventWatchSysteminfo.h"
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <TimeTracer.h>
#include "SysteminfoListener.h"
if (!priv) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
Try
{
return (static_cast<JSValueRef>(JSDeviceCapabilitiesInfo::createJSObject(context, result)));
}
Catch(WrtDeviceApis::Commons::ConversionException) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid values error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid values error");
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException){
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid values error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid values error");
}
Catch(WrtDeviceApis::Commons::Exception) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
}
}
if (!priv) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Wrong Object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Wrong Object");
}
if (argumentCount < 2) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
if (!check.isCallback(arguments[1])) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
if (check.isCallback(arguments[2])) {
onErrorForCbm = arguments[2];
} else if (!JSValueIsNull(context, arguments[2])) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
}
}
Catch(WrtDeviceApis::Commons::ConversionException) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
Catch(WrtDeviceApis::Commons::Exception) {
- cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Unknown error"));
+ cbm->callOnError(JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error"));
}
return JSValueMakeUndefined(context);
}
if (!priv) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Wrong Object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Wrong Object");
}
if (argumentCount < 2) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
if (!check.isCallback(arguments[1])) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
JSValueRef onSuccessForCbm = NULL;
option.highThreshold = converter.toDouble(JSUtils::getJSProperty(context, arguments[2], "highThreshold", exception));
option.lowThreshold = converter.toDouble(JSUtils::getJSProperty(context, arguments[2], "lowThreshold", exception));
} else if (!JSValueIsNull(context, arguments[2])) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
}
ISysteminfoPtr Systeminfos(priv->getObject());
}
Catch(WrtDeviceApis::Commons::ConversionException) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid values error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid values error");
}
Catch(WrtDeviceApis::Commons::Exception) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
}
}
Converter converter(context);
if (!priv) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Wrong Object");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Wrong Object");
}
if (argumentCount < 1) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
Try {
return JSValueMakeUndefined(context);
}
Catch(WrtDeviceApis::Commons::ConversionException) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid values error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid values error");
}
Catch(WrtDeviceApis::Commons::Exception) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
}
}
connection_address_family_e addressFamily = CONNECTION_ADDRESS_FAMILY_IPV4;
char* ipAddr = NULL;
char* apn = NULL;
- char* imei = NULL;
int plmn = 0, cellId = 0, lac = 0, isRoaming = 0, isFlightMode = 0;
TIME_TRACER_ITEM_BEGIN("(cellular)mcc", 0);
}
}
- TIME_TRACER_ITEM_BEGIN("(cellular)imei", 0);
- if (system_info_get_value_string(SYSTEM_INFO_KEY_MOBILE_DEVICE_ID, &imei) == SYSTEM_INFO_ERROR_NONE) {
- if (imei) {
- LoggerD("imei : " << imei);
- cellularNetwork->imei = imei;
- free(imei);
- }
- }
- TIME_TRACER_ITEM_END("(cellular)imei", 0);
-
return JSCellularNetworkInfo::createJSObject(context, cellularNetwork);
}
#include <CommonsJavaScript/PrivateObject.h>
#include <CommonsJavaScript/JSUtils.h>
#include <Commons/Exception.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
-#include <JSWebAPIException.h>
#include "DurationProperties.h"
#include "JSTZDate.h"
}
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
const JSClassRef JSTZDate::getClassRef()
{
return converter.toJSValueRef(timezone);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::toTimezone(JSContextRef context, JSObjectRef function,
TZDatePtr tzDate(privateObject->getObject());
return createJSObject(context, tzDate->getTime(), timezone);
} catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::diffTZDate(JSContextRef context, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef * exception, CompareType type) {
Try {
return diffTZDate(context, thisObject, argumentCount, arguments, exception, DIFFERENCE);
} catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} Catch(InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::equalsTo(JSContextRef context, JSObjectRef function,
Try {
return diffTZDate(context, thisObject, argumentCount, arguments, exception, EQUALSTO);
} catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::earlierThan(JSContextRef context, JSObjectRef function,
Try {
return diffTZDate(context, thisObject, argumentCount, arguments, exception, EARLIERTHAN);
} catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
Try {
return diffTZDate(context, thisObject, argumentCount, arguments, exception, LATERTHAN);
} catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
return (static_cast<JSValueRef>(createJSObject(context, result)));
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (OutOfRangeException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "The result is beyond the scope that TZDate can handle.");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "The result is beyond the scope that TZDate can handle.");
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::toUTC(JSContextRef context, JSObjectRef function,
return createJSObject(context, tzDate->getTime(), tzDate->getUTCTimezoneName());
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
return createJSObject(context, tzDate->getTime(), tzDate->getLocalTimezoneName());
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::toLocaleDateString(JSContextRef context, JSObjectRef function,
return converter.toJSValueRef(result);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::toLocaleTimeString(JSContextRef context, JSObjectRef function,
return converter.toJSValueRef(result);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::toLocaleString(JSContextRef context, JSObjectRef function,
return converter.toJSValueRef(result);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::toDateString(JSContextRef context, JSObjectRef function,
return converter.toJSValueRef(result);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::toTimeString(JSContextRef context, JSObjectRef function,
return converter.toJSValueRef(result);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
return converter.toJSValueRef(result);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::getDate(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
if (privateObject == NULL) {
LoggerE(">>> NULL Exception");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
TZDatePtr tzDate(privateObject->getObject());
return converter.toJSValueRef(static_cast<int> (retVal));
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::setDate(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
try{
setTZDateValue(context, thisObject, argumentCount, arguments, exception, dateFields);
} catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
return JSValueMakeNull(context);
try{
setTZDateValue(context, thisObject, argumentCount, arguments, exception, dateFields);
} catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
return JSValueMakeNull(context);
Try {
setTZDateValue(context, thisObject, argumentCount, arguments, exception, dateFields);
} catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
return JSValueMakeNull(context);
Try{
setTZDateValue(context, thisObject, argumentCount, arguments, exception, dateFields);
} catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
return JSValueMakeNull(context);
Try {
setTZDateValue(context, thisObject, argumentCount, arguments, exception, dateFields);
} catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
return JSValueMakeNull(context);
Try {
setTZDateValue(context, thisObject, argumentCount, arguments, exception, dateFields);
} catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
return JSValueMakeNull(context);
Try {
setTZDateValue(context, thisObject, argumentCount, arguments, exception, dateFields);
} catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
}Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
return JSValueMakeNull(context);
return converter.toJSValueRefLong(result);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::setUTCDate(JSContextRef context, JSObjectRef function,
return JSValueMakeNull(context);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::getTimezoneAbbreviation(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef * exception) {
return converter.toJSValueRef(tzDate->getTimezoneAbbreviation());
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::secondsFromUTC(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef * exception) {
return converter.toJSValueRefLong(tzDate->secondsFromUTC());
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::isDST(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef * exception) {
LoggerD("entered");
return converter.toJSValueRef(tzDate->isDST());
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::getPreviousDSTTransition(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef * exception) {
return createJSObject(context, resultDate);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTZDate::getNextDSTTransition(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef * exception) {
return createJSObject(context, resultDate);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
} //DeviceAPI
#include <Commons/Exception.h>
#include <CommonsJavaScript/Utils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include "JSTimeDuration.h"
#include "TimeUtilConverter.h"
#include <Logger.h>
return true;
} Catch (NullPointerException) {
LoggerE("NullPointerException: " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (ConversionException) {
LoggerE("ConversionException: " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("InvalidArgumentException: " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
return false;
}
}
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
- *exception = error;
- return error;
- } Catch(UnknownException) {
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ } Catch(WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
- *exception = error;
- return error;
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerW("Trying to get incorrect value");
}
- JSObjectRef error = JSTizenExceptionFactory::makeErrorObject(ctx, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
- *exception = error;
- return error;
-
+ return JSWebAPIErrorFactory::postException(ctx, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTimeDuration::diffTimeDuration(JSContextRef context, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef * exception, CompareType type) {
TimeDurationPrivObject* privateObject = static_cast<TimeDurationPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("Private object is not set.");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
TimeUtilConverter converter(context);
return diffTimeDuration(context, thisObject, argumentCount, arguments, exception, DIFFERENCE);
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (UnsupportedException) {
LoggerE("JSTimeUtil::hasInstance NotSupportedException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR , "Not Support");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR , "Not Support");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTimeDuration::equalsTo(JSContextRef context, JSObjectRef function,
return diffTimeDuration(context, thisObject, argumentCount, arguments, exception, EQUALSTO);
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (UnsupportedException) {
LoggerE("JSTimeUtil::hasInstance NotSupportedException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR , "Not Support");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR , "Not Support");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTimeDuration::lessThan(JSContextRef context, JSObjectRef function,
return diffTimeDuration(context, thisObject, argumentCount, arguments, exception, LESSTHAN);
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (UnsupportedException) {
LoggerE("JSTimeUtil::hasInstance NotSupportedException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR , "Not Support");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR , "Not Support");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTimeDuration::greaterThan(JSContextRef context, JSObjectRef function,
return diffTimeDuration(context, thisObject, argumentCount, arguments, exception, GREATERTHAN);
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (UnsupportedException) {
LoggerE("JSTimeUtil::hasInstance NotSupportedException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR , "Not Support");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR , "Not Support");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
} //Time
#include <Commons/Exception.h>
#include <CommonsJavaScript/Utils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
-#include <JSTizenExceptionFactory.h>
-#include <JSTizenException.h>
+#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
-#include <JSWebAPIException.h>
#include "JSTimeUtil.h"
#include "JSTZDate.h"
TimeUtilPrivObject* privateObject = static_cast<TimeUtilPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
return JSTZDate::createJSObject(context);
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTimeUtil::getLocalTimezone(JSContextRef context,
return converter.toJSValueRef(localTimezone);
} Catch(NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTimeUtil::getAvailableTimezones(JSContextRef context,
return converter.toJSValueRef(timezonesArray);
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");;
} Catch (UnsupportedException) {
LoggerE("JSTimeUtil::hasInstance NotSupportedException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR , "Not Support");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR , "Not Support");
} Catch (NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTimeUtil::getDateFormat(JSContextRef context,
return converter.toJSValueRef(dateformat);
} catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");;
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");;
} Catch (UnsupportedException) {
LoggerE("JSTimeUtil::hasInstance NotSupportedException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR , "Not Support");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR , "Not Support");
} Catch (NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTimeUtil::getTimeFormat(JSContextRef context,
return converter.toJSValueRef(timeFormat);
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (UnsupportedException) {
LoggerE("JSTimeUtil::hasInstance NotSupportedException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR , "Not Support");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR , "Not Support");
} Catch (NullPointerException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
JSValueRef JSTimeUtil::isLeapYear(JSContextRef context, JSObjectRef function,
return converter.toJSValueRef(true);
}catch(const BasePlatformException& err){
- return JSWebAPIException::throwException(context, exception, err);
+ return JSWebAPIErrorFactory::postException(context, exception, err);
} Catch(ConversionException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
} Catch (InvalidArgumentException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Invalid Values");
} Catch (UnsupportedException) {
LoggerE("JSTimeUtil::hasInstance NotSupportedException");
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR , "Not Support");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR , "Not Support");
} Catch (PlatformException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
} Catch (WrtDeviceApis::Commons::Exception) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
}
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown Error");
}
} //TimeUtil
#include <string>
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/ScopedJSStringRef.h>
-#include <JSWebAPIException.h>
#include <JSUtil.h>
#include <ArgumentValidator.h>
+#include <JSWebAPIErrorFactory.h>
#include "AnyFactory.h"
#include <Logger.h>
}
catch(BasePlatformException &e)
{
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(context, e);
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
try
}
catch(BasePlatformException &e)
{
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(context, e);
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
matchValue = AnyFactory::createAnyEmpty(context);
Catch(Exception)
{
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(
- context, TypeMismatchException("Error occurred while creating object"));
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception,
+ TypeMismatchException("Error occurred while creating object"));
}
return jsobject;
#include "JSAttributeRangeFilter.h"
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/ScopedJSStringRef.h>
-#include <JSWebAPIException.h>
#include <JSUtil.h>
#include <ArgumentValidator.h>
+#include <JSWebAPIErrorFactory.h>
#include "AnyFactory.h"
#include <Logger.h>
}
catch(BasePlatformException &e)
{
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(context, e);
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
initialValue = AnyFactory::createAnyEmpty(context);
Catch(Exception)
{
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(
- context, TypeMismatchException("Error occurred while creating object"));
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception,
+ TypeMismatchException("Error occurred while creating object"));
}
return jsobject;
#include <string>
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/ScopedJSStringRef.h>
-#include <JSWebAPIException.h>
#include <JSUtil.h>
#include <ArgumentValidator.h>
+#include <JSWebAPIErrorFactory.h>
#include <Logger.h>
#define ATTRIBUTE_FILTER_CLASS_NAME "CompositeFilter"
}
catch(BasePlatformException &e)
{
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(context, e);
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
try
}
catch(BasePlatformException &e)
{
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(context, e);
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
CompositeFilterPtr compositeFilter(new CompositeFilter(type, FilterArrayPtr(new FilterArray())));
Catch(Exception)
{
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(
- context, TypeMismatchException("Error occurred while creating object"));
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception,
+ TypeMismatchException("Error occurred while creating object"));
}
return jsobject;
#include <string>
#include <dpl/shared_ptr.h>
-#include <JSWebAPIException.h>
#include <JSUtil.h>
#include <ArgumentValidator.h>
+#include <JSWebAPIErrorFactory.h>
#include <Logger.h>
#define ATTRIBUTE_FILTER_CLASS_NAME "SimpleCoordinates"
}
catch(BasePlatformException &e)
{
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(context, e);
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
SimpleCoordinatesPtr simpleCoordinates(new SimpleCoordinates(latitude, longitude));
Catch(Exception)
{
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(
- context, TypeMismatchException("Error occurred while creating object"));
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception,
+ TypeMismatchException("Error occurred while creating object"));
}
return jsobject;
#include "JSSortMode.h"
#include <string>
#include <dpl/shared_ptr.h>
-#include <JSWebAPIException.h>
#include <JSUtil.h>
#include <ArgumentValidator.h>
+#include <JSWebAPIErrorFactory.h>
#include <Logger.h>
#define ATTRIBUTE_FILTER_CLASS_NAME "SortMode"
}
catch(BasePlatformException &e)
{
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(context, e);
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
try
}
catch(BasePlatformException &e)
{
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(context, e);
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception, e);
}
SortModePtr sortMode(new SortMode(attributeName, sortOrder));
Catch(Exception)
{
LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
- JSObjectRef exceptionObj = JSWebAPIException::makeJSWebAPIException(
- context, TypeMismatchException("Error occurred while creating object"));
- *exception = exceptionObj;
- return exceptionObj;
+ return JSWebAPIErrorFactory::postException(context, exception,
+ TypeMismatchException("Error occurred while creating object"));
}
return jsobject;
//return false.
return false;
}
+
} // Tizen
} // DeviceAPI
projects / framework / web / wrt-plugins-tizen.git / commitdiff