Name: wrt-plugins-tizen
Summary: JavaScript plugins for WebRuntime
-Version: 0.4.69
+Version: 0.4.70
Release: 0
Group: Development/Libraries
License: Apache License, Version 2.0
Description: wrt-plugins-tizen-${module_name}
Version: @CMAKE_PROJECT_VERSION@
Requires: capi-appfw-app-manager capi-appfw-application capi-appfw-package-manager pkgmgr pkgmgr-info
-Libs: -L${libdir} -lwrt-plugins-tizen-${module_name}-impl -lwrt-plugins-tizen-${module_name}-config
+Libs: -L${libdir} -lwrt-plugins-tizen-${module_name}-impl
Cflags: -I${includedir}/${module_name}
\ No newline at end of file
Description: wrt-plugins-tizen-${module_name}
Version: @CMAKE_PROJECT_VERSION@
Requires: contacts-service2 libpcrecpp
-Libs: -L${libdir} -lwrt-plugins-tizen-${module_name}-impl -lwrt-plugins-tizen-${module_name}-config
+Libs: -L${libdir} -lwrt-plugins-tizen-${module_name}-impl
Cflags: -I${includedir}/${module_name}
\ No newline at end of file
Description: wrt-plugins-tizen-${module_name}
Version: @CMAKE_PROJECT_VERSION@
Requires:
-Libs: -L${libdir} -lwrt-plugins-tizen-${module_name}-impl -lwrt-plugins-tizen-${module_name}-config
-Cflags: -I${includedir}/${module_name}
\ No newline at end of file
+Libs: -L${libdir} -lwrt-plugins-tizen-${module_name}-impl
+Cflags: -I${includedir}/${module_name}
TARGET_LINK_LIBRARIES(${TARGET_NAME}
${TARGET_IMPL_NAME}
- "-Wl,--no-as-needed" ${application_config}
)
INSTALL(TARGETS ${TARGET_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
#include <JSUtil.h>
#include <TimeTracer.h>
-#include "plugin_config.h"
#include "JSAlarmAbsolute.h"
#include "JSAlarmManager.h"
#include <Export.h>
#include <Logger.h>
+#define ALARM_FUNCTION_API_GET_NEXT_SCHEDULED_DATE "getNextScheduledDate"
+
namespace DeviceAPI {
namespace Alarm {
#include <ArgumentValidator.h>
#include <JSUtil.h>
+#include <Security.h>
#include <SecurityExceptions.h>
#include <Commons/Exception.h>
#include <ail.h>
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
#include "AlarmConverter.h"
#include "JSAlarmAbsolute.h"
#include "AlarmAbsolute.h"
void JSAlarmManager::initialize(JSContextRef ctx, JSObjectRef object)
{
gContext = ctx;
+
+ SecurityAccessor *priv = new SecurityAccessor();
+ JSObjectSetPrivate(object, static_cast<void*>(priv));
}
void JSAlarmManager::finalize(JSObjectRef object)
{
+ SecurityAccessor *priv = static_cast<SecurityAccessor*>(JSObjectGetPrivate(object));
+ delete priv;
}
JSValueRef JSAlarmManager::add(JSContextRef ctx, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
std::string applicationId;
std::string page;
+ SecurityAccessor *thisPriv = static_cast<SecurityAccessor*>(JSObjectGetPrivate(thisObject));
+ if (!thisPriv) {
+ LoggerE("private object is null");
+ return JSWebAPIErrorFactory::postException(ctx, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
+ }
TIME_TRACER_ITEM_BEGIN("(add)ace_check", 0);
- AceSecurityStatus status = ALARM_CHECK_ACCESS(ALARM_FUNCTION_API_ADD);
- TIZEN_SYNC_ACCESS_HANDLER(status, ctx, exception);
+ TIZEN_CHECK_ACCESS(ctx, exception, thisPriv, ALARM_FUNCTION_API_ADD);
TIME_TRACER_ITEM_END("(add)ace_check", 0);
try {
JSValueRef JSAlarmManager::remove(JSContextRef ctx, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
+ SecurityAccessor *thisPriv = static_cast<SecurityAccessor*>(JSObjectGetPrivate(thisObject));
+ if (!thisPriv) {
+ LoggerE("private object is null");
+ return JSWebAPIErrorFactory::postException(ctx, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
+ }
TIME_TRACER_ITEM_BEGIN("(add)ace_check", 0);
- AceSecurityStatus status = ALARM_CHECK_ACCESS(ALARM_FUNCTION_API_REMOVE);
- TIZEN_SYNC_ACCESS_HANDLER(status, ctx, exception);
+ TIZEN_CHECK_ACCESS(ctx, exception, thisPriv, ALARM_FUNCTION_API_REMOVE);
TIME_TRACER_ITEM_END("(add)ace_check", 0);
try {
JSValueRef JSAlarmManager::removeAll(JSContextRef ctx, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
+ SecurityAccessor *thisPriv = static_cast<SecurityAccessor*>(JSObjectGetPrivate(thisObject));
+ if (!thisPriv) {
+ LoggerE("private object is null");
+ return JSWebAPIErrorFactory::postException(ctx, exception,
+ JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
+ }
TIME_TRACER_ITEM_BEGIN("(add)ace_check", 0);
- AceSecurityStatus status = ALARM_CHECK_ACCESS(ALARM_FUNCTION_API_REMOVE_ALL);
- TIZEN_SYNC_ACCESS_HANDLER(status, ctx, exception);
+ TIZEN_CHECK_ACCESS(ctx, exception, thisPriv, ALARM_FUNCTION_API_REMOVE_ALL);
TIME_TRACER_ITEM_END("(add)ace_check", 0);
TIME_TRACER_ITEM_BEGIN("(removeAll)alarm_cancel_all", 0);
#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
-#include "plugin_config.h"
-
#include "AlarmRelative.h"
#include "AlarmConverter.h"
#include "JSAlarmRelative.h"
#include <Export.h>
#include <Logger.h>
+#define ALARM_FUNCTION_API_GET_REMAINING_SECONDS "getRemainingSeconds"
+
namespace DeviceAPI {
namespace Alarm {
#include <dpl/exception.h>
#include <map>
+#include "plugin_config_impl.h"
#include "plugin_config.h"
#define ALARM_FEATURE_API "http://tizen.org/privilege/alarm"
static FunctionMapping AlarmFunctions =
createAlarmFunctions();
-#pragma GCC visibility push(default)
-
DEFINE_FUNCTION_GETTER(Alarm, AlarmFunctions);
-#pragma GCC visibility pop
-
static FunctionMapping createAlarmFunctions()
{
/**
-//\r
-// Tizen Web Device API\r
-// Copyright (c) 2012 Samsung Electronics Co., Ltd.\r
-//\r
-// Licensed under the Apache License, Version 2.0 (the License);\r
-// you may not use this file except in compliance with the License.\r
-// You may obtain a copy of the License at\r
-//\r
-// http://www.apache.org/licenses/LICENSE-2.0\r
-//\r
-// Unless required by applicable law or agreed to in writing, software\r
-// distributed under the License is distributed on an AS IS BASIS,\r
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
-// See the License for the specific language governing permissions and\r
-// limitations under the License.\r
-//\r
-\r
-#ifndef _ALARM_PLUGIN_CONFIG_H_\r
-#define _ALARM_PLUGIN_CONFIG_H_\r
-\r
-#include <string>\r
-#include <Commons/FunctionDeclaration.h>\r
-\r
-#define ALARM_FUNCTION_API_GET_ALL "getAll"\r
-#define ALARM_FUNCTION_API_GET "get"\r
-#define ALARM_FUNCTION_API_ADD "add"\r
-#define ALARM_FUNCTION_API_REMOVE "remove"\r
-#define ALARM_FUNCTION_API_REMOVE_ALL "removeAll"\r
-#define ALARM_FUNCTION_API_GET_NEXT_SCHEDULED_DATE "getNextScheduledDate"\r
-#define ALARM_FUNCTION_API_GET_REMAINING_SECONDS "getRemainingSeconds"\r
-\r
-namespace DeviceAPI {\r
-namespace Alarm {\r
-\r
-DECLARE_FUNCTION_GETTER(Alarm);\r
-\r
-#define ALARM_CHECK_ACCESS(functionName) \\r
- aceCheckAccess<AceFunctionGetter, DefaultArgsVerifier<> >( \\r
- getAlarmFunctionData, \\r
- functionName)\r
-}\r
-}\r
-#endif\r
-\r
+//
+// 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 _ALARM_PLUGIN_CONFIG_H_
+#define _ALARM_PLUGIN_CONFIG_H_
+
+#include <string>
+#include <Commons/FunctionDeclaration.h>
+
+namespace DeviceAPI {
+namespace Alarm {
+
+DECLARE_FUNCTION_GETTER(Alarm);
+
+#define ALARM_CHECK_ACCESS(functionName) \
+ aceCheckAccess<AceFunctionGetter, DefaultArgsVerifier<> >( \
+ getAlarmFunctionData, \
+ functionName)
+}
+}
+#endif
+
--- /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 _ALARM_PLUGIN_CONFIG_IMPL_H_
+#define _ALARM_PLUGIN_CONFIG_IMPL_H_
+
+#define ALARM_FUNCTION_API_GET_ALL "getAll"
+#define ALARM_FUNCTION_API_GET "get"
+#define ALARM_FUNCTION_API_ADD "add"
+#define ALARM_FUNCTION_API_REMOVE "remove"
+#define ALARM_FUNCTION_API_REMOVE_ALL "removeAll"
+#define ALARM_FUNCTION_API_GET_NEXT_SCHEDULED_DATE "getNextScheduledDate"
+#define ALARM_FUNCTION_API_GET_REMAINING_SECONDS "getRemainingSeconds"
+
+#endif
#include "JSAlarmAbsolute.h"
#include "JSAlarmRelative.h"
#include <Logger.h>
+#include <Security.h>
+#include "plugin_config.h"
#define WRT_JS_EXTENSION_OBJECT_TIZEN "tizen"
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
+AceSecurityStatus alarmAceCheckAccessFunction(const char* functionName)
+{
+ return ALARM_CHECK_ACCESS(functionName);
+}
+
+DEFINE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
+
+DEFINE_SECURITY_ACCESSOR_SETTER(AceCheckerAlarmSetter,
+ DeviceAPI::Common::SecurityAccessor,
+ gSecurityAccessor);
+
+class_definition_options_t ClassOptions =
+{
+ JS_CLASS,
+ NONE,
+ ALWAYS_NOTICE,
+ IGNORED,
+ AceCheckerAlarmSetter,
+ NULL,
+ NULL
+};
+
class_definition_options_t ConstructorClassOptions =
{
JS_INTERFACE,
{
LoggerE("WrtAccess initialization failed");
}
+
+ INITAILIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor, alarmAceCheckAccessFunction);
}
void on_widget_stop_callback(int widgetId)
{
LoggerE("WrtAccess deinitialization failed");
}
+
+ FINALIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
}
PLUGIN_ON_WIDGET_START(on_widget_start_callback)
WRT_JS_EXTENSION_OBJECT_TIZEN,
"alarm",
(js_class_template_getter)DeviceAPI::Alarm::JSAlarmManager::getClassRef,
- NULL)
+ &ClassOptions)
PLUGIN_CLASS_MAP_ADD_INTERFACE(
WRT_JS_EXTENSION_OBJECT_TIZEN,
TIZEN_ALARM_ABSOLUTE_INTERFACE,
ret = package_info_foreach_app_from_package(package_info, PACKAGE_INFO_ALLAPP, app_callback, user_data);
if (ret != PACKAGE_MANAGER_ERROR_NONE) {
LoggerE("failed while getting appids");
+ package_info_destroy(package_info);
return;
}
EventApplicationGetAppsContextEventAnswerReceiver(ThreadEnum::NULL_THREAD),
EventApplicationGetAppsInfoEventAnswerReceiver(ThreadEnum::NULL_THREAD),
EventApplicationAppInfoEventListenerListener(ThreadEnum::NULL_THREAD),
+ SecurityAccessor(),
ApplicationPrivObject(context, application)
{
if (!application) {
#include <CommonsJavaScript/PrivateObject.h>
#include <CommonsJavaScript/JSPendingOperationPrivateObject.h>
#include <CommonsJavaScript/JSPendingOperation.h>
+#include <Security.h>
#include "IApplicationManager.h"
namespace DeviceAPI {
public EventApplicationGetAppsContextEventAnswerReceiver,
public EventApplicationGetAppsInfoEventAnswerReceiver,
public EventApplicationAppInfoEventListenerListener,
+ public DeviceAPI::Common::SecurityAccessor,
public ApplicationPrivObject
{
public:
TIME_TRACER_ITEM_END("(getAppCerts)package_info_foreach_cert_info", 0);
if ((result != PACKAGE_MANAGER_ERROR_NONE) && (result != PACKAGE_MANAGER_ERROR_IO_ERROR))
{
+ package_info_destroy(pkg_info);
ThrowMsg(UnknownException, "Can not get package cert info");
}
+ TIME_TRACER_ITEM_BEGIN("(getAppCerts)package_info_destroy", 0);
+ result = package_info_destroy(pkg_info);
+ TIME_TRACER_ITEM_END("(getAppCerts)package_info_destroy", 0);
+ if (result != PACKAGE_MANAGER_ERROR_NONE)
+ {
+ LoggerE("Failed to destroy package_info");
+ }
+
return certArray;
}
SET(TARGET_NAME ${application_target})
SET(DESTINATION_NAME ${application_dest})
SET(TARGET_IMPL_NAME ${application_impl})
-SET(TARGET_CONFIG_NAME ${application_config})
PKG_CHECK_MODULES(platform_pkgs_application REQUIRED
capi-appfw-app-manager
${platform_pkgs_application_LIBRARIES}
)
-SET(SRCS_CONFIG
- plugin_config.cpp
-)
-
-ADD_LIBRARY(${TARGET_CONFIG_NAME} SHARED ${SRCS_CONFIG})
-
-TARGET_LINK_LIBRARIES(${TARGET_CONFIG_NAME}
- ${LIBS_COMMON}
-)
-
SET(SRCS
+ plugin_config.cpp
plugin_initializer.cpp
)
TARGET_LINK_LIBRARIES(${TARGET_NAME}
${TARGET_IMPL_NAME}
- ${TARGET_CONFIG_NAME}
)
-INSTALL(TARGETS ${TARGET_NAME} ${TARGET_CONFIG_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
+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})
INSTALL(
DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${DESTINATION_HEADER_PREFIX}/application
#include <JSWebAPIErrorFactory.h>
#include "ApplicationFactory.h"
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
#include "ApplicationController.h"
#include "JSApplicationManager.h"
#include "ApplicationConverter.h"
#include <TimeTracer.h>
#include <Export.h>
#include <Logger.h>
+#include <Security.h>
#include <plugins-ipc-message/ipc_message_support.h>
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
TIME_TRACER_ITEM_BEGIN("launch(async)", 0);
- TIME_TRACER_ITEM_BEGIN("launch(ACE)", 0);
- AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_LAUNCH);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
- TIME_TRACER_ITEM_END("launch(ACE)", 0);
-
try {
IApplicationManagerPtr appmgr;
JSContextRef gContext;
appmgr = controller->getObject();
gContext = controller->getContext();
+ TIME_TRACER_ITEM_BEGIN("launch(ACE)", 0);
+ TIZEN_CHECK_ACCESS(context, exception, controller, APPLICATION_FUNCTION_API_LAUNCH);
+ TIME_TRACER_ITEM_END("launch(ACE)", 0);
+
EventApplicationLaunchPtr event(new EventApplicationLaunch());
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
TIME_TRACER_ITEM_BEGIN("kill(async)", 0);
- TIME_TRACER_ITEM_BEGIN("kill(ACE)", 0);
- AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_KILL);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
- TIME_TRACER_ITEM_END("kill(ACE)", 0);
-
try {
IApplicationManagerPtr appmgr;
JSContextRef gContext;
appmgr = controller->getObject();
gContext = controller->getContext();
+ TIME_TRACER_ITEM_BEGIN("kill(ACE)", 0);
+ TIZEN_CHECK_ACCESS(context, exception, controller, APPLICATION_FUNCTION_API_KILL);
+ TIME_TRACER_ITEM_END("kill(ACE)", 0);
+
EventApplicationKillPtr event(new EventApplicationKill());
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
ArgumentValidator validator(context, argumentCount, arguments);
TIME_TRACER_ITEM_BEGIN("launchAppControl(async)", 0);
TIME_TRACER_ITEM_BEGIN("launchAppControlReply(async)", 0);
- TIME_TRACER_ITEM_BEGIN("launchAppControl(ACE)", 0);
- AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_LAUNCH_APP_CONTROL);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
- TIME_TRACER_ITEM_END("launchAppControl(ACE)", 0);
-
try {
IApplicationManagerPtr appmgr;
JSContextRef gContext;
appmgr = controller->getObject();
gContext = controller->getContext();
+ TIME_TRACER_ITEM_BEGIN("launchAppControl(ACE)", 0);
+ TIZEN_CHECK_ACCESS(context, exception, controller, APPLICATION_FUNCTION_API_LAUNCH_APP_CONTROL);
+ TIME_TRACER_ITEM_END("launchAppControl(ACE)", 0);
EventApplicationLaunchAppControlPtr event(new EventApplicationLaunchAppControl());
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- TIME_TRACER_ITEM_BEGIN("(getAppCerts)ACE", 0);
- AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_GET_APP_CERTS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
- TIME_TRACER_ITEM_END("(getAppCerts)ACE", 0);
-
try {
+ ApplicationController *controller;
+ controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
+ if (!controller) {
+ throw TypeMismatchException("No private object.");
+ }
+
+ TIME_TRACER_ITEM_BEGIN("getAppCerts(ACE)", 0);
+ TIZEN_CHECK_ACCESS(context, exception, controller, APPLICATION_FUNCTION_API_GET_APP_CERTS);
+ TIME_TRACER_ITEM_END("getAppCerts(ACE)", 0);
+
ArgumentValidator validator(context, argumentCount, arguments);
ApplicationCertArrayPtr result = ApplicationManager::getAppCerts(validator.toString(0, true, ""));
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- TIME_TRACER_ITEM_BEGIN("(getAppMetaData)ACE", 0);
- AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_GET_APP_META_DATA);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
- TIME_TRACER_ITEM_END("(getAppMetaData)ACE", 0);
-
try {
+ ApplicationController *controller;
+ controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
+ if (!controller) {
+ throw TypeMismatchException("No private object.");
+ }
+
+ TIME_TRACER_ITEM_BEGIN("getAppMetaData(ACE)", 0);
+ TIZEN_CHECK_ACCESS(context, exception, controller, APPLICATION_FUNCTION_API_GET_APP_META_DATA);
+ TIME_TRACER_ITEM_END("getAppMetaData(ACE)", 0);
+
ArgumentValidator validator(context, argumentCount, arguments);
ApplicationMetaDataArrayPtr result = ApplicationManager::getAppMetaData(validator.toString(0, true, ""));
#define TIZEN_INTERFACE_APPLICATION_MANAGER "ApplicationManager"
-typedef WrtDeviceApis::CommonsJavaScript::PrivateObject
- <IApplicationManagerPtr, WrtDeviceApis::CommonsJavaScript::NoOwnership> JSApplicationManagerPriv;
-
class JSApplicationManager {
public:
static const JSClassDefinition* getClassInfo();
static FunctionMapping ApplicationFunctions =
createApplicationFunctions();
-#pragma GCC visibility push(default)
-
DEFINE_FUNCTION_GETTER(Application, ApplicationFunctions);
-#pragma GCC visibility pop
-
static FunctionMapping createApplicationFunctions()
{
/**
-//\r
-// Tizen Web Device API\r
-// Copyright (c) 2012 Samsung Electronics Co., Ltd.\r
-//\r
-// Licensed under the Apache License, Version 2.0 (the License);\r
-// you may not use this file except in compliance with the License.\r
-// You may obtain a copy of the License at\r
-//\r
-// http://www.apache.org/licenses/LICENSE-2.0\r
-//\r
-// Unless required by applicable law or agreed to in writing, software\r
-// distributed under the License is distributed on an AS IS BASIS,\r
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
-// See the License for the specific language governing permissions and\r
-// limitations under the License.\r
-//\r
-\r
-\r
-#ifndef _APPLICATOIN_PLUGIN_CONFIG_H_\r
-#define _APPLICATOIN_PLUGIN_CONFIG_H_\r
-\r
-#include <string>\r
-#include <Commons/FunctionDeclaration.h>\r
-\r
-// feature : launch\r
-#define APPLICATION_FUNCTION_API_LAUNCH "launch"\r
-#define APPLICATION_FUNCTION_API_LAUNCH_APP_CONTROL "launchAppControl"\r
-\r
-// feature : kill - public candidate\r
-#define APPLICATION_FUNCTION_API_KILL "kill"\r
-\r
-// feature : certificate - public candidate\r
-#define APPLICATION_FUNCTION_API_GET_APP_CERTS "getAppCerts"\r
-\r
-// no feature required\r
-#define APPLICATION_FUNCTION_API_GET_APPS_INFO "getAppsInfo"\r
-#define APPLICATION_FUNCTION_API_GET_APP_INFO "getAppInfo"\r
-#define APPLICATION_FUNCTION_API_GET_APPS_CONTEXT "getAppsContext"\r
-#define APPLICATION_FUNCTION_API_GET_APP_CONTEXT "getAppContext"\r
-#define APPLICATION_FUNCTION_API_FIND_APP_CONTROL "findAppControl"\r
-#define APPLICATION_FUNCTION_API_ADD_APP_INFO_EVENT_LISTENER "addAppInfoEventListener"\r
-#define APPLICATION_FUNCTION_API_REMOVE_APP_INFO_EVENT_LISTENER "removeAppInfoEventListener"\r
-#define APPLICATION_FUNCTION_API_GET_CURRENT_APP "getCurrentApplication"\r
-#define APPLICATION_FUNCTION_API_GET_REQUESTED_APP_CONTROL "getRequestedAppControl"\r
-#define APPLICATION_FUNCTION_API_EXIT "exit"\r
-#define APPLICATION_FUNCTION_API_HIDE "hide"\r
-#define APPLICATION_FUNCTION_API_REPLY_RESULT "replyResult"\r
-#define APPLICATION_FUNCTION_API_REPLY_FAILURE "replyFailure"\r
-#define APPLICATION_FUNCTION_API_GET_APP_SHARED_URI "getAppSharedURI"\r
-#define APPLICATION_FUNCTION_API_GET_APP_META_DATA "getAppMetaData"\r
-#define APPLICATION_FUNCTION_API_SET_USER_AGENT "setUserAgent"\r
-\r
-namespace DeviceAPI {\r
-namespace Application {\r
-\r
-DECLARE_FUNCTION_GETTER(Application);\r
-\r
-#define APPLICATION_CHECK_ACCESS(functionName) \\r
- aceCheckAccess<AceFunctionGetter, DefaultArgsVerifier<> >( \\r
- getApplicationFunctionData, \\r
- functionName)\r
-\r
-}\r
-}\r
-#endif\r
-\r
+//
+// 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 _APPLICATOIN_PLUGIN_CONFIG_H_
+#define _APPLICATOIN_PLUGIN_CONFIG_H_
+
+#include <string>
+#include <Commons/FunctionDeclaration.h>
+#include "plugin_config_impl.h"
+
+namespace DeviceAPI {
+namespace Application {
+
+DECLARE_FUNCTION_GETTER(Application);
+
+#define APPLICATION_CHECK_ACCESS(functionName) \
+ aceCheckAccess<AceFunctionGetter, DefaultArgsVerifier<> >( \
+ getApplicationFunctionData, \
+ functionName)
+
+}
+}
+#endif
+
--- /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 _APPLICATOIN_PLUGIN_CONFIG_IMPL_H_
+#define _APPLICATOIN_PLUGIN_CONFIG_IMPL_H_
+
+// feature : launch
+#define APPLICATION_FUNCTION_API_LAUNCH "launch"
+#define APPLICATION_FUNCTION_API_LAUNCH_APP_CONTROL "launchAppControl"
+
+// feature : kill - public candidate
+#define APPLICATION_FUNCTION_API_KILL "kill"
+
+// feature : certificate - public candidate
+#define APPLICATION_FUNCTION_API_GET_APP_CERTS "getAppCerts"
+
+// no feature required
+#define APPLICATION_FUNCTION_API_GET_APPS_INFO "getAppsInfo"
+#define APPLICATION_FUNCTION_API_GET_APP_INFO "getAppInfo"
+#define APPLICATION_FUNCTION_API_GET_APPS_CONTEXT "getAppsContext"
+#define APPLICATION_FUNCTION_API_GET_APP_CONTEXT "getAppContext"
+#define APPLICATION_FUNCTION_API_FIND_APP_CONTROL "findAppControl"
+#define APPLICATION_FUNCTION_API_ADD_APP_INFO_EVENT_LISTENER "addAppInfoEventListener"
+#define APPLICATION_FUNCTION_API_REMOVE_APP_INFO_EVENT_LISTENER "removeAppInfoEventListener"
+#define APPLICATION_FUNCTION_API_GET_CURRENT_APP "getCurrentApplication"
+#define APPLICATION_FUNCTION_API_GET_REQUESTED_APP_CONTROL "getRequestedAppControl"
+#define APPLICATION_FUNCTION_API_EXIT "exit"
+#define APPLICATION_FUNCTION_API_HIDE "hide"
+#define APPLICATION_FUNCTION_API_REPLY_RESULT "replyResult"
+#define APPLICATION_FUNCTION_API_REPLY_FAILURE "replyFailure"
+#define APPLICATION_FUNCTION_API_GET_APP_SHARED_URI "getAppSharedURI"
+#define APPLICATION_FUNCTION_API_GET_APP_META_DATA "getAppMetaData"
+#define APPLICATION_FUNCTION_API_SET_USER_AGENT "setUserAgent"
+
+#endif
+
#include <sys/types.h>
#include <unistd.h>
#include <TimeTracer.h>
+#include <Security.h>
#include "JSApplicationManager.h"
#include "JSApplicationControl.h"
#include "ApplicationAsyncCallbackManager.h"
#include "ApplicationListenerManager.h"
#include "AppManagerWrapper.h"
+#include "plugin_config.h"
#include <Logger.h>
using namespace WrtDeviceApis;
namespace DeviceAPI {
namespace Application {
+AceSecurityStatus applicationAceCheckAccessFunction(const char* functionName)
+{
+ return APPLICATION_CHECK_ACCESS(functionName);
+}
+
+DEFINE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
+
+DEFINE_SECURITY_ACCESSOR_SETTER(AceCheckerApplicationSetter, ApplicationController, gSecurityAccessor);
+
class_definition_options_t ApplicationOptions =
{
+ JS_CLASS,
+ NONE,
+ ALWAYS_NOTICE,
+ IGNORED,
+ AceCheckerApplicationSetter,
+ NULL,
+ NULL
+};
+
+class_definition_options_t ApplicationConstructorOptions =
+{
JS_INTERFACE,
CREATE_INSTANCE,
NONE_NOTICE,
} Catch(WrtDeviceApis::Commons::Exception) {
LoggerE("WrtAccess initialization failed");
}
+
+ INITAILIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor, applicationAceCheckAccessFunction);
}
void on_widget_stop_callback(int widgetId) {
} Catch(WrtDeviceApis::Commons::Exception) {
LoggerE("WrtAccess deinitialization failed");
}
+
+ FINALIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
}
void on_frame_load_callback(const void * context)
WRT_JS_EXTENSION_OBJECT_TIZEN,
"application",
(js_class_template_getter)DeviceAPI::Application::JSApplicationManager::getClassRef,
- NULL)
+ &ApplicationOptions)
PLUGIN_CLASS_MAP_ADD_INTERFACE(
WRT_JS_EXTENSION_OBJECT_TIZEN,
TIZEN_INTERFACE_APPLICATION_CONTROL,
(js_class_template_getter)DeviceAPI::Application::JSApplicationControl::getClassRef,
reinterpret_cast<js_class_constructor_cb_t>(JSApplicationControl::constructor),
- &ApplicationOptions)
+ &ApplicationConstructorOptions)
PLUGIN_CLASS_MAP_ADD_INTERFACE(
WRT_JS_EXTENSION_OBJECT_TIZEN,
TIZEN_INTERFACE_APPLICATION_CONTROL_DATA,
(js_class_template_getter)DeviceAPI::Application::JSApplicationControlData::getClassRef,
reinterpret_cast<js_class_constructor_cb_t>(JSApplicationControlData::constructor),
- &ApplicationOptions)
+ &ApplicationConstructorOptions)
PLUGIN_CLASS_MAP_END
#include <JSWebAPIErrorFactory.h>
#include <JSUtil.h>
#include <TimeTracer.h>
-
+#include "plugin_config_impl.h"
#include "BluetoothAdapter.h"
#include "BluetoothCallbackUtil.h"
#include "JSBluetoothDevice.h"
if(result == BT_ERROR_NONE) {
// create BluetoothDevice
BluetoothDeviceSharedPtr device(new BluetoothDevice(discoveryInfo));
+ device->copyAceCheckAccessFunction(getInstance());
JSContextRef context = callback->getContext();
JSObjectRef deviceObj = JSBluetoothDevice::createJSObject(context, device);
object->mFoundDevices.push_back(device);
if(iter == adapter->knownDevices.end()) {
BluetoothDeviceSharedPtr device(new BluetoothDevice(deviceInfo));
+ device->copyAceCheckAccessFunction(getInstance());
adapter->knownDevices.push_back(device);
}
if(result == BT_ERROR_NONE && deviceInfo != NULL) {
if(callback) {
BluetoothDeviceSharedPtr device(new BluetoothDevice(deviceInfo));
+ device->copyAceCheckAccessFunction(getInstance());
JSContextRef context = callback->getContext();
JSObjectRef deviceObj = JSBluetoothDevice::createJSObject(context, device);
callback->invokeCallback("success", deviceObj);
service->setConnectionState(true);
// Call BluetoothServiceHandler.onconnect
- BluetoothSocketPtr socket = new BluetoothSocket(connection);
+ BluetoothSocketPtr socket = new BluetoothSocket(connection, getInstance());
MultiCallbackUserDataPtr callback = service->getOnConnect();
JSContextRef context = callback->getContext();
JSObjectRef socketObj = JSBluetoothSocket::createJSObject(context, socket);
if(result == BT_ERROR_NONE) {
// Update mConnectedSocket
- BluetoothSocketPtr socket = new BluetoothSocket(connection);
+ BluetoothSocketPtr socket = new BluetoothSocket(connection, getInstance());
+
object->mConnectedSocket.insert(std::pair<int, BluetoothSocketPtr>(connection->socket_fd, socket));
bt_socket_set_data_received_cb(onSocketReceivedCB, userData);
BluetoothAdapter::BluetoothAdapter():
mEnabled(false), mVisible(false)
{
+ Common::SecurityAccessor();
+
bt_adapter_state_e state;
if (bt_adapter_get_state(&state) == BT_ERROR_NONE) {
if (state == BT_ADAPTER_ENABLED) {
mConnReqMap.clear();
mFoundDevices.clear();
mConnectedSocket.clear();
+
+
}
void BluetoothAdapter::unloadFrame(JSContextRef context)
knownDevices = mFoundDevices;
if(bt_adapter_foreach_bonded_device(foreachBondedDevicesCB, this) == BT_ERROR_NONE) {
if(knownDevices.size() > 0) { // There are found devices
- LoggerD("There are found devices");
+
int num = knownDevices.size();
+ LoggerD("There are found devices " << num);
JSObjectRef devices[num];
for(int i = 0; i < num; i++) {
- JSObjectRef deviceObj = JSBluetoothDevice::createJSObject(userData->getContext(), knownDevices[i]);
+ JSObjectRef deviceObj = JSBluetoothDevice::createJSObject(userData->getContext(), knownDevices[i]);
devices[i] = deviceObj;
}
deviceInfo != NULL) {
TIME_TRACER_ITEM_END("returnDevice::bt_adapter_get_bonded_device_info", 1);
BluetoothDeviceSharedPtr device(new BluetoothDevice(deviceInfo));
+ device->copyAceCheckAccessFunction(getInstance());
bt_adapter_free_device_info(deviceInfo);
LoggerD("invoke successCallback");
bt_socket_set_connection_state_changed_cb(onSocketConnected, this);
BluetoothServiceHandlerPtr serviceHandler = new BluetoothServiceHandler(uuid, name, socket);
+ serviceHandler->copyAceCheckAccessFunction(getInstance());
mRegisteredUUID.insert(std::pair<std::string, BluetoothServiceHandlerPtr>(uuid, serviceHandler));
JSObjectRef serviceObj = JSBluetoothServiceHandler::createJSObject(userData->getContext(), serviceHandler);
}
+
+
+
} // Bluetooth
} // DeviceAPI
#include <map>
#include <bluetooth.h>
-
+#include <Security.h>
#include <MultiCallbackUserData.h>
#include <PlatformException.h>
-
#include "BluetoothDevice.h"
#include "BluetoothServiceHandler.h"
#include "BluetoothSocket.h"
};
typedef BluetoothConnReq* BluetoothConnReqPtr;
-class BluetoothAdapter
+class BluetoothAdapter : public Common::SecurityAccessor
{
public:
enum adapterAsyncE
static bool isValidAddress(std::string &address);
static bool isValidUUID(std::string &uuid);
void unloadFrame(JSContextRef context);
-
private:
BluetoothAdapter();
virtual ~BluetoothAdapter();
std::vector<BluetoothDeviceSharedPtr> mFoundDevices;
std::vector<BluetoothDeviceSharedPtr> knownDevices;
Common::MultiCallbackUserDataPtr mChangeListener;
+
};
typedef BluetoothAdapter* BluetoothAdapterPtr;
BluetoothClass::BluetoothClass(bt_class_s bluetoothClass)
{
+ Common::SecurityAccessor();
mMajor = BluetoothClassDeviceMajor::getInstance()->getMajorValue(bluetoothClass.major_device_class);
mMinor = BluetoothClassDeviceMinor::getInstance()->getMinorValue(bluetoothClass.minor_device_class);
mServices= BluetoothClassDeviceService::getInstance()->getServiceValues(bluetoothClass.major_service_class_mask);
#include <JavaScriptCore/JavaScript.h>
#include <bluetooth.h>
-
+#include <Security.h>
#include <boost/shared_ptr.hpp>
#include <PropertyBag.h>
namespace DeviceAPI {
namespace Bluetooth {
-class BluetoothClass
+class BluetoothClass : public Common::SecurityAccessor
{
public:
BluetoothClass(bt_class_s bluetoothClass);
BluetoothDevice::BluetoothDevice(bt_adapter_device_discovery_info_s *discoveryInfo)
{
+ Common::SecurityAccessor();
mName = std::string(discoveryInfo->remote_name);
mAddress = std::string(discoveryInfo->remote_address);
mDeviceClass = BluetoothClassSharedPtr(new BluetoothClass(discoveryInfo->bt_class));
BluetoothDevice::BluetoothDevice(bt_device_info_s *deviceInfo)
{
+ Common::SecurityAccessor();
mName = std::string(deviceInfo->remote_name);
mAddress = std::string(deviceInfo->remote_address);
mDeviceClass = BluetoothClassSharedPtr(new BluetoothClass(deviceInfo->bt_class));
+
for(int i = 0; i < deviceInfo->service_count; i++) {
mUUIDs.push_back(std::string(deviceInfo->service_uuid[i]));
}
return mAddress;
}
+void BluetoothDevice::copyAceCheckAccessFunction(const Common::SecurityAccessor *securityAccessor)
+{
+ Common::SecurityAccessor::copyAceCheckAccessFunction(securityAccessor);
+ mDeviceClass->copyAceCheckAccessFunction(securityAccessor);
+}
+
JSValueRef BluetoothDevice::getDeviceClass(JSContextRef context)
{
/*
#include <bluetooth.h>
#include <boost/shared_ptr.hpp>
#include <PropertyBag.h>
-
+#include <Security.h>
#include "BluetoothClass.h"
namespace DeviceAPI {
namespace Bluetooth {
-class BluetoothDevice
+class BluetoothDevice : public Common::SecurityAccessor
{
public:
BluetoothDevice(bt_adapter_device_discovery_info_s *discoveryInfo);
bool isTrusted() const;
bool isConnected() const;
JSValueRef getUUIDs(JSContextRef context);
-
+ void copyAceCheckAccessFunction(const Common::SecurityAccessor *securityAccessor);
private:
std::string mName;
std::string mAddress;
BluetoothHealthApplication::BluetoothHealthApplication(std::string appID, std::string name, unsigned short dataType)
{
+ Common::SecurityAccessor();
mAppID = appID;
mName = name;
mDataType = dataType;
#include <MultiCallbackUserData.h>
#include <PropertyBag.h>
+#include <Security.h>
namespace DeviceAPI {
namespace Bluetooth {
-class BluetoothHealthApplication
+class BluetoothHealthApplication : public Common::SecurityAccessor
{
public:
BluetoothHealthApplication(std::string appID, std::string name, unsigned short dataType);
BluetoothHealthChannel::BluetoothHealthChannel(unsigned int channel, BluetoothDeviceSharedPtr remoteDevice,
bt_hdp_channel_type_e type, BluetoothHealthApplicationSharedPtr application)
{
+ Common::SecurityAccessor();
mChannel = channel;
mRemoteDevice = remoteDevice;
if(type == BT_HDP_CHANNEL_TYPE_RELIABLE) {
#include <string>
#include <bluetooth.h>
#include <JavaScriptCore/JavaScript.h>
-
+#include <Security.h>
#include <MultiCallbackUserData.h>
#include "BluetoothDevice.h"
#include "BluetoothHealthApplication.h"
namespace DeviceAPI {
namespace Bluetooth {
-class BluetoothHealthChannel
+class BluetoothHealthChannel : public Common::SecurityAccessor
{
public:
BluetoothHealthChannel(unsigned int channel, BluetoothDeviceSharedPtr remoteDevice, bt_hdp_channel_type_e type, BluetoothHealthApplicationSharedPtr application);
if(bt_adapter_get_bonded_device_info(remote_address, &deviceInfo) == BT_ERROR_NONE &&
deviceInfo != NULL) {
BluetoothDeviceSharedPtr device(new BluetoothDevice(deviceInfo));
+ // need to check
+ device->copyAceCheckAccessFunction(getInstance());
bt_adapter_free_device_info(deviceInfo);
LoggerD("invoke BluetoothHealthApplication.onconnect");
healthChannel = new BluetoothHealthChannel(channel, device, type, application);
+ healthChannel->copyAceCheckAccessFunction(getInstance());
object->mConnectedSocketMap.insert(std::pair<unsigned int, BluetoothHealthChannelPtr>(channel, healthChannel));
isChannelInserted = true;
callback->invokeCallback("onconnect", JSBluetoothHealthChannel::createJSObject(callback->getContext(), healthChannel));
if(result == BT_ERROR_NONE) {
if(isChannelInserted == false) {
healthChannel = new BluetoothHealthChannel(channel, i->second->mRemoteDevice, type, application);
+ healthChannel->copyAceCheckAccessFunction(getInstance());
object->mConnectedSocketMap.insert(std::pair<unsigned int, BluetoothHealthChannelPtr>(channel, healthChannel));
}
callback->invokeCallback("success", JSBluetoothHealthChannel::createJSObject(callback->getContext(), healthChannel));
BluetoothHealthProfileHandler::BluetoothHealthProfileHandler()
{
+ Common::SecurityAccessor();
+
if(bt_hdp_set_connection_state_changed_cb(onConnected, onDisconnected, this) != BT_ERROR_NONE) {
LoggerE("bt_hdp_set_connection_state_changed_cb() failed");
}
}
}
+
BluetoothHealthProfileHandler::~BluetoothHealthProfileHandler()
{
// unset platform callback
std::string appID(app_id);
//free(app_id);
BluetoothHealthApplicationSharedPtr application(new BluetoothHealthApplication(appID, name, dataType));
+ application->copyAceCheckAccessFunction(getInstance());
+
mRegisteredHealthAppMap.insert(std::pair<std::string, BluetoothHealthApplicationSharedPtr>(appID, application));
if(callback)
callback->invokeCallback("success", JSBluetoothHealthApplication::createJSObject(callback->getContext(), application));
// limitations under the License.
//
-#ifndef __TIZEN_BLUETOOTH_ADAPTER_H__
+#ifndef __TIZEN_HEALTH_PROFILE_HANDLER_H__
#define __TIZEN_HEALTH_PROFILE_HANDLER_H__
#include <string>
};
typedef HealthConnReq* HealthConnReqPtr;
-class BluetoothHealthProfileHandler
+class BluetoothHealthProfileHandler : public Common::SecurityAccessor
{
public:
static BluetoothHealthProfileHandler* getInstance();
void unregisterApp(std::string appID, Common::MultiCallbackUserDataPtr callback);
void returnUnregisteringAppResult(std::string appID, Common::MultiCallbackUserDataPtr callback);
void connectToSource(JSObjectRef remoteDeviceObj, JSObjectRef appObj, Common::MultiCallbackUserDataPtr callback);
-
+
private:
BluetoothHealthProfileHandler();
virtual ~BluetoothHealthProfileHandler();
typedef std::map<BluetoothHealthApplicationSharedPtr, HealthConnReqPtr> HealthConnReqMapT;
typedef std::map<unsigned int, BluetoothHealthChannelPtr> HealthConnectedSocketMapT; // <channel, BluetoothHealthChannelPtr>
typedef std::map<std::string, BluetoothHealthApplicationSharedPtr> RegisteredHealthAppMapT; // <app_id, BluetoothHealthApplicationSharedPtr>
-
+
+
HealthConnReqMapT mHealthConnReqMap;
HealthConnectedSocketMapT mConnectedSocketMap;
RegisteredHealthAppMapT mRegisteredHealthAppMap;
BluetoothServiceHandler::BluetoothServiceHandler(std::string uuid, std::string name, int registeredSocket)
{
+ Common::SecurityAccessor();
+
mUUID = uuid;
mName = name;
mRegisteredSocket = registeredSocket;
//#include <boost/shared_ptr.hpp>
#include <MultiCallbackUserData.h>
#include <PropertyBag.h>
+#include <Security.h>
namespace DeviceAPI {
namespace Bluetooth {
-class BluetoothServiceHandler
+class BluetoothServiceHandler : public Common::SecurityAccessor
{
public:
BluetoothServiceHandler(std::string uuid, std::string name, int registeredSocket);
namespace DeviceAPI {
namespace Bluetooth {
-BluetoothSocket::BluetoothSocket(bt_socket_connection_s *connection)
+BluetoothSocket::BluetoothSocket(bt_socket_connection_s *connection, Common::SecurityAccessor* accessor)
{
+ Common::SecurityAccessor();
+ Common::SecurityAccessor::copyAceCheckAccessFunction(accessor);
+
mConnectedSocket = connection->socket_fd;
mUUID = std::string(connection->service_uuid);
mIsConnected = true;
-
+
bt_device_info_s *deviceInfo = NULL;
if(bt_adapter_get_bonded_device_info(connection->remote_address, &deviceInfo) == BT_ERROR_NONE && deviceInfo != NULL) {
BluetoothDeviceSharedPtr device(new BluetoothDevice(deviceInfo));
+ device->copyAceCheckAccessFunction(accessor);
mPeer = device;
bt_adapter_free_device_info(deviceInfo);
}
//#include <boost/shared_ptr.hpp>
#include <MultiCallbackUserData.h>
#include <PropertyBag.h>
-
+#include <Security.h>
#include "BluetoothDevice.h"
namespace DeviceAPI {
namespace Bluetooth {
-class BluetoothSocket
+class BluetoothSocket : public Common::SecurityAccessor
{
public:
- BluetoothSocket(bt_socket_connection_s *connection);
+ BluetoothSocket(bt_socket_connection_s *connection, Common::SecurityAccessor* accessor);
virtual ~BluetoothSocket();
std::string getUUID() const;
#include "plugin_config.h"
#include "JSBluetoothAdapter.h"
#include "BluetoothAdapter.h"
+#include "BluetoothHealthProfileHandler.h"
#include "JSBluetoothHealthProfileHandler.h"
#include <system_info.h>
#include <TimeTracer.h>
#include <Logger.h>
-
+#include "plugin_config_impl.h"
using namespace WrtDeviceApis::Commons;
using namespace DeviceAPI::Common;
// Access Check
TIME_TRACER_ITEM_BEGIN("setName::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_ADAPTER_API_SET_NAME);
+ TIZEN_CHECK_ACCESS(context, exception, BluetoothAdapter::getInstance(), BLUETOOTH_ADAPTER_API_SET_NAME);
TIME_TRACER_ITEM_END("setName::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
ArgumentValidator validator(context, argumentCount, arguments);
// Access Check
TIME_TRACER_ITEM_BEGIN("setPowered::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_ADAPTER_API_SET_POWERED);
+ TIZEN_CHECK_ACCESS(context, exception, BluetoothAdapter::getInstance(), BLUETOOTH_ADAPTER_API_SET_POWERED);
TIME_TRACER_ITEM_END("setPowered::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
try {
// Check whether BT is supported or not
// Access Check
TIME_TRACER_ITEM_BEGIN("setVisible::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_ADAPTER_API_SET_VISIBLE);
+ TIZEN_CHECK_ACCESS(context, exception, BluetoothAdapter::getInstance(), BLUETOOTH_ADAPTER_API_SET_VISIBLE);
TIME_TRACER_ITEM_END("setVisible::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
// Validate arguments
// Access Check
TIME_TRACER_ITEM_BEGIN("discoverDevices::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_ADAPTER_API_DISCOVER_DEVICES);
+ TIZEN_CHECK_ACCESS(context, exception, BluetoothAdapter::getInstance(), BLUETOOTH_ADAPTER_API_DISCOVER_DEVICES);
TIME_TRACER_ITEM_END("discoverDevices::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
TIME_TRACER_ITEM_BEGIN("discoverDevices::parameter", 1);
// Access Check
TIME_TRACER_ITEM_BEGIN("stopDiscovery::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_ADAPTER_API_STOP_DISCOVERY);
+ TIZEN_CHECK_ACCESS(context, exception, BluetoothAdapter::getInstance(), BLUETOOTH_ADAPTER_API_STOP_DISCOVERY);
TIME_TRACER_ITEM_END("stopDiscovery::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
// Validate arguments
// Access Check
TIME_TRACER_ITEM_BEGIN("getKnownDevices::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_ADAPTER_API_GET_KNOWN_DEVICES);
+ TIZEN_CHECK_ACCESS(context, exception, BluetoothAdapter::getInstance(), BLUETOOTH_ADAPTER_API_GET_KNOWN_DEVICES);
TIME_TRACER_ITEM_END("getKnownDevices::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
// Validate arguments
// Access Check
TIME_TRACER_ITEM_BEGIN("getDevice::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_ADAPTER_API_GET_DEVICE);
+ TIZEN_CHECK_ACCESS(context, exception, BluetoothAdapter::getInstance(), BLUETOOTH_ADAPTER_API_GET_DEVICE);
TIME_TRACER_ITEM_END("getDevice::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
// Validate arguments
// Access Check
TIME_TRACER_ITEM_BEGIN("createBonding::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_ADAPTER_API_CREATE_BONDING);
+ TIZEN_CHECK_ACCESS(context, exception, BluetoothAdapter::getInstance(), BLUETOOTH_ADAPTER_API_CREATE_BONDING);
TIME_TRACER_ITEM_END("createBonding::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
// Validate arguments
// Access Check
TIME_TRACER_ITEM_BEGIN("destroyBonding::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_ADAPTER_API_DESTROY_BONDING);
+ TIZEN_CHECK_ACCESS(context, exception, BluetoothAdapter::getInstance(), BLUETOOTH_ADAPTER_API_DESTROY_BONDING);
TIME_TRACER_ITEM_END("destroyBonding::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
// Validate arguments
// Access Check
TIME_TRACER_ITEM_BEGIN("registerRFCOMMServiceByUUID::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_ADAPTER_API_REGISTER_RFCOMMSERVICE_BY_UUID);
+ TIZEN_CHECK_ACCESS(context, exception, BluetoothAdapter::getInstance(), BLUETOOTH_ADAPTER_API_REGISTER_RFCOMMSERVICE_BY_UUID);
TIME_TRACER_ITEM_END("registerRFCOMMServiceByUUID::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
// Validate arguments
bool isCorrectParameter = false;
if(type.compare("HEALTH") == 0) {
isCorrectParameter = true;
+ BluetoothHealthProfileHandler::getInstance()->copyAceCheckAccessFunction(BluetoothAdapter::getInstance());
+
profileHandler = JSBluetoothHealthProfileHandler::createJSObject(context);
}
TIME_TRACER_ITEM_END(__FUNCTION__, 1);
#define __TIZEN_JS_BLUETOOTH_ADAPTER_H__
#include <JavaScriptCore/JavaScript.h>
+#include <Security.h>
namespace DeviceAPI {
namespace Bluetooth {
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
- // Access Check
- TIME_TRACER_ITEM_BEGIN("hasService::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_CLASS_API_HAS_SERVICE);
- TIME_TRACER_ITEM_END("hasService::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
try {
// Private Object
BluetoothClassHolderPtr priv = static_cast<BluetoothClassHolderPtr>(JSObjectGetPrivate(thisObject));
if (!priv) {
throw TypeMismatchException("Private object is NULL.");
}
+
+ // Access Check
+ BluetoothClass* btclass = priv->mClass.get();
+ TIME_TRACER_ITEM_BEGIN("hasService::ACE", 1);
+ TIZEN_CHECK_ACCESS(context, exception, btclass, BLUETOOTH_CLASS_API_HAS_SERVICE);
+ TIME_TRACER_ITEM_END("hasService::ACE", 1);
+
ArgumentValidator validator(context, argumentCount, arguments);
unsigned long service = validator.toULong(0); // uuid
namespace DeviceAPI {
namespace Bluetooth {
-class BluetoothClassHolder
+class BluetoothClassHolder
{
public:
- BluetoothClassHolder(BluetoothClassSharedPtr bluetoothClass) {mClass = bluetoothClass;}
+ BluetoothClassHolder(BluetoothClassSharedPtr bluetoothClass) { mClass = bluetoothClass;}
BluetoothClassSharedPtr mClass;
};
typedef BluetoothClassHolder* BluetoothClassHolderPtr;
JSValueRef* exception)
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
-
- // Access Check
- TIME_TRACER_ITEM_BEGIN("connectToServiceByUUID::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_DEVICE_API_CONNECT_TO_SERVICE_BY_UUID);
- TIME_TRACER_ITEM_END("connectToServiceByUUID::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
try {
// Private Object
if (!priv) {
throw TypeMismatchException("Private object is NULL.");
}
+ // Access Check
+ TIME_TRACER_ITEM_BEGIN("connectToServiceByUUID::ACE", 1);
+ TIZEN_CHECK_ACCESS(context, exception, priv->mDevice.get(), BLUETOOTH_DEVICE_API_CONNECT_TO_SERVICE_BY_UUID);
+ TIME_TRACER_ITEM_END("connectToServiceByUUID::ACE", 1);
ArgumentValidator validator(context, argumentCount, arguments);
std::string uuid = validator.toString(0); // uuid
#define __TIZEN_JS_BLUETOOTH_DEVICE_H__
#include <JavaScriptCore/JavaScript.h>
-
#include "BluetoothDevice.h"
namespace DeviceAPI {
namespace Bluetooth {
-class BluetoothDeviceHolder
+class BluetoothDeviceHolder
{
public:
- BluetoothDeviceHolder(BluetoothDeviceSharedPtr device) {mDevice = device;}
+ BluetoothDeviceHolder(BluetoothDeviceSharedPtr device) : mDevice(device) {}
BluetoothDeviceSharedPtr mDevice;
};
typedef BluetoothDeviceHolder* BluetoothDeviceHolderPtr;
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
// Access Check
- TIME_TRACER_ITEM_BEGIN("unregister::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_HEALTH_APPLICATION_API_UNREGISTER);
- TIME_TRACER_ITEM_END("unregister::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
BluetoothHealthApplicationHolderPtr priv = static_cast<BluetoothHealthApplicationHolderPtr>(JSObjectGetPrivate(thisObject));
if (!priv) {
throw TypeMismatchException("Private object is NULL");
}
+ TIME_TRACER_ITEM_BEGIN("unregister::ACE", 1);
+ TIZEN_CHECK_ACCESS(context, exception, priv->mApp.get(), BLUETOOTH_HEALTH_APPLICATION_API_UNREGISTER);
+ TIME_TRACER_ITEM_END("unregister::ACE", 1);
ArgumentValidator validator(context, argumentCount, arguments);
JSObjectRef successCallback = validator.toFunction(0, true); // successCallback
#define __TIZEN_JS_BLUETOOTH_HEALTH_APPLICATION_H__
#include <JavaScriptCore/JavaScript.h>
-
#include "BluetoothHealthApplication.h"
namespace DeviceAPI {
namespace Bluetooth {
-class BluetoothHealthApplicationHolder
+class BluetoothHealthApplicationHolder
{
public:
- BluetoothHealthApplicationHolder(BluetoothHealthApplicationSharedPtr app) {mApp = app;}
+ BluetoothHealthApplicationHolder(BluetoothHealthApplicationSharedPtr app){mApp = app;}
BluetoothHealthApplicationSharedPtr mApp;
};
typedef BluetoothHealthApplicationHolder* BluetoothHealthApplicationHolderPtr;
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);;
- // Access Check
- TIME_TRACER_ITEM_BEGIN("sendData::ACE", 1);;
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_HEALTH_CHANNEL_API_SEND_DATA);
- TIME_TRACER_ITEM_END("sendData::ACE", 1);;
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
try {
// Private Object
BluetoothHealthChannelPtr priv = static_cast<BluetoothHealthChannelPtr>(JSObjectGetPrivate(thisObject));
if (!priv) {
throw DeviceAPI::Common::UnknownException("Private object is NULL.");
}
-
+ // Access Check
+ TIME_TRACER_ITEM_BEGIN("sendData::ACE", 1);;
+ TIZEN_CHECK_ACCESS(context, exception, priv, BLUETOOTH_HEALTH_CHANNEL_API_SEND_DATA);
+ TIME_TRACER_ITEM_END("sendData::ACE", 1);;
+
ArgumentValidator validator(context, argumentCount, arguments);
JSObjectRef dataArrayObj = validator.toArrayObject(0); // data
{
LoggerD("Enter");
- TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);;
+ TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
- // Access Check
- TIME_TRACER_ITEM_BEGIN("close::ACE", 1);;
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_HEALTH_CHANNEL_API_CLOSE);
- TIME_TRACER_ITEM_END("close::ACE", 1);;
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
// Private Object
if (!priv) {
throw DeviceAPI::Common::UnknownException("Private object is NULL.");
}
+ // Access Check
+ TIME_TRACER_ITEM_BEGIN("close::ACE", 1);;
+ TIZEN_CHECK_ACCESS(context, exception, priv, BLUETOOTH_HEALTH_CHANNEL_API_CLOSE);
+ TIME_TRACER_ITEM_END("close::ACE", 1);;
priv->close();
TIME_TRACER_ITEM_END(__FUNCTION__, 1);;
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);;
- // Access Check
- TIME_TRACER_ITEM_BEGIN("setListener::ACE", 1);;
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_HEALTH_CHANNEL_API_SET_LISTENER);
- TIME_TRACER_ITEM_END("setListener::ACE", 1);;
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
// Private Object
throw DeviceAPI::Common::UnknownException("Private object is NULL.");
}
+ // Access Check
+ TIME_TRACER_ITEM_BEGIN("setListener::ACE", 1);;
+ TIZEN_CHECK_ACCESS(context, exception, priv, BLUETOOTH_HEALTH_CHANNEL_API_SET_LISTENER);
+ TIME_TRACER_ITEM_END("setListener::ACE", 1);;
+
+
// Validate arguments
ArgumentValidator validator(context, argumentCount, arguments);
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);;
- // Access Check
- TIME_TRACER_ITEM_BEGIN("unsetListener::ACE", 1);;
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_HEALTH_CHANNEL_API_UNSET_LISTENER);
- TIME_TRACER_ITEM_END("unsetListener::ACE", 1);;
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
try {
// Private Object
if (!priv) {
throw DeviceAPI::Common::UnknownException("Private object is NULL.");
}
+ // Access Check
+ TIME_TRACER_ITEM_BEGIN("unsetListener::ACE", 1);
+ TIZEN_CHECK_ACCESS(context, exception, priv, BLUETOOTH_HEALTH_CHANNEL_API_UNSET_LISTENER);
+ TIME_TRACER_ITEM_END("unsetListener::ACE", 1);
+
priv->unsetListener();
TIME_TRACER_ITEM_END(__FUNCTION__, 1);;
LoggerD("Enter");
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
-
- // Access Check
- TIME_TRACER_ITEM_BEGIN("registerSinkApplication::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_HEALTH_PROFILE_HANDLER_API_REGISTER_SINK_APPLICATION);
- TIME_TRACER_ITEM_END("registerSinkApplication::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ // Access Check
+ TIME_TRACER_ITEM_BEGIN("registerSinkApplication::ACE", 1);
+ TIZEN_CHECK_ACCESS(context, exception, BluetoothHealthProfileHandler::getInstance(), BLUETOOTH_HEALTH_PROFILE_HANDLER_API_REGISTER_SINK_APPLICATION);
+ TIME_TRACER_ITEM_END("registerSinkApplication::ACE", 1);
+
try {
ArgumentValidator validator(context, argumentCount, arguments);
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
// Access Check
- TIME_TRACER_ITEM_BEGIN("setName::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_HEALTH_PROFILE_HANDLER_API_CONNECT_TO_SOURCE);
- TIME_TRACER_ITEM_END("setName::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIME_TRACER_ITEM_BEGIN("connectToSource::ACE", 1);
+ TIZEN_CHECK_ACCESS(context, exception, BluetoothHealthProfileHandler::getInstance(), BLUETOOTH_HEALTH_PROFILE_HANDLER_API_CONNECT_TO_SOURCE);
+ TIME_TRACER_ITEM_END("connectToSource::ACE", 1);
+
try {
ArgumentValidator validator(context, argumentCount, arguments);
#include <PropertyBag.h>
#include <bluetooth.h>
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
#include "JSBluetoothManager.h"
#include "JSBluetoothClassDeviceMajor.h"
#include "JSBluetoothClassDeviceMinor.h"
void JSBluetoothManager::initialize(JSContextRef context, JSObjectRef object)
{
+ LoggerD("initialize");
+
if (!JSObjectGetPrivate(object)) {
- PropertyBag *priv = new PropertyBag();
- if(priv) {
- // deviceMajor
- priv->setProperty(context, BLUETOOTH_MANAGER_DEVICE_MAJOR,
- JSBluetoothClassDeviceMajor::createJSObject(context));
-
- // deviceMinor
- priv->setProperty(context, BLUETOOTH_MANAGER_DEVICE_MINOR,
- JSBluetoothClassDeviceMinor::createJSObject(context));
-
- // deviceService
- priv->setProperty(context, BLUETOOTH_MANAGER_DEVICE_SERVICE,
- JSBluetoothClassDeviceService::createJSObject(context));
-
- if (!JSObjectSetPrivate(object, static_cast<void*>(priv))) {
- LoggerW("Failed to set private data");
- delete priv;
- }
- }
- else {
- LoggerW("Failed to create private data");
- }
- }
- else {
- LoggerW("Private data already exists");
- }
+ JSBluetoothManagerPriv* priv = new JSBluetoothManagerPriv();
+
+ if(priv) {
+ // deviceMajor
+ priv->setProperty(context, BLUETOOTH_MANAGER_DEVICE_MAJOR,
+ JSBluetoothClassDeviceMajor::createJSObject(context));
+
+ // deviceMinor
+ priv->setProperty(context, BLUETOOTH_MANAGER_DEVICE_MINOR,
+ JSBluetoothClassDeviceMinor::createJSObject(context));
+
+ // deviceService
+ priv->setProperty(context, BLUETOOTH_MANAGER_DEVICE_SERVICE,
+ JSBluetoothClassDeviceService::createJSObject(context));
+
+ if (!JSObjectSetPrivate(object, static_cast<void*>(priv))) {
+ LoggerW("Failed to set private data");
+ delete priv;
+ }
+ LoggerD("Private creation ok");
+ }
+ else {
+ LoggerW("Failed to create private data");
+ }
+ }
+ else {
+ LoggerW("already has private data");
+ }
}
void JSBluetoothManager::finalize(JSObjectRef object)
{
- PropertyBag *priv = static_cast<PropertyBag*>(JSObjectGetPrivate(object));
+ JSBluetoothManagerPriv *priv = static_cast<JSBluetoothManagerPriv*>(JSObjectGetPrivate(object));
if (priv) {
JSObjectSetPrivate(object, NULL);
delete priv;
}
JSValueRef JSBluetoothManager::getReadOnlyProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception) {
- PropertyBag *priv = static_cast<PropertyBag*>(JSObjectGetPrivate(object));
+ JSBluetoothManagerPriv *priv = static_cast<JSBluetoothManagerPriv*>(JSObjectGetPrivate(object));
if(!priv) {
LoggerW("There is no private data");
return NULL;
const JSValueRef arguments[],
JSValueRef* exception)
{
+ JSBluetoothManagerPriv *priv = static_cast<JSBluetoothManagerPriv*>(JSObjectGetPrivate(thisObject));
+
+ if (!priv)
+ {
+ DeviceAPI::Common::TypeMismatchException err("Private Object is null");
+ return JSWebAPIErrorFactory::postException(context, exception, err);
+ }
+
TIME_TRACER_ITEM_BEGIN("getDefaultAdapter", 1);
-
- // Access Check
- TIME_TRACER_ITEM_BEGIN("getDefaultAdapter::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_MANAGER_API_GET_DEFAULT_ADAPTER);
+ TIZEN_CHECK_ACCESS(context, exception, priv, BLUETOOTH_MANAGER_API_GET_DEFAULT_ADAPTER);
TIME_TRACER_ITEM_END("getDefaultAdapter::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
- JSObjectRef adapter = JSBluetoothAdapter::createJSObject(context);
-
+
if(bt_initialize() != BT_ERROR_NONE) {
LoggerE("bt_initialize() failed");
}
+
+ BluetoothAdapter::getInstance()->copyAceCheckAccessFunction(priv);
+ JSObjectRef adapter = JSBluetoothAdapter::createJSObject(context);
TIME_TRACER_ITEM_END("getDefaultAdapter", 1);
return adapter;
#define __TIZEN_JS_BLUETOOTH_MANAGER_H__
#include <JavaScriptCore/JavaScript.h>
+#include <PropertyBag.h>
+#include <memory>
+#include <Security.h>
namespace DeviceAPI {
namespace Bluetooth {
+
+
+class JSBluetoothManagerPriv :
+ public DeviceAPI::Common::SecurityAccessor,
+ public DeviceAPI::Common::PropertyBag
+{
+public:
+ JSBluetoothManagerPriv() :
+ DeviceAPI::Common::SecurityAccessor(),
+ DeviceAPI::Common::PropertyBag()
+ {
+ }
+ virtual ~JSBluetoothManagerPriv() {}
+};
class JSBluetoothManager
{
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
- // Access Check
- TIME_TRACER_ITEM_BEGIN("unregister::ACE", 1);
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_SERVICE_HANDLER_API_UNREGISTER);
- TIME_TRACER_ITEM_END("unregister::ACE", 1);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
try {
// Private Object
throw TypeMismatchException("Private object is NULL.");
}
+ // Access Check
+ TIME_TRACER_ITEM_BEGIN("unregister::ACE", 1);
+ TIZEN_CHECK_ACCESS(context, exception, priv, BLUETOOTH_SERVICE_HANDLER_API_UNREGISTER);
+ TIME_TRACER_ITEM_END("unregister::ACE", 1);
+
+
ArgumentValidator validator(context, argumentCount, arguments);
JSObjectRef successCallback = validator.toFunction(0, true); // successCallback
JSObjectRef errorCallback = validator.toFunction(1, true); // errorCallback
const JSValueRef arguments[],
JSValueRef* exception)
{
- TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);;
-
- // Access Check
- TIME_TRACER_ITEM_BEGIN("writeData::ACE", 1);;
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_SOCKET_API_WRITE_DATA);
- TIME_TRACER_ITEM_END("writeData::ACE", 1);;
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
try {
// Private Object
if (!priv) {
throw DeviceAPI::Common::UnknownException("Private object is NULL.");
}
-
+
+ // Access Check
+ TIME_TRACER_ITEM_BEGIN("writeData::ACE", 1);
+ TIZEN_CHECK_ACCESS(context, exception, priv, BLUETOOTH_SOCKET_API_WRITE_DATA);
+ TIME_TRACER_ITEM_END("writeData::ACE", 1);
+
ArgumentValidator validator(context, argumentCount, arguments);
JSObjectRef dataArrayObj = validator.toArrayObject(0); // data
const JSValueRef arguments[],
JSValueRef* exception)
{
- TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);;
-
- // Access Check
- TIME_TRACER_ITEM_BEGIN("readData::ACE", 1);;
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_SOCKET_API_READ_DATA);
- TIME_TRACER_ITEM_END("readData::ACE", 1);;
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
+
try {
// Private Object
if (!priv) {
throw DeviceAPI::Common::UnknownException("Private object is NULL.");
}
+
+ // Access Check
+ TIME_TRACER_ITEM_BEGIN("readData::ACE", 1);
+ TIZEN_CHECK_ACCESS(context, exception, priv, BLUETOOTH_SOCKET_API_READ_DATA);
+ TIME_TRACER_ITEM_END("readData::ACE", 1);
+
std::vector<signed char> data = priv->readData();
- TIME_TRACER_ITEM_END(__FUNCTION__, 1);;
+ TIME_TRACER_ITEM_END(__FUNCTION__, 1);
return JSUtil::toJSValueRef_(context, data);
} catch (const BasePlatformException &err) {
JSValueRef* exception)
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);;
-
- // Access Check
- TIME_TRACER_ITEM_BEGIN("close::ACE", 1);;
- AceSecurityStatus status = BLUETOOTH_CHECK_ACCESS(BLUETOOTH_SOCKET_API_CLOSE);
- TIME_TRACER_ITEM_END("close::ACE", 1);;
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
try {
// Private Object
throw DeviceAPI::Common::UnknownException("Private object is NULL.");
}
+ // Access Check
+ TIME_TRACER_ITEM_BEGIN("close::ACE", 1);
+ TIZEN_CHECK_ACCESS(context, exception, priv, BLUETOOTH_SOCKET_API_CLOSE);
+ TIME_TRACER_ITEM_END("close::ACE", 1);
+
+
priv->close();
TIME_TRACER_ITEM_END(__FUNCTION__, 1);;
#define _BLUETOOTH_PLUGIN_CONFIG_H_
#include <Commons/FunctionDeclaration.h>
+#include "plugin_config_impl.h"
namespace DeviceAPI {
namespace Bluetooth {
-// attributes
-#define BLUETOOTH_MANAGER_DEVICE_MAJOR "deviceMajor"
-#define BLUETOOTH_MANAGER_DEVICE_MINOR "deviceMinor"
-#define BLUETOOTH_MANAGER_DEVICE_SERVICE "deviceService"
-#define BLUETOOTH_ADAPTER_NAME "name"
-#define BLUETOOTH_ADAPTER_ADDRESS "address"
-#define BLUETOOTH_ADAPTER_POWERED "powered"
-#define BLUETOOTH_ADAPTER_VISIBLE "visible"
-#define BLUETOOTH_DEVICE_NAME "name"
-#define BLUETOOTH_DEVICE_ADDRESS "address"
-#define BLUETOOTH_DEVICE_DEVICE_CLASS "deviceClass"
-#define BLUETOOTH_DEVICE_IS_BONDED "isBonded"
-#define BLUETOOTH_DEVICE_IS_TRUSTED "isTrusted"
-#define BLUETOOTH_DEVICE_IS_CONNECTED "isConnected"
-#define BLUETOOTH_DEVICE_UUIDS "uuids"
-#define BLUETOOTH_SOCKET_UUID "uuid"
-#define BLUETOOTH_SOCKET_STATE "state"
-#define BLUETOOTH_SOCKET_PEER "peer"
-#define BLUETOOTH_SOCKET_ONMESSAGE "onmessage"
-#define BLUETOOTH_SOCKET_ONCLOSE "onclose"
-#define BLUETOOTH_SOCKET_ONERROR "onerror"
-#define BLUETOOTH_CLASS_MAJOR "major"
-#define BLUETOOTH_CLASS_MINOR "minor"
-#define BLUETOOTH_CLASS_SERVICES "services"
-#define BLUETOOTH_SERVICE_HANDLER_UUID "uuid"
-#define BLUETOOTH_SERVICE_HANDLER_NAME "name"
-#define BLUETOOTH_SERVICE_HANDLER_IS_CONNECTED "isConnected"
-#define BLUETOOTH_SERVICE_HANDLER_ONCONNECT "onconnect"
-#define BLUETOOTH_PROFILE_TYPE "profileType"
-#define BLUETOOTH_HEALTH_APPLICATION_DATA_TYPE "dataType"
-#define BLUETOOTH_HEALTH_APPLICATION_NAME "name"
-#define BLUETOOTH_HEALTH_APPLICATION_ONCONNECT "onconnect"
-#define BLUETOOTH_HEALTH_CHANNEL_PEER "peer"
-#define BLUETOOTH_HEALTH_CHANNEL_TYPE "channelType"
-#define BLUETOOTH_HEALTH_CHANNEL_APP "application"
-#define BLUETOOTH_HEALTH_CHANNEL_IS_CONNECTED "isConnected"
-
-
-// functions
-#define BLUETOOTH_MANAGER_API_GET_DEFAULT_ADAPTER "getDefaultAdapter"
-#define BLUETOOTH_ADAPTER_API_SET_NAME "setName"
-#define BLUETOOTH_ADAPTER_API_SET_POWERED "setPowered"
-#define BLUETOOTH_ADAPTER_API_SET_VISIBLE "setVisible"
-#define BLUETOOTH_ADAPTER_API_DISCOVER_DEVICES "discoverDevices"
-#define BLUETOOTH_ADAPTER_API_STOP_DISCOVERY "stopDiscovery"
-#define BLUETOOTH_ADAPTER_API_GET_KNOWN_DEVICES "getKnownDevices"
-#define BLUETOOTH_ADAPTER_API_GET_DEVICE "getDevice"
-#define BLUETOOTH_ADAPTER_API_CREATE_BONDING "createBonding"
-#define BLUETOOTH_ADAPTER_API_DESTROY_BONDING "destroyBonding"
-#define BLUETOOTH_ADAPTER_API_REGISTER_RFCOMMSERVICE_BY_UUID "registerRFCOMMServiceByUUID"
-#define BLUETOOTH_ADAPTER_API_GET_BLUETOOTH_PROFILE_HANDLER "getBluetoothProfileHandler"
-#define BLUETOOTH_ADAPTER_API_SET_CHANGE_LISTENER "setChangeListener"
-#define BLUETOOTH_ADAPTER_API_UNSET_CHANGE_LISTENER "unsetChangeListener"
-#define BLUETOOTH_DEVICE_API_CONNECT_TO_SERVICE_BY_UUID "connectToServiceByUUID"
-#define BLUETOOTH_SOCKET_API_WRITE_DATA "writeData"
-#define BLUETOOTH_SOCKET_API_READ_DATA "readData"
-#define BLUETOOTH_SOCKET_API_CLOSE "close"
-#define BLUETOOTH_CLASS_API_HAS_SERVICE "hasService"
-#define BLUETOOTH_SERVICE_HANDLER_API_UNREGISTER "unregister"
-#define BLUETOOTH_HEALTH_PROFILE_HANDLER_API_REGISTER_SINK_APPLICATION "registerSinkApplication"
-#define BLUETOOTH_HEALTH_APPLICATION_API_UNREGISTER "healthUnregister"
-#define BLUETOOTH_HEALTH_PROFILE_HANDLER_API_CONNECT_TO_SOURCE "connectToSource"
-#define BLUETOOTH_HEALTH_CHANNEL_API_SEND_DATA "sendData"
-#define BLUETOOTH_HEALTH_CHANNEL_API_SET_LISTENER "setListener"
-#define BLUETOOTH_HEALTH_CHANNEL_API_UNSET_LISTENER "unsetListener"
-#define BLUETOOTH_HEALTH_CHANNEL_API_CLOSE "healthClose"
-
-
DECLARE_FUNCTION_GETTER(Bluetooth);
#define BLUETOOTH_CHECK_ACCESS(functionName) \
--- /dev/null
+#ifndef _BLUETOOTH_PLUGIN_CONFIG_IMPL_H_\r
+#define _BLUETOOTH_PLUGIN_CONFIG_IMPL_H_\r
+\r
+namespace DeviceAPI {\r
+namespace Bluetooth {\r
+\r
+// attributes\r
+#define BLUETOOTH_MANAGER_DEVICE_MAJOR "deviceMajor"\r
+#define BLUETOOTH_MANAGER_DEVICE_MINOR "deviceMinor"\r
+#define BLUETOOTH_MANAGER_DEVICE_SERVICE "deviceService"\r
+#define BLUETOOTH_ADAPTER_NAME "name"\r
+#define BLUETOOTH_ADAPTER_ADDRESS "address"\r
+#define BLUETOOTH_ADAPTER_POWERED "powered"\r
+#define BLUETOOTH_ADAPTER_VISIBLE "visible"\r
+#define BLUETOOTH_DEVICE_NAME "name"\r
+#define BLUETOOTH_DEVICE_ADDRESS "address"\r
+#define BLUETOOTH_DEVICE_DEVICE_CLASS "deviceClass"\r
+#define BLUETOOTH_DEVICE_IS_BONDED "isBonded"\r
+#define BLUETOOTH_DEVICE_IS_TRUSTED "isTrusted"\r
+#define BLUETOOTH_DEVICE_IS_CONNECTED "isConnected"\r
+#define BLUETOOTH_DEVICE_UUIDS "uuids"\r
+#define BLUETOOTH_SOCKET_UUID "uuid"\r
+#define BLUETOOTH_SOCKET_STATE "state"\r
+#define BLUETOOTH_SOCKET_PEER "peer"\r
+#define BLUETOOTH_SOCKET_ONMESSAGE "onmessage"\r
+#define BLUETOOTH_SOCKET_ONCLOSE "onclose"\r
+#define BLUETOOTH_SOCKET_ONERROR "onerror"\r
+#define BLUETOOTH_CLASS_MAJOR "major"\r
+#define BLUETOOTH_CLASS_MINOR "minor"\r
+#define BLUETOOTH_CLASS_SERVICES "services"\r
+#define BLUETOOTH_SERVICE_HANDLER_UUID "uuid"\r
+#define BLUETOOTH_SERVICE_HANDLER_NAME "name"\r
+#define BLUETOOTH_SERVICE_HANDLER_IS_CONNECTED "isConnected"\r
+#define BLUETOOTH_SERVICE_HANDLER_ONCONNECT "onconnect"\r
+#define BLUETOOTH_PROFILE_TYPE "profileType"\r
+#define BLUETOOTH_HEALTH_APPLICATION_DATA_TYPE "dataType"\r
+#define BLUETOOTH_HEALTH_APPLICATION_NAME "name"\r
+#define BLUETOOTH_HEALTH_APPLICATION_ONCONNECT "onconnect"\r
+#define BLUETOOTH_HEALTH_CHANNEL_PEER "peer"\r
+#define BLUETOOTH_HEALTH_CHANNEL_TYPE "channelType"\r
+#define BLUETOOTH_HEALTH_CHANNEL_APP "application"\r
+#define BLUETOOTH_HEALTH_CHANNEL_IS_CONNECTED "isConnected"\r
+\r
+\r
+// functions\r
+#define BLUETOOTH_MANAGER_API_GET_DEFAULT_ADAPTER "getDefaultAdapter"\r
+#define BLUETOOTH_ADAPTER_API_SET_NAME "setName"\r
+#define BLUETOOTH_ADAPTER_API_SET_POWERED "setPowered"\r
+#define BLUETOOTH_ADAPTER_API_SET_VISIBLE "setVisible"\r
+#define BLUETOOTH_ADAPTER_API_DISCOVER_DEVICES "discoverDevices"\r
+#define BLUETOOTH_ADAPTER_API_STOP_DISCOVERY "stopDiscovery"\r
+#define BLUETOOTH_ADAPTER_API_GET_KNOWN_DEVICES "getKnownDevices"\r
+#define BLUETOOTH_ADAPTER_API_GET_DEVICE "getDevice"\r
+#define BLUETOOTH_ADAPTER_API_CREATE_BONDING "createBonding"\r
+#define BLUETOOTH_ADAPTER_API_DESTROY_BONDING "destroyBonding"\r
+#define BLUETOOTH_ADAPTER_API_REGISTER_RFCOMMSERVICE_BY_UUID "registerRFCOMMServiceByUUID"\r
+#define BLUETOOTH_ADAPTER_API_GET_BLUETOOTH_PROFILE_HANDLER "getBluetoothProfileHandler"\r
+#define BLUETOOTH_ADAPTER_API_SET_CHANGE_LISTENER "setChangeListener"\r
+#define BLUETOOTH_ADAPTER_API_UNSET_CHANGE_LISTENER "unsetChangeListener"\r
+#define BLUETOOTH_DEVICE_API_CONNECT_TO_SERVICE_BY_UUID "connectToServiceByUUID"\r
+#define BLUETOOTH_SOCKET_API_WRITE_DATA "writeData"\r
+#define BLUETOOTH_SOCKET_API_READ_DATA "readData"\r
+#define BLUETOOTH_SOCKET_API_CLOSE "close"\r
+#define BLUETOOTH_CLASS_API_HAS_SERVICE "hasService"\r
+#define BLUETOOTH_SERVICE_HANDLER_API_UNREGISTER "unregister"\r
+#define BLUETOOTH_HEALTH_PROFILE_HANDLER_API_REGISTER_SINK_APPLICATION "registerSinkApplication"\r
+#define BLUETOOTH_HEALTH_APPLICATION_API_UNREGISTER "healthUnregister"\r
+#define BLUETOOTH_HEALTH_PROFILE_HANDLER_API_CONNECT_TO_SOURCE "connectToSource"\r
+#define BLUETOOTH_HEALTH_CHANNEL_API_SEND_DATA "sendData"\r
+#define BLUETOOTH_HEALTH_CHANNEL_API_SET_LISTENER "setListener"\r
+#define BLUETOOTH_HEALTH_CHANNEL_API_UNSET_LISTENER "unsetListener"\r
+#define BLUETOOTH_HEALTH_CHANNEL_API_CLOSE "healthClose"\r
+}\r
+}\r
+#endif\r
#include <Commons/plugin_initializer_def.h>
#include <Commons/WrtAccess/WrtAccess.h>
-
+#include <Security.h>
#include <GlobalContextManager.h>
-
+#include "plugin_config.h"
#include "JSBluetoothManager.h"
#include "BluetoothAdapter.h"
namespace DeviceAPI {
namespace Bluetooth {
+
+AceSecurityStatus bluetoothAceCheckAccessFunction(const char* functionName)
+{
+ return BLUETOOTH_CHECK_ACCESS(functionName);
+}
+
+DEFINE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
+DEFINE_SECURITY_ACCESSOR_SETTER(AceCheckerBluetoothSetter, JSBluetoothManagerPriv, gSecurityAccessor);
+
+class_definition_options_t BluetoothOptions =
+{
+ JS_CLASS,
+ CREATE_INSTANCE,
+ ALWAYS_NOTICE,
+ USE_OVERLAYED,
+ AceCheckerBluetoothSetter,
+ NULL
+};
+
void on_widget_start_callback(int widgetId)
} catch (...) {
LoggerE("WrtAccess initialization failed");
}
+ INITAILIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor, bluetoothAceCheckAccessFunction);
}
void on_widget_stop_callback(int widgetId)
} catch (...) {
LoggerE("WrtAccess deinitialization failed");
}
+ FINALIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
}
void on_frame_load_callback(const void *context)
PLUGIN_CLASS_MAP_ADD_CLASS(WRT_JS_EXTENSION_OBJECT_TIZEN,
"bluetooth",
(js_class_template_getter)JSBluetoothManager::getClassRef,
- NULL)
+ &BluetoothOptions)
PLUGIN_CLASS_MAP_END
} // Bluetooth
TARGET_LINK_LIBRARIES(${TARGET_NAME}
${TARGET_IMPL_NAME}
- "-Wl,--no-as-needed" ${contact_config}
)
INSTALL(TARGETS ${TARGET_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
namespace DeviceAPI {
namespace Calendar {
-CalendarConverter::CalendarConverter(JSContextRef context, CalendarEvent::CalendarType calendarType) : Converter(context)
+CalendarConverter::CalendarConverter(JSContextRef context, CalendarEvent::CalendarType calendarType,
+ DeviceAPI::Common::SecurityAccessor *securityAccessor) : Converter(context)
{
m_calendarType = calendarType;
+ m_securityAccessor = securityAccessor;
+}
+
+CalendarConverter::CalendarConverter(JSContextRef context, DeviceAPI::Common::SecurityAccessor *securityAccessor,
+ CalendarEvent::CalendarType calendarType) : Converter(context)
+{
+ m_securityAccessor = securityAccessor;
+ m_calendarType = calendarType;
}
CalendarConverter::~CalendarConverter()
JSValueRef CalendarConverter::toJSValueRefEvent(const CalendarEventPtr& arg)
{
- return JSUtils::makeObject(m_context, JSCalendarEvent::getClassRef(), arg);
+ CalendarEventPrivObject *priv = new CalendarEventPrivObject(m_context, arg);
+ if(m_securityAccessor != NULL)
+ priv->copyAceCheckAccessFunction(m_securityAccessor);
+ return JSObjectMake(m_context, JSCalendarEvent::getClassRef(), priv);
}
JSValueRef CalendarConverter::toJSValueRefTask(const CalendarEventPtr& arg)
{
- return JSUtils::makeObject(m_context, JSCalendarTask::getClassRef(), arg);
+ CalendarTaskPrivObject *priv = new CalendarTaskPrivObject(m_context, arg);
+ if(m_securityAccessor != NULL)
+ priv->copyAceCheckAccessFunction(m_securityAccessor);
+ return JSObjectMake(m_context, JSCalendarTask::getClassRef(), priv);
}
JSValueRef CalendarConverter::toJSValueRefEventArray(const CalendarEventListPtr &arg)
JSValueRef CalendarConverter::toJSValueRefCalendar(const ICalendarPtr& arg)
{
CalendarPrivObject *priv = new CalendarPrivObject(m_context, arg);
+ if(m_securityAccessor != NULL)
+ priv->copyAceCheckAccessFunction(m_securityAccessor);
return JSObjectMake(m_context, JSCalendar::getClassRef(), priv);
}
#include "EventAlarm.h"
#include <CommonsJavaScript/Converter.h>
#include <CommonsJavaScript/ScopedJSStringRef.h>
+#include <Security.h>
namespace DeviceAPI {
namespace Calendar {
public:
using Converter::toJSValueRef;
public:
- explicit CalendarConverter(JSContextRef context, CalendarEvent::CalendarType calendarType=CalendarEvent::EVENT_TYPE);
+ explicit CalendarConverter(JSContextRef context, CalendarEvent::CalendarType calendarType=CalendarEvent::EVENT_TYPE,
+ DeviceAPI::Common::SecurityAccessor *securityAccessor=NULL);
+ explicit CalendarConverter(JSContextRef context, DeviceAPI::Common::SecurityAccessor *securityAccessor,
+ CalendarEvent::CalendarType calendarType=CalendarEvent::EVENT_TYPE);
virtual ~CalendarConverter();
CalendarEventPtr toItem(const JSValueRef value, bool updateMode);
private:
CalendarEvent::CalendarType m_calendarType;
+ DeviceAPI::Common::SecurityAccessor* m_securityAccessor;
};
}
#include <Commons/IEvent.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <JavaScriptCore/JavaScript.h>
+#include <Security.h>
#include "CalendarEvent.h"
{ }
};
-class CalendarChangeCallbackPrivateData : public WrtDeviceApis::Commons::IEventPrivateData
+class CalendarChangeCallbackPrivateData :
+ public WrtDeviceApis::Commons::IEventPrivateData,
+ public DeviceAPI::Common::SecurityAccessor
{
public:
CalendarChangeCallbackPrivateData(const JSCallbackManagerPtr& onAdded,
Try
{
if (event->getResult()) {
- CalendarConverter converter(cbm->getContext());
+ CalendarConverter converter(cbm->getContext(), event.Get());
const std::vector<ICalendarPtr> &results = event->getCalendars();
LoggerD("found calendars: " << results.size());
JSValueRef result = converter.toJSValueRef(results);
if (event->getResult()) {
LoggerD("result success");
- CalendarConverter converter(cbm->getContext());
+ CalendarConverter converter(cbm->getContext(), event.Get());
JSValueRef result;
if (CalendarEvent::TASK_TYPE==event->getCalendarType()) {
Try
{
if (event->getResult()) {
- CalendarConverter converter(cbm->getContext());
+ CalendarConverter converter(cbm->getContext(), event.Get());
JSValueRef result;
if (CalendarEvent::TASK_TYPE==event->getCalendarType()) {
}
if (event->getResult()) {
- CalendarConverter converter(cbm->getContext());
+ CalendarConverter converter(cbm->getContext(), event.Get());
cbm->callOnSuccess(converter.toJSValueRefEventArray(event->getExpandedEventList()));
return;
} else {
DPL::StaticPointerCast<CalendarChangeCallbackPrivateData>(event->getPrivateData());
JSContextRef context = multiCallbacks->getOnAdded()->getContext();
- CalendarConverter converter(context);
+ CalendarConverter converter(context, multiCallbacks.Get());
JSValueRef result;
Try
#include <Commons/IEvent.h>
#include "CalendarEvent.h"
#include <dpl/shared_ptr.h>
+#include <Security.h>
namespace DeviceAPI {
namespace Calendar {
-class IEventAddEvents : public WrtDeviceApis::Commons::IEvent<IEventAddEvents>
+class IEventAddEvents : public WrtDeviceApis::Commons::IEvent<IEventAddEvents>, public DeviceAPI::Common::SecurityAccessor
{
CalendarEventListPtr m_events;
bool m_result;
#include <Commons/IEvent.h>
#include "CalendarEvent.h"
#include <dpl/shared_ptr.h>
+#include <Security.h>
namespace DeviceAPI {
namespace Calendar {
-class IEventExpandEventRecurrence : public WrtDeviceApis::Commons::IEvent<IEventExpandEventRecurrence>
+class IEventExpandEventRecurrence : public WrtDeviceApis::Commons::IEvent<IEventExpandEventRecurrence>, public DeviceAPI::Common::SecurityAccessor
{
CalendarEventListPtr m_expandedEventList; //output
bool m_result; // ouput
#include <IFilter.h>
#include <SortMode.h>
#include <dpl/shared_ptr.h>
+#include <Security.h>
namespace DeviceAPI {
namespace Calendar {
-class IEventFindEvents : public WrtDeviceApis::Commons::IEvent<IEventFindEvents>
+class IEventFindEvents : public WrtDeviceApis::Commons::IEvent<IEventFindEvents>, public DeviceAPI::Common::SecurityAccessor
{
/* user is responsible to free objects inside list */
CalendarEventListPtr m_events;
#include <Commons/IEvent.h>
#include "ICalendar.h"
#include <dpl/shared_ptr.h>
+#include <Security.h>
namespace DeviceAPI {
namespace Calendar {
-class IEventGetCalendars : public WrtDeviceApis::Commons::IEvent<IEventGetCalendars>
+class IEventGetCalendars : public WrtDeviceApis::Commons::IEvent<IEventGetCalendars>, public DeviceAPI::Common::SecurityAccessor
{
std::vector<ICalendarPtr> m_calendars;
bool m_result;
CalendarPrivObject *privateObject =
static_cast<CalendarPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_ADD);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_ADD);
Try
{
CalendarPrivObject *privateObject =
static_cast<CalendarPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_ADD_BATCH);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_ADD_BATCH);
Try
{
dplEvent->setEvents(events);
dplEvent->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(cbm));
dplEvent->setForAsynchronousCall(&CalendarResponseDispatcher::getInstance());
+ dplEvent->copyAceCheckAccessFunction(privateObject);
calendar->addEvents(dplEvent);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
CalendarPrivObject *privateObject =
static_cast<CalendarPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_UPDATE);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_UPDATE);
Try
{
CalendarPrivObject *privateObject =
static_cast<CalendarPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_UPDATE_BATCH);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_UPDATE_BATCH);
Try
{
CalendarPrivObject *privateObject =
static_cast<CalendarPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_REMOVE);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_REMOVE);
Try
{
CalendarPrivObject *privateObject =
static_cast<CalendarPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_REMOVE_BATCH);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_REMOVE_BATCH);
Try
{
CalendarPrivObject *privateObject =
static_cast<CalendarPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_FIND);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_FIND);
Try
{
dplEvent->setCalendarType(calendar->getType());
dplEvent->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(cbm));
dplEvent->setForAsynchronousCall(&CalendarResponseDispatcher::getInstance());
+ dplEvent->copyAceCheckAccessFunction(privateObject);
if (argumentCount>=3) {
if (JSValueIsObject(context, arguments[2])) {
CalendarPrivObject *privateObject =
static_cast<CalendarPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_GET);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_GET);
Try
{
if (CalendarEvent::EVENT_TYPE==calendar->getType()) {
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
// Use global context for the expandRecurrence api in event.
- return JSCalendarEvent::createJSCalendarEvent(globalContext, dplEvent->getItem());
+ return JSCalendarEvent::createJSCalendarEvent(globalContext, dplEvent->getItem(), privateObject);
} else if (CalendarEvent::TASK_TYPE==calendar->getType()) {
- return JSCalendarTask::createJSCalendarTask(context, dplEvent->getItem());
+ return JSCalendarTask::createJSCalendarTask(context, dplEvent->getItem(), privateObject);
} else {
ThrowMsg(UnknownException, "Wrong calendar type.");
}
CalendarPrivObject *privateObject =
static_cast<CalendarPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_ADD_CHANGE_LISTENER);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_ADD_CHANGE_LISTENER);
Try
{
CalendarChangeCallbackPrivateDataPtr privData(new CalendarChangeCallbackPrivateData(
onAddedCbm, onUpdatedCbm, onDeletedCbm));
+ privData->copyAceCheckAccessFunction(privateObject);
OnEventsChangedEmitterPtr emitter(new OnEventsChangedEmitter());
emitter->setListener(&CalendarResponseDispatcher::getInstance());
emitter->setEventPrivateData(DPL::StaticPointerCast<IEventPrivateData>(privData));
CalendarPrivObject *privateObject =
static_cast<CalendarPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_REMOVE_CHANGE_LISTENER);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_REMOVE_CHANGE_LISTENER);
Try
{
#include <CommonsJavaScript/PrivateObject.h>
#include "ICalendar.h"
#include <CommonsJavaScript/JSCallbackManager.h>
+#include <Security.h>
namespace DeviceAPI {
namespace Calendar {
#define TIZEN_CALENDAR_PROPERTY_ID "id"
typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<ICalendarPtr,
- WrtDeviceApis::CommonsJavaScript::NoOwnership> CalendarPrivObject;
+ WrtDeviceApis::CommonsJavaScript::NoOwnership> CalendarPrivObjectBase;
+
+class CalendarPrivObject :
+ public CalendarPrivObjectBase,
+ public DeviceAPI::Common::SecurityAccessor
+{
+public:
+ CalendarPrivObject(JSContextRef context, ICalendarPtr calendar) :
+ CalendarPrivObjectBase(context, calendar),
+ DeviceAPI::Common::SecurityAccessor()
+ {
+ }
+
+ virtual ~CalendarPrivObject()
+ {
+ }
+};
class JSCalendar
{
#include <TimeUtilConverter.h>
#include <JSTZDate.h>
#include <JSWebAPIErrorFactory.h>
+#include <Security.h>
#include <SecurityExceptions.h>
#include <GlobalContextManager.h>
#include <TimeTracer.h>
CalendarEventPtr event(new CalendarEvent());
JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
+ DeviceAPI::Common::SecurityAccessor *securityAccessor = NULL;
+
+ try
+ {
+ securityAccessor = DeviceAPI::Common::JSObjectGetSecurityAccessor(context, constructor);
+ }
+ catch(BasePlatformException &e)
+ {
+ event->setCalendarType(CalendarEvent::EVENT_TYPE);
+ return createJSCalendarEvent(globalContext, event, securityAccessor);
+ }
+
Try
{
CalendarConverter converter(globalContext);
}
event->setCalendarType(CalendarEvent::EVENT_TYPE);
- return createJSCalendarEvent(globalContext, event);
+ return createJSCalendarEvent(globalContext, event, securityAccessor);
}
Catch(UnsupportedException)
{
}
event->setCalendarType(CalendarEvent::EVENT_TYPE);
- return createJSCalendarEvent(globalContext, event);
+ return createJSCalendarEvent(globalContext, event, securityAccessor);
}
-JSObjectRef JSCalendarEvent::createJSCalendarEvent(JSContextRef context, CalendarEventPtr event)
+JSObjectRef JSCalendarEvent::createJSCalendarEvent(JSContextRef context, CalendarEventPtr event, const DeviceAPI::Common::SecurityAccessor *securityAccessor)
{
CalendarEventPrivObject *priv = new CalendarEventPrivObject(context, event);
+ priv->copyAceCheckAccessFunction(securityAccessor);
return JSObjectMake(context, getClassRef(), priv);
}
CalendarEventPrivObject *privateObject =
static_cast<CalendarEventPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_EXPAND_RECURRENCE);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_EXPAND_RECURRENCE);
Try
{
dplEvent->setEvent(event);
dplEvent->setStartDate(startDate);
dplEvent->setEndDate(endDate);
+ dplEvent->copyAceCheckAccessFunction(privateObject);
m_calendar->expandEventRecurrence(dplEvent);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
#include "CalendarEvent.h"
#include "ICalendar.h"
#include "CalendarFactory.h"
+#include "JSCalendarItemProperties.h"
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
namespace DeviceAPI {
namespace Calendar {
#define TIZEN_CALENDAR_EVENT_AVAILABILITY "availability"
#define TIZEN_CALENDAR_EVENT_RECURRENCE_RULE "recurrenceRule"
-typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<CalendarEventPtr,
- WrtDeviceApis::CommonsJavaScript::NoOwnership> CalendarEventPrivObject;
+typedef CalendarItemPropertiesPrivObject CalendarEventPrivObject;
class JSCalendarEvent
{
JSContextRef ctx,
const JSObjectRef object);
- static JSObjectRef createJSCalendarEvent(JSContextRef context, CalendarEventPtr event);
+ static JSObjectRef createJSCalendarEvent(JSContextRef context, CalendarEventPtr event, const DeviceAPI::Common::SecurityAccessor *securityAccessor);
static JSObjectRef constructor(JSContextRef context,
JSObjectRef constructor,
CalendarItemPropertiesPrivObject *privateObject =
static_cast<CalendarItemPropertiesPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_CONVERT_TO_STRING);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_CONVERT_TO_STRING);
Try
{
CalendarItemPropertiesPrivObject *privateObject =
static_cast<CalendarItemPropertiesPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_CLONE);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_CLONE);
Try
{
if (CalendarEvent::TASK_TYPE==clonedItem->getCalendarType()) {
TIME_TRACER_ITEM_END("clone(TASK)", 0);
- return JSCalendarTask::createJSCalendarTask(context, clonedItem);
+ return JSCalendarTask::createJSCalendarTask(context, clonedItem, privateObject);
} else if (CalendarEvent::EVENT_TYPE==clonedItem->getCalendarType()) {
TIME_TRACER_ITEM_END("clone(EVENT)", 0);
// Use global context for potential async api invocation.
- return JSCalendarEvent::createJSCalendarEvent(globalContext, clonedItem);
+ return JSCalendarEvent::createJSCalendarEvent(globalContext, clonedItem, privateObject);
} else {
ThrowMsg(ConversionException, "Wrong object type.");
}
#include <JavaScriptCore/JavaScript.h>
#include "CalendarEvent.h"
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
namespace DeviceAPI {
namespace Calendar {
#define TIZEN_CALENDAR_EVENT_LAST_MODIFICATION_DATE "lastModificationDate"
typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<CalendarEventPtr,
- WrtDeviceApis::CommonsJavaScript::NoOwnership> CalendarItemPropertiesPrivObject;
+ WrtDeviceApis::CommonsJavaScript::NoOwnership> CalendarItemPropertiesPrivObjectBase;
+
+class CalendarItemPropertiesPrivObject :
+ public CalendarItemPropertiesPrivObjectBase,
+ public DeviceAPI::Common::SecurityAccessor
+{
+public:
+ CalendarItemPropertiesPrivObject(JSContextRef context, CalendarEventPtr calendarEvent) :
+ CalendarItemPropertiesPrivObjectBase(context, calendarEvent),
+ DeviceAPI::Common::SecurityAccessor()
+ {
+ }
+
+ virtual ~CalendarItemPropertiesPrivObject()
+ {
+ }
+};
class JSCalendarItemProperties
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
CalendarManagerPrivObject *privateObject = static_cast<CalendarManagerPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_GET_CALENDARS);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_GET_CALENDARS);
Try {
if (!privateObject) {
dplEvent->setType(calendarType);
dplEvent->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(cbm));
dplEvent->setForAsynchronousCall(&CalendarResponseDispatcher::getInstance());
+ dplEvent->copyAceCheckAccessFunction(privateObject);
privateObject->getObject()->getCalendars(dplEvent);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
CalendarManagerPrivObject *privateObject = static_cast<CalendarManagerPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_GET_DEFAULT_CALENDAR);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_GET_DEFAULT_CALENDAR);
Try {
if (!privateObject) {
// Global context should be passed to the calendar object.
JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
- CalendarConverter converter(globalContext);
+ CalendarConverter converter(globalContext, privateObject);
CalendarEvent::CalendarType calendarType = CalendarEvent::UNDEFINED_TYPE;
if (argumentCount>=1) {
calendarType = converter.toCalendarType(converter.toString(arguments[0]));
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
CalendarManagerPrivObject *privateObject = static_cast<CalendarManagerPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_GET_UNIFIED_CALENDAR);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_GET_UNIFIED_CALENDAR);
Try {
if (!privateObject) {
// Global context should be passed to the calendar object.
JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
- CalendarConverter converter(globalContext);
+ CalendarConverter converter(globalContext, privateObject);
CalendarEvent::CalendarType calendarType = CalendarEvent::UNDEFINED_TYPE;
if (argumentCount>=1) {
calendarType = converter.toCalendarType(converter.toString(arguments[0]));
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
CalendarManagerPrivObject *privateObject = static_cast<CalendarManagerPrivObject*>(JSObjectGetPrivate(thisObject));
- AceSecurityStatus status = CALENDAR_CHECK_ACCESS(CALENDAR_FUNCTION_API_GET_CALENDAR);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CALENDAR_FUNCTION_API_GET_CALENDAR);
Try {
if (!privateObject) {
// Global context should be passed to the calendar object.
JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
- CalendarConverter converter(globalContext);
+ CalendarConverter converter(globalContext, privateObject);
CalendarEvent::CalendarType calendarType = CalendarEvent::UNDEFINED_TYPE;
if (argumentCount>=1) {
#include <JavaScriptCore/JavaScript.h>
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
#include "ICalendarManager.h"
#include "ICalendar.h"
namespace Calendar {
typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<ICalendarManagerPtr,
- WrtDeviceApis::CommonsJavaScript::NoOwnership> CalendarManagerPrivObject;
+ WrtDeviceApis::CommonsJavaScript::NoOwnership> CalendarManagerPrivObjectBase;
+
+class CalendarManagerPrivObject : public CalendarManagerPrivObjectBase, public DeviceAPI::Common::SecurityAccessor
+{
+public:
+ CalendarManagerPrivObject(JSContextRef context, ICalendarManagerPtr calendarManager) :
+ CalendarManagerPrivObjectBase(context, calendarManager),
+ DeviceAPI::Common::SecurityAccessor()
+ {
+ }
+
+ virtual ~CalendarManagerPrivObject()
+ {
+ }
+};
#define TIZEN_CALENDAR_PROPERTY_VCALENDAR_20_FORMAT "ICALENDAR_20"
#define TIZEN_CALENDAR_PROPERTY_VCALENDAR_10_FORMAT "VCALENDAR_10"
#include "ICalendar.h"
#include "CalendarFactory.h"
#include "JSCalendarTask.h"
-#include "JSCalendarItemProperties.h"
#include "CalendarConverter.h"
#include "JSCalendarEventId.h"
#include <TimeUtilConverter.h>
#include <JSTZDate.h>
#include <JSWebAPIErrorFactory.h>
#include <GlobalContextManager.h>
+#include <Security.h>
#include <Logger.h>
#include <Export.h>
JSValueRef* exception)
{
CalendarEventPtr task(new CalendarEvent());
+ DeviceAPI::Common::SecurityAccessor *securityAccessor = NULL;
+
+ try
+ {
+ securityAccessor = DeviceAPI::Common::JSObjectGetSecurityAccessor(context, constructor);
+ }
+ catch(BasePlatformException &e)
+ {
+ task->setCalendarType(CalendarEvent::TASK_TYPE);
+ return createJSCalendarTask(context, task, securityAccessor);
+ }
Try
{
}
task->setCalendarType(CalendarEvent::TASK_TYPE);
- return createJSCalendarTask(context, task);
+ return createJSCalendarTask(context, task, securityAccessor);
}
Catch(UnsupportedException)
{
}
task->setCalendarType(CalendarEvent::TASK_TYPE);
- return createJSCalendarTask(context, task);
+ return createJSCalendarTask(context, task, securityAccessor);
}
-JSObjectRef JSCalendarTask::createJSCalendarTask(JSContextRef context, CalendarEventPtr task)
+JSObjectRef JSCalendarTask::createJSCalendarTask(JSContextRef context, CalendarEventPtr task, const DeviceAPI::Common::SecurityAccessor *securityAccessor)
{
CalendarTaskPrivObject *priv = new CalendarTaskPrivObject(context, task);
+ priv->copyAceCheckAccessFunction(securityAccessor);
return JSObjectMake(context, getClassRef(), priv);
}
#include <JavaScriptCore/JavaScript.h>
#include "CalendarEvent.h"
+#include "JSCalendarItemProperties.h"
#include <CommonsJavaScript/PrivateObject.h>
namespace DeviceAPI {
#define TIZEN_CALENDAR_TASK_COMPLETED_DATE "completedDate"
#define TIZEN_CALENDAR_TASK_PROGRESS "progress"
-typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<CalendarEventPtr,
- WrtDeviceApis::CommonsJavaScript::NoOwnership> CalendarTaskPrivObject;
+typedef CalendarItemPropertiesPrivObject CalendarTaskPrivObject;
class JSCalendarTask
{
JSContextRef ctx,
const JSObjectRef object);
- static JSObjectRef createJSCalendarTask(JSContextRef context, CalendarEventPtr task);
+ static JSObjectRef createJSCalendarTask(JSContextRef context, CalendarEventPtr task, const DeviceAPI::Common::SecurityAccessor *securityAccessor);
static JSObjectRef constructor(JSContextRef context,
JSObjectRef constructor,
static FunctionMapping CalendarFunctions = createCalendarFunctions();
-#pragma GCC visibility push(default)
-
DEFINE_FUNCTION_GETTER(Calendar, CalendarFunctions);
-#pragma GCC visibility pop
-
static FunctionMapping createCalendarFunctions()
{
/**
#include <string>
#include <Commons/FunctionDeclaration.h>
+#include "plugin_config_impl.h"
namespace DeviceAPI {
namespace Calendar {
-// Functions from calendar manager
-#define CALENDAR_FUNCTION_API_GET_CALENDARS "getCalendars"
-#define CALENDAR_FUNCTION_API_GET_DEFAULT_CALENDAR "getDefaultCalendar"
-#define CALENDAR_FUNCTION_API_GET_UNIFIED_CALENDAR "getUnifiedCalendar"
-#define CALENDAR_FUNCTION_API_GET_CALENDAR "getCalendar"
-
-// Functions from calendar
-#define CALENDAR_FUNCTION_API_ADD "add"
-#define CALENDAR_FUNCTION_API_ADD_BATCH "addBatch"
-#define CALENDAR_FUNCTION_API_UPDATE "update"
-#define CALENDAR_FUNCTION_API_UPDATE_BATCH "updateBatch"
-#define CALENDAR_FUNCTION_API_REMOVE "remove"
-#define CALENDAR_FUNCTION_API_REMOVE_BATCH "removeBatch"
-#define CALENDAR_FUNCTION_API_FIND "find"
-#define CALENDAR_FUNCTION_API_CONVERT_TO_STRING "convertToString"
-#define CALENDAR_FUNCTION_API_ADD_CHANGE_LISTENER "addChangeListener"
-#define CALENDAR_FUNCTION_API_REMOVE_CHANGE_LISTENER "removeChangeListener"
-#define CALENDAR_FUNCTION_API_EXPAND_RECURRENCE "expandRecurrence"
-#define CALENDAR_FUNCTION_API_GET "get"
-#define CALENDAR_FUNCTION_API_CLONE "clone"
-
DECLARE_FUNCTION_GETTER(Calendar);
#define CALENDAR_CHECK_ACCESS(functionName) \
--- /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 _CALENDAR_PLUGIN_CONFIG_IMPL_H_
+#define _CALENDAR_PLUGIN_CONFIG_IMPL_H_
+
+// Functions from calendar manager
+#define CALENDAR_FUNCTION_API_GET_CALENDARS "getCalendars"
+#define CALENDAR_FUNCTION_API_GET_DEFAULT_CALENDAR "getDefaultCalendar"
+#define CALENDAR_FUNCTION_API_GET_UNIFIED_CALENDAR "getUnifiedCalendar"
+#define CALENDAR_FUNCTION_API_GET_CALENDAR "getCalendar"
+
+// Functions from calendar
+#define CALENDAR_FUNCTION_API_ADD "add"
+#define CALENDAR_FUNCTION_API_ADD_BATCH "addBatch"
+#define CALENDAR_FUNCTION_API_UPDATE "update"
+#define CALENDAR_FUNCTION_API_UPDATE_BATCH "updateBatch"
+#define CALENDAR_FUNCTION_API_REMOVE "remove"
+#define CALENDAR_FUNCTION_API_REMOVE_BATCH "removeBatch"
+#define CALENDAR_FUNCTION_API_FIND "find"
+#define CALENDAR_FUNCTION_API_CONVERT_TO_STRING "convertToString"
+#define CALENDAR_FUNCTION_API_ADD_CHANGE_LISTENER "addChangeListener"
+#define CALENDAR_FUNCTION_API_REMOVE_CHANGE_LISTENER "removeChangeListener"
+#define CALENDAR_FUNCTION_API_EXPAND_RECURRENCE "expandRecurrence"
+#define CALENDAR_FUNCTION_API_GET "get"
+#define CALENDAR_FUNCTION_API_CLONE "clone"
+
+#endif // _CALENDAR_PLUGIN_CONFIG_IMPL_H_
#include <TimeTracer.h>
#include <GlobalContextManager.h>
+#include <JSStringRefWrapper.h>
+#include <Security.h>
#include <Logger.h>
+#include "plugin_config.h"
+
+namespace DeviceAPI {
+namespace Calendar {
+
+using namespace WrtDeviceApis;
+using namespace WrtDeviceApis::Commons;
+
+AceSecurityStatus calendarAceCheckAccessFunction(const char* functionName)
+{
+ return CALENDAR_CHECK_ACCESS(functionName);
+}
+
+DEFINE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
+
+DEFINE_SECURITY_ACCESSOR_SETTER(AceCheckerCalendarSetter, CalendarManagerPrivObject, gSecurityAccessor);
+DEFINE_JSOBJECT_SECURITY_ACCESSOR_SETTER(AceCheckerCalendarConstructorSetter, gSecurityAccessor);
+
namespace Options{
class_definition_options_t CalendarOptions =
{
JS_CLASS,
CREATE_INSTANCE,
- NONE_NOTICE,
+ ALWAYS_NOTICE,
USE_OVERLAYED, //ignored
- NULL,
+ AceCheckerCalendarSetter,
NULL
};
class_definition_options_t CalendarInterfaceOptions = {
JS_INTERFACE,
CREATE_INSTANCE,
- NONE_NOTICE,
+ ALWAYS_NOTICE,
USE_OVERLAYED, //ignored
- NULL, // JSWidget::acquireGlobalContext,
+ AceCheckerCalendarConstructorSetter, // JSWidget::acquireGlobalContext,
NULL,
NULL
};
}
-namespace DeviceAPI {
-namespace Calendar {
-
-using namespace WrtDeviceApis;
-using namespace WrtDeviceApis::Commons;
-
void on_widget_start_callback(int widgetId)
{
LoggerD("[Tizen\\Calendar] on_widget_start_callback (" << widgetId << ")");
} Catch (Exception) {
LoggerE("WrtAccess initialization failed");
}
+
+ INITAILIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor, calendarAceCheckAccessFunction);
}
void on_widget_stop_callback(int widgetId)
} Catch (Exception) {
LoggerE("WrtAccess deinitialization failed");
}
+
+ FINALIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
}
void on_frame_load_callback(const void * context)
IF(ENABLE_OPTIONAL_CALL_HISTORY)
PKG_CHECK_MODULES(platform_pkgs_callhistory REQUIRED contacts-service2 glib-2.0 libpcrecpp)
+ADD_DEFINITIONS("-fvisibility=hidden")
+
INCLUDE_DIRECTORIES(
${INCLUDE_COMMON}
${TOP}/Tizen
//
#include "CallHistoryAsyncCallbackManager.h"
-#include <dpl/singleton_impl.h>
-
-
-
-IMPLEMENT_SINGLETON(DeviceAPI::CallHistory::CallHistoryAsyncCallbackManager)
namespace DeviceAPI {
namespace CallHistory {
+SINGLETON_IMPLEMENTATION(CallHistoryAsyncCallbackManager)
+
} // Tizen1_0
} // TizenApis
#ifndef _TIZEN_CALLHISTORY_ASYNC_CALLBACK_MANAGER_H_
#define _TIZEN_CALLHISTORY_ASYNC_CALLBACK_MANAGER_H_
-#include <dpl/singleton.h>
#include <AsyncCallbackManager.h>
namespace DeviceAPI {
friend class DPL::Singleton<CallHistoryAsyncCallbackManager>;
};
-typedef DPL::Singleton<CallHistoryAsyncCallbackManager> CallHistoryAsyncCallbackManagerSingleton;
+SINGLETON_DEFINITION(CallHistoryAsyncCallbackManager)
} // Tizen1_0
} // TizenApis
//
#include "CallHistoryListenerManager.h"
-#include <dpl/singleton_impl.h>
-
-
-
-IMPLEMENT_SINGLETON(DeviceAPI::CallHistory::CallHistoryListenerManager)
namespace DeviceAPI {
namespace CallHistory {
+SINGLETON_IMPLEMENTATION(CallHistoryListenerManager)
+
} // Tizen1_0
} // TizenApis
#include <map>
#include <JavaScriptCore/JavaScript.h>
#include <dpl/shared_ptr.h>
-#include <dpl/singleton.h>
#include <IListenerManager.h>
#include "JSCallHistory.h"
#include <Logger.h>
{
}
};
-typedef DPL::Singleton<CallHistoryListenerManager> CallHistoryListenerManagerSingleton;
+SINGLETON_DEFINITION(CallHistoryListenerManager)
class CallHistoryListenerCanceller : public DeviceAPI::Common::IListenerItem
{
#include "CallHistoryMultiCallback.h"
#include "ResponseDispatcher.h"
#include "Converter.h"
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
#include "CallHistoryAsyncCallbackManager.h"
#include "CallHistoryListenerManager.h"
#include "CallHistoryFilterConverter.h"
{ 0, 0, 0 }
};
-const JSClassRef JSCallHistory::getClassRef() {
+const JSClassRef DLL_EXPORT JSCallHistory::getClassRef() {
if (!m_jsClassRef) {
m_jsClassRef = JSClassCreate(&m_classInfo);
}
JSValueRef JSCallHistory::find(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
const JSValueRef arguments[], JSValueRef* exception) {
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- AceSecurityStatus status = CALLHISTORY_CHECK_ACCESS(
- CALL_HISTORY_FUNCTION_API_FIND);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
- if (argumentCount < 1) {
- return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
- }
JSCallHistoryPriv *priv = static_cast<JSCallHistoryPriv*> (JSObjectGetPrivate(thisObject));
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
+ TIZEN_CHECK_ACCESS(context, exception, priv, CALL_HISTORY_FUNCTION_API_FIND);
+
+ if (argumentCount < 1) {
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ }
+
JSContextRef gContext = priv->getContext();
WrtDeviceApis::CommonsJavaScript::Converter converter(context);
Validator check(context, exception);
const JSValueRef arguments[], JSValueRef* exception) {
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- AceSecurityStatus status = CALLHISTORY_CHECK_ACCESS(
- CALL_HISTORY_FUNCTION_API_REMOVE);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
try{
ArgumentValidator validator(context, argumentCount, arguments);
- JSObjectRef entryObj = validator.toObject(0);
-
- if (argumentCount < 1) {
- return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
- }
-
JSCallHistoryPriv *priv = static_cast<JSCallHistoryPriv*> (JSObjectGetPrivate(thisObject));
if (!priv) {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
+ TIZEN_CHECK_ACCESS(context, exception, priv, CALL_HISTORY_FUNCTION_API_REMOVE);
+
+ JSObjectRef entryObj = validator.toObject(0);
+
+ if (argumentCount < 1) {
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ }
+
Converter converter(context);
if (!JSValueIsObjectOfClass(context, arguments[0], JSCallHistoryEntry::getClassRef())) {
const JSValueRef arguments[], JSValueRef* exception) {
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- AceSecurityStatus status = CALLHISTORY_CHECK_ACCESS(
- CALL_HISTORY_FUNCTION_API_REMOVE_BATCH);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
- if (argumentCount < 1) {
- return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
- }
JSCallHistoryPriv *priv = static_cast<JSCallHistoryPriv*> (JSObjectGetPrivate(thisObject));
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
+ TIZEN_CHECK_ACCESS(context, exception, priv, CALL_HISTORY_FUNCTION_API_REMOVE_BATCH);
+
+ if (argumentCount < 1) {
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ }
+
JSContextRef gContext = priv->getContext();
Converter converter(context);
const JSValueRef arguments[], JSValueRef* exception) {
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- AceSecurityStatus status = CALLHISTORY_CHECK_ACCESS(
- CALL_HISTORY_FUNCTION_API_REMOVE_ALL);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
JSCallHistoryPriv *priv = static_cast<JSCallHistoryPriv*> (JSObjectGetPrivate(thisObject));
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
+ TIZEN_CHECK_ACCESS(context, exception, priv, CALL_HISTORY_FUNCTION_API_REMOVE_ALL);
+
JSContextRef gContext = priv->getContext();
Converter converter(context);
JSValueRef JSCallHistory::addChangeListener(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
const JSValueRef arguments[], JSValueRef* exception) {
- AceSecurityStatus status = CALLHISTORY_CHECK_ACCESS(
- CALL_HISTORY_FUNCTION_API_ADDLISTENER);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
try{
ArgumentValidator validator(context, argumentCount, arguments);
JSObjectRef observerObj = validator.toCallbackObject(0, false,"onadded","onchanged","onremoved",NULL);
- if (argumentCount < 1) {
- return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
- }
-
JSCallHistoryPriv *priv = static_cast<JSCallHistoryPriv*> (JSObjectGetPrivate(thisObject));
if (!priv) {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
+ TIZEN_CHECK_ACCESS(context, exception, priv, CALL_HISTORY_FUNCTION_API_ADDLISTENER);
+
+ if (argumentCount < 1) {
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
+ }
+
JSContextRef gContext = priv->getContext();
Converter converter(context);
JSValueRef JSCallHistory::removeChangeListener(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount,
const JSValueRef arguments[], JSValueRef* exception) {
- AceSecurityStatus status = CALLHISTORY_CHECK_ACCESS(
- CALL_HISTORY_FUNCTION_API_REMOVELISTENER);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
long handle = 0;
try{
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error : Invalid private pointer");
}
+ TIZEN_CHECK_ACCESS(context, exception, priv, CALL_HISTORY_FUNCTION_API_REMOVELISTENER);
+
JSContextRef gContext = priv->getContext();
if (handle != 0) {
#include <JavaScriptCore/JavaScript.h>
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
#include "ICallHistory.h"
+using namespace WrtDeviceApis::Commons;
+using namespace WrtDeviceApis::CommonsJavaScript;
+
namespace DeviceAPI {
namespace CallHistory {
-typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<ICallHistoryPtr>::Type JSCallHistoryPriv;
+typedef PrivateObject<ICallHistoryPtr, NoOwnership> JSCallHistoryPrivObject;
+
+class JSCallHistoryPriv :
+ public JSCallHistoryPrivObject,
+ public DeviceAPI::Common::SecurityAccessor
+{
+public:
+ JSCallHistoryPriv(JSContextRef context, ICallHistoryPtr callHistory) :
+ JSCallHistoryPrivObject(context, callHistory),
+ DeviceAPI::Common::SecurityAccessor()
+ {
+ }
+
+ virtual ~JSCallHistoryPriv()
+ {
+ }
+};
class JSCallHistory
{
{ 0, 0, 0, 0 }
};
-const JSClassRef JSCallHistoryEntry::getClassRef()
+const JSClassRef DLL_EXPORT JSCallHistoryEntry::getClassRef()
{
if (!m_jsClassRef) {
m_jsClassRef = JSClassCreate(&m_classInfo);
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
#include <JSWebAPIErrorFactory.h>
-#include "JSCallHistory.h"
#include "Converter.h"
#include "CallHistoryAsyncCallbackManager.h"
#include <Logger.h>
#include <Commons/FunctionDefinition.h>
#include <Commons/FunctionDeclaration.h>
#include <Commons/Exception.h>
+#include "plugin_config.h"
#define CALL_HISTORY_FEATURE_API_READ "http://tizen.org/privilege/callhistory.read"
#define CALL_HISTORY_FEATURE_API_WRITE "http://tizen.org/privilege/callhistory.write"
const char* CALL_HISTORY_DEVICE_CAP_READ = "callhistory.read";
const char* CALL_HISTORY_DEVICE_CAP_WRITE = "callhistory.write";
-const char* CALL_HISTORY_FUNCTION_API_FIND = "find";
-const char* CALL_HISTORY_FUNCTION_API_REMOVE = "remove";
-const char* CALL_HISTORY_FUNCTION_API_REMOVE_BATCH = "removeBatch";
-const char* CALL_HISTORY_FUNCTION_API_REMOVE_ALL = "removeAll";
-const char* CALL_HISTORY_FUNCTION_API_ADDLISTENER = "addListener";
-const char* CALL_HISTORY_FUNCTION_API_REMOVELISTENER = "removeListener";
-
static WrtDeviceApis::Commons::FunctionMapping createCallHistoryFunctions();
static WrtDeviceApis::Commons::FunctionMapping CallHistoryFunctions = createCallHistoryFunctions();
-#pragma GCC visibility push(default)
-
DEFINE_FUNCTION_GETTER(CallHistory, CallHistoryFunctions);
-#pragma GCC visibility pop
-
static WrtDeviceApis::Commons::FunctionMapping createCallHistoryFunctions()
{
using namespace WrtDeviceApis::Commons;
#define _CALLHISTORY_PLUGIN_CONFIG_H_
#include <Commons/FunctionDeclaration.h>
+#include "plugin_config_impl.h"
namespace DeviceAPI {
namespace CallHistory {
-extern const char* CALL_HISTORY_FUNCTION_API_FIND;
-extern const char* CALL_HISTORY_FUNCTION_API_REMOVE;
-extern const char* CALL_HISTORY_FUNCTION_API_REMOVE_BATCH;
-extern const char* CALL_HISTORY_FUNCTION_API_REMOVE_ALL;
-extern const char* CALL_HISTORY_FUNCTION_API_ADDLISTENER;
-extern const char* CALL_HISTORY_FUNCTION_API_REMOVELISTENER;
-
DECLARE_FUNCTION_GETTER(CallHistory);
-}
-}
-
-namespace WrtDeviceApis {
-namespace Commons {
-
#define CALLHISTORY_CHECK_ACCESS(functionName) \
WrtDeviceApis::Commons::aceCheckAccess<AceFunctionGetter, \
WrtDeviceApis::Commons::DefaultArgsVerifier<> >( \
--- /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 _CALLHISTORY_PLUGIN_CONFIG_IMPL_H_
+#define _CALLHISTORY_PLUGIN_CONFIG_IMPL_H_
+
+#define CALL_HISTORY_FUNCTION_API_FIND "find"
+#define CALL_HISTORY_FUNCTION_API_REMOVE "remove"
+#define CALL_HISTORY_FUNCTION_API_REMOVE_BATCH "removeBatch"
+#define CALL_HISTORY_FUNCTION_API_REMOVE_ALL "removeAll"
+#define CALL_HISTORY_FUNCTION_API_ADDLISTENER "addListener"
+#define CALL_HISTORY_FUNCTION_API_REMOVELISTENER "removeListener"
+
+#endif // _CALLHISTORY_PLUGIN_CONFIG_IMPL_H_
#include <Commons/WrtAccess/WrtAccess.h>
#include <Commons/Exception.h>
#include <TimeTracer.h>
+#include <Security.h>
+#include "plugin_config.h"
#include "JSCallHistory.h"
#include "CallHistoryAsyncCallbackManager.h"
#include "CallHistoryListenerManager.h"
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
+AceSecurityStatus callhistoryAceCheckAccessFunction(const char* functionName)
+{
+ return CALLHISTORY_CHECK_ACCESS(functionName);
+}
+
+DEFINE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
+
+DEFINE_SECURITY_ACCESSOR_SETTER(AceCheckerCallhistorySetter,
+ JSCallHistoryPriv,
+ gSecurityAccessor);
+
+class_definition_options_t option =
+{
+ JS_CLASS,
+ NONE,
+ ALWAYS_NOTICE,
+ IGNORED,
+ AceCheckerCallhistorySetter,
+ NULL,
+ NULL
+};
+
void on_widget_start_callback(int widgetId) {
LoggerD("[Tizen\\callhistory] on_widget_start_callback");
TIME_TRACER_INIT();
} catch(WrtDeviceApis::Commons::Exception) {
LoggerE("WrtAccess initialization failed");
}
+ INITAILIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor, callhistoryAceCheckAccessFunction);
}
void on_widget_stop_callback(int widgetId) {
} catch(WrtDeviceApis::Commons::Exception) {
LoggerE("WrtAccess deinitialization failed");
}
+ FINALIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
}
void on_frame_load_callback(const void * context)
WRT_JS_EXTENSION_OBJECT_TIZEN,
CALLHISTORY,
(js_class_template_getter)DeviceAPI::CallHistory::JSCallHistory::getClassRef,
- NULL)
+ &option)
PLUGIN_CLASS_MAP_END
} // CallHistory
EventAddressBookRemoveBatchEventAnswerReceiver(ThreadEnum::NULL_THREAD),
EventAddressBookFindEventAnswerReceiver(ThreadEnum::NULL_THREAD),
EventAddressBookChangeListenerListener(ThreadEnum::NULL_THREAD),
+ DeviceAPI::Common::SecurityAccessor(),
AddressBookPrivObject(context, addressBook)
{
LoggerD("AddressBookController constructed : " << this);
#include <CommonsJavaScript/PrivateObject.h>
#include <CommonsJavaScript/JSPendingOperationPrivateObject.h>
#include <CommonsJavaScript/JSPendingOperation.h>
+#include <Security.h>
#include "IAddressBook.h"
namespace DeviceAPI {
public EventAddressBookRemoveBatchEventAnswerReceiver,
public EventAddressBookFindEventAnswerReceiver,
public EventAddressBookChangeListenerListener,
+ public DeviceAPI::Common::SecurityAccessor,
public AddressBookPrivObject
{
public:
SET(TARGET_NAME ${contact_target})
SET(DESTINATION_NAME ${contact_dest})
SET(TARGET_IMPL_NAME ${contact_impl})
-SET(TARGET_CONFIG_NAME ${contact_config})
PKG_CHECK_MODULES(platform_pkgs_contact REQUIRED contacts-service2 libpcrecpp)
${platform_pkgs_contact_LIBRARIES}
)
-SET(SRCS_CONFIG
- plugin_config.cpp
-)
-
-ADD_LIBRARY(${TARGET_CONFIG_NAME} SHARED ${SRCS_CONFIG})
-
-TARGET_LINK_LIBRARIES(${TARGET_CONFIG_NAME}
- ${LIBS_COMMON}
-)
-
SET(SRCS
+ plugin_config.cpp
plugin_initializer.cpp
)
TARGET_LINK_LIBRARIES(${TARGET_NAME}
${TARGET_IMPL_NAME}
- ${TARGET_CONFIG_NAME}
)
-INSTALL(TARGETS ${TARGET_NAME} ${TARGET_CONFIG_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
+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})
INSTALL(
DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${DESTINATION_HEADER_PREFIX}/contact
{
}
-JSValueRef ContactConverter::toJSValueRef(const AddressBookPtr &arg)
+JSValueRef ContactConverter::toJSValueRef(const AddressBookPtr &arg, const DeviceAPI::Common::SecurityAccessor *securityAccessor)
{
// It may not used
AddressBookController *priv = new AddressBookController(m_context, arg);
+ priv->copyAceCheckAccessFunction(securityAccessor);
return JSObjectMake(m_context, JSAddressBook::getClassRef(), priv);
}
return JSAddressBook::getAddressBook(m_context, jsValue);
}
-JSValueRef ContactConverter::toJSValueRef(const AddressBookArrayPtr &arg)
+JSValueRef ContactConverter::toJSValueRef(const AddressBookArrayPtr &arg, const DeviceAPI::Common::SecurityAccessor *securityAccessor)
{
int size = arg->size();
for(int i = 0; i < size; i++)
{
- JSValueRef jsvalue = toJSValueRef(arg->at(i));
+ JSValueRef jsvalue = toJSValueRef(arg->at(i), securityAccessor);
if (!JSSetArrayElement(m_context, resultObject, i, jsvalue))
ThrowMsg(ConversionException, "Can not fill address book array.");
}
return result;
}
-JSValueRef ContactConverter::toJSValueRef(const PersonPtr &arg)
+JSValueRef ContactConverter::toJSValueRef(const PersonPtr &arg, const DeviceAPI::Common::SecurityAccessor *securityAccessor)
{
- return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSPerson::getClassRef(), arg);
+ JSPersonPriv *priv = new JSPersonPriv(m_context, arg);
+ priv->copyAceCheckAccessFunction(securityAccessor);
+ return JSObjectMake(m_context, JSPerson::getClassRef(), priv);
}
PersonPtr ContactConverter::toPerson(const JSValueRef &jsValue)
return JSPerson::getPerson(m_context, jsValue);
}
-JSValueRef ContactConverter::toJSValueRef(const PersonArrayPtr &arg)
+JSValueRef ContactConverter::toJSValueRef(const PersonArrayPtr &arg, const DeviceAPI::Common::SecurityAccessor *securityAccessor)
{
int size = arg->size();
for(int i = 0; i < size; i++)
{
- JSValueRef jsvalue = toJSValueRef(arg->at(i));
+ JSValueRef jsvalue = toJSValueRef(arg->at(i), securityAccessor);
if (!JSSetArrayElement(m_context, resultObject, i, jsvalue))
ThrowMsg(ConversionException, "Can not add object to array.");
}
#include "ContactEmailAddress.h"
#include <ArgumentValidator.h>
#include <JSWebAPIErrorFactory.h>
+#include <Security.h>
#include <JSUtil.h>
#include <Export.h>
explicit ContactConverter(JSContextRef context);
virtual ~ContactConverter();
- JSValueRef toJSValueRef(const AddressBookPtr &arg);
+ JSValueRef toJSValueRef(const AddressBookPtr &arg, const DeviceAPI::Common::SecurityAccessor *securityAccessor);
AddressBookPtr toAddressBook(const JSValueRef &jsValue);
- JSValueRef toJSValueRef(const AddressBookArrayPtr &arg);
+ JSValueRef toJSValueRef(const AddressBookArrayPtr &arg, const DeviceAPI::Common::SecurityAccessor *securityAccessor);
AddressBookArrayPtr toAddressBookArray(const JSValueRef &jsValue);
JSValueRef toJSValueRef(const ContactPtr &arg);
JSValueRef toJSValueRef(const ContactGroupArrayPtr &arg);
ContactGroupArrayPtr toContactGroupArray(const JSValueRef &jsValue);
- JSValueRef toJSValueRef(const PersonPtr &arg);
+ JSValueRef toJSValueRef(const PersonPtr &arg, const DeviceAPI::Common::SecurityAccessor *securityAccessor);
PersonPtr toPerson(const JSValueRef &jsValue);
- JSValueRef toJSValueRef(const PersonArrayPtr &arg);
+ JSValueRef toJSValueRef(const PersonArrayPtr &arg, const DeviceAPI::Common::SecurityAccessor *securityAccessor);
PersonArrayPtr toPersonArray(const JSValueRef &jsValue);
JSValueRef toJSValueRef(const ContactRefPtr &arg);
EventContactManagerRemoveBatchAnswerReceiver(ThreadEnum::NULL_THREAD),
EventContactManagerFindAnswerReceiver(ThreadEnum::NULL_THREAD),
EventContactManagerChangeListenerListener(ThreadEnum::NULL_THREAD),
+ SecurityAccessor(),
ContactManagerPrivObject(context, contactManager)
{
LoggerD("ContactManagerController constructed : " << this);
LoggerD("ContactManagerController destructed : " << this);
}
-void ContactManagerAsyncAnswerHandler::getAddressBooks(const EventContactManagerGetAddressBooksPtr &event)
+void ContactManagerAsyncAnswerHandler::getAddressBooks(const EventContactManagerGetAddressBooksPtr &event, SecurityAccessor *securityAccessor)
{
LoggerD("entered");
JSCallbackManagerPtr callbackManager =
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(gContext);
AddressBookArrayPtr addressBooks = event->getAddressBooks();
- JSValueRef result = converter->toJSValueRef(addressBooks);
+ JSValueRef result = converter->toJSValueRef(addressBooks, securityAccessor);
callbackManager->callOnSuccess(result);
return;
callbackManager->callOnSuccess();
}
-void ContactManagerAsyncAnswerHandler::find(const EventContactManagerFindPtr &event)
+void ContactManagerAsyncAnswerHandler::find(const EventContactManagerFindPtr &event, SecurityAccessor *securityAccessor)
{
LoggerD("entered");
JSCallbackManagerPtr callbackManager =
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(gContext);
PersonArrayPtr contacts = event->getPersons();
- JSValueRef result = converter->toJSValueRef(contacts);
+ JSValueRef result = converter->toJSValueRef(contacts, securityAccessor);
callbackManager->callOnSuccess(result);
return;
cbm->callOnError(errorObject);
}
-void ContactManagerAsyncAnswerHandler::changeListenerPersonAdded(const EventContactManagerChangeListenerPtr &event)
+void ContactManagerAsyncAnswerHandler::changeListenerPersonAdded(const EventContactManagerChangeListenerPtr &event, SecurityAccessor *securityAccessor)
{
LoggerD("entered");
JSContactManagerChangeCallbackManagerPtr cbm =
JSValueRef contacts;
Try {
- contacts = converter->toJSValueRef(eventInfo->getPersons());
+ contacts = converter->toJSValueRef(eventInfo->getPersons(), securityAccessor);
} Catch (Exception) {
LoggerE("Conversion error");
return;
cbm->callOnPersonsAdded(contacts);
}
-void ContactManagerAsyncAnswerHandler::changeListenerPersonUpdated(const EventContactManagerChangeListenerPtr &event)
+void ContactManagerAsyncAnswerHandler::changeListenerPersonUpdated(const EventContactManagerChangeListenerPtr &event, SecurityAccessor *securityAccessor)
{
LoggerD("entered");
JSContactManagerChangeCallbackManagerPtr cbm =
JSValueRef contacts;
Try {
- contacts = converter->toJSValueRef(eventInfo->getPersons());
+ contacts = converter->toJSValueRef(eventInfo->getPersons(), securityAccessor);
} Catch (Exception) {
LoggerE("Conversion error");
return;
void ContactManagerController::OnAnswerReceived(const EventContactManagerGetAddressBooksPtr &event)
{
- ContactManagerAsyncAnswerHandler::getAddressBooks(event);
+ ContactManagerAsyncAnswerHandler::getAddressBooks(event, this);
}
void ContactManagerController::OnAnswerReceived(const EventContactManagerUpdateBatchPtr &event)
void ContactManagerController::OnAnswerReceived(const EventContactManagerFindPtr &event)
{
- ContactManagerAsyncAnswerHandler::find(event);
+ ContactManagerAsyncAnswerHandler::find(event, this);
}
void ContactManagerController::onAnswerReceived(const EventContactManagerChangeListenerPtr &event)
EventInfoContactManagerChange::CallbackType type = eventInfo->getCallbackType();
if(type == EventInfoContactManagerChange::OnPersonsAdded)
- ContactManagerAsyncAnswerHandler::changeListenerPersonAdded(event);
+ ContactManagerAsyncAnswerHandler::changeListenerPersonAdded(event, this);
else if(type == EventInfoContactManagerChange::OnPersonsUpdated)
- ContactManagerAsyncAnswerHandler::changeListenerPersonUpdated(event);
+ ContactManagerAsyncAnswerHandler::changeListenerPersonUpdated(event, this);
else if(type == EventInfoContactManagerChange::OnPersonsRemoved)
ContactManagerAsyncAnswerHandler::changeListenerPersonRemoved(event);
else if(type == EventInfoContactManagerChange::OnError)
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/PrivateObject.h>
#include <CommonsJavaScript/JSPendingOperationPrivateObject.h>
+#include <Security.h>
#include "IContactManager.h"
namespace DeviceAPI {
public EventContactManagerRemoveBatchAnswerReceiver,
public EventContactManagerFindAnswerReceiver,
public EventContactManagerChangeListenerListener,
+ public DeviceAPI::Common::SecurityAccessor,
public ContactManagerPrivObject
{
private:
class ContactManagerAsyncAnswerHandler
{
public:
- static void getAddressBooks(const EventContactManagerGetAddressBooksPtr &event);
+ static void getAddressBooks(const EventContactManagerGetAddressBooksPtr &event, DeviceAPI::Common::SecurityAccessor *securityAccessor);
static void updateBatch(const EventContactManagerUpdateBatchPtr &event);
static void removeBatch(const EventContactManagerRemoveBatchPtr &event);
- static void find(const EventContactManagerFindPtr &event);
+ static void find(const EventContactManagerFindPtr &event, DeviceAPI::Common::SecurityAccessor *securityAccessor);
static void changeListenerError(const EventContactManagerChangeListenerPtr &event);
- static void changeListenerPersonAdded(const EventContactManagerChangeListenerPtr &event);
- static void changeListenerPersonUpdated(const EventContactManagerChangeListenerPtr &event);
+ static void changeListenerPersonAdded(const EventContactManagerChangeListenerPtr &event, DeviceAPI::Common::SecurityAccessor *securityAccessor);
+ static void changeListenerPersonUpdated(const EventContactManagerChangeListenerPtr &event, DeviceAPI::Common::SecurityAccessor *securityAccessor);
static void changeListenerPersonRemoved(const EventContactManagerChangeListenerPtr &event);
};
#include "EventAddressBookFind.h"
#include "EventAddressBookChangeListener.h"
#include "EventAddressBookRemoveBatch.h"
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
#include "JSAddressBook.h"
#include "JSContact.h"
#include "JSContactGroup.h"
#include <JSWebAPIErrorFactory.h>
#include <JSUtil.h>
#include <TimeTracer.h>
+#include <Security.h>
#include <Logger.h>
#include "ContactUtility.h"
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_GET);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_GET);
string id;
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD);
try {
ArgumentValidator validator(context, argumentCount, arguments);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_BATCH);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_BATCH);
try {
ArgumentValidator validator(context, argumentCount, arguments);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE);
try {
ArgumentValidator validator(context, argumentCount, arguments);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE_BATCH);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE_BATCH);
try {
ArgumentValidator validator(context, argumentCount, arguments);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE);
ArgumentValidator validator(context, argumentCount, arguments);
string contactId;
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_BATCH);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_BATCH);
try {
ArgumentValidator validator(context, argumentCount, arguments);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_FIND);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_FIND);
try {
ArgumentValidator validator(context, argumentCount, arguments);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_CHANGE_LISTENER);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_CHANGE_LISTENER);
BasicValidator validator = BasicValidatorFactory::getValidator(context, exception);
try {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_CHANGE_LISTENER);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_CHANGE_LISTENER);
long watchId = 0;
string id;
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_GET_GROUP);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_GET_GROUP);
string id;
JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_GROUP);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_GROUP);
try {
ArgumentValidator validator(context, argumentCount, arguments);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE_GROUP);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE_GROUP);
try {
ArgumentValidator validator(context, argumentCount, arguments);
JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_GROUP);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_GROUP);
string groupId;
JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_ADDRESS_BOOK_GET_GROUPS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_ADDRESS_BOOK_GET_GROUPS);
string id;
#include <CommonsJavaScript/Validator.h>
#include <SecurityExceptions.h>
#include "ContactFactory.h"
-#include "plugin_config.h"
#include "ContactConverter.h"
#include "JSContact.h"
#include "Contact.h"
#include <FilterConverter.h>
#include "ContactFactory.h"
#include "ContactTypes.h"
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
#include "ContactManagerController.h"
#include "ContactAsyncCallbackManager.h"
#include "ContactListenerManager.h"
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_ADDRESS_BOOKS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_ADDRESS_BOOKS);
BasicValidator validator = BasicValidatorFactory::getValidator(context, exception);
try {
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);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, priv, CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_DEFAULT_ADDRESS_BOOK);
ContactManagerPtr contactManager;
JSContextRef gContext;
JSValueRef resultValue;
Try {
- resultValue = converter->toJSValueRef(defaultAddressBook);
+ resultValue = converter->toJSValueRef(defaultAddressBook, priv);
} Catch(Exception){
LoggerE("Conversion error.");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
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);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, priv, CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_UNIFIED_ADDRESS_BOOK);
ContactManagerPtr contactManager;
JSContextRef gContext;
JSValueRef resultValue;
Try {
- resultValue = converter->toJSValueRef(unifiedAddressBook);
+ resultValue = converter->toJSValueRef(unifiedAddressBook, priv);
} Catch(Exception){
LoggerE("Conversion error.");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_ADDRESS_BOOK);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, priv, CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_ADDRESS_BOOK);
ContactManagerPtr contactManager;
JSContextRef gContext;
JSValueRef resultValue;
Try {
- resultValue = converter->toJSValueRef(addressBook);
+ resultValue = converter->toJSValueRef(addressBook, priv);
} Catch(Exception){
LoggerE("Conversion error.");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_GET);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_CONTACT_MANAGER_GET);
std::string id;
JSValueRef result;
Try {
- result = converter->toJSValueRef(person);
+ result = converter->toJSValueRef(person, controller);
} Catch(Exception) {
LoggerE("Error on conversion : " << _rethrown_exception.GetMessage());
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_UPDATE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_CONTACT_MANAGER_UPDATE);
try {
ArgumentValidator validator(context, argumentCount, arguments);
JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_UPDATE_BATCH);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_CONTACT_MANAGER_UPDATE_BATCH);
try {
ArgumentValidator validator(context, argumentCount, arguments);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE);
std::string personId;
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE_BATCH);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE_BATCH);
try {
ArgumentValidator validator(context, argumentCount, arguments);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_FIND);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_CONTACT_MANAGER_FIND);
try {
ArgumentValidator validator(context, argumentCount, arguments);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_ADD_CHANGE_LISTENER);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_CONTACT_MANAGER_ADD_CHANGE_LISTENER);
BasicValidator validator = BasicValidatorFactory::getValidator(context, exception);
try {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE_CHANGE_LISTENER);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, controller, CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE_CHANGE_LISTENER);
ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(context);
#include <CommonsJavaScript/Validator.h>
#include <SecurityExceptions.h>
#include "ContactFactory.h"
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
#include "ContactConverter.h"
#include "JSPerson.h"
#include <ArgumentValidator.h>
{
LoggerD("entered");
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
+ JSPersonPriv *priv = NULL;
PersonPtr person(NULL);
Try
{
- person = getPrivData(thisObject);
+ priv = static_cast<JSPersonPriv*>(JSObjectGetPrivate(thisObject));
+ if (!priv) {
+ ThrowMsg(WrtDeviceApis::Commons::NullPointerException, "Private object is null");
+ }
+ person = priv->getObject();
if (person == NULL)
ThrowMsg(InvalidArgumentException, "No private object.");
}
JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_PERSON_LINK);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, priv, CONTACT_FUNCTION_API_PERSON_LINK);
ArgumentValidator validator(context, argumentCount, arguments);
std::string personId;
{
LoggerD("entered");
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
+ JSPersonPriv *priv = NULL;
PersonPtr person(NULL);
Try
{
- person = getPrivData(thisObject);
+ priv = static_cast<JSPersonPriv*>(JSObjectGetPrivate(thisObject));
+ if (!priv) {
+ ThrowMsg(WrtDeviceApis::Commons::NullPointerException, "Private object is null");
+ }
+ person = priv->getObject();
if (person == NULL)
ThrowMsg(InvalidArgumentException, "No private object.");
}
JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
}
- AceSecurityStatus status = CONTACT_CHECK_ACCESS(CONTACT_FUNCTION_API_PERSON_UNLINK);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, priv, CONTACT_FUNCTION_API_PERSON_UNLINK);
ArgumentValidator validator(context, argumentCount, arguments);
std::string contactId;
JSValueRef result;
Try
{
- result = converter->toJSValueRef(unlinkedPerson);
+ result = converter->toJSValueRef(unlinkedPerson, priv);
}
Catch(Exception)
{
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/PrivateObject.h>
#include <Commons/IEvent.h>
+#include <Security.h>
#include "IPerson.h"
namespace DeviceAPI {
namespace Contact {
-typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<PersonPtr, WrtDeviceApis::CommonsJavaScript::NoOwnership> JSPersonPriv;
+typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<PersonPtr, WrtDeviceApis::CommonsJavaScript::NoOwnership> JSPersonPrivObject;
+
+class JSPersonPriv :
+ public DeviceAPI::Common::SecurityAccessor,
+ public JSPersonPrivObject
+{
+public:
+ JSPersonPriv(JSContextRef context, PersonPtr person) :
+ DeviceAPI::Common::SecurityAccessor(),
+ JSPersonPrivObject(context, person)
+ {
+ }
+
+ virtual ~JSPersonPriv()
+ {
+ }
+};
class JSPerson {
public:
static FunctionMapping ContactFunctions =
createContactFunctions();
-#pragma GCC visibility push(default)
-
DEFINE_FUNCTION_GETTER(Contact, ContactFunctions);
-#pragma GCC visibility pop
-
static FunctionMapping createContactFunctions()
{
/**
#include <string>
#include <Commons/FunctionDeclaration.h>
+#include "plugin_config_impl.h"
namespace DeviceAPI {
namespace Contact {
-#define CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_ADDRESS_BOOKS "ContactManager.getAddressBooks"
-#define CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_DEFAULT_ADDRESS_BOOK "ContactManager.getDefaultAddressBook"
-#define CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_UNIFIED_ADDRESS_BOOK "ContactManager.getUnifiedAddressBook"
-#define CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_ADDRESS_BOOK "ContactManager.getAddressBook"
-#define CONTACT_FUNCTION_API_CONTACT_MANAGER_GET "ContactManager.get"
-#define CONTACT_FUNCTION_API_CONTACT_MANAGER_UPDATE "ContactManager.update"
-#define CONTACT_FUNCTION_API_CONTACT_MANAGER_UPDATE_BATCH "ContactManager.updateBatch"
-#define CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE "ContactManager.remove"
-#define CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE_BATCH "ContactManager.removeBatch"
-#define CONTACT_FUNCTION_API_CONTACT_MANAGER_FIND "ContactManager.find"
-#define CONTACT_FUNCTION_API_CONTACT_MANAGER_ADD_CHANGE_LISTENER "ContactManager.addChangeListener"
-#define CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE_CHANGE_LISTENER "ContactManager.removeChangeListener"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_GET "AddressBook.get"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD "AddressBook.add"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_BATCH "AddressBook.addBatch"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE "AddressBook.update"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE_BATCH "AddressBook.updateBatch"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE "AddressBook.remove"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_BATCH "AddressBook.removeBatch"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_FIND "AddressBook.find"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_CHANGE_LISTENER "AddressBook.addChangeListener"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_CHANGE_LISTENER "AddressBook.removeChangeListener"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_GET_GROUP "AddressBook.getGroup"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_GROUP "AddressBook.addGroup"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE_GROUP "AddressBook.updateGroup"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_GROUP "AddressBook.removeGroup"
-#define CONTACT_FUNCTION_API_ADDRESS_BOOK_GET_GROUPS "AddressBook.getGroups"
-#define CONTACT_FUNCTION_API_PERSON_LINK "AddressBook.link"
-#define CONTACT_FUNCTION_API_PERSON_UNLINK "AddressBook.unlink"
-
DECLARE_FUNCTION_GETTER(Contact);
#define CONTACT_CHECK_ACCESS(functionName) \
--- /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 _CONTACT_PLUGIN_CONFIG_IMPL_H_
+#define _CONTACT_PLUGIN_CONFIG_IMPL_H_
+
+#define CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_ADDRESS_BOOKS "ContactManager.getAddressBooks"
+#define CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_DEFAULT_ADDRESS_BOOK "ContactManager.getDefaultAddressBook"
+#define CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_UNIFIED_ADDRESS_BOOK "ContactManager.getUnifiedAddressBook"
+#define CONTACT_FUNCTION_API_CONTACT_MANAGER_GET_ADDRESS_BOOK "ContactManager.getAddressBook"
+#define CONTACT_FUNCTION_API_CONTACT_MANAGER_GET "ContactManager.get"
+#define CONTACT_FUNCTION_API_CONTACT_MANAGER_UPDATE "ContactManager.update"
+#define CONTACT_FUNCTION_API_CONTACT_MANAGER_UPDATE_BATCH "ContactManager.updateBatch"
+#define CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE "ContactManager.remove"
+#define CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE_BATCH "ContactManager.removeBatch"
+#define CONTACT_FUNCTION_API_CONTACT_MANAGER_FIND "ContactManager.find"
+#define CONTACT_FUNCTION_API_CONTACT_MANAGER_ADD_CHANGE_LISTENER "ContactManager.addChangeListener"
+#define CONTACT_FUNCTION_API_CONTACT_MANAGER_REMOVE_CHANGE_LISTENER "ContactManager.removeChangeListener"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_GET "AddressBook.get"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD "AddressBook.add"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_BATCH "AddressBook.addBatch"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE "AddressBook.update"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE_BATCH "AddressBook.updateBatch"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE "AddressBook.remove"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_BATCH "AddressBook.removeBatch"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_FIND "AddressBook.find"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_CHANGE_LISTENER "AddressBook.addChangeListener"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_CHANGE_LISTENER "AddressBook.removeChangeListener"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_GET_GROUP "AddressBook.getGroup"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_ADD_GROUP "AddressBook.addGroup"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_UPDATE_GROUP "AddressBook.updateGroup"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_REMOVE_GROUP "AddressBook.removeGroup"
+#define CONTACT_FUNCTION_API_ADDRESS_BOOK_GET_GROUPS "AddressBook.getGroups"
+#define CONTACT_FUNCTION_API_PERSON_LINK "AddressBook.link"
+#define CONTACT_FUNCTION_API_PERSON_UNLINK "AddressBook.unlink"
+
+#endif // _CONTACT_PLUGIN_CONFIG_IMPL_H_
#include <Commons/plugin_initializer_def.h>
#include <Commons/WrtAccess/WrtAccess.h>
#include <TimeTracer.h>
+#include <Security.h>
#include "JSContactManager.h"
#include "JSContact.h"
#include "JSContactGroup.h"
#include "JSContactEmailAddress.h"
#include "ContactAsyncCallbackManager.h"
#include "ContactListenerManager.h"
+#include "plugin_config.h"
#include <Logger.h>
namespace DeviceAPI {
using namespace WrtDeviceApis;
using namespace WrtDeviceApis::Commons;
+AceSecurityStatus contactAceCheckAccessFunction(const char* functionName)
+{
+ return CONTACT_CHECK_ACCESS(functionName);
+}
+
+DEFINE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
+
+DEFINE_SECURITY_ACCESSOR_SETTER(AceCheckerContactSetter, ContactManagerController, gSecurityAccessor);
+
+class_definition_options_t option =
+{
+ JS_CLASS,
+ NONE,
+ ALWAYS_NOTICE,
+ IGNORED,
+ AceCheckerContactSetter,
+ NULL,
+ NULL
+};
+
void on_widget_start_callback(int widgetId)
{
LoggerD("[Tizen\\contact] on_widget_start_callback (" << widgetId << ")");
{
LoggerE("WrtAccess initialization failed");
}
+
+ INITAILIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor, contactAceCheckAccessFunction);
}
void on_widget_stop_callback(int widgetId)
{
LoggerE("WrtAccess deinitialization failed");
}
+
+ FINALIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
}
void on_frame_load_callback(const void * context)
PLUGIN_CLASS_MAP_ADD_CLASS(WRT_JS_EXTENSION_OBJECT_TIZEN,
"contact",
(js_class_template_getter)DeviceAPI::Contact::JSContactManager::getClassRef,
- NULL)
+ &option)
PLUGIN_CLASS_MAP_ADD_CLASS(WRT_JS_EXTENSION_OBJECT_TIZEN,
"Contact",
(js_class_template_getter)DeviceAPI::Contact::JSContact::getClassRef,
#include <JSWebAPIErrorFactory.h>
#include <ArgumentValidator.h>
#include <TimeTracer.h>
+#include <Security.h>
#include "JSUtil.h"
#include "ContentFactory.h"
#include "JSVideo.h"
#include "JSAudio.h"
#include "ContentConverter.h"
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
#include "ContentAsyncCallbackManager.h"
#include "ContentListener.h"
#include "ContentVideo.h"
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- MediacontentManagerPrivObject *privateObject;
- privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
+ MediacontentManagerPriv *privateObject;
+ privateObject = static_cast<MediacontentManagerPriv*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- MediacontentManagerPrivObject *privateObject;
- privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
+ MediacontentManagerPriv *privateObject;
+ privateObject = static_cast<MediacontentManagerPriv*>(JSObjectGetPrivate(thisObject));
if(!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
- AceSecurityStatus status = CONTENT_CHECK_ACCESS(CONTENT_FUNCTION_API_FIND_ITEMS);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CONTENT_FUNCTION_API_FIND_ITEMS);
JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
JSValueRef* exception)
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- MediacontentManagerPrivObject *privateObject;
- privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
+ MediacontentManagerPriv *privateObject;
+ privateObject = static_cast<MediacontentManagerPriv*>(JSObjectGetPrivate(thisObject));
if(!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
JSContextRef globalContext = GlobalContextManager::getInstance()->getGlobalContext(context);
- AceSecurityStatus status = CONTENT_CHECK_ACCESS(CONTENT_FUNCTION_API_UPDATE_ITEMS_BATCH);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CONTENT_FUNCTION_API_UPDATE_ITEMS_BATCH);
JSCallbackManagerPtr cbm(NULL);
MediaConverterFactory::ConverterType converter = MediaConverterFactory::getConverter(context);
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- MediacontentManagerPrivObject *privateObject;
- privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
+ MediacontentManagerPriv *privateObject;
+ privateObject = static_cast<MediacontentManagerPriv*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
- AceSecurityStatus status = CONTENT_CHECK_ACCESS(CONTENT_FUNCTION_API_UPDATE_ITEM);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CONTENT_FUNCTION_API_UPDATE_ITEM);
Try
{
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- MediacontentManagerPrivObject *privateObject;
- privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
+ MediacontentManagerPriv *privateObject;
+ privateObject = static_cast<MediacontentManagerPriv*>(JSObjectGetPrivate(thisObject));
if(!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
- AceSecurityStatus status = CONTENT_CHECK_ACCESS(CONTENT_FUNCTION_API_SCAN_FILE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CONTENT_FUNCTION_API_SCAN_FILE);
string path;
CallbackUserData *callback = NULL;
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- MediacontentManagerPrivObject *privateObject;
- privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
+ MediacontentManagerPriv *privateObject;
+ privateObject = static_cast<MediacontentManagerPriv*>(JSObjectGetPrivate(thisObject));
if(!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
- AceSecurityStatus status = CONTENT_CHECK_ACCESS(CONTENT_FUNCTION_API_SET_CHANGE_LISTENER);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CONTENT_FUNCTION_API_SET_CHANGE_LISTENER);
try{
ArgumentValidator argValidator(context, argumentCount, arguments);
JSValueRef* exception)
{
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- MediacontentManagerPrivObject *privateObject;
- privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(thisObject));
+ MediacontentManagerPriv *privateObject;
+ privateObject = static_cast<MediacontentManagerPriv*>(JSObjectGetPrivate(thisObject));
if(!privateObject) {
DeviceAPI::Common::UnknownException err("Content's private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
- AceSecurityStatus status = CONTENT_CHECK_ACCESS(CONTENT_FUNCTION_API_SET_CHANGE_LISTENER);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, CONTENT_FUNCTION_API_SET_CHANGE_LISTENER);
try{
// perform
void JSMediacontentManager::initialize(JSContextRef context, JSObjectRef object)
{
- MediacontentManagerPrivObject *privateObject = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(object));
+ MediacontentManagerPriv *privateObject = static_cast<MediacontentManagerPriv*>(JSObjectGetPrivate(object));
if (NULL == privateObject)
{
IMediacontentManagerPtr contentManager = MediacontentFactory::getInstance().createMediacontentManagerObject();
- privateObject = new MediacontentManagerPrivObject(context, contentManager);
+ privateObject = new MediacontentManagerPriv(context, contentManager);
if (!JSObjectSetPrivate(object, static_cast<void*>(privateObject)))
{
delete privateObject;
void JSMediacontentManager::finalize(JSObjectRef object)
{
- MediacontentManagerPrivObject* priv = static_cast<MediacontentManagerPrivObject*> (JSObjectGetPrivate(object));
+ MediacontentManagerPriv* priv = static_cast<MediacontentManagerPriv*> (JSObjectGetPrivate(object));
if(priv != NULL)
{
delete priv;
const JSObjectRef object,
JSValueRef* exception)
{
- MediacontentManagerPrivObject *priv = static_cast<MediacontentManagerPrivObject*>(JSObjectGetPrivate(object));
+ MediacontentManagerPriv *priv = static_cast<MediacontentManagerPriv*>(JSObjectGetPrivate(object));
if (priv)
{
return priv->getObject();
typedef PrivateObject<IMediacontentManagerPtr, NoOwnership> MediacontentManagerPrivObject;
+class MediacontentManagerPriv :
+ public MediacontentManagerPrivObject,
+ public DeviceAPI::Common::SecurityAccessor
+{
+public:
+ MediacontentManagerPriv(JSContextRef context, IMediacontentManagerPtr contentManager) :
+ MediacontentManagerPrivObject(context, contentManager),
+ DeviceAPI::Common::SecurityAccessor()
+ {
+ }
+
+ virtual ~MediacontentManagerPriv()
+ {
+ }
+};
+
class JSMediacontentManager
{
public:
#include <string>
#include <Commons/FunctionDeclaration.h>
+#include "plugin_config_impl.h"
namespace DeviceAPI {
namespace Content {
-// Functions from content manager
-#define CONTENT_FUNCTION_API_GET_LOCAL_MEDIASOURCE "getLocalMediaSource"
-
-// Functions from content
-#define CONTENT_FUNCTION_API_FIND_ITEMS "find"
-#define CONTENT_FUNCTION_API_GET_FOLDERS "getDirectories"
-#define CONTENT_FUNCTION_API_UPDATE_ITEM "update"
-#define CONTENT_FUNCTION_API_UPDATE_ITEMS_BATCH "updateBatch"
-#define CONTENT_FUNCTION_API_SCAN_FILE "scanFile"
-#define CONTENT_FUNCTION_API_SET_CHANGE_LISTENER "setChangeListener"
-#define CONTENT_FUNCTION_API_UNSET_CHANGE_LISTENER "unsetChangeListener"
-
-
DECLARE_FUNCTION_GETTER(Content);
#define CONTENT_CHECK_ACCESS(functionName) \
--- /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 _CONTENT_PLUGIN_CONFIG_IMPL_H_
+#define _CONTENT_PLUGIN_CONFIG_IMPL_H_
+
+#define CONTENT_FUNCTION_API_GET_LOCAL_MEDIASOURCE "getLocalMediaSource"
+#define CONTENT_FUNCTION_API_FIND_ITEMS "find"
+#define CONTENT_FUNCTION_API_GET_FOLDERS "getDirectories"
+#define CONTENT_FUNCTION_API_UPDATE_ITEM "update"
+#define CONTENT_FUNCTION_API_UPDATE_ITEMS_BATCH "updateBatch"
+#define CONTENT_FUNCTION_API_SCAN_FILE "scanFile"
+#define CONTENT_FUNCTION_API_SET_CHANGE_LISTENER "setChangeListener"
+#define CONTENT_FUNCTION_API_UNSET_CHANGE_LISTENER "unsetChangeListener"
+
+
+#endif // _CONTENT_PLUGIN_CONFIG_IMPL_H_
#include <Commons/Exception.h>
#include <GlobalContextManager.h>
#include <TimeTracer.h>
-
+#include <Security.h>
+#include "plugin_config.h"
#include "JSContentManager.h"
#include "ContentAsyncCallbackManager.h"
#include <Logger.h>
namespace DeviceAPI {
namespace Content {
+AceSecurityStatus contentAceCheckAccessFunction(const char* functionName)
+{
+ return CONTENT_CHECK_ACCESS(functionName);
+}
+
+DEFINE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
+
+DEFINE_SECURITY_ACCESSOR_SETTER(AceCheckerContentSetter,
+ MediacontentManagerPriv,
+ gSecurityAccessor);
+
+class_definition_options_t option =
+{
+ JS_CLASS,
+ NONE,
+ ALWAYS_NOTICE,
+ IGNORED,
+ AceCheckerContentSetter,
+ NULL,
+ NULL
+};
+
void on_frame_load_callback(const void * context)
{
LoggerD("[Tizen\\content] on_frame_load_callback (" << context << ")");
LoggerE("WrtAccess intialization failed");
}
+ INITAILIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor, contentAceCheckAccessFunction);
}
void on_widget_stop_callback(int widgetId)
{
LoggerE("WrtAccess deinitialization failed");
}
+ FINALIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
}
PLUGIN_ON_WIDGET_START(on_widget_start_callback)
PLUGIN_CLASS_MAP_ADD_CLASS(WRT_JS_EXTENSION_OBJECT_TIZEN,
"content",
(js_class_template_getter)JSMediacontentManager::getClassRef,
- NULL)
+ &option)
PLUGIN_CLASS_MAP_END
}
TARGET_LINK_LIBRARIES(${TARGET_NAME}
${TARGET_IMPL_NAME}
- "-Wl,--no-as-needed" ${filesystem_config}
)
INSTALL(TARGETS ${TARGET_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
SET(TARGET_NAME ${filesystem_target})
SET(DESTINATION_NAME ${filesystem_dest})
SET(TARGET_IMPL_NAME ${filesystem_impl})
-SET(TARGET_CONFIG_NAME ${filesystem_config})
PKG_CHECK_MODULES(platform_pkgs_filesystem REQUIRED capi-appfw-application libpcrecpp ecore)
)
SET(SRCS_IMPL
+ JSFilesystemManager.cpp
+ JSFile.cpp
+ JSFilestream.cpp
+ JSStorage.cpp
IManager.cpp
IPath.cpp
IStream.cpp
Stream.cpp
NodeFilterMatcher.cpp
Utils.cpp
- JSFilesystemManager.cpp
- JSFile.cpp
- JSFilestream.cpp
- JSStorage.cpp
Converter.cpp
EventGetNodeData.cpp
Encodings.cpp
${platform_pkgs_filesystem_LIBRARIES}
)
-SET(SRCS_CONFIG
- plugin_config.cpp
-)
-
-ADD_LIBRARY(${TARGET_CONFIG_NAME} SHARED ${SRCS_CONFIG})
-
-TARGET_LINK_LIBRARIES(${TARGET_CONFIG_NAME}
- ${LIBS_COMMON}
-)
-
SET(SRCS
+ plugin_config.cpp
plugin_initializer.cpp
)
${TARGET_CONFIG_NAME}
)
-INSTALL(TARGETS ${TARGET_NAME} ${TARGET_CONFIG_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
+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})
INSTALL(
DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${DESTINATION_HEADER_PREFIX}/filesystem
JSValueRef Converter::toJSValueRef(
const NodeList& arg,
const JSFile::PrivateObjectDef::PermissionList &parentPermissions,
- JSContextRef context)
+ JSContextRef context, DeviceAPI::Common::SecurityAccessor *securityAccessor)
{
JSObjectRef jsResult = JSCreateArrayObject(m_context, 0, NULL);
if (!jsResult) {
JSFile::PrivateObject* privateObject = new JSFile::PrivateObject(
context,
privData);
+
+ if (securityAccessor)
+ privateObject->copyAceCheckAccessFunction(securityAccessor);
+
JSObjectRef jsObject = JSObjectMake(m_context,
JSFile::getClassRef(),
privateObject);
#include <map>
#include <JavaScriptCore/JavaScript.h>
#include <CommonsJavaScript/Converter.h>
+#include <Security.h>
#include "Enums.h"
#include "IPath.h"
#include "INodeTypes.h"
JSValueRef toJSValueRef(
const NodeList& arg,
const JSFile::PrivateObjectDef::PermissionList &parentPermissions,
- JSContextRef context);
+ JSContextRef context, DeviceAPI::Common::SecurityAccessor *securityAccessor);
JSValueRef toJSValueRef(unsigned char* data,
std::size_t num);
JSValueRef toJSValueRef(unsigned long long arg);
#include <dpl/shared_ptr.h>
#include <Commons/IEvent.h>
+#include <Security.h>
#include "IPath.h"
#include "INode.h"
namespace DeviceAPI {
namespace Filesystem {
-class EventCopy : public WrtDeviceApis::Commons::IEvent<EventCopy>
+class EventCopy :
+ public WrtDeviceApis::Commons::IEvent<EventCopy>,
+ public DeviceAPI::Common::SecurityAccessor
{
public:
/**
#include <Commons/IEvent.h>
#include <dpl/shared_ptr.h>
#include <string>
+#include <Security.h>
#include "StorageProperties.h"
namespace DeviceAPI {
namespace Filesystem {
-class EventGetStorage : public WrtDeviceApis::Commons::IEvent<
- EventGetStorage>
+class EventGetStorage :
+ public WrtDeviceApis::Commons::IEvent<EventGetStorage>,
+ public DeviceAPI::Common::SecurityAccessor
{
private:
std::string label;
} // Filesystem
} // TizenApis
-#endif //TIZENAPIS_API_FILESYSTEM_EVENT_GET_STORAGE_H_
\ No newline at end of file
+#endif //TIZENAPIS_API_FILESYSTEM_EVENT_GET_STORAGE_H_
#include <dpl/shared_ptr.h>
#include <Commons/IEvent.h>
+#include <Security.h>
#include "INodeTypes.h"
#include "NodeFilter.h"
namespace DeviceAPI {
namespace Filesystem {
-class EventListNodes : public WrtDeviceApis::Commons::IEvent<EventListNodes>
+class EventListNodes :
+ public WrtDeviceApis::Commons::IEvent<EventListNodes>,
+ public DeviceAPI::Common::SecurityAccessor
{
public:
/**
} // Filesystem
} // TizenApis
-#endif // TIZENAPIS_FILESYSTEM_EVENTLISTNODES_H_
\ No newline at end of file
+#endif // TIZENAPIS_FILESYSTEM_EVENTLISTNODES_H_
#include <Commons/IEvent.h>
#include <dpl/shared_ptr.h>
#include <vector>
+#include <Security.h>
#include "StorageProperties.h"
namespace DeviceAPI {
namespace Filesystem {
-class EventListStorages : public WrtDeviceApis::Commons::IEvent<
- EventListStorages>
+class EventListStorages :
+ public WrtDeviceApis::Commons::IEvent<EventListStorages>,
+ public DeviceAPI::Common::SecurityAccessor
{
private:
std::vector<StoragePropertiesPtr> storages;
}
}
-#endif
\ No newline at end of file
+#endif
#include <dpl/shared_ptr.h>
#include <Commons/IEvent.h>
+#include <Security.h>
#include "IPath.h"
#include "INode.h"
namespace DeviceAPI {
namespace Filesystem {
-class EventMove : public WrtDeviceApis::Commons::IEvent<EventMove>
+class EventMove :
+ public WrtDeviceApis::Commons::IEvent<EventMove>,
+ public DeviceAPI::Common::SecurityAccessor
{
public:
/**
} // Filesystem
} // TizenApis
-#endif // TIZENAPIS_FILESYSTEM_EVENTMOVE_H_
\ No newline at end of file
+#endif // TIZENAPIS_FILESYSTEM_EVENTMOVE_H_
#include <dpl/shared_ptr.h>
#include <Commons/IEvent.h>
+#include <Security.h>
#include "IStream.h"
namespace DeviceAPI {
namespace Filesystem {
-class EventOpen : public WrtDeviceApis::Commons::IEvent<EventOpen>
+class EventOpen :
+ public WrtDeviceApis::Commons::IEvent<EventOpen>,
+ public DeviceAPI::Common::SecurityAccessor
{
public:
/**
} // Filesystem
} // TizenApis
-#endif // TIZENAPIS_FILESYSTEM_EVENTOPEN_H_
\ No newline at end of file
+#endif // TIZENAPIS_FILESYSTEM_EVENTOPEN_H_
#include <string>
#include <dpl/shared_ptr.h>
#include <Commons/IEvent.h>
+#include <Security.h>
#include "IPath.h"
namespace DeviceAPI {
namespace Filesystem {
-class EventReadText : public WrtDeviceApis::Commons::IEvent<EventReadText>
+class EventReadText :
+ public WrtDeviceApis::Commons::IEvent<EventReadText>,
+ public DeviceAPI::Common::SecurityAccessor
{
public:
/**
} // Filesystem
} // TizenApis
-#endif // TIZENAPIS_FILESYSTEM_EVENTREADTEXT_H_
\ No newline at end of file
+#endif // TIZENAPIS_FILESYSTEM_EVENTREADTEXT_H_
#include <dpl/shared_ptr.h>
#include <Commons/IEvent.h>
+#include <Security.h>
#include "INode.h"
#include "Enums.h"
namespace DeviceAPI {
namespace Filesystem {
-class EventRemove : public WrtDeviceApis::Commons::IEvent<EventRemove>
+class EventRemove :
+ public WrtDeviceApis::Commons::IEvent<EventRemove>,
+ public DeviceAPI::Common::SecurityAccessor
{
public:
/**
} // Filesystem
} // TizenApis
-#endif // TIZENAPIS_FILESYSTEM_EVENTREMOVE_H_
\ No newline at end of file
+#endif // TIZENAPIS_FILESYSTEM_EVENTREMOVE_H_
#include <dpl/shared_ptr.h>
#include <Commons/IEvent.h>
+#include <Security.h>
+
#include "IPath.h"
#include "INode.h"
namespace DeviceAPI {
namespace Filesystem {
-class EventResolve : public WrtDeviceApis::Commons::IEvent<EventResolve>
+class EventResolve :
+ public WrtDeviceApis::Commons::IEvent<EventResolve>,
+ public DeviceAPI::Common::SecurityAccessor
{
public:
/**
#include "JSFile.h"
+#include "plugin_config_impl.h"
#include <string>
#include <ctime>
#include "Converter.h"
#include "plugin_config.h"
#include "Encodings.h"
-#include "JSFilestream.h"
#include "ResponseDispatcher.h"
#include "FilesystemAsyncCallbackManager.h"
#include <Logger.h>
{
parent->setPermissions(perms.back());
perms.pop_back();
- PrivateObjectDefPtr privData(new PrivateObjectDef(parent, perms));
+ PrivateObjectDefPtr privDefData(new PrivateObjectDef(parent, perms));
+ JSFile::PrivateObject* privData = new JSFile::PrivateObject(globalContext, privDefData);
+ privData->copyAceCheckAccessFunction(privateObject);
+
+ JSObjectRef object = JSObjectMake(globalContext, JSFile::getClassRef(), privData);
- return JSUtils::makeObject(privateObject->getContext(), getClassRef(), privData);
+ return object;
}
return JSValueMakeNull(context);
}
LoggerE("Private object is not set.");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_TO_URI);
Converter converter(context);
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_TO_URI);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
-
try {
int widgetId = WrtAccessSingleton::Instance().getWidgetId();
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
LoggerD("OK");
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_LIST_FILES);
+
// argument validation with new validator
try {
ArgumentValidator validator(context, argc, argv);
try {
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_LIST_FILES);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
for (index = 0; index < 3; index++)
{
event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData>(privData));
event->setForAsynchronousCall(&ResponseDispatcher::getInstance());
+ event->copyAceCheckAccessFunction(privateObject);
privateObject->getObject()->getNode()->getChildNodes(event);
FilesystemAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, globalContext);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_OPEN_STREAM);
+
// argument validation with new validator
try {
ArgumentValidator validator(context, argumentCount, arguments);
size_t index = 0;
JSValueRef reserveArguments[4];
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_OPEN_STREAM);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
try {
std::string path = privateObject->getObject()->getNode()->getPath()->getFullPath();
std::string vpath = Utils::toVirtualPath(globalContext, path);
- AccessModeInfo am = AccessModeInfo(mode, vpath);
- status = FILESYSTEM_ACCESSMODE_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_OPEN_STREAM, am);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
EventOpenPtr event(new EventOpen(mode));
event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData>(cbm));
event->setCharSet(encoding);
event->setForAsynchronousCall(&ResponseDispatcher::getInstance());
+ event->copyAceCheckAccessFunction(privateObject);
+
FilesystemAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, globalContext);
privateObject->getObject()->getNode()->open(event);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_READ_AS_TEXT);
// argument validation with new validator
try {
JSContextRef globalContext = privateObject->getContext();
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_READ_AS_TEXT);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+
size_t index = 0;
JSValueRef reserveArguments[3];
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,FILESYSTEM_FUNCTION_API_COPY_TO);
+
JSContextRef globalContext = privateObject->getContext();
size_t index = 0;
JSValueRef reserveArguments[5];
JSCallbackManagerPtr cbm = JSCallbackManager::createObject(globalContext);
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_COPY_TO);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
// argument validation with new validator
try {
}
std::string virtualDestPath = Utils::toVirtualPath(globalContext, dest->getFullPath());
- AccessModeInfo amode = AccessModeInfo(AM_WRITE, virtualDestPath);
- status = FILESYSTEM_ACCESSMODE_CHECK_ACCESS(
- FILESYSTEM_FUNCTION_API_COPY_TO,
- amode);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
EventCopyPtr event(new EventCopy(src, dest));
JSCallbackManager>(
cbm));
event->setForAsynchronousCall(&ResponseDispatcher::getInstance());
+ event->copyAceCheckAccessFunction(privateObject);
+
FilesystemAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, globalContext);
IManager::getInstance().copy(event);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_MOVE_TO);
+
JSContextRef globalContext = privateObject->getContext();
LoggerD("OK");
JSValueRef reserveArguments[5];
JSCallbackManagerPtr cbm = JSCallbackManager::createObject(globalContext);
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_MOVE_TO);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
try {
std::string virtualDestPath = Utils::toVirtualPath(globalContext, dest->getFullPath());
- AccessModeInfo amode = AccessModeInfo(AM_WRITE, virtualDestPath);
- AceSecurityStatus status = FILESYSTEM_ACCESSMODE_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_MOVE_TO, amode);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
EventMovePtr event(new EventMove(src, dest));
if (overwrite) {
event->setOptions(OPT_OVERWRITE);
event->setForAsynchronousCall(&ResponseDispatcher::getInstance());
event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData > (cbm));
+ event->copyAceCheckAccessFunction(privateObject);
+
FilesystemAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, globalContext);
IManager::getInstance().move(event);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_CREATE_DIR);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_CREATE_DIR);
Converter converter(context);
try {
INodePtr node(privateObject->getObject()->getNode()->createChild(path, NT_DIRECTORY, OPT_RECURSIVE));
node->setPermissions(privateObject->getObject()->getNode()->getPermissions());
- PrivateObjectDefPtr privData(new PrivateObjectDef(node, privateObject->getObject()->getParentPermissions()));
- privData->pushParentPermissions(privateObject->getObject()->getNode()->getPermissions());
+ PrivateObjectDefPtr privDefData(new PrivateObjectDef(node, privateObject->getObject()->getParentPermissions()));
+ privDefData->pushParentPermissions(privateObject->getObject()->getNode()->getPermissions());
+ JSFile::PrivateObject* privData = new JSFile::PrivateObject(privateObject->getContext(), privDefData);
+ privData->copyAceCheckAccessFunction(privateObject);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
- return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(privateObject->getContext(), getClassRef(), privData);
+
+
+ JSObjectRef object = JSObjectMake(privateObject->getContext(), JSFile::getClassRef(), privData);
+ return object;
} catch (const WrtDeviceApis::Commons::SecurityException& ex) {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
}
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_CREATE_FILE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_CREATE_FILE);
Converter converter(context);
try {
IPathPtr path = converter.toPath(argv[0]);
INodePtr node = privateObject->getObject()->getNode()->createChild(path, NT_FILE);
- PrivateObjectDefPtr privData(new PrivateObjectDef(node, privateObject->getObject()->getParentPermissions()));
- privData->pushParentPermissions(privateObject->getObject()->getNode()->getPermissions());
+ PrivateObjectDefPtr privDefData(new PrivateObjectDef(node, privateObject->getObject()->getParentPermissions()));
+ privDefData->pushParentPermissions(privateObject->getObject()->getNode()->getPermissions());
+
+ JSFile::PrivateObject* privData = new JSFile::PrivateObject(privateObject->getContext(), privDefData);
+ privData->copyAceCheckAccessFunction(privateObject);
+
+ JSObjectRef object = JSObjectMake(privateObject->getContext(), JSFile::getClassRef(), privData);
+
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
- return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(privateObject->getContext(), getClassRef(), privData);
+ return object;
+
} catch (const WrtDeviceApis::Commons::SecurityException& ex) {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, ex.GetMessage());
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);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_RESOLVE);
if (privateObject->getObject()->getNode()->getType() != NT_DIRECTORY) {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::IO_ERROR, "IO error");
IPathPtr path = converter.toPath(argv[0]);
INodePtr node = privateObject->getObject()->getNode()->getChild(path);
node->setPermissions(privateObject->getObject()->getNode()->getPermissions());
- PrivateObjectDefPtr privData(new PrivateObjectDef(node, privateObject->getObject()->getParentPermissions()));
- privData->pushParentPermissions(privateObject->getObject()->getNode()->getPermissions());
+ PrivateObjectDefPtr privDefData(new PrivateObjectDef(node, privateObject->getObject()->getParentPermissions()));
+ privDefData->pushParentPermissions(privateObject->getObject()->getNode()->getPermissions());
+
+ JSFile::PrivateObject* privData = new JSFile::PrivateObject(privateObject->getContext(), privDefData);
+ privData->copyAceCheckAccessFunction(privateObject);
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
- return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(privateObject->getContext(), getClassRef(), privData);
- /*
- IPathPtr path = converter.toPath(argv[0]);
- INodePtr node = privateObject->getObject()->getNode()->getChild(path);
- node->setPermissions(privateObject->getObject()->getNode()->getPermissions());
- return JSUtils::makeObject(privateObject->getContext(), getClassRef(), node);
- */
+
+ JSObjectRef object = JSObjectMake(privateObject->getContext(), JSFile::getClassRef(), privData);
+ return object;
} catch (const WrtDeviceApis::Commons::PlatformException& ex) {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::IO_ERROR, ex.GetMessage());
} catch(const WrtDeviceApis::Commons::ConversionException& ex) {
if (!privateObject) {
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);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,FILESYSTEM_FUNCTION_API_DELETE_DIR);
if (argc < 2) {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
eventRemove->setForAsynchronousCall(&ResponseDispatcher::getInstance());
eventRemove->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData > (cbm));
+ eventRemove->copyAceCheckAccessFunction(privateObject);
+
FilesystemAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, globalContext);
IManager::getInstance().remove(eventRemove);
PrivateObject* privateObject = static_cast<PrivateObject*>(JSObjectGetPrivate(thisObject));
+
if (!privateObject) {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
+
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_DELETE_FILE);
+
// argument validation with new validator
try {
ArgumentValidator validator(context, argc, argv);
JSValueRef reserveArguments[3];
JSCallbackManagerPtr cbm = JSCallbackManager::createObject(globalContext);
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_DELETE_FILE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
-
try {
for (index = 0; index < 3; index++) {
if (index < argc)
EventRemovePtr eventRemove(new EventRemove(path));
eventRemove->setForAsynchronousCall(&ResponseDispatcher::getInstance());
eventRemove->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData > (cbm));
+ eventRemove->copyAceCheckAccessFunction(privateObject);
+
FilesystemAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, globalContext);
IManager::getInstance().remove(eventRemove);
#include <Commons/IEvent.h>
#include <CommonsJavaScript/PrivateObject.h>
#include <CommonsJavaScript/JSCallbackManager.h>
+#include <Security.h>
#include "INode.h"
namespace DeviceAPI {
};
typedef DPL::SharedPtr<ListFilesPrivateData> ListFilesPrivateDataPtr;
- typedef DPL::SharedPtr<PrivateObjectDef> PrivateObjectDefPtr;
- typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<PrivateObjectDefPtr>::Type PrivateObject;
+ typedef DPL::SharedPtr<PrivateObjectDef> PrivateObjectDefPtr;
+ typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<PrivateObjectDefPtr>::Type PrivateObjectSecurity;
+
+ class PrivateObject :
+ public DeviceAPI::Common::SecurityAccessor,
+ public PrivateObjectSecurity
+ {
+ public :
+ PrivateObject (JSContextRef context, PrivateObjectDefPtr privDef) :
+ DeviceAPI::Common::SecurityAccessor(),
+ PrivateObjectSecurity(context, privDef)
+ {
+ }
+
+ virtual ~PrivateObject()
+ {
+ }
+ };
public:
static const JSClassDefinition* getClassInfo();
}
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_CLOSE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_CLOSE);
Try {
privateObject->getObject()->close();
}
Converter converter(context);
+
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_READ);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_READ);
try {
JSValueRef undefinedValue = JSValueMakeUndefined(context);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_READ_BYTES);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_READ_BYTES);
Converter converter(context);
Try {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_READ_BASE64);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_READ_BASE64);
Converter converter(context);
try {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_WRITE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_WRITE);
Converter converter(context);
try {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_WRITE_BYTES);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_WRITE_BYTES);
Converter converter(context);
Try {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch error");
}
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_WRITE_BASE64);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_WRITE_BASE64);
Converter converter(context);
try {
#include <JavaScriptCore/JavaScript.h>
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
#include "IStream.h"
namespace DeviceAPI {
namespace Filesystem {
+
+
class JSFilestream
{
public:
- typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<IStreamPtr>::Type PrivateObject;
-
+ typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<IStreamPtr>::Type PrivateObjectSecurity;
+
+ class PrivateObject :
+ public DeviceAPI::Common::SecurityAccessor,
+ public PrivateObjectSecurity
+ {
+ public :
+ PrivateObject (JSContextRef context, IStreamPtr stream) :
+ DeviceAPI::Common::SecurityAccessor(),
+ PrivateObjectSecurity(context, stream)
+ {
+ }
+
+ virtual ~PrivateObject()
+ {
+ }
+ };
+
public:
static const JSClassDefinition* getClassInfo();
}
}
-#endif
\ No newline at end of file
+#endif
#include "JSFilesystemManager.h"
+#include "plugin_config_impl.h"
#include <Commons/Exception.h>
#include "EventResolve.h"
#include "IManager.h"
return JSValueMakeUndefined(context);
}
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_GET_STORAGE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_GET_STORAGE);
// argument validation with new validator
try {
return JSValueMakeUndefined(context);
}
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_LIST_STORAGE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_LIST_STORAGE);
// argument validation with new validator
try {
return JSValueMakeUndefined(context);
}
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_ADD_STORAGE_LISTENER);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
+
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_ADD_STORAGE_LISTENER);
// argument validation with new validator
try {
validator.toFunction(1, true);
}
catch (const BasePlatformException &err) {
- LogDebug("Exception");
return JSWebAPIErrorFactory::postException(context, exception, err);
} catch (...) {
DeviceAPI::Common::UnknownException err("");
return JSValueMakeUndefined(context);
}
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_REMOVE_STORAGE_LISTENER);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_REMOVE_STORAGE_LISTENER);
- LogDebug("a");
// argument validation with new validator
try {
}
- AceSecurityStatus status = FILESYSTEM_CHECK_ACCESS(FILESYSTEM_FUNCTION_API_MGR_RESOLVE_ID);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject, FILESYSTEM_FUNCTION_API_MGR_RESOLVE_ID);
+ LoggerD("<<<" << std::hex << privateObject);
// argument validation with new validator
try {
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type missmatch error");
}
- LogDebug("resolve");
-
-
JSContextRef globalContext = privateObject->getContext();
return JSValueMakeUndefined(context);
}
- PermissionsAccessInfo perms(permissions, virtualPath);
- AceSecurityStatus status = FILESYSTEM_PERMISSION_CHECK_ACCESS(
- FILESYSTEM_FUNCTION_API_MGR_RESOLVE_ID,
- perms);
-
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
EventGetNodeDataPtr data(new EventGetNodeData(permissions, cbm));
EventResolvePtr event(new EventResolve(path));
event->setForAsynchronousCall(&ResponseDispatcher::getInstance());
event->setMode(perm);
event->setPrivateData(DPL::StaticPointerCast<WrtDeviceApis::Commons::IEventPrivateData > (data));
+ event->copyAceCheckAccessFunction(privateObject);
FilesystemAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, globalContext);
IManager::getInstance().getNode(event);
#include <JavaScriptCore/JavaScript.h>
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
namespace DeviceAPI {
namespace Filesystem {
+
+
+
+
class JSFilesystemManager
{
public:
- typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<void>::Type PrivateObject;
-
+ typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<void>::Type PrivateObjectSecurity;
+
+ class PrivateObject :
+ public DeviceAPI::Common::SecurityAccessor,
+ public PrivateObjectSecurity
+ {
+ public:
+ PrivateObject(JSContextRef context) :
+ DeviceAPI::Common::SecurityAccessor(),
+ PrivateObjectSecurity(context)
+ {
+ }
+
+ virtual ~PrivateObject()
+ {
+ }
+ };
public:
static const JSClassDefinition* getClassInfo();
}
}
-#endif
\ No newline at end of file
+#endif
#include <JavaScriptCore/JavaScript.h>
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
#include "StorageProperties.h"
namespace DeviceAPI {
namespace Filesystem {
+
typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<StorageProperties*>::Type JSStoragePriv;
class JSStorage
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
event->getResult()->setPermissions(data->getPerms());
- JSFile::PrivateObjectDefPtr privData(new JSFile::PrivateObjectDef(event->getResult(), JSFile::PrivateObjectDef::PermissionList()));
+
+ JSFile::PrivateObjectDefPtr privDefData(new JSFile::PrivateObjectDef(event->getResult(), JSFile::PrivateObjectDef::PermissionList()));
+ JSFile::PrivateObject* privData = new JSFile::PrivateObject(data->getCallbackManager()->getContext(), privDefData);
+ privData->copyAceCheckAccessFunction(event.Get());
+
try {
INodePtr parent = event->getResult()->getParent();
if (parent)
{
- privData->pushParentPermissions(data->getPerms());
+ privDefData->pushParentPermissions(data->getPerms());
}
}
catch (...)
LoggerD("no parent");
}
- JSObjectRef object = JSUtils::makeObject(data->getCallbackManager()->getContext(), JSFile::getClassRef(), privData);
+ JSObjectRef object = JSObjectMake(data->getCallbackManager()->getContext(), JSFile::getClassRef(), privData);
data->getCallbackManager()->callOnSuccess(object);
} else {
JSObjectRef jsException;
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
Converter converter(data->getContext());
Try {
- JSValueRef result = converter.toJSValueRef(event->getResult(), privData->getParentPermissions(), data->getContext());
+ JSValueRef result = converter.toJSValueRef(event->getResult(), privData->getParentPermissions(), data->getContext(), event.Get());
data->callOnSuccess(result);
}
Catch(WrtDeviceApis::Commons::ConversionException) {
FilesystemAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(data);
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
- JSObjectRef object = JSUtils::makeObject(data->getContext(), JSFilestream::getClassRef(), event->getResult());
+ JSFilestream::PrivateObject* privData = new JSFilestream::PrivateObject(data->getContext(), event->getResult());
+ privData->copyAceCheckAccessFunction(event.Get());
+
+ JSObjectRef object = JSObjectMake(data->getContext(), JSFilestream::getClassRef(), privData);
data->callOnSuccess(object);
} else {
JSObjectRef jsException;
FilesystemAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(data);
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
- JSFile::PrivateObjectDefPtr privData(new JSFile::PrivateObjectDef(
- event->getResult(),
- JSFile::PrivateObjectDef::PermissionList()));
+ JSFile::PrivateObjectDefPtr privDefData(new JSFile::PrivateObjectDef(event->getResult(),JSFile::PrivateObjectDef::PermissionList()));
+ JSFile::PrivateObject* privData = new JSFile::PrivateObject(data->getContext(), privDefData);
+ privData->copyAceCheckAccessFunction(event.Get());
- JSObjectRef object = JSUtils::makeObject(data->getContext(), JSFile::getClassRef(), privData);
+ JSObjectRef object = JSObjectMake(data->getContext(), JSFile::getClassRef(), privData);
data->callOnSuccess(object);
} else {
JSObjectRef jsException = NULL;
FilesystemAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(data);
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
- JSFile::PrivateObjectDefPtr privData(new JSFile::PrivateObjectDef(
- event->getResult(),
- JSFile::PrivateObjectDef::PermissionList()));
- JSObjectRef object = JSUtils::makeObject(data->getContext(),
- JSFile::getClassRef(),
- privData);
+ JSFile::PrivateObjectDefPtr privDefData(new JSFile::PrivateObjectDef(event->getResult(), JSFile::PrivateObjectDef::PermissionList()));
+ JSFile::PrivateObject* privData = new JSFile::PrivateObject(data->getContext(), privDefData);
+ privData->copyAceCheckAccessFunction(event.Get());
+
+ JSObjectRef object = JSObjectMake(data->getContext(), JSFile::getClassRef(), privData);
data->callOnSuccess(object);
} else {
JSObjectRef jsException = NULL;
#include <map>
#include <utility>
-
+#include "plugin_config.h"
#include <Commons/FunctionDefinition.h>
#include <Commons/FunctionDeclaration.h>
#include <Commons/Exception.h>
namespace DeviceAPI {
namespace Filesystem {
-#pragma GCC visibility push(default)
-
-const char* FILESYSTEM_PARAM_LOCATION = "param:location";
-const char* FILESYSTEM_DEVICE_CAP_READ = "filesystem.read";
-const char* FILESYSTEM_DEVICE_CAP_WRITE = "filesystem.write";
-
-const char* FILESYSTEM_FUNCTION_API_MGR_RESOLVE_ID = "manager_resolve";
-const char* FILESYSTEM_FUNCTION_API_MGR_RESOLVE = "resolve";
-
-const char* FILESYSTEM_FUNCTION_API_GET_STORAGE = "getStorage";
-const char* FILESYSTEM_FUNCTION_API_LIST_STORAGE = "listStorage";
-const char* FILESYSTEM_FUNCTION_API_ADD_STORAGE_LISTENER = "addStorageStateChangeListener";
-const char* FILESYSTEM_FUNCTION_API_REMOVE_STORAGE_LISTENER = "removeStorageStateChangeListener";
-
-const char* FILESYSTEM_FUNCTION_API_RESOLVE = "resolve";
-const char* FILESYSTEM_FUNCTION_API_TO_URI = "toURI";
-const char* FILESYSTEM_FUNCTION_API_LIST_FILES = "listFiles";
-const char* FILESYSTEM_FUNCTION_API_OPEN_STREAM = "openStream";
-const char* FILESYSTEM_FUNCTION_API_READ_AS_TEXT = "readAsText";
-const char* FILESYSTEM_FUNCTION_API_COPY_TO = "copyTo";
-const char* FILESYSTEM_FUNCTION_API_MOVE_TO = "moveTo";
-const char* FILESYSTEM_FUNCTION_API_CREATE_DIR = "createDirectory";
-const char* FILESYSTEM_FUNCTION_API_CREATE_FILE = "createFile";
-const char* FILESYSTEM_FUNCTION_API_DELETE_DIR = "deleteDirectory";
-const char* FILESYSTEM_FUNCTION_API_DELETE_FILE = "deleteFile";
-
-const char* FILESYSTEM_FUNCTION_API_CLOSE = "close";
-const char* FILESYSTEM_FUNCTION_API_READ = "read";
-const char* FILESYSTEM_FUNCTION_API_READ_BYTES = "readBytes";
-const char* FILESYSTEM_FUNCTION_API_READ_BASE64 = "readBase64";
-const char* FILESYSTEM_FUNCTION_API_WRITE = "write";
-const char* FILESYSTEM_FUNCTION_API_WRITE_BYTES = "writeBytes";
-const char* FILESYSTEM_FUNCTION_API_WRITE_BASE64 = "writeBase64";
+
static WrtDeviceApis::Commons::FunctionMapping createFilesystemFunctions();
return FilesystemMapping;
}
-void setFilesystemPermDevCaps(int permissions,
- const std::string& path,
- WrtDeviceApis::Commons::AceFunction* outFunction)
-{
- using namespace WrtDeviceApis::Commons;
- AceDeviceCapParam paramLocation = AceDeviceCapParam(
- FILESYSTEM_PARAM_LOCATION, path);
-
- AceDeviceCaps devCaps;
-
- if (permissions & Filesystem::PERM_READ) {
- AceDeviceCapability devCapRead = AceDeviceCapability(
- FILESYSTEM_DEVICE_CAP_READ,
- AceDeviceCapParams());
- devCaps.push_back(devCapRead);
-
- ACE_ADD_DEV_CAP_PARAM(
- devCaps,
- FILESYSTEM_DEVICE_CAP_READ,
- paramLocation);
- }
-
- if (permissions & Filesystem::PERM_WRITE) {
- AceDeviceCapability devCapWrite = AceDeviceCapability(
- FILESYSTEM_DEVICE_CAP_WRITE,
- AceDeviceCapParams());
-
- devCaps.push_back(devCapWrite);
-
- ACE_ADD_DEV_CAP_PARAM(
- devCaps,
- FILESYSTEM_DEVICE_CAP_WRITE,
- paramLocation);
- }
-
- outFunction->deviceCapabilities = devCaps;
-}
-
-void setFilesystemAccessModeDevCaps(int accessMode,
- const std::string& path,
- WrtDeviceApis::Commons::AceFunction
- *outFunction)
-{
- using namespace WrtDeviceApis::Commons;
-
- AceDeviceCapParam paramLocation = AceDeviceCapParam(
- FILESYSTEM_PARAM_LOCATION,
- path);
- AceDeviceCaps devCaps;
-
- if (accessMode & Filesystem::AM_READ) {
- AceDeviceCapability devCapRead = AceDeviceCapability(
- FILESYSTEM_DEVICE_CAP_READ,
- AceDeviceCapParams());
-
- devCaps.push_back(devCapRead);
-
- ACE_ADD_DEV_CAP_PARAM(
- devCaps,
- FILESYSTEM_DEVICE_CAP_READ,
- paramLocation);
- }
-
- if ((accessMode & Filesystem::AM_WRITE) ||
- (accessMode & Filesystem::AM_APPEND)) {
- AceDeviceCapability devCapWrite = AceDeviceCapability(
- FILESYSTEM_DEVICE_CAP_WRITE,
- AceDeviceCapParams());
-
- devCaps.push_back(devCapWrite);
-
- ACE_ADD_DEV_CAP_PARAM(
- devCaps,
- FILESYSTEM_DEVICE_CAP_WRITE,
- paramLocation);
- }
- outFunction->deviceCapabilities = devCaps;
-}
-
-#pragma GCC visibility pop
-
}
}
#define _FILESYSTEM_PLUGIN_CONFIG_H_
#include <Commons/FunctionDeclaration.h>
+#include "plugin_config_impl.h"
namespace DeviceAPI {
namespace Filesystem {
-extern const char* FILESYSTEM_FUNCTION_API_MGR_RESOLVE_ID;
-extern const char* FILESYSTEM_FUNCTION_API_GET_STORAGE;
-extern const char* FILESYSTEM_FUNCTION_API_LIST_STORAGE;
-extern const char* FILESYSTEM_FUNCTION_API_ADD_STORAGE_LISTENER;
-extern const char* FILESYSTEM_FUNCTION_API_REMOVE_STORAGE_LISTENER;
-
-extern const char* FILESYSTEM_FUNCTION_API_RESOLVE;
-extern const char* FILESYSTEM_FUNCTION_API_TO_URI;
-extern const char* FILESYSTEM_FUNCTION_API_LIST_FILES;
-extern const char* FILESYSTEM_FUNCTION_API_OPEN_STREAM;
-extern const char* FILESYSTEM_FUNCTION_API_READ_AS_TEXT;
-extern const char* FILESYSTEM_FUNCTION_API_COPY_TO;
-extern const char* FILESYSTEM_FUNCTION_API_MOVE_TO;
-extern const char* FILESYSTEM_FUNCTION_API_CREATE_DIR;
-extern const char* FILESYSTEM_FUNCTION_API_CREATE_FILE;
-extern const char* FILESYSTEM_FUNCTION_API_DELETE_DIR;
-extern const char* FILESYSTEM_FUNCTION_API_DELETE_FILE;
-
-extern const char* FILESYSTEM_FUNCTION_API_CLOSE;
-extern const char* FILESYSTEM_FUNCTION_API_READ;
-extern const char* FILESYSTEM_FUNCTION_API_READ_BYTES;
-extern const char* FILESYSTEM_FUNCTION_API_READ_BASE64;
-extern const char* FILESYSTEM_FUNCTION_API_WRITE;
-extern const char* FILESYSTEM_FUNCTION_API_WRITE_BYTES;
-extern const char* FILESYSTEM_FUNCTION_API_WRITE_BASE64;
DECLARE_FUNCTION_GETTER(Filesystem);
-void setFilesystemPermDevCaps(int permissions,
- const std::string& path,
- WrtDeviceApis::Commons::AceFunction* outFunction);
-
-void setFilesystemAccessModeDevCaps(int accessMode,
- const std::string& path,
- WrtDeviceApis::Commons::AceFunction*
- outFunction);
-
-struct PermissionsAccessInfo
-{
- PermissionsAccessInfo(int perms,
- const std::string& fpath) :
- permissions(perms),
- path(fpath)
- {
- }
-
- int permissions;
- const std::string path;
-};
-
-struct AccessModeInfo
-{
- AccessModeInfo(int amode,
- const std::string& fpath) :
- accessMode(amode),
- path(fpath)
- {
- }
-
- int accessMode;
- const std::string path;
-};
-
-}
-}
-
-namespace WrtDeviceApis {
-namespace Commons {
-
-/**
- * template specialization for security access basing on permissions
- */
-template <>
-class DefaultArgsVerifier <DeviceAPI::Filesystem::PermissionsAccessInfo>
-{
- public:
- void operator()(AceFunction& aceFunction,
- const DeviceAPI::Filesystem::PermissionsAccessInfo& permInfo) const
- {
- DeviceAPI::Filesystem::setFilesystemPermDevCaps(permInfo.permissions,
- permInfo.path,
- &aceFunction);
- }
-};
-
-/**
- * template specialization for security access basing on access mode
- */
-template <>
-class DefaultArgsVerifier <DeviceAPI::Filesystem::AccessModeInfo>
-{
- public:
- void operator()(AceFunction& aceFunction,
- const DeviceAPI::Filesystem::AccessModeInfo& accessInfo) const
- {
- DeviceAPI::Filesystem::setFilesystemAccessModeDevCaps(accessInfo.accessMode,
- accessInfo.path,
- &aceFunction);
- }
-};
-
#define FILESYSTEM_CHECK_ACCESS(functionName) \
WrtDeviceApis::Commons::aceCheckAccess<AceFunctionGetter, \
WrtDeviceApis::Commons::DefaultArgsVerifier<> >( \
getFilesystemFunctionData, \
functionName)
-#define FILESYSTEM_PERMISSION_CHECK_ACCESS(functionName, perm) \
- WrtDeviceApis::Commons::aceCheckAccess<AceFunctionGetter, \
- WrtDeviceApis::Commons::DefaultArgsVerifier <DeviceAPI::Filesystem::PermissionsAccessInfo> >( \
- getFilesystemFunctionData, \
- functionName, \
- perm)
-
-#define FILESYSTEM_ACCESSMODE_CHECK_ACCESS(functionName, amode) \
- WrtDeviceApis::Commons::aceCheckAccess<AceFunctionGetter, \
- WrtDeviceApis::Commons::DefaultArgsVerifier <DeviceAPI::Filesystem::AccessModeInfo> >( \
- getFilesystemFunctionData, \
- functionName, \
- amode)
}
}
-
#endif
--- /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 _FILESYSTEM_PLUGIN_CONFIG_IMPL_H_
+#define _FILESYSTEM_PLUGIN_CONFIG_IMPL_H_
+
+#define FILESYSTEM_PARAM_LOCATION "param:location"
+#define FILESYSTEM_DEVICE_CAP_READ "filesystem.read"
+#define FILESYSTEM_DEVICE_CAP_WRITE "filesystem.write"
+
+#define FILESYSTEM_FUNCTION_API_MGR_RESOLVE_ID "manager_resolve"
+#define FILESYSTEM_FUNCTION_API_MGR_RESOLVE "resolve"
+
+#define FILESYSTEM_FUNCTION_API_GET_STORAGE "getStorage"
+#define FILESYSTEM_FUNCTION_API_LIST_STORAGE "listStorage"
+#define FILESYSTEM_FUNCTION_API_ADD_STORAGE_LISTENER "addStorageStateChangeListener"
+#define FILESYSTEM_FUNCTION_API_REMOVE_STORAGE_LISTENER "removeStorageStateChangeListener"
+
+#define FILESYSTEM_FUNCTION_API_RESOLVE "resolve"
+#define FILESYSTEM_FUNCTION_API_TO_URI "toURI"
+#define FILESYSTEM_FUNCTION_API_LIST_FILES "listFiles"
+#define FILESYSTEM_FUNCTION_API_OPEN_STREAM "openStream"
+#define FILESYSTEM_FUNCTION_API_READ_AS_TEXT "readAsText"
+#define FILESYSTEM_FUNCTION_API_COPY_TO "copyTo"
+#define FILESYSTEM_FUNCTION_API_MOVE_TO "moveTo"
+#define FILESYSTEM_FUNCTION_API_CREATE_DIR "createDirectory"
+#define FILESYSTEM_FUNCTION_API_CREATE_FILE "createFile"
+#define FILESYSTEM_FUNCTION_API_DELETE_DIR "deleteDirectory"
+#define FILESYSTEM_FUNCTION_API_DELETE_FILE "deleteFile"
+
+#define FILESYSTEM_FUNCTION_API_CLOSE "close"
+#define FILESYSTEM_FUNCTION_API_READ "read"
+#define FILESYSTEM_FUNCTION_API_READ_BYTES "readBytes"
+#define FILESYSTEM_FUNCTION_API_READ_BASE64 "readBase64"
+#define FILESYSTEM_FUNCTION_API_WRITE "write"
+#define FILESYSTEM_FUNCTION_API_WRITE_BYTES "writeBytes"
+#define FILESYSTEM_FUNCTION_API_WRITE_BASE64 "writeBase64"
+
+#endif
#include <Commons/WrtAccess/WrtAccess.h>
#include <Commons/plugin_initializer_def.h>
#include <TimeTracer.h>
+#include <Security.h>
#include "JSFilesystemManager.h"
#include "JSFile.h"
#include "JSFilestream.h"
#include "FilesystemAsyncCallbackManager.h"
#include "FilesystemListenerManager.h"
+#include "plugin_config.h"
+
#include <Logger.h>
using namespace WrtDeviceApis;
namespace DeviceAPI {
namespace Filesystem {
+AceSecurityStatus filesystemAceCheckAccessFunction(const char* functionName)
+{
+ return FILESYSTEM_CHECK_ACCESS(functionName);
+}
+
+DEFINE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
+
+DEFINE_SECURITY_ACCESSOR_SETTER(AceCheckerFilesystemSetter, JSFilesystemManager::PrivateObject, gSecurityAccessor);
+DEFINE_JSOBJECT_SECURITY_ACCESSOR_SETTER(AceCheckerFilesystemConstructorSetter, gSecurityAccessor);
+
+class_definition_options_t FilesystemOptions =
+{
+ JS_CLASS,
+ CREATE_INSTANCE,
+ ALWAYS_NOTICE,
+ USE_OVERLAYED, //ignored
+ AceCheckerFilesystemSetter,
+ NULL
+};
+
void on_widget_start_callback(int widgetId)
{
TIME_TRACER_INIT();
} Catch (Commons::Exception) {
LoggerE("WrtAccess initialization failed");
}
+ INITAILIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor, filesystemAceCheckAccessFunction);
}
void on_widget_stop_callback(int widgetId)
} Catch (Commons::Exception) {
LoggerE("WrtAccess deinitialization failed");
}
+ FINALIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
}
void on_frame_unload_callback(const void * context)
PLUGIN_CLASS_MAP_ADD_CLASS(WRT_JS_EXTENSION_OBJECT_TIZEN,
"filesystem",
(js_class_template_getter)DeviceAPI::Filesystem::JSFilesystemManager::getClassRef,
- NULL)
+ &FilesystemOptions)
PLUGIN_CLASS_MAP_END
#undef FILESYSTEM
TARGET_LINK_LIBRARIES(${TARGET_NAME}
${TARGET_IMPL_NAME}
- "-Wl,--no-as-needed" ${filesystem_config}
)
INSTALL(TARGETS ${TARGET_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
#include <Commons/IEvent.h>
#include <dpl/shared_ptr.h>
#include <Commons/Exception.h>
+#include <Security.h>
#include "IMessagingService.h"
#include "IMessagingTypes.h"
namespace DeviceAPI {
namespace Messaging {
-class EventGetMessagingService: public WrtDeviceApis::Commons::IEvent<EventGetMessagingService>
+class EventGetMessagingService: public WrtDeviceApis::Commons::IEvent<EventGetMessagingService>, public DeviceAPI::Common::SecurityAccessor
{
public:
} // Messaging
} // DeviceAPI
-#endif //WRTPLUGINS_API_GET_MESSAGING_SERVICE_EVENT_MESSAGING_H_
\ No newline at end of file
+#endif //WRTPLUGINS_API_GET_MESSAGING_SERVICE_EVENT_MESSAGING_H_
#include "EventSendMessagePrivateData.h" //for send message
#include "EventMessagingServicePrivateData.h"
#include "MessageAsyncCallbackManager.h"
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
using namespace std;
return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
}
-JSObjectRef JSMessagingService::createJSObject(JSContextRef context, const IMessagingServicePtr &messagingService)
+JSObjectRef JSMessagingService::createJSObject(JSContextRef context, const IMessagingServicePtr &messagingService, const DeviceAPI::Common::SecurityAccessor *securityAccessor)
{
JSMessagingServicePriv* priv = new JSMessagingServicePriv( context, messagingService); //make private class.
+ priv->copyAceCheckAccessFunction(securityAccessor);
return JSObjectMake(context, getClassRef(), priv);
}
LoggerD("type" << ": " << storagePrivObj->m_type);
MessagingStoragePriv *privStorage = new MessagingStoragePriv(l_globalContext, storagePrivObj);
+ privStorage->copyAceCheckAccessFunction(priv);
return JSObjectMake(l_globalContext, JSMessagingStorage::getClassRef(), privStorage);
}
JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(thisObject));
if (priv)
{
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_CREATE_MESSAGE]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_CREATE_MESSAGE);
try {
ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
{
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_SEND_MESSAGE]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_SEND_MESSAGE);
+
JSContextRef globalContext = priv->getContext();
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(globalContext);
{
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_LOAD_MESSAGE_BODY]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_LOAD_MESSAGE_BODY);
+
JSContextRef globalContext = priv->getContext(); //create global Context
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(globalContext);
{
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_LOAD_MESSAGE_ATTACHMENT]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_LOAD_MESSAGE_ATTACHMENT);
+
JSContextRef globalContext = priv->getContext(); //create global Context
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(globalContext);
{
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_SYNC]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_SYNC);
+
JSContextRef globalContext = priv->getContext(); //get global Context
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(globalContext);
{
LoggerD("Entered");
- //check permission
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_SYNC_FOLDER]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
JSMessagingServicePriv* priv = static_cast<JSMessagingServicePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_SYNC_FOLDER);
+
JSContextRef globalContext = priv->getContext(); //get global Context
WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(globalContext);
#include <JavaScriptCore/JavaScript.h>
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
#include "IMessagingService.h"
namespace DeviceAPI {
namespace Messaging {
-typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<IMessagingServicePtr>::Type JSMessagingServicePriv;
+typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<DeviceAPI::Messaging::IMessagingServicePtr>::Type JSMessagingServicePrivObject;
+
+class JSMessagingServicePriv :
+ public JSMessagingServicePrivObject,
+ public DeviceAPI::Common::SecurityAccessor
+{
+public:
+ JSMessagingServicePriv(JSContextRef context, IMessagingServicePtr messagingService) :
+ JSMessagingServicePrivObject(context, messagingService),
+ DeviceAPI::Common::SecurityAccessor()
+ {
+ }
+
+ virtual ~JSMessagingServicePriv()
+ {
+ }
+};
class JSMessagingService {
static const JSClassDefinition* getClassInfo();
static const JSClassRef getClassRef();
- static JSObjectRef createJSObject(JSContextRef context, const IMessagingServicePtr &messagingService);
+ static JSObjectRef createJSObject(JSContextRef context, const IMessagingServicePtr &messagingService, const DeviceAPI::Common::SecurityAccessor *securityAccessor);
private :
event->setEventType(EventGetMessagingService::MESSAGING_SERVICE_MANAGER_EVENT_TYPE_ALL);
event->setMessagingServiceType(messagingType);
+ event->copyAceCheckAccessFunction(priv);
messagingServiceManager->getMessagingServiceManager(event); //call postEvent
MessageAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
#include <JavaScriptCore/JavaScript.h>
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
#include "IMessagingServiceManager.h"
namespace DeviceAPI {
namespace Messaging {
-typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<DeviceAPI::Messaging::IMessagingServiceManagerPtr>::Type JSMessagingServiceManagerPriv;
+typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<DeviceAPI::Messaging::IMessagingServiceManagerPtr>::Type JSMessagingServiceManagerPrivObject;
+
+class JSMessagingServiceManagerPriv :
+ public JSMessagingServiceManagerPrivObject,
+ public DeviceAPI::Common::SecurityAccessor
+{
+public:
+ JSMessagingServiceManagerPriv(JSContextRef context, IMessagingServiceManagerPtr messagingServiceManager) :
+ JSMessagingServiceManagerPrivObject(context, messagingServiceManager),
+ DeviceAPI::Common::SecurityAccessor()
+ {
+ }
+
+ virtual ~JSMessagingServiceManagerPriv()
+ {
+ }
+};
class JSMessagingServiceManager {
public:
#include "MessagingErrorMsg.h"
#include "MessageAsyncCallbackManager.h"
#include "MessageFilterConverter.h"
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
using namespace std;
{
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_DRAFT_MESSAGE]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_ADD_DRAFT_MESSAGE);
+
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_FIND_MESSAGES]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_FIND_MESSAGES);
+
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
{
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_REMOVE_MESSAGES]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_REMOVE_MESSAGES);
+
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_UPDATE_MESSAGES]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_UPDATE_MESSAGES);
+
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
{
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_FIND_CONVERSATIONS]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_FIND_CONVERSATIONS);
+
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
{
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_REMOVE_CONVERSATIONS]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_REMOVE_CONVERSATIONS);
+
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
{
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_FIND_FOLDERS]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_FIND_FOLDERS);
+
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_MESSAGES_CHANGE_LISTNER]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_ADD_MESSAGES_CHANGE_LISTNER);
+
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
{
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_CONVERSATIONS_CHANGE_LISTNER]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_ADD_CONVERSATIONS_CHANGE_LISTNER);
+
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
{
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_FOLDERS_CHANGE_LISTNER]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_ADD_FOLDERS_CHANGE_LISTNER);
+
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
{
LoggerD("Entered");
- //check permission.
- AceSecurityStatus status = MESSAGING_CHECK_ACCESS(
- MessagingExportedNames[MESSAGING_FUNCTION_API_REMOVE_CHANGE_LISTENER]);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
MessagingStoragePriv* priv = static_cast<MessagingStoragePriv*>(JSObjectGetPrivate(thisObject));
if (!priv) {
LoggerE("Private object is NULL.");
return JSWebAPIErrorFactory::postException(context, exception, err);
}
+ //check permission.
+ TIZEN_CHECK_ACCESS(context, exception, priv, MESSAGING_FUNCTION_API_REMOVE_CHANGE_LISTENER);
+
MessagingStoragePrivObjPtr objectPriv = priv->getObject();
if (!objectPriv) {
LoggerE("objectPriv is NULL.");
#include <JavaScriptCore/JavaScript.h>
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
#include "MessagingListener.h"
typedef DPL::SharedPtr<MessagingStoragePrivObj> MessagingStoragePrivObjPtr;
-typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<MessagingStoragePrivObjPtr, WrtDeviceApis::CommonsJavaScript::NoOwnership> MessagingStoragePriv;
+typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT<MessagingStoragePrivObjPtr>::Type MessagingStoragePrivObject;
+
+class MessagingStoragePriv :
+ public MessagingStoragePrivObject,
+ public DeviceAPI::Common::SecurityAccessor
+{
+public:
+ MessagingStoragePriv(JSContextRef context, MessagingStoragePrivObjPtr messageStorage) :
+ MessagingStoragePrivObject(context, messageStorage),
+ DeviceAPI::Common::SecurityAccessor()
+ {
+ }
+
+ virtual ~MessagingStoragePriv()
+ {
+ }
+};
class JSMessagingStorage {
public:
for (index = 0; index < count; index++)
{
- jsMessagingServiceObject[index] = JSMessagingService::createJSObject(callbackManager->getContext(), messagingServices[index] );
+ jsMessagingServiceObject[index] = JSMessagingService::createJSObject(callbackManager->getContext(), messagingServices[index], event.Get() );
}
JSObjectRef result = JSObjectMakeArray(callbackManager->getContext(), count, jsMessagingServiceObject, NULL);
<plugin-properties>
<library-name>libwrt-plugins-tizen-messaging.so</library-name>
<feature-install-uri>messaging.install.uri</feature-install-uri>
+ <feature-key-cn>SAMSUNG plugin group</feature-key-cn>
+ <feature-root-cn>SAMSUNG certificate authority</feature-root-cn>
+ <feature-root-fingerprint>AAAABBBBCCCCDDDEEEE0000</feature-root-fingerprint>
<api-feature>
using namespace WrtDeviceApis::Commons;
-#pragma GCC visibility push(default)
-
-const char* MessagingExportedNames[] =
-{
- "getMessageServices",
- "createMessage",
- "sendMessage",
- "loadMessageBody",
- "loadMessageAttachment",
- "sync",
- "syncFolder",
- "cancelOperation",
- "addDraftMessage",
- "findMessages",
- "removeMessages",
- "updateMessages",
- "findConversations",
- "removeConversations",
- "findFolders",
- "addMessagesChangeListener",
- "addConversationsChangeListener",
- "addFoldersChangeListener",
- "removeChangeListener"
-};
-
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()
{
/**
//get Message Service
AceFunction getMessagingServiceFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_GET_MESSAGING_SERVICE],
+ MESSAGING_FUNCTION_API_GET_MESSAGING_SERVICE,
MESSAGING_FEATURES_MESSAGING_READ_SEND_WRITE,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert(std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_GET_MESSAGING_SERVICE],
+ MESSAGING_FUNCTION_API_GET_MESSAGING_SERVICE,
getMessagingServiceFunc));
/** Read **/
AceFunction cancelOpFolderFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_CANCEL_OPERATION],
+ MESSAGING_FUNCTION_API_CANCEL_OPERATION,
MESSAGING_FEATURES_MESSAGING_READ,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_CANCEL_OPERATION],
+ MESSAGING_FUNCTION_API_CANCEL_OPERATION,
cancelOpFolderFunc));
AceFunction findMessagesFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_FIND_MESSAGES],
+ MESSAGING_FUNCTION_API_FIND_MESSAGES,
MESSAGING_FEATURES_MESSAGING_READ,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_FIND_MESSAGES],
+ MESSAGING_FUNCTION_API_FIND_MESSAGES,
findMessagesFunc));
AceFunction findConversationsFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_FIND_CONVERSATIONS],
+ MESSAGING_FUNCTION_API_FIND_CONVERSATIONS,
MESSAGING_FEATURES_MESSAGING_READ,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_FIND_CONVERSATIONS],
+ MESSAGING_FUNCTION_API_FIND_CONVERSATIONS,
findConversationsFunc));
AceFunction findFoldersFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_FIND_FOLDERS],
+ MESSAGING_FUNCTION_API_FIND_FOLDERS,
MESSAGING_FEATURES_MESSAGING_READ,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_FIND_FOLDERS],
+ MESSAGING_FUNCTION_API_FIND_FOLDERS,
findFoldersFunc));
AceFunction addMessagesChangeListenerFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_MESSAGES_CHANGE_LISTNER],
+ MESSAGING_FUNCTION_API_ADD_MESSAGES_CHANGE_LISTNER,
MESSAGING_FEATURES_MESSAGING_READ,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_MESSAGES_CHANGE_LISTNER],
+ MESSAGING_FUNCTION_API_ADD_MESSAGES_CHANGE_LISTNER,
addMessagesChangeListenerFunc));
AceFunction addConversationsChangeListenerFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_CONVERSATIONS_CHANGE_LISTNER],
+ MESSAGING_FUNCTION_API_ADD_CONVERSATIONS_CHANGE_LISTNER,
MESSAGING_FEATURES_MESSAGING_READ,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_CONVERSATIONS_CHANGE_LISTNER],
+ MESSAGING_FUNCTION_API_ADD_CONVERSATIONS_CHANGE_LISTNER,
addConversationsChangeListenerFunc));
AceFunction addFoldersChangeListenerFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_FOLDERS_CHANGE_LISTNER],
+ MESSAGING_FUNCTION_API_ADD_FOLDERS_CHANGE_LISTNER,
MESSAGING_FEATURES_MESSAGING_READ,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_FOLDERS_CHANGE_LISTNER],
+ MESSAGING_FUNCTION_API_ADD_FOLDERS_CHANGE_LISTNER,
addFoldersChangeListenerFunc));
AceFunction removeChangeListenerFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_REMOVE_CHANGE_LISTENER],
+ MESSAGING_FUNCTION_API_REMOVE_CHANGE_LISTENER,
MESSAGING_FEATURES_MESSAGING_READ,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_REMOVE_CHANGE_LISTENER],
+ MESSAGING_FUNCTION_API_REMOVE_CHANGE_LISTENER,
removeChangeListenerFunc));
//create Message
AceFunction createMessageFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_CREATE_MESSAGE],
+ MESSAGING_FUNCTION_API_CREATE_MESSAGE,
MESSAGING_FEATURES_MESSAGING_SEND,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_CREATE_MESSAGE],
+ MESSAGING_FUNCTION_API_CREATE_MESSAGE,
createMessageFunc));
// before sendMessage move to write privilege start
AceFunction sendMessageFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_SEND_MESSAGE],
+ MESSAGING_FUNCTION_API_SEND_MESSAGE,
MESSAGING_FEATURES_MESSAGING_SEND_WRITE,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_SEND_MESSAGE],
+ MESSAGING_FUNCTION_API_SEND_MESSAGE,
sendMessageFunc));
// before sendMessage move to write privilege end
/** Write **/
AceFunction loadMessageBodyFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_LOAD_MESSAGE_BODY],
+ MESSAGING_FUNCTION_API_LOAD_MESSAGE_BODY,
MESSAGING_FEATURES_MESSAGING_WRITE,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_LOAD_MESSAGE_BODY],
+ MESSAGING_FUNCTION_API_LOAD_MESSAGE_BODY,
loadMessageBodyFunc));
AceFunction loadMessageAttachmentFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_LOAD_MESSAGE_ATTACHMENT],
+ MESSAGING_FUNCTION_API_LOAD_MESSAGE_ATTACHMENT,
MESSAGING_FEATURES_MESSAGING_WRITE,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_LOAD_MESSAGE_ATTACHMENT],
+ MESSAGING_FUNCTION_API_LOAD_MESSAGE_ATTACHMENT,
loadMessageAttachmentFunc));
AceFunction syncFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_SYNC],
+ MESSAGING_FUNCTION_API_SYNC,
MESSAGING_FEATURES_MESSAGING_WRITE,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_SYNC],
+ MESSAGING_FUNCTION_API_SYNC,
syncFunc));
AceFunction syncFolderFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_SYNC_FOLDER],
+ MESSAGING_FUNCTION_API_SYNC_FOLDER,
MESSAGING_FEATURES_MESSAGING_WRITE,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_SYNC_FOLDER],
+ MESSAGING_FUNCTION_API_SYNC_FOLDER,
syncFolderFunc));
AceFunction addDraftMessageFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_DRAFT_MESSAGE],
+ MESSAGING_FUNCTION_API_ADD_DRAFT_MESSAGE,
MESSAGING_FEATURES_MESSAGING_WRITE,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_ADD_DRAFT_MESSAGE],
+ MESSAGING_FUNCTION_API_ADD_DRAFT_MESSAGE,
addDraftMessageFunc));
AceFunction removeMessagesFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_REMOVE_MESSAGES],
+ MESSAGING_FUNCTION_API_REMOVE_MESSAGES,
MESSAGING_FEATURES_MESSAGING_WRITE,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_REMOVE_MESSAGES],
+ MESSAGING_FUNCTION_API_REMOVE_MESSAGES,
removeMessagesFunc));
AceFunction removeConversationsFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_REMOVE_CONVERSATIONS],
+ MESSAGING_FUNCTION_API_REMOVE_CONVERSATIONS,
MESSAGING_FEATURES_MESSAGING_WRITE,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_REMOVE_CONVERSATIONS],
+ MESSAGING_FUNCTION_API_REMOVE_CONVERSATIONS,
removeConversationsFunc));
AceFunction updateMessagesFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_UPDATE_MESSAGES],
+ MESSAGING_FUNCTION_API_UPDATE_MESSAGES,
MESSAGING_FEATURES_MESSAGING_WRITE,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_UPDATE_MESSAGES],
+ MESSAGING_FUNCTION_API_UPDATE_MESSAGES,
updateMessagesFunc));
// before sendMessage move to write privilege start
/*
AceFunction sendMessageFunc = ACE_CREATE_FUNCTION(
FUNCTION_GET_MGR_SERVICE,
- MessagingExportedNames[MESSAGING_FUNCTION_API_SEND_MESSAGE],
+ MESSAGING_FUNCTION_API_SEND_MESSAGE,
MESSAGING_FEATURES_MESSAGING_WRITE,
EMPTY_DEVICE_LIST);
MessagingFunctions.insert( std::make_pair(
- MessagingExportedNames[MESSAGING_FUNCTION_API_SEND_MESSAGE],
+ MESSAGING_FUNCTION_API_SEND_MESSAGE,
sendMessageFunc));
*/
// before sendMessage move to write privilege end
#define _MESSAGING_PLUGIN_CONFIG_H_
#include <Commons/FunctionDeclaration.h>
+#include "plugin_config_impl.h"
namespace DeviceAPI {
namespace Messaging {
-typedef enum
-{
-MESSAGING_FUNCTION_API_GET_MESSAGING_SERVICE = 0,
-MESSAGING_FUNCTION_API_CREATE_MESSAGE,
-MESSAGING_FUNCTION_API_SEND_MESSAGE,
-MESSAGING_FUNCTION_API_LOAD_MESSAGE_BODY,
-MESSAGING_FUNCTION_API_LOAD_MESSAGE_ATTACHMENT,
-MESSAGING_FUNCTION_API_SYNC,
-MESSAGING_FUNCTION_API_SYNC_FOLDER,
-MESSAGING_FUNCTION_API_CANCEL_OPERATION,
-MESSAGING_FUNCTION_API_ADD_DRAFT_MESSAGE,
-MESSAGING_FUNCTION_API_FIND_MESSAGES,
-MESSAGING_FUNCTION_API_REMOVE_MESSAGES,
-MESSAGING_FUNCTION_API_UPDATE_MESSAGES,
-MESSAGING_FUNCTION_API_FIND_CONVERSATIONS,
-MESSAGING_FUNCTION_API_REMOVE_CONVERSATIONS,
-MESSAGING_FUNCTION_API_FIND_FOLDERS,
-MESSAGING_FUNCTION_API_ADD_MESSAGES_CHANGE_LISTNER,
-MESSAGING_FUNCTION_API_ADD_CONVERSATIONS_CHANGE_LISTNER,
-MESSAGING_FUNCTION_API_ADD_FOLDERS_CHANGE_LISTNER,
-MESSAGING_FUNCTION_API_REMOVE_CHANGE_LISTENER
-} MessagingFuncNames;
-
-extern const char* MessagingExportedNames[];
-
DECLARE_FUNCTION_GETTER(Messaging);
#define MESSAGING_CHECK_ACCESS(functionName) \
}
}
-#endif //MESSAGING_PLUGIN_CONFIG_H_
-
+#endif // _MESSAGING_PLUGIN_CONFIG_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.
+//
+
+#ifndef _MESSAGING_PLUGIN_CONFIG_IMPL_H_
+#define _MESSAGING_PLUGIN_CONFIG_IMPL_H_
+
+#define MESSAGING_FUNCTION_API_GET_MESSAGING_SERVICE "getMessageServices"
+#define MESSAGING_FUNCTION_API_CREATE_MESSAGE "createMessage"
+#define MESSAGING_FUNCTION_API_SEND_MESSAGE "sendMessage"
+#define MESSAGING_FUNCTION_API_LOAD_MESSAGE_BODY "loadMessageBody"
+#define MESSAGING_FUNCTION_API_LOAD_MESSAGE_ATTACHMENT "loadMessageAttachment"
+#define MESSAGING_FUNCTION_API_SYNC "sync"
+#define MESSAGING_FUNCTION_API_SYNC_FOLDER "syncFolder"
+#define MESSAGING_FUNCTION_API_CANCEL_OPERATION "cancelOperation"
+#define MESSAGING_FUNCTION_API_ADD_DRAFT_MESSAGE "addDraftMessage"
+#define MESSAGING_FUNCTION_API_FIND_MESSAGES "findMessages"
+#define MESSAGING_FUNCTION_API_REMOVE_MESSAGES "removeMessages"
+#define MESSAGING_FUNCTION_API_UPDATE_MESSAGES "updateMessages"
+#define MESSAGING_FUNCTION_API_FIND_CONVERSATIONS "findConversations"
+#define MESSAGING_FUNCTION_API_REMOVE_CONVERSATIONS "removeConversations"
+#define MESSAGING_FUNCTION_API_FIND_FOLDERS "findFolders"
+#define MESSAGING_FUNCTION_API_ADD_MESSAGES_CHANGE_LISTNER "addMessagesChangeListener"
+#define MESSAGING_FUNCTION_API_ADD_CONVERSATIONS_CHANGE_LISTNER "addConversationsChangeListener"
+#define MESSAGING_FUNCTION_API_ADD_FOLDERS_CHANGE_LISTNER "addFoldersChangeListener"
+#define MESSAGING_FUNCTION_API_REMOVE_CHANGE_LISTENER "removeChangeListener"
+
+#endif // _MESSAGING_PLUGIN_CONFIG_IMPL_H_
#include "JSMessageAttachment.h"
#include "MessageAsyncCallbackManager.h"
#include "MessageListenerManager.h"
+#include "plugin_config.h"
#include <GlobalContextManager.h>
#include <Logger.h>
namespace DeviceAPI {
namespace Messaging {
+using namespace WrtDeviceApis;
+using namespace WrtDeviceApis::Commons;
+
+AceSecurityStatus messagingAceCheckAccessFunction(const char* functionName)
+{
+ return MESSAGING_CHECK_ACCESS(functionName);
+}
+
+DEFINE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
+
+DEFINE_SECURITY_ACCESSOR_SETTER(AceCheckerMessagingSetter, JSMessagingServiceManagerPriv, gSecurityAccessor);
+
namespace Options{
class_definition_options_t MessagingOptions =
{
JS_CLASS,
CREATE_INSTANCE,
- NONE_NOTICE,
+ ALWAYS_NOTICE,
USE_OVERLAYED, //ignored
+ AceCheckerMessagingSetter,
NULL,
NULL
};
}
-using namespace WrtDeviceApis;
-using namespace WrtDeviceApis::Commons;
-
void on_widget_start_callback(int widgetId) {
LoggerD("[Tizen\\MessagingServiceManager] on_widget_start_callback ("<<widgetId<<")");
Try {
} Catch(Commons::Exception) {
LoggerE("WrtAccess initialization failed");
}
+
+ INITAILIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor, messagingAceCheckAccessFunction);
}
void on_widget_stop_callback(int widgetId) {
} Catch(Commons::Exception) {
LoggerE("WrtAccess deinitialization failed");
}
+
+ FINALIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
}
void on_frame_load_callback(const void * context)
#include <dpl/shared_ptr.h>
#include <Commons/IEvent.h>
#include <CommonsJavaScript/JSCallbackManager.h>
+#include <Security.h>
namespace DeviceAPI {
namespace NFC {
-class EventNFCChangedPrivateData : public WrtDeviceApis::Commons::IEventPrivateData
+class EventNFCChangedPrivateData : public WrtDeviceApis::Commons::IEventPrivateData,
+ public DeviceAPI::Common::SecurityAccessor
{
public:
EventNFCChangedPrivateData(const WrtDeviceApis::CommonsJavaScript::JSCallbackManagerPtr& callbackManager,
#include "NFCListenerManager.h"
#include "NFCFactory.h"
#include "EventNFCChanged.h"
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
#include <Logger.h>
using namespace std;
JSObjectSetPrivate(object, NULL);
}
-JSObjectRef JSNFCAdapter::createJSObject(JSContextRef context) {
+JSObjectRef JSNFCAdapter::createJSObject(JSContextRef context, NFCManagerPrivObject *nfcManagerPriv) {
LoggerD("entered");
INFCAdapterPtr nfcAdapter(NFCFactory::getInstance().createNFCAdapterObject());
ThrowMsg(NullPointerException, "Can not new a NFCTag object");
}
+ priv->copyAceCheckAccessFunction(nfcManagerPriv);
return JSObjectMake(context, getClassRef(), priv);
}
JSValueRef* exception) {
LoggerD("JSNFCAdapter::setTagListener Enter");
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_TAG_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
- JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
+ NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
+ if (!privateObject) {
+ LoggerE("private object is null");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ }
+
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_TAG_FUNCS);
+
Try {
ArgumentValidator validator(context, argumentCount, arguments);
NFCChangedCallback callbacks;
callbacks = nfcConverter.toNFCChangedCallback(arguments[0]);
std::vector<std::string> filterValue = validator.toStringVector(1, true);
-
+
+ JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(global_context, callbacks.onattach, NULL, true, true);
JSCallbackManagerPtr detachedCallbackManager = JSCallbackManager::createObject(global_context, callbacks.ondetach, NULL);
TagFilterPtr tagFilter(new TagFilter());
LoggerD("tag_types.at(i): " << filterValue.at(i));
}
- NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
- if (!privateObject) {
- LoggerE("private object is null");
- return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
- }
-
INFCAdapterPtr nfcAdapter(privateObject->getObject());
EventNFCChangedPrivateDataPtr privateData(
new EventNFCChangedPrivateData(callbackManager,
detachedCallbackManager)
);
+ privateData->copyAceCheckAccessFunction(privateObject);
+
EventNFCChangedEmitterPtr emitter(new EventNFCChangedEmitter);
emitter->setListener(&NFCStaticController::getInstance());
emitter->setEventPrivateData(DPL::StaticPointerCast<EventNFCChanged::PrivateDataType>(privateData));
JSValueRef* exception) {
LoggerD("JSNFCAdapter::setPeerListener Enter");
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_P2P_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
+ if (!privateObject) {
+ LoggerE("private object is null");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
+ }
- JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_P2P_FUNCS);
Try {
ArgumentValidator validator(context, argumentCount, arguments);
if (validator.toObject(0))
callbacks = nfcConverter.toNFCChangedCallback(arguments[0]);
-
+
+ JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(global_context, callbacks.onattach, NULL, true, true);
JSCallbackManagerPtr detachedCallbackManager = JSCallbackManager::createObject(global_context, callbacks.ondetach, NULL);
- NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
- if (!privateObject) {
- LoggerE("private object is null");
- return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
- }
-
INFCAdapterPtr nfcAdapter(privateObject->getObject());
EventNFCChangedPrivateDataPtr privateData(
detachedCallbackManager)
);
+ privateData->copyAceCheckAccessFunction(privateObject);
EventNFCChangedEmitterPtr emitter(new EventNFCChangedEmitter);
emitter->setListener(&NFCStaticController::getInstance());
emitter->setEventPrivateData(DPL::StaticPointerCast<EventNFCChanged::PrivateDataType>(privateData));
size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) {
LoggerD("JSNFCAdapter::unsetNFCTagListener Enter");
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_TAG_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("private object is null");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_TAG_FUNCS);
+
Try {
INFCAdapterPtr nfcAdapter(privateObject->getObject());
size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) {
LoggerD("JSNFCAdapter::unsetPeerListener Enter");
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_P2P_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("private object is null");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_P2P_FUNCS);
Try {
- INFCAdapterPtr nfcAdapter( privateObject->getObject() );
+ INFCAdapterPtr nfcAdapter( privateObject->getObject());
nfcAdapter->unsetPeerListener();
JSValueRef* exception) {
LoggerD("JSNFCAdapter::getCachedMessage Enter");
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_COMMON_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("private object is null");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
- JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_COMMON_FUNCS);
+
Try {
INFCAdapterPtr nfcAdapter(privateObject->getObject());
void *cachedMessage = nfcAdapter->getCachedMessage();
- if (cachedMessage != NULL)
+ if (cachedMessage != NULL) {
+ JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
return JSNdefMessage::createJSObject(global_context, cachedMessage);
+ }
return JSValueMakeNull(context);
} Catch (WrtDeviceApis::Commons::UnknownException) {
LoggerE("Exception: " << _rethrown_exception.GetMessage());
JSValueRef* exception) {
LoggerD("Enter");
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_ADMIN_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
- JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
-
NFCAdapterPrivObject* privateObject = static_cast<NFCAdapterPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("private object is null");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
- INFCAdapterPtr nfcAdapter(privateObject->getObject());
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_ADMIN_FUNCS);
+
+ JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(global_context, NULL, NULL, true, true);
Try {
if (validator.toFunction(2, true))
callbackManager->setOnError(arguments[2]);
- NFCConverter nfcConverter(context);
-
EventNFCChangedSetPoweredPtr event(new EventNFCChangedSetPowered(state));
- event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager) );
+ event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager) );
event->setForAsynchronousCall(&NFCStaticController::getInstance());
callbackManager->setObject(thisObject);
+ INFCAdapterPtr nfcAdapter(privateObject->getObject());
nfcAdapter->setPowered(event);
NFCAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, global_context);
return JSValueMakeUndefined(context);
#include <JavaScriptCore/JavaScript.h>
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
#include "INFCAdapter.h"
+#include "JSNFCManager.h"
namespace DeviceAPI {
namespace NFC {
-typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<INFCAdapterPtr, WrtDeviceApis::CommonsJavaScript::NoOwnership> NFCAdapterPrivObject;
+typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<INFCAdapterPtr, WrtDeviceApis::CommonsJavaScript::NoOwnership> NFCAdapterPrivObjectBase;
+class NFCAdapterPrivObject :
+ public DeviceAPI::Common::SecurityAccessor,
+ public NFCAdapterPrivObjectBase
+{
+public:
+ NFCAdapterPrivObject(JSContextRef context, INFCAdapterPtr adapter) :
+ DeviceAPI::Common::SecurityAccessor(),
+ NFCAdapterPrivObjectBase(context, adapter)
+ {
+ }
+
+ virtual ~ NFCAdapterPrivObject()
+ {
+ }
+};
+
class JSNFCAdapter
{
public:
static const JSClassRef getClassRef();
- static JSObjectRef createJSObject(JSContextRef context);
+ static JSObjectRef createJSObject(JSContextRef context, NFCManagerPrivObject *nfcManagerPriv);
private:
/**
* This member variable contains the values which has to be passed when
#include "JSNFCAdapter.h"
#include "NFCConverter.h"
#include "NFCFactory.h"
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
#include "NFCDefaultAdapter.h"
#include <Logger.h>
LoggerD("Enter");
Try {
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_COMMON_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
NFCManagerPrivObject* privateObject = static_cast<NFCManagerPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("private object is null");
ThrowMsg(UnsupportedException, "private object is null");
}
- return JSNFCAdapter::createJSObject(GlobalContextManager::getInstance()->getGlobalContext(context));
+
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_COMMON_FUNCS);
+
+ return JSNFCAdapter::createJSObject(GlobalContextManager::getInstance()->getGlobalContext(context), privateObject);
} Catch (UnsupportedException) {
LoggerE("UnsupportedException: " << _rethrown_exception.GetMessage());
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Not Supported");
LoggerD("Enter");
Try {
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_COMMON_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
- ArgumentValidator validator(context, argumentCount, arguments);
- // mode
- bool mode = validator.toBool(0);
- LoggerD("mode : " << mode);
NFCManagerPrivObject* privateObject = static_cast<NFCManagerPrivObject*>(JSObjectGetPrivate(thisObject));
if (!privateObject) {
LoggerE("private object is null");
throw TypeMismatchException("private object is null");
}
+
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_COMMON_FUNCS);
+
+ ArgumentValidator validator(context, argumentCount, arguments);
+ // mode
+ bool mode = validator.toBool(0);
+ LoggerD("mode : " << mode);
+
NFCDefaultAdapterSingleton::Instance().setExclusiveMode(mode);
return JSValueMakeUndefined(context);
} Catch (BasePlatformException) {
#include <JavaScriptCore/JavaScript.h>
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
#include "INFCAdapter.h"
namespace DeviceAPI {
namespace NFC {
-typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<void, WrtDeviceApis::CommonsJavaScript::NoOwnership> NFCManagerPrivObject;
+typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<void, WrtDeviceApis::CommonsJavaScript::NoOwnership> NFCManagerPrivObjectBase;
+class NFCManagerPrivObject :
+ public DeviceAPI::Common::SecurityAccessor,
+ public NFCManagerPrivObjectBase
+{
+public:
+ NFCManagerPrivObject(JSContextRef context) :
+ DeviceAPI::Common::SecurityAccessor(),
+ NFCManagerPrivObjectBase(context)
+ {
+ }
+
+ virtual ~NFCManagerPrivObject()
+ {
+ }
+};
+
class JSNFCManager
{
public:
#include "NFCFactory.h"
#include "EventTagAction.h"
#include "NFCAsyncCallbackManager.h"
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
#include <Logger.h>
using namespace DeviceAPI::Common;
JSClassRef JSNFCTag::m_jsClassRef = JSClassCreate(JSNFCTag::getClassInfo());
-JSObjectRef JSNFCTag::createJSObject(JSContextRef context, void *tagHandle) {
+JSObjectRef JSNFCTag::createJSObject(JSContextRef context, void *tagHandle, EventNFCChangedPrivateDataPtr eventNFCChangedPriv) {
LoggerD("entered");
INFCTagPtr nfcTag = NFCFactory::getInstance().createNFCTagObject(tagHandle);
ThrowMsg(NullPointerException, "Can not new a NFCTag object");
}
+ priv->copyAceCheckAccessFunction(eventNFCChangedPriv.Get());
return JSObjectMake(context, getClassRef(), priv);
}
{
LoggerD("Entered ");
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_TAG_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
- JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
-
NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
- INFCTagPtr nfcTag(privateObject->getObject());
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_TAG_FUNCS);
+
+ JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(global_context, NULL, NULL, true, true);
Try {
callbackManager->setOnError(arguments[1]);
EventTagActionReadPtr event(new EventTagActionRead());
- event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager) );
+ event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager) );
event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
callbackManager->setObject(thisObject);
+ INFCTagPtr nfcTag(privateObject->getObject());
nfcTag->readNdef(event);
NFCAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, global_context);
return JSValueMakeUndefined(context);
{
LoggerD("Entered ");
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_TAG_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
- JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
-
NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
- INFCTagPtr nfcTag(privateObject->getObject());
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_TAG_FUNCS);
+
+ JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(global_context, NULL, NULL, true, true);
Try {
ArgumentValidator validator(context, argumentCount, arguments);
callbackManager->setOnError(arguments[2]);
EventTagActionWritePtr event(new EventTagActionWrite());
- JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
- NFCConverter convert(global_context);
void *messageHandle = NULL;
try {
NdefMessagePrivObject* ndefMessagePrivateObj = static_cast<NdefMessagePrivObject*>(JSObjectGetPrivate(ndefMessageObj));
}
INdefMessagePtr ndefMessage(ndefMessagePrivateObj->getObject());
JSValueRef recordsValue = (ndefMessage->mLocalProperty).getProperty(global_context, TIZEN_NDEFMESSAGE_RECORDS);
+ NFCConverter convert(global_context);
std::vector<void *> records = convert.toVectorOfRecordHandles(recordsValue);
messageHandle = ndefMessage->makeNdefMessageHandle(records);
} catch (WrtDeviceApis::Commons::Exception& err) {
ThrowMsg(InvalidArgumentException, "Invalid NDEF Message");
event->writeNdef(messageHandle);
- event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
+ event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
callbackManager->setObject(thisObject);
+ INFCTagPtr nfcTag(privateObject->getObject());
nfcTag->writeNdef(event);
NFCAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, global_context);
return JSValueMakeUndefined(context);
{
LoggerD("Entered ");
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_TAG_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
- JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
-
NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
- INFCTagPtr nfcTag(privateObject->getObject());
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_TAG_FUNCS);
+
+ JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(global_context, NULL, NULL, true, true);
Try {
ArgumentValidator validator(context, argumentCount, arguments);
callbackManager->setOnError(arguments[2]);
EventTagActionTransceivePtr event(new EventTagActionTransceive());
- NFCConverter convert(context);
std::vector<unsigned char> data;
- if (dataObj)
+ if (dataObj) {
+ NFCConverter convert(context);
data= convert.toVectorOfOctets(arguments[0]);
+ }
event->transceive(data);
event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager) );
event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
callbackManager->setObject(thisObject);
+ INFCTagPtr nfcTag(privateObject->getObject());
nfcTag->transceive(event);
NFCAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, global_context);
return JSValueMakeUndefined(context);
#include <JavaScriptCore/JavaScript.h>
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
#include "INFCTag.h"
+#include "EventNFCChangedPrivateData.h"
+
namespace DeviceAPI {
namespace NFC {
-typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<INFCTagPtr, WrtDeviceApis::CommonsJavaScript::NoOwnership> NFCTagPrivObject;
+typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<INFCTagPtr, WrtDeviceApis::CommonsJavaScript::NoOwnership> NFCTagPrivObjectBase;
+class NFCTagPrivObject :
+ public DeviceAPI::Common::SecurityAccessor,
+ public NFCTagPrivObjectBase
+{
+public:
+ NFCTagPrivObject(JSContextRef context, INFCTagPtr nfcTag) :
+ DeviceAPI::Common::SecurityAccessor(),
+ NFCTagPrivObjectBase(context, nfcTag)
+ {
+ }
+
+ virtual ~NFCTagPrivObject()
+ {
+ }
+};
class JSNFCTag
{
static const JSClassRef getClassRef();
- static JSObjectRef createJSObject(JSContextRef context, void *tagHandle);
+ static JSObjectRef createJSObject(JSContextRef context, void *tagHandle, EventNFCChangedPrivateDataPtr eventNFCChangedPriv);
private:
/**
#include "NFCListenerManager.h"
#include "NFCFactory.h"
#include "EventTargetAction.h"
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
#include <Logger.h>
JSClassRef JSNFCTarget::m_jsClassRef = JSClassCreate(JSNFCTarget::getClassInfo());
-JSObjectRef JSNFCTarget::createJSObject(JSContextRef context, void *tagHandle) {
+JSObjectRef JSNFCTarget::createJSObject(JSContextRef context, void *tagHandle, EventNFCChangedPrivateDataPtr eventNFCChangedPriv) {
LoggerD("entered");
INFCTargetPtr nfcTarget = NFCFactory::getInstance().createNFCTargetObject(tagHandle);
ThrowMsg(NullPointerException, "Can not new a NFCTarget object");
}
+ priv->copyAceCheckAccessFunction(eventNFCChangedPriv.Get());
return JSObjectMake(context, getClassRef(), priv);
}
{
LoggerD("Entered ");
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_P2P_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
- JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
-
NFCTargetPrivObject* privateObject = static_cast<NFCTargetPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
-
- INFCTargetPtr nfcTarget(privateObject->getObject());
+
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_P2P_FUNCS);
Try {
ArgumentValidator validator(context, argumentCount, arguments);
if (validator.toFunction(0))
onSuccessForCbm = arguments[0];
+ JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(global_context, onSuccessForCbm, NULL, true, true);
EventTargetActionReceiveEmitterPtr emitter(new EventTargetActionReceiveEmitter);
emitter->setListener(&NFCResponseDispatcher::getInstance());
emitter->setEventPrivateData(DPL::StaticPointerCast<EventTargetActionReceive::PrivateDataType>(callbackManager));
+ INFCTargetPtr nfcTarget(privateObject->getObject());
nfcTarget->setReceiveNDEFListener(emitter);
NFCListenerCancellerPtr canceller = NFCListenerCancellerPtr(new NFCListenerCanceller(global_context, thisObject, static_cast<long>(ID_NFCPEER_RECEIVENDEF_LISTENER)));
{
LoggerD("Entered ");
Try {
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_P2P_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
- JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
-
NFCTargetPrivObject* privateObject = static_cast<NFCTargetPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_P2P_FUNCS);
+
INFCTargetPtr nfcTarget(privateObject->getObject());
nfcTarget->unsetReceiveNDEFListener();
+ JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
NFCListenerCancellerPtr canceller = NFCListenerCancellerPtr(new NFCListenerCanceller(global_context, thisObject, static_cast<long>(ID_NFCPEER_RECEIVENDEF_LISTENER)));
IListenerItemPtr listenerItem = DPL::StaticPointerCast<IListenerItem>(canceller);
NFCListenerManagerSingleton::Instance().unregisterListener(listenerItem);
{
LoggerD("Entered ");
- AceSecurityStatus status = NFC_CHECK_ACCESS(NFC_FUNCTION_API_P2P_FUNCS);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
-
- JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
-
- NFCConverter convert(context);
-
NFCTargetPrivObject* privateObject = static_cast<NFCTargetPrivObject*>(JSObjectGetPrivate(thisObject));
if (NULL == privateObject) {
LoggerE("private object is null");
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type Mismatch");
}
- INFCTargetPtr nfcTarget(privateObject->getObject());
+ TIZEN_CHECK_ACCESS(context, exception, privateObject,
+ NFC_FUNCTION_API_P2P_FUNCS);
+
+ JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
+
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(global_context, NULL, NULL, true, true);
Try {
ArgumentValidator validator(context, argumentCount, arguments);
if (validator.toFunction(2, true))
callbackManager->setOnError(arguments[2]);
- JSContextRef global_context = GlobalContextManager::getInstance()->getGlobalContext(context);
- NFCConverter convert(global_context);
void *messageHandle = NULL;
try {
NdefMessagePrivObject* ndefMessagePrivateObj = static_cast<NdefMessagePrivObject*>(JSObjectGetPrivate(ndefMessageObj));
}
INdefMessagePtr ndefMessage(ndefMessagePrivateObj->getObject());
JSValueRef recordsValue = (ndefMessage->mLocalProperty).getProperty(global_context, TIZEN_NDEFMESSAGE_RECORDS);
+ NFCConverter convert(global_context);
std::vector<void *> records = convert.toVectorOfRecordHandles(recordsValue);
messageHandle = ndefMessage->makeNdefMessageHandle(records);
} catch (WrtDeviceApis::Commons::Exception& err) {
EventTargetActionSendPtr event(new EventTargetActionSend(messageHandle));
callbackManager->setObject(thisObject);
- event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
+ event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
+ INFCTargetPtr nfcTarget(privateObject->getObject());
nfcTarget->sendNDEF(event);
NFCAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, global_context);
return JSValueMakeUndefined(context);
#include <JavaScriptCore/JavaScript.h>
#include <CommonsJavaScript/PrivateObject.h>
+#include <Security.h>
+#include "EventNFCChangedPrivateData.h"
#include "INFCTarget.h"
namespace DeviceAPI {
namespace NFC {
-typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<INFCTargetPtr, WrtDeviceApis::CommonsJavaScript::NoOwnership> NFCTargetPrivObject;
+typedef WrtDeviceApis::CommonsJavaScript::PrivateObject<INFCTargetPtr, WrtDeviceApis::CommonsJavaScript::NoOwnership> NFCTargetPrivObjectBase;
+class NFCTargetPrivObject :
+ public DeviceAPI::Common::SecurityAccessor,
+ public NFCTargetPrivObjectBase
+{
+public:
+ NFCTargetPrivObject(JSContextRef context, INFCTargetPtr nfcTarget) :
+ DeviceAPI::Common::SecurityAccessor(),
+ NFCTargetPrivObjectBase(context, nfcTarget)
+ {
+ }
+
+ virtual ~NFCTargetPrivObject()
+ {
+ }
+};
class JSNFCTarget
{
static const JSClassRef getClassRef();
- static JSObjectRef createJSObject(JSContextRef context, void *tagHandle);
+ static JSObjectRef createJSObject(JSContextRef context, void *tagHandle, EventNFCChangedPrivateDataPtr eventNFCChangedPriv);
private:
/**
#include <PlatformException.h>
#include "NFCFactory.h"
-#include "plugin_config.h"
#include <Logger.h>
using namespace DeviceAPI::Common;
#include "NFCFactory.h"
#include "JSNdefRecord.h"
-#include "plugin_config.h"
#include "NFCConverter.h"
#include <Logger.h>
JSContextRef context = callbackManager->getContext();
if (event->getNFCType() == NFC_TAG_TYPE)
- nfcObj = JSNFCTag::createJSObject(context, nfcProp);
+ nfcObj = JSNFCTag::createJSObject(context, nfcProp, privateData);
else
- nfcObj = JSNFCTarget::createJSObject(context, nfcProp);
+ nfcObj = JSNFCTarget::createJSObject(context, nfcProp, privateData);
LoggerD("callOnSuccess");
callbackManager->callOnSuccess(static_cast<JSValueRef>(nfcObj));
} else {
namespace DeviceAPI {
namespace NFC {
-const char* NFC_FUNCTION_API_COMMON_FUNCS = "NFCCommonFunctions";
-const char* NFC_FUNCTION_API_ADMIN_FUNCS = "NFCAdminFunctions";
-const char* NFC_FUNCTION_API_TAG_FUNCS = "NFCTagFunctions";
-const char* NFC_FUNCTION_API_P2P_FUNCS = "NFCP2PFunctions";
-const char* NFC_FUNCTION_API_CARDEMULATION_FUNCS = "NFCCardEmulationFunctions";
-
static WrtDeviceApis::Commons::FunctionMapping createNFCFunctions();
static WrtDeviceApis::Commons::FunctionMapping NFCFunctions =
createNFCFunctions();
-#pragma GCC visibility push(default)
-
DEFINE_FUNCTION_GETTER(NFC, NFCFunctions);
-#pragma GCC visibility pop
-
static WrtDeviceApis::Commons::FunctionMapping createNFCFunctions()
{
using namespace WrtDeviceApis::Commons;
#define _NFC_PLUGIN_CONFIG_H_
#include <Commons/FunctionDeclaration.h>
+#include "plugin_config_impl.h"
namespace DeviceAPI {
namespace NFC {
-extern const char* NFC_FUNCTION_API_COMMON_FUNCS;
-extern const char* NFC_FUNCTION_API_ADMIN_FUNCS;
-extern const char* NFC_FUNCTION_API_TAG_FUNCS;
-extern const char* NFC_FUNCTION_API_P2P_FUNCS;
-extern const char* NFC_FUNCTION_API_CARDEMULATION_FUNCS;
DECLARE_FUNCTION_GETTER(NFC);
--- /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 _NFC_PLUGIN_CONFIG_IMPL_H_
+#define _NFC_PLUGIN_CONFIG_IMPL_H_
+
+#define NFC_FUNCTION_API_COMMON_FUNCS "NFCCommonFunctions"
+#define NFC_FUNCTION_API_ADMIN_FUNCS "NFCAdminFunctions"
+#define NFC_FUNCTION_API_TAG_FUNCS "NFCTagFunctions"
+#define NFC_FUNCTION_API_P2P_FUNCS "NFCP2PFunctions"
+#define NFC_FUNCTION_API_CARDEMULATION_FUNCS "NFCCardEmulationFunctions"
+
+
+#endif // _NFC_PLUGIN_CONFIG_IMPL_H_
\ No newline at end of file
#include "NFCAsyncCallbackManager.h"
#include "NFCListenerManager.h"
#include "NFCDefaultAdapter.h"
+#include "plugin_config.h"
+#include <Security.h>
+#include <JSStringRefWrapper.h>
#include <Logger.h>
using namespace WrtDeviceApis;
namespace DeviceAPI {
namespace NFC {
+AceSecurityStatus nfcAceCheckAccessFunction(const char* functionName)
+{
+ return NFC_CHECK_ACCESS(functionName);
+}
+
+DEFINE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
+DEFINE_SECURITY_ACCESSOR_SETTER(AceCheckerNfcSetter, NFCManagerPrivObject, gSecurityAccessor);
+DEFINE_JSOBJECT_SECURITY_ACCESSOR_SETTER(AceCheckerNfcConstructorSetter, gSecurityAccessor);
+
+class_definition_options_t ClassOptions =
+{
+ JS_CLASS,
+ CREATE_INSTANCE,
+ ALWAYS_NOTICE,
+ USE_OVERLAYED, //ignored
+ AceCheckerNfcSetter,
+ NULL
+};
+
+
class_definition_options_t ConstructorClassOptions =
{
JS_INTERFACE,
CREATE_INSTANCE,
- NONE_NOTICE,
+ ALWAYS_NOTICE,
USE_OVERLAYED, //ignored
- NULL,
+ AceCheckerNfcConstructorSetter, // JSWidget::acquireGlobalContext,
NULL,
NULL
};
{
LoggerE("WrtAccess initialization failed");
}
+ INITAILIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor, nfcAceCheckAccessFunction);
}
void on_widget_stop_callback(int widgetId)
{
LoggerE("WrtAccess deinitialization failed");
}
+ FINALIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
}
-void on_frame_load_callback(const void * context)
+void on_frame_load_callback(const void *context)
{
LoggerD("[Tizen\\NFC] on_frame_load_callback (" << context << ")");
GlobalContextManager::getInstance()->addGlobalContext(static_cast<JSContextRef>(context));
}
-void on_frame_unload_callback(const void * context)
+void on_frame_unload_callback(const void *context)
{
LoggerD("[Tizen\\NFC] on_frame_unload_callback (" << context << ")");
GlobalContextManager::getInstance()->removeGlobalContext(static_cast<JSContextRef>(context));
PLUGIN_CLASS_MAP_ADD_CLASS(WRT_JS_EXTENSION_OBJECT_TIZEN,
"nfc",
(js_class_template_getter)JSNFCManager::getClassRef,
- NULL)
+ &ClassOptions)
PLUGIN_CLASS_MAP_ADD_INTERFACE(WRT_JS_EXTENSION_OBJECT_TIZEN,
"NDEFMessage",
(js_class_template_getter)JSNdefMessage::getClassRef,
${TARGET_IMPL_NAME}
${tizen_impl}
${timeutil_impl}
- "-Wl,--no-as-needed" ${application_config}
- "-Wl,--no-as-needed" ${filesystem_config}
)
INSTALL(TARGETS ${TARGET_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME})
ret = app_info_get_package(handle, pkg_id);
if ((ret != APP_MANAGER_ERROR_NONE) || (*pkg_id == NULL)) {
LoggerE("Fail to get pkg_id");
+ app_info_destroy(handle);
return ret;
}
//
#include <SecurityExceptions.h>
-#include <CallbackUserData.h>
#include <GlobalContextManager.h>
#include <JSUtil.h>
#include <ArgumentValidator.h>
#include <TimeTracer.h>
#include "JSPowerManager.h"
-#include "plugin_config.h"
+#include "plugin_config_impl.h"
#include "PowerManager.h"
#include <Logger.h>
void JSPowerManager::initialize(JSContextRef context, JSObjectRef object)
{
+ LoggerD("entered");
+ PowerManagerPriv *priv = new PowerManagerPriv(GlobalContextManager::getInstance()->getGlobalContext(context));
+ JSObjectSetPrivate(object, static_cast<void*>(priv));
}
void JSPowerManager::finalize(JSObjectRef object)
{
- CallbackUserData *callback = static_cast<CallbackUserData*>(JSObjectGetPrivate(object));
- if( callback != NULL ){
- PowerManager::getInstance()->removeScreenStateChangedCallback(callback);
+ LoggerD("entered");
+ PowerManagerPriv *priv = static_cast<PowerManagerPriv*>(JSObjectGetPrivate(object));
+ if( priv != NULL ){
+ PowerManager::getInstance()->removeScreenStateChangedCallback(priv);
JSObjectSetPrivate(object, NULL);
- delete callback;
+ delete priv;
}
}
JSValueRef* exception)
{
LoggerD("entered");
- TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- AceSecurityStatus status = POWER_CHECK_ACCESS(POWER_FUNCTION_API_REQUEST);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ PowerManagerPriv *thisPriv = static_cast<PowerManagerPriv*>(JSObjectGetPrivate(thisObject));
+ if (!thisPriv) {
+ LoggerE("private object is null");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
+ }
+ TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
+ TIZEN_CHECK_ACCESS(context, exception, thisPriv, POWER_FUNCTION_API_REQUEST);
try{
ArgumentValidator validator(context, argumentCount, arguments);
try{
ArgumentValidator validator(context, argumentCount, arguments);
JSObjectRef func = validator.toFunction(0);
- CallbackUserData *callback = static_cast<CallbackUserData*>(JSObjectGetPrivate(thisObject));
- if( callback == NULL ){
- callback = new CallbackUserData(GlobalContextManager::getInstance()->getGlobalContext(context));
- JSObjectSetPrivate(thisObject, callback);
- }
- callback->setSuccessCallback(func);
- PowerManager::getInstance()->addScreenStateChangedCallback(callback);
+ PowerManagerPriv *thisPriv = static_cast<PowerManagerPriv*>(JSObjectGetPrivate(thisObject));
+ thisPriv->setSuccessCallback(func);
+ PowerManager::getInstance()->addScreenStateChangedCallback(thisPriv);
}catch(const BasePlatformException& err){
return JSWebAPIErrorFactory::postException(context, exception, err);
LoggerD("entered");
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- CallbackUserData *callback = static_cast<CallbackUserData*>(JSObjectGetPrivate(thisObject));
- if( callback != NULL ){
- PowerManager::getInstance()->removeScreenStateChangedCallback(callback);
- JSObjectSetPrivate(thisObject, NULL);
- delete callback;
- }
+ PowerManagerPriv *thisPriv = static_cast<PowerManagerPriv*>(JSObjectGetPrivate(thisObject));
+
TIME_TRACER_ITEM_END(__FUNCTION__, 0);
return JSValueMakeUndefined(context);
}
JSValueRef* exception)
{
LoggerD("entered");
+
+ PowerManagerPriv *thisPriv = static_cast<PowerManagerPriv*>(JSObjectGetPrivate(thisObject));
+ if (!thisPriv) {
+ LoggerE("private object is null");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
+ }
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- AceSecurityStatus status = POWER_CHECK_ACCESS(POWER_FUNCTION_API_RELEASE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, thisPriv, POWER_FUNCTION_API_SET_SCREEN_BRIGHTNESS);
+
try{
ArgumentValidator validator(context, argumentCount, arguments);
JSValueRef* exception)
{
LoggerD("entered");
+
+ PowerManagerPriv *thisPriv = static_cast<PowerManagerPriv*>(JSObjectGetPrivate(thisObject));
+ if (!thisPriv) {
+ LoggerE("private object is null");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
+ }
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- AceSecurityStatus status = POWER_CHECK_ACCESS(POWER_FUNCTION_API_RELEASE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, thisPriv, POWER_FUNCTION_API_TURN_SCREEN_ON);
try{
PowerManager::getInstance()->setScreenState(true);
JSValueRef* exception)
{
LoggerD("entered");
+ PowerManagerPriv *thisPriv = static_cast<PowerManagerPriv*>(JSObjectGetPrivate(thisObject));
+ if (!thisPriv) {
+ LoggerE("private object is null");
+ return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong object");
+ }
TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
- AceSecurityStatus status = POWER_CHECK_ACCESS(POWER_FUNCTION_API_RELEASE);
- TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TIZEN_CHECK_ACCESS(context, exception, thisPriv, POWER_FUNCTION_API_TURN_SCREEN_OFF);
try{
PowerManager::getInstance()->setScreenState(false);
#include <string>
#include <JavaScriptCore/JavaScript.h>
+#include <Security.h>
+#include <CallbackUserData.h>
namespace DeviceAPI {
namespace Power {
+class PowerManagerPriv : public DeviceAPI::Common::CallbackUserData, public DeviceAPI::Common::SecurityAccessor
+{
+public:
+ PowerManagerPriv(JSContextRef ctx) : DeviceAPI::Common::CallbackUserData(ctx), DeviceAPI::Common::SecurityAccessor() {}
+ virtual ~PowerManagerPriv() {}
+};
+
class JSPowerManager
{
public:
#include <Commons/FunctionDeclaration.h>
#include <map>
+#include "plugin_config_impl.h"
#include "plugin_config.h"
#define POWER_FEATURE_API "http://tizen.org/privilege/power"
static FunctionMapping PowerFunctions =
createPowerFunctions();
-#pragma GCC visibility push(default)
-
DEFINE_FUNCTION_GETTER(Power, PowerFunctions);
-#pragma GCC visibility pop
-
static FunctionMapping createPowerFunctions()
{
/**
namespace DeviceAPI {
namespace Power {
-// Functions from power manager
-#define POWER_FUNCTION_API_REQUEST "request"
-#define POWER_FUNCTION_API_RELEASE "release"
-#define POWER_FUNCTION_API_SET_SCREEN_STATE_CHANGE_LISTENER "setScreenStateChangeListener"
-#define POWER_FUNCTION_API_UNSET_SCREEN_STATE_CHANGE_LISTENER "unsetScreenStateChangeListener"
-#define POWER_FUNCTION_API_GET_SCREEN_BRIGHTNESS "getScreenBrightness"
-#define POWER_FUNCTION_API_SET_SCREEN_BRIGHTNESS "setScreenBrightness"
-#define POWER_FUNCTION_API_IS_SCREEN_ON "isScreenOn"
-#define POWER_FUNCTION_API_RESTORE_SCREEN_BRIGHTNESS "restoreScreenBrightness"
-#define POWER_FUNCTION_API_TURN_SCREEN_ON "turnScreenOn"
-#define POWER_FUNCTION_API_TURN_SCREEN_OFF "turnScreenOff"
-
DECLARE_FUNCTION_GETTER(Power);
#define POWER_CHECK_ACCESS(functionName) \
--- /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 _POWER_PLUGIN_CONFIG_IMPL_H_
+#define _POWER_PLUGIN_CONFIG_IMPL_H_
+
+#define POWER_FUNCTION_API_REQUEST "request"
+#define POWER_FUNCTION_API_RELEASE "release"
+#define POWER_FUNCTION_API_SET_SCREEN_STATE_CHANGE_LISTENER "setScreenStateChangeListener"
+#define POWER_FUNCTION_API_UNSET_SCREEN_STATE_CHANGE_LISTENER "unsetScreenStateChangeListener"
+#define POWER_FUNCTION_API_GET_SCREEN_BRIGHTNESS "getScreenBrightness"
+#define POWER_FUNCTION_API_SET_SCREEN_BRIGHTNESS "setScreenBrightness"
+#define POWER_FUNCTION_API_IS_SCREEN_ON "isScreenOn"
+#define POWER_FUNCTION_API_RESTORE_SCREEN_BRIGHTNESS "restoreScreenBrightness"
+#define POWER_FUNCTION_API_TURN_SCREEN_ON "turnScreenOn"
+#define POWER_FUNCTION_API_TURN_SCREEN_OFF "turnScreenOff"
+
+#endif
#include "JSPowerManager.h"
#include <GlobalContextManager.h>
#include <TimeTracer.h>
+#include <Security.h>
+#include "plugin_config.h"
namespace DeviceAPI {
namespace Power {
using namespace WrtDeviceApis::Commons;
using namespace DeviceAPI::Common;
+AceSecurityStatus powerAceCheckAccessFunction(const char* functionName)
+{
+ return POWER_CHECK_ACCESS(functionName);
+}
+
+DEFINE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
+
+DEFINE_SECURITY_ACCESSOR_SETTER(AceCheckerPowerSetter,
+ DeviceAPI::Power::PowerManagerPriv,
+ gSecurityAccessor);
+
+class_definition_options_t ClassOptions =
+{
+ JS_CLASS,
+ NONE,
+ ALWAYS_NOTICE,
+ IGNORED,
+ AceCheckerPowerSetter,
+ NULL,
+ NULL
+};
+
void on_widget_start_callback(int widgetId)
{
LoggerD("[Tizen\\Power] on_widget_start_callback (" << widgetId << ")");
} Catch (Exception) {
LoggerE("WrtAccess initialization failed");
}
+
+ INITAILIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor, powerAceCheckAccessFunction);
}
void on_widget_stop_callback(int widgetId)
} Catch (Exception) {
LoggerE("WrtAccess deinitialization failed");
}
+
+ FINALIZE_GLOBAL_SECURITY_ACCESSOR(gSecurityAccessor);
}
void on_frame_load_callback(const void * context)
PLUGIN_CLASS_MAP_ADD_CLASS(WRT_JS_EXTENSION_OBJECT_TIZEN,
"power",
(js_class_template_getter)JSPowerManager::getClassRef,
- NULL)
+ &ClassOptions)
PLUGIN_CLASS_MAP_END
}
+++ /dev/null
-SET(TARGET_NAME ${power_target}_test)
-
-include_directories(
- ${TOP}/Common
- ${TOP}/Power
- ${TOP}/Common/StandaloneConsole
-)
-
-set(CMAKE_INSTALL_RPATH
- ${CMAKE_INSTALL_RPATH}
- ${CMAKE_INSTALL_PREFIX}/${DESTINATION_LIB_PREFIX}/${tizen_dest}
- ${CMAKE_INSTALL_PREFIX}/${DESTINATION_LIB_PREFIX}/${power_dest}
-)
-
-set(SRCS
- main.cpp
-)
-
-
-ADD_EXECUTABLE(${TARGET_NAME} ${SRCS})
-
-target_link_libraries(${TARGET_NAME}
- ${power_impl}
- ${LIBS_COMMON}
- ${LIBS_TEST}
-)
-
-
+++ /dev/null
-/*
-* wrt-plugins
-*
-* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
-*
-* Contact: Seung Mo Cho <seungm.cho@samsung.com>
-*
-* This library is free software; you can redistribute it and/or modify it under
-* the terms of the GNU Lesser General Public License as published by the
-* Free Software Foundation; either version 2.1 of the License, or (at your
-* option) any later version.
-*
-* This library is distributed in the hope that it will be useful, but WITHOUT
-* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
-* License for more details.
-*
-* You should have received a copy of the GNU Lesser General Public License
-* along with this library; if not, write to the Free Software Foundation, Inc.,
-* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-*
-*/
-/**
- * This file contains the implementation of test engine class.
- *
- * @author Wojciech Bielawski(w.bielawski@samsung.com)
- * @author Pawel Misiak (p.misiak@samsung.com)
- * @version 0.1
- */
-var jsPrint = console.log;
-var logFail = console.log;
-var logError = console.log;
-
-var TestEngine = {
- logText : "",
- testCaseTimeout : 10 * 1000, //in miliseconds
- currentCaseTimeout : 10 * 1000,
- timer : null,
- countOK : 0,
- countErr : 0,
- countException : 0,
- callbackMutex : 0,
- callbackMethodName : "",
- currentTestCase : 0,
- countAllPassed : 0,
- countAllFailed : 0,
- testCasesFailedCount : 0,
- testCasesPassedCount : 0,
- testCasesFailed : [],
- testList : [],
- finalLog : "\n",
- testSuccessCallback : null,
- testErrorCallback : null,
- testSuiteName : null,
- testSuiteStats : [],
- resultLogger : new HTMLTestResultLogger('log'),
- summaryRenderer : new HTMLTestSummaryRenderer('summary'),
-
- stepsArray : null,
- stepTimeout : null,
- currentStep : null,
- errorType : null,
- errorField : null,
-
- /*
- * Values used only as types representations.
- */
- STRING : '',
- NUMBER : 0,
- OBJECT : {},
- ARRAY : [],
- DATE : new Date(),
- BOOL : false,
- FUNCTION : function() {
- },
- /*
- * Error test possible results.
- */
- ERROR_TEST_RESULT : {
- NOT_RUN : -4,
- NOT_THROWN : -3,
- BAD_TYPE : -2,
- BAD_VALUE : -1,
- OK : 0
- },
-
- /**
- * Prints specified object in a TreeView like structure.
- * @param obj Object to print.
- * @param indent Must be undefined (don't pass anything).
- */
- dumpObject : function(obj, indent) {
- if(indent === undefined)
- indent = '';
- else
- indent += ' ';
- var prefix = (indent.length == 0 ? indent : indent + '|--');
- for(var i in obj) {
- if( typeof (obj[i]) == "object") {
- TestEngine.log(prefix + i + ":");
- TestEngine.dumpObject(obj[i], indent);
- } else
- TestEngine.log(prefix + i + ": " + obj[i]);
- }
- },
- addTest : function(enabled, testFunc, testName, testPrereq) {
- if(null == testName) {
- testName = "unnamed test"
- }
- jsPrint("Add test: " + testName)
- var data = new Object();
- data.enabled = enabled;
- data.testFunc = testFunc;
- data.testName = testName;
- data.testPrereq = testPrereq;
- data.testSuite = TestEngine.testSuiteName;
- data.failMessage = "";
- // this.testList.push(testFunc)
- this.testList.push(data);
- },
- setTestSuiteName : function(name, timeout) {
- this.testSuiteName = name;
- this.testSuiteStats[name] = new Object();
- this.testSuiteStats[name].passed = 0;
- this.testSuiteStats[name].failed = 0;
- this.testSuiteStats[name].assertsOK = 0;
- this.testSuiteStats[name].assertsErr = 0;
- TestEngine.currentCaseTimeout = (timeout === undefined) ? TestEngine.testCaseTimeout : timeout;
- },
- log : function(text) {
- try {
- jsPrint(text);
- this.logText += text + "<br/>";
- this.finalLog += text + "\n";
- // document.getElementById(TestEngine.currentTestSuite).innerHTML += text + "<br/>";
- //document.getElementById('log').innerHTML += text + "<br/>";
- } catch(err) {
- this.countException++;
- logError(" TestEngine.log failure: " + err.message);
- }
- },
- logException : function(text) {
- try {
- logFail(text);
- TestEngine.countException++;
- TestEngine.log("[EXCEPTION] " + text);
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.logErr failure: " + err.message);
- }
- },
- logErr : function(text) {
- try {
- TestEngine.countErr++;
- TestEngine.log("[FAILED] " + text);
- logFail("[FAILED] " + text);
-
- TestEngine.testList[TestEngine.currentTestCase-1].failMessage = text;
-
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.logErr failure: " + err.message);
- }
- },
- logOK : function(text) {
- try {
- TestEngine.countOK++;
- TestEngine.log("[OK] " + text);
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.logOK failure: " + err.message);
- }
- },
- test : function(text, value) {
- try {
- if( typeof (value) == "undefined") {
- TestEngine.logErr("value not defined for test: '" + text + "'");
- } else if(!value) {
- TestEngine.logErr(text);
- } else {
- TestEngine.logOK(text);
- return true;
- }
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.test failure: " + err.message);
- }
- return false;
- },
- assertEqual : function(text, value1, value2){
- try {
- if( typeof (value1) == "undefined") {
- TestEngine.logErr("value1 not defined for test: '" + text + "'");
- } else if( typeof (value2) == "undefined") {
- TestEngine.logErr("value2 not defined for test: '" + text + "'");
- }else if(value1 == value2) {
- TestEngine.logOK(text +" (value1:[" + value1 + "] value2:[" + value2 + "])");
- } else {
- TestEngine.logErr(text + " (expected value1:[" + value1 + "] but value2:[" + value2 + "])");
- return true;
- }
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.test failure: " + err.message);
- }
- return false;
- },
-
- /**
- * Sets error type used in every typePresetError check.
- * @param type Type of an error/exception.
- */
- setErrorType : function(type) {
- TestEngine.errorType = type;
- },
- /**
- * Sets error field used in every typePresetError check.
- * @param field Name of the field in error structure to check its value.
- */
- setErrorField : function(field) {
- TestEngine.errorField = field;
- },
- /**
- * Checks if specified expression throws a specified error.
- * Expression must be enclosed in a function. Use setErrorType and
- * setErrorField to set what error to look for.
- * Error type must be set but if error field is left unset (i.e. null)
- * then whole exception object is compared to specified value.
- * @param msg Text to display for this test.
- * @param fn Function eclosing the expression one wants to verify.
- * @param value Value of an error/exception one looks for.
- */
- testPresetError : function(msg, fn, value) {
- if(TestEngine.errorType === null) {
- TestEngine.logException("testPresetError skipped. Set error type first.");
- return;
- }
-
- return TestEngine.testError(msg, fn, TestEngine.errorType, TestEngine.errorField, value);
- },
- /**
- * Checks if specified expression throws a specified error.
- * This is a more general version of testPresetError function.
- * Expression must be enclosed in a function.
- * Error type must be set but if error field is left unset (i.e. null)
- * then whole exception object is compared to specified value.
- * @param msg Text to display for this test.
- * @param fn Function eclosing the expression one wants to verify.
- * @param errType Type of desired error/exception.
- * @param errField Property from exception structure to look for exception
- * value.
- * @param errValue Value of an error/exception one looks for.
- */
- testError : function(msg, fn, errType, errField, errValue) {
- if(errType === null) {
- TestEngine.logException("testError skipped. Error type can't be null.");
- return TestEngine.ERROR_TEST_RESULT.NOT_RUN;
- }
-
- try {
- fn();
- TestEngine.logErr(msg + ' Exception has not been thrown.');
- return TestEngine.ERROR_TEST_RESULT.NOT_THROWN;
- } catch (ex) {
- if( ex instanceof errType) {
- var exValue = (errField !== null ? ex[errField] : ex);
- if(exValue === errValue) {
- TestEngine.logOK(msg + ' [' + errValue + ']');
- return TestEngine.ERROR_TEST_RESULT.OK;
- } else {
- TestEngine.logErr(msg + ' Exception is not of value ' + errValue);
- return TestEngine.ERROR_TEST_RESULT.BAD_VALUE;
- }
- } else {
- TestEngine.logErr(msg + ' Exception is of wrong type.');
- return TestEngine.ERROR_TEST_RESULT.BAD_TYPE;
- }
- }
- },
- testPresence : function(text, object) {
- try {
- if(object === undefined) {
- TestEngine.logErr("value not defined. Name: " + text);
- } else {
- TestEngine.logOK("object " + text + " present");
- }
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.testPresence failure: " + err.message);
- }
- },
- /**
- * Checks whether object implements given property.
- * In addition it also checks whether any exception (e.g. "Not Supported")
- * is thrown.
- * @param object Object to check property for.
- * @param property Property to look for.
- * @return True if object implements such property, false otherwise.
- */
- testPresence2 : function(object, property) {
- var result = property in object;
- if(result) {
- TestEngine.logOK("property " + property + " present");
- } else {
- TestEngine.logErr("property " + property + " absent");
- }
- return result;
- },
- /**
- * Checks whether mainObj object equals templateObj object, property by
- * property.
- * Runs recursively through all the properties of templateObj object and
- * checks if they exist and are equal to those in mainObj object.
- * mainObj has to implement no less properties than templateObj.
- * @param mainObj Object to check for properties implementation.
- * @param templateObj Object to verify properties against.
- * @return True if mainObj has at least the same properties as templateObj,
- * false otherwise.
- */
- checkObjectsEqual : function(mainObj, templateObj) {
- try {
- if((!mainObj && templateObj) || ( typeof (mainObj) != typeof (templateObj))) {
- return false;
- } else if(isNumber(templateObj) || isString(templateObj) || isBoolean(templateObj)) {
- return (mainObj === templateObj);
- } else if(isDate(templateObj)) {
- return (mainObj.valueOf() === templateObj.valueOf());
- } else {
- for(var i in templateObj) {
- if(!TestEngine.checkObjectsEqual(mainObj[i], templateObj[i])) {
- return false;
- }
- }
- }
- } catch(err) {
- TestEngine.logException("TestEngine.checkObjectsEqual failure: " + err.message);
- return false;
- }
- return true;
- },
- // test properties of given object. Steps:
- // - check name presence
- // - check default value (if not null value passed)
- // - check if name is writable
- //
- // description of properties array:
- // [0] - property name
- // [1] - default value - check if property equals given value
- // undefined or null - disable check
- // [2] - value to do writability test - try to write given value
- // undefined or null - don't check writability
- // [3] - indicates if property should be read-only
- // [4] - assumed type, undefined value skips this check
- testProperties : function(object, props) {
- var result = new Object();
- try {
- for(var i in props) {
- var name = props[i][0];
- var defaultVal = props[i][1];
- var setVal = props[i][2];
- var isReadonly = props[i][3];
- var type = props[i][4];
- var errors = TestEngine.countErr + TestEngine.countException;
-
- if(( typeof (name) != "string") || (name == "")) {
- TestEngine.logException("Property name not defined, skipping it.");
- continue;
- }
-
- result[name] = false;
- if(TestEngine.testPresence2(object, name)) {
- if((defaultVal != null) && (defaultVal !== undefined)) {
- var isObjectEqual = TestEngine.checkObjectsEqual(object[name], defaultVal);
- TestEngine.test(name + " default value", isObjectEqual);
- }
-
- if((setVal != null) && (setVal !== undefined)) {
- // try-catch is needed when SetProperty returns 'false'
- if(setVal === defaultVal) {
- TestEngine.logException("Default value and set value are equal");
- continue;
- }
- try {
- object[name] = setVal;
- } catch (e) {
- }
- if( typeof (isReadonly) == "undefined") {
- TestEngine.test(name + " writability, reason: isReadonly not specified", false);
- }
- if(isReadonly) {
- TestEngine.test(name + " writability", object[name] != setVal);
- } else {
- var isObjectEqual = TestEngine.checkObjectsEqual(object[name], setVal);
- TestEngine.test(name + " writability", isObjectEqual);
- }
- }
-
- if(type !== undefined) {
- var isType = ( typeof (object[name]) == typeof (type));
- if( typeof (type) == 'object') {
- if(isArray(type)) {
- isType = isArray(object[name]);
- } else if(isDate(type)) {
- isType = isDate(object[name]);
- }
- }
- TestEngine.test(name + " type check.", isType);
- }
- }
- if(errors == TestEngine.countErr + TestEngine.countException) {
- result[name] = true;
- }
- }
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.testProperties failure: " + err.message);
- }
- return result;
- },
- startTestCase : function() {
- try {
- TestEngine.countOK = 0;
- TestEngine.countErr = 0;
- TestEngine.countException = 0;
- TestEngine.timer = setTimeout(TestEngine.timeout, TestEngine.currentCaseTimeout);
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.startTestCase failure: " + err.message);
- }
-
- },
- endTestCase : function(testCase) {
- try {
- if(this.timer === null) {
- return;
- }
-
- clearTimeout(this.timer);
- this.log("");
- var failed = this.countErr || ((this.countOK + this.countErr) < 1) || this.countException;
- this.log("Test case " + ( failed ? "FAILED" : "PASSED"));
- this.log("Passed: " + this.countOK);
- this.log("Failed: " + this.countErr);
- if(this.countException) {
- this.log("Exception occured!");
- }
-
- this.countAllPassed += this.countOK;
- this.countAllFailed += this.countErr;
- this.testSuiteStats[testCase.testSuite].assertsOK += this.countOK;
- this.testSuiteStats[testCase.testSuite].assertsErr += this.countErr;
-
- if(failed) {
- TestEngine.testCasesFailedCount++;
- this.testSuiteStats[testCase.testSuite].failed++;
- if(isVerbose()) {
- TestEngine.testCasesFailed.push(testCase.testName + ":" + testCase.failMessage);
- }
- TestEngine.resultLogger.logFail(testCase.testName + ":" + testCase.failMessage);
- } else {
- TestEngine.testCasesPassedCount++;
- this.testSuiteStats[testCase.testSuite].passed++;
- TestEngine.resultLogger.logPass(testCase.testName);
- }
- TestEngine.summaryRenderer.render(TestEngine);
- } catch(err) {
- this.countException++;
- logError(" TestEngine.endTestCase failure:" + err.message);
- }
- },
- timeout : function() {
- try {
- TestEngine.callbackMutex = 0;
- TestEngine.logErr("Widget run timeout.", false);
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.timeout failure:" + err.message);
- }
- },
- /**
- * Registers callbacks for asynchronous function.
- *
- * To avoid finish test case before callbacks will execute it's necessary
- * to register callbacks in the engine.
- *
- * @param methodName Testcase name, suggested asynchronous function name.
- * @param testSuccessCallback Callback that will be executed on success.
- * @param testErrorCallback Callback that will be executed on failure.
- * @param callbacksCount number of callbacks to register.
- * @return An object with defined functions "successCallback" and "errorCallback" you
- * need to pass as arguments to asynchronous function e.g.
- *
- * function success() { }
- * function failure() { }
- *
- * {
- * var obj = TestEngine.registerCallback("myAsyncFunc", success, failure);
- * myAsyncFunc(obj.successCallback, obj.errorCallback);
- * }
- */
- registerCallback : function(methodName, testSuccessCallback, testErrorCallback, callbacksCount) {
- try {
- if(callbacksCount !== undefined && callbacksCount > 0) {
- TestEngine.callbackMutex += callbacksCount;
- } else {
- TestEngine.callbackMutex++;
- }
- TestEngine.callbackMethodName = methodName;
- TestEngine.testSuccessCallback = testSuccessCallback;
- TestEngine.testErrorCallback = testErrorCallback;
-
- var retObj = new Object();
- retObj.callbackMethodName = methodName;
- retObj.testSuccessCallback = testSuccessCallback;
- retObj.successCallback = function(param) {
- try {
- if(( typeof retObj.testSuccessCallback != "undefined") && (retObj.testSuccessCallback !== null)) {
- retObj.testSuccessCallback(param);
- } else {
- TestEngine.logOK(retObj.callbackMethodName + " succeed");
- }
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.this.successCallback failure:" + err.message);
- }
- TestEngine.callbackMutex--;
- };
-
- retObj.testErrorCallback = testErrorCallback;
- retObj.errorCallback = function(param) {
- try {
- if(( typeof retObj.testErrorCallback != "undefined") && (retObj.testErrorCallback !== null)) {
- retObj.testErrorCallback(param);
- } else {
- TestEngine.logErr(retObj.callbackMethodName + " failed");
- }
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.retObj.errorCallback failure:" + err.message);
- }
- TestEngine.callbackMutex--;
- };
- return retObj;
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.registerCallback failure:" + err.message);
- }
- },
- successCallback : function(params) {
- TestEngine.log("[Warning] Function TestEngine.successCallback deprecated");
- try {
- TestEngine.callbackMutex--;
- if( typeof TestEngine.testSuccessCallback != "undefined") {
- TestEngine.testSuccessCallback(params);
- } else {
- TestEngine.logOK(TestEngine.callbackMethodName + " succeed");
- }
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.successCallback failure:" + err.message);
- }
- },
- errorCallback : function(params) {
- TestEngine.log("[Warning] Function TestEngine.errorCallback deprecated");
- try {
- TestEngine.callbackMutex--;
- if( typeof TestEngine.testErrorCallback != "undefined") {
- TestEngine.testErrorCallback(params);
- } else {
- TestEngine.logErr(TestEngine.callbackMethodName + " failed");
- }
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.errorCallback failure:" + err.message);
- }
- },
- waitForCallback : function() {
- try {
- // while( TestEngine.callbackMutex )
- {
- }
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.waitForCallback failure:" + err.message);
- }
- },
- /*
- * code - error code which is expected
- * object - object which will be used to call method
- * functionName - method name to call
- * restArguments - rest arguments which will be passed to callback (max arguments = 10)
- *
- * example:
- * TestEngine.catchError(10001, bondi.messaging, findSMSs, succCallback, null, filter)
- */
- catchError : function(code, object, functionName, restArguments /* , ... */ ) {
- try {
- TestEngine.log("TestEngine.catchError is DEPRECATED. Please use TestEngine.catchErrorType.");
- var error;
- try {
- var newArgs = []
- for(var i = 3; i < arguments.length; i++) {
- newArgs.push(arguments[i])
- }
- var retVal = null;
- //no args
- if(arguments.length == 3) {
- retVal = object[functionName]();
- }
- //1 arg
- if(arguments.length == 4) {
- retVal = object[functionName](newArgs[0]);
- }
- //2 args
- if(arguments.length == 5) {
- retVal = object[functionName](newArgs[0], newArgs[1]);
- }
- //3 args
- if(arguments.length == 6) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2]);
- }
- // 4 args
- if(arguments.length == 7) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3]);
- }
- // 5 args
- if(arguments.length == 8) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3], newArgs[4]);
- }
- // 6 args
- if(arguments.length == 9) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3], newArgs[4], newArgs[5]);
- }
- // 7 args
- if(arguments.length == 10) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3], newArgs[4], newArgs[5], newArgs[6]);
- }
- // 8 args
- if(arguments.length == 11) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3], newArgs[4], newArgs[5], newArgs[6], newArgs[7]);
- }
- // 9 args
- if(arguments.length == 12) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3], newArgs[4], newArgs[5], newArgs[6], newArgs[7], newArgs[8]);
- }
- // 10 args
- if(arguments.length == 13) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3], newArgs[4], newArgs[5], newArgs[6], newArgs[7], newArgs[8], newArgs[9]);
- }
-
- TestEngine.logErr(functionName + " no error thrown");
- return retVal;
- } catch(error) {
- TestEngine.testPresence("<error code from: " + functionName + ">", error.code);
- TestEngine.test("Error number", error.code == code);
- return;
- }
- TestEngine.logErr("Function " + functionName + " desn't throw");
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.testError failure:" + err.message);
- }
- },
- /*
- * errorTypeName - attribute name of catched exception to compare with code
- * code - error code which is expected
- * object - object which will be used to call method
- * functionName - method name to call
- * restArguments - rest arguments which will be passed to callback (max arguments = 10)
- *
- * example:
- * TestEngine.catchErrorType("code", 10001, bondi.messaging, findSMSs, succCallback, null, filter)
- */
- catchErrorType : function(errorTypeName, code, object, functionName, restArguments /* , ... */ ) {
- try {
- var error;
- try {
- var newArgs = []
- for(var i = 4; i < arguments.length; i++) {
- newArgs.push(arguments[i])
- }
- var retVal = null;
- if(arguments.length < 4) {
- TestEngine.logErr("Wrong catchErrorType usage.");
- return retVal;
- }
- //no args
- if(arguments.length == 4) {
- retVal = object[functionName]();
- }
- //1 arg
- if(arguments.length == 5) {
- retVal = object[functionName](newArgs[0]);
- }
- //2 args
- if(arguments.length == 6) {
- retVal = object[functionName](newArgs[0], newArgs[1]);
- }
- //3 args
- if(arguments.length == 7) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2]);
- }
- // 4 args
- if(arguments.length == 8) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3]);
- }
- // 5 args
- if(arguments.length == 9) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3], newArgs[4]);
- }
- // 6 args
- if(arguments.length == 10) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3], newArgs[4], newArgs[5]);
- }
- // 7 args
- if(arguments.length == 11) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3], newArgs[4], newArgs[5], newArgs[6]);
- }
- // 8 args
- if(arguments.length == 12) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3], newArgs[4], newArgs[5], newArgs[6], newArgs[7]);
- }
- // 9 args
- if(arguments.length == 13) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3], newArgs[4], newArgs[5], newArgs[6], newArgs[7], newArgs[8]);
- }
- // 10 args
- if(arguments.length == 14) {
- retVal = object[functionName](newArgs[0], newArgs[1], newArgs[2], newArgs[3], newArgs[4], newArgs[5], newArgs[6], newArgs[7], newArgs[8], newArgs[9]);
- }
-
- TestEngine.logErr(functionName + " no error thrown");
- return retVal;
- } catch(error) {
- TestEngine.testPresence("<error code from: " + functionName + ">", error[errorTypeName]);
- TestEngine.test("Error number", error[errorTypeName] == code);
- return;
- }
- TestEngine.logErr("Function " + functionName + " desn't throw");
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.testError failure:" + err.message);
- }
- },
- /*
- * code - error type which is expected
- * object - object which will be used to call method
- * functionName - method name to call
- * restArguments - rest arguments which will be passed to callback (max arguments = 10)
- *
- * example:
- * TestEngine.catchErrorJil("INVALID_ARGUMENT", Widget.Telephony, "getCallRecord", null, null)
- */
- catchErrorJil : function(code, object, functionName, restArguments /* , ... */ ) {
- try {
- TestEngine.logErr("TestEngine.catchErrorJil is DEPRECATED. Please use TestEngine.catchErrorType.");
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.testError failure:" + err.message);
- }
- },
- // Executes step by step functions passed in steps array
- // and waits after every execution time defined in timeInterval
- executeSteps : function(steps, timeInterval) {
- try {
- if( typeof (timeInterval) == "undefined") {
- timeInterval = 100;
- //default value
- }
-
- TestEngine.stepsArray = steps;
- TestEngine.stepTimeout = timeInterval;
- TestEngine.currentStep = 0;
- TestEngine.executeNextStep();
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.executeSteps failure:" + err.message);
- }
- },
- executeNextStep : function() {
- try {
- if(TestEngine.stepsArray && (TestEngine.currentStep < TestEngine.stepsArray.length)) {
- if(isArray(TestEngine.stepsArray[TestEngine.currentStep])) {
- TestEngine.stepsArray[ TestEngine.currentStep ][0]();
- setTimeout(TestEngine.executeNextStep, TestEngine.stepsArray[ TestEngine.currentStep ][1]);
-
- } else {
- TestEngine.stepsArray[ TestEngine.currentStep ]();
- setTimeout(TestEngine.executeNextStep, TestEngine.stepTimeout);
- }
- TestEngine.currentStep++;
- } else {
- TestEngine.currentStep = null;
- TestEngine.stepTimeout = null;
- TestEngine.stepsArray = null;
- }
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.executeNextStep failure:" + err.message);
- jsPrint(" Current step:" + TestEngine.currentStep);
-
- TestEngine.currentStep = null;
- TestEngine.stepTimeout = null;
- TestEngine.stepsArray = null;
- }
- },
- enumerate : function(obj, level) {
- try {
- if( typeof level == "undefined") {
- TestEngine.log(obj + ":");
- level = "";
- }
- for(i in obj) {
- if(!( typeof obj[i] == "object" || typeof obj[i] == "array")) {
- TestEngine.log(level + i + " = " + obj[i]);
- } else {
- TestEngine.log(level + i + " = ");
- TestEngine.enumerate(obj[i], level + "----");
- }
- }
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.enumerate failure:" + err.message);
- }
- },
- doTests : function() {
- try {
- TestEngine.testCasesFailed = [];
- TestEngine.doNextTestCase();
- } catch(err) {
- TestEngine.countException++;
- logError(" TestEngine.doTests failure:" + err.message);
- }
- },
- showSuitesStats : function() {
- try {
- jsPrint("============ Test suites:");
- for(var i in this.testSuiteStats) {
- jsPrint(i + " - " + this.testSuiteStats[i].passed + " passed, " + this.testSuiteStats[i].failed + " failed," + " asserts: " + this.testSuiteStats[i].assertsOK + " passed, " + this.testSuiteStats[i].assertsErr + " failed");
- }
- } catch(err) {
- logError(" TestEngine.showSuitesStats failure:" + err.message);
- }
- },
- doNextTestCase : function() {
- try {
- if(TestEngine.stepsArray !== null || (TestEngine.callbackMutex > 0)) {
- setTimeout(TestEngine.doNextTestCase, 100);
- return;
- }
-
- if(TestEngine.currentTestCase) {
- TestEngine.endTestCase(TestEngine.testList[TestEngine.currentTestCase - 1]);
- }
-
- if(TestEngine.testList.length == TestEngine.currentTestCase) {
- jsPrint("============");
- jsPrint(TestEngine.finalLog);
- TestEngine.showSuitesStats();
- jsPrint("============ Summary:");
- jsPrint("Test cases all: " + TestEngine.testList.length);
- jsPrint("Test cases passed: " + TestEngine.testCasesPassedCount);
- jsPrint("Test cases failed: " + TestEngine.testCasesFailedCount);
- jsPrint("Asserts passed: " + TestEngine.countAllPassed);
- jsPrint("Asserts failed: " + TestEngine.countAllFailed);
- if(isVerbose()) {
- jsPrint("============ Failing test cases:");
- for( i = 0; i < TestEngine.testCasesFailed.length; ++i) {
- logError(TestEngine.testCasesFailed[i]);
- }
- }
- TestEngine.summaryRenderer.render(TestEngine);
- return;
- }
-
- var i = TestEngine.currentTestCase++;
- try {
- TestEngine.log("");
- TestEngine.log("==== Test case: " + TestEngine.testList[i].testName);
- TestEngine.startTestCase();
- var testPrereq = true;
- if(TestEngine.testList[i].testPrereq !== undefined) {
- testPrereq = TestEngine.testList[i].testPrereq();
- }
- if(testPrereq) {
- if(TestEngine.testList[i].enabled) {
- TestEngine.testList[i].testFunc();
- } else {
- TestEngine.logErr("Test disabled");
- }
-
- } else {
- TestEngine.logException("Test case prerequisites unfulfilled. Skipping it.");
- }
- } catch(err) {
- TestEngine.countException++;
- TestEngine.log(" Test case '" + TestEngine.testList[i].testName + "' failed:" + err.message);
- }
- setTimeout(TestEngine.doNextTestCase, 100);
- } catch(err) {
- logError(" TestEngine.doNextTestCase failure:" + err.message);
- }
- }
-};
-
-function isUndefined(val) {
- if( typeof val == "undefined") {
- return true;
- }
- return false;
-}
-
-function isNull(val) {
- return val === null;
-}
-
-function isString(val) {
- if( typeof val == typeof "") {
- return true;
- }
- return false;
-}
-
-function isNumber(val) {
- if( typeof val == typeof 0) {
- return true
- }
- return false;
-}
-
-function isDate(val) {
- return ( val instanceof Date);
-}
-
-function isFunction(val) {
- return ( typeof (val) == 'function');
-}
-
-function isBoolean(val) {
- if( typeof val == typeof true) {
- return true
- }
- return false;
-}
-
-function isArray(val) {
- return ( val instanceof Array);
-}
-
-function isObject(val) {
- return ( val );
-}
-
-function isVerbose() {
- return (( typeof (VERBOSE) != "undefined") && (VERBOSE === 1));
-}
-
-/**
- * Tests results logger.
- */
-function HTMLTestResultLogger(sinkId) {
-
- /**
- * Logs a message.
- * @param message Message to log.
- * @param status Status of the message (PASSED, FAILED, EXCEPTION).
- * By default status is set to PASSED.
- */
- this.log = function(message, status) {
- if(arguments.length < 2)
- throw "Not enough number of arguments.";
- console.log("["+status+"]:"+message);
- }
- /**
- * Helper functions.
- */
- this.logPass = function(message) {
- if(arguments.length < 1)
- throw "Not enough number of arguments.";
- this.log(message, HTMLTestResultLogger.PASSED);
- }
-
- this.logFail = function(message) {
- if(arguments.length < 1)
- throw "Not enough number of arguments.";
- this.log(message, HTMLTestResultLogger.FAILED);
- }
-
- var createLogEntry = function(message, status) {
- var entry = '<div class="entry ' + status + '">';
- entry += message.toString();
- entry += '</div>';
- return entry;
- }
- var id = sinkId;
- var sink = null;
-}
-
-HTMLTestResultLogger.PASSED = "passed";
-HTMLTestResultLogger.FAILED = "failed";
-HTMLTestResultLogger.EXCEPTION = "exception";
-
-/**
- * Tests summary renderer.
- */
-function HTMLTestSummaryRenderer(summaryId) {
-
- this.render = function(engine) {
- }
-
- var isSuiteStarted = function(stats) {
- return (stats.passed + stats.failed != 0);
- }
- var renderSuite = function(name, stats) {
- }
- var setupSummary = function(summary) {
- }
- var id = summaryId;
- var summary = null;
-}
+++ /dev/null
-//
-// Tizen Web Device API
-// Copyright (c) 2013 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.
-//
-
-var TYPE_MISMATCH_ERR = 'TypeMismatchError';
-var INVALID_VALUES_ERR = 'InvalidValuesError';
-var NOT_SUPPORTED_ERR = 'NotSupportedError';
-var NOT_FOUND_ERR = 'NotFoundError';
-//var UNKNOWN_ERR = 'UnknownError';
-//var PERMISSION_DENIED_ERR = 'PermissionDeniedError';
-
-var ERROR_STR = "GG";
-
-function UTC_power_module_presence_P_001()
-{
- TestEngine.log("UTC_power_module_presence_P_001");
-
- TestEngine.test("Power manager presence", power);
- TestEngine.testPresence("request presence", power.request);
- TestEngine.testPresence("release presence", power.release);
- TestEngine.testPresence("setScreenStateChangeListener presence", power.setScreenStateChangeListener);
- TestEngine.testPresence("unsetScreenStateChangeListener presence", power.unsetScreenStateChangeListener);
- TestEngine.testPresence("getScreenBrightness presence", power.getScreenBrightness);
- TestEngine.testPresence("setScreenBrightness presence", power.setScreenBrightness);
- TestEngine.testPresence("isScreenOn presence", power.isScreenOn);
- TestEngine.testPresence("restoreScreenBrightness presence", power.restoreScreenBrightness);
- TestEngine.testPresence("turnScreenOn presence", power.turnScreenOn);
- TestEngine.testPresence("turnScreenOff presence", power.turnScreenOff);
-}
-
-function UTC_power_request_P_001()
-{
- TestEngine.log("UTC_power_request_P_001");
-
- testNoExceptionWithMessage("test request display",
- function(){
- power.request("SCREEN", "SCREEN_DIM");
- power.request("SCREEN", "SCREEN_NORMAL");
- power.request("SCREEN", "SCREEN_BRIGHT");
- }
- );
-
- testNoExceptionWithMessage("test request cpu",
- function(){
- power.request("CPU", "CPU_AWAKE");
- }
- );
-
- testNoExceptionWithMessage("test request additional",
- function(){
- power.request("SCREEN", "SCREEN_BRIGHT", ERROR_STR);
- }
- );
-}
-
-function UTC_power_request_N_001()
-{
- TestEngine.log("UTC_power_request_N_001");
-
- TestEngine.log("First parameter check.");
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "request", ERROR_STR);
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "request", null);
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "request", undefined);
-
- TestEngine.log("Second parameter check.");
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "request", "SCREEN", ERROR_STR);
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "request", "SCREEN", null);
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "request", "SCREEN", undefined);
-
- TestEngine.log("Invalid number of parameters check.");
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "request");
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "request", "SCREEN");
-}
-
-function UTC_power_release_P_001()
-{
- TestEngine.log("UTC_power_release_P_001");
-
- testNoExceptionWithMessage("test release display",
- function(){
- power.release("SCREEN");
- }
- );
-
- testNoExceptionWithMessage("test release display additional",
- function(){
- power.release("SCREEN", 1);
- }
- );
-}
-
-function UTC_power_release_N_001()
-{
- TestEngine.log("UTC_power_release_N_001");
-
- TestEngine.log("First parameter check.");
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "release", ERROR_STR);
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "release", null);
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "release", undefined);
-
- TestEngine.log("Invalid number of parameters check.");
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "release");
-}
-
-function onChanged(previousState, changedState) {
- TestEngine.log("State changed." + ", previousState: " + previousState + ", changedState: " + changedState);
-}
-
-function UTC_power_setScreenStateChangeListener_P_001()
-{
- TestEngine.log("UTC_power_setScreenStateChangeListener_P_001");
-
- testNoExceptionWithMessage("test setScreenStateChangeListener",
- function(){
- power.setScreenStateChangeListener(onChanged);
- }
- );
-
- testNoExceptionWithMessage("test setScreenStateChangeListener additional",
- function(){
- power.setScreenStateChangeListener(onChanged, ERROR_STR);
- }
- );
-}
-
-function UTC_power_setScreenStateChangeListener_N_001()
-{
- TestEngine.log("UTC_power_setScreenStateChangeListener_N_001");
-
- TestEngine.log("First parameter check.");
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "setScreenStateChangeListener", ERROR_STR);
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "setScreenStateChangeListener", null);
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "setScreenStateChangeListener", undefined);
-
- TestEngine.log("Invalid number of parameters check.");
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "setScreenStateChangeListener");
-}
-
-function UTC_power_unsetScreenStateChangeListener_P_001()
-{
- TestEngine.log("UTC_power_unsetScreenStateChangeListener_P_001");
-
- testNoExceptionWithMessage("test unsetScreenStateChangeListener",
- function(){
- power.unsetScreenStateChangeListener();
- }
- );
-
- testNoExceptionWithMessage("test request additional",
- function(){
- power.unsetScreenStateChangeListener(ERROR_STR);
- }
- );
-}
-
-function UTC_power_getScreenBrightness_P_001()
-{
- TestEngine.log("UTC_power_getScreenBrightness_P_001");
-
- testNoExceptionWithMessage("test getScreenBrightness",
- function(){
- power.getScreenBrightness();
- }
- );
-
- testNoExceptionWithMessage("test getScreenBrightness additional",
- function(){
- power.getScreenBrightness(ERROR_STR);
- }
- );
-}
-
-function UTC_power_setScreenBrightness_P_001()
-{
- TestEngine.log("UTC_power_setScreenBrightness_P_001");
-
- testNoExceptionWithMessage("test setScreenBrightness",
- function(){
- power.setScreenBrightness(0.5);
- }
- );
-
- testNoExceptionWithMessage("test setScreenBrightness additional",
- function(){
- power.setScreenBrightness(0.1, ERROR_STR);
- }
- );
-}
-
-function UTC_power_setScreenBrightness_N_001()
-{
- TestEngine.log("UTC_power_setScreenBrightness_N_001");
-
- TestEngine.log("First parameter check.");
- TestEngine.catchErrorType("name", TYPE_MISMATCH_ERR, power, "setScreenBrightness", ERROR_STR);
-}
-
-function UTC_power_isScreenOn_P_001()
-{
- TestEngine.log("UTC_power_isScreenOn_P_001");
-
- testNoExceptionWithMessage("test isScreenOn",
- function(){
- power.isScreenOn();
- }
- );
-
- testNoExceptionWithMessage("test isScreenOn additional",
- function(){
- power.isScreenOn(ERROR_STR);
- }
- );
-}
-
-function UTC_power_restoreScreenBrightness_P_001()
-{
- TestEngine.log("UTC_power_restoreScreenBrightness_P_001");
-
- testNoExceptionWithMessage("test restoreScreenBrightness",
- function(){
- power.restoreScreenBrightness();
- }
- );
-
- testNoExceptionWithMessage("test restoreScreenBrightness additional",
- function(){
- power.restoreScreenBrightness(ERROR_STR);
- }
- );
-}
-
-function UTC_power_turnScreenOff_P_001()
-{
- TestEngine.log("UTC_power_turnScreenOff_P_001");
-
- testNoExceptionWithMessage("test turnScreenOff",
- function(){
- power.turnScreenOff();
- }
- );
-
- testNoExceptionWithMessage("test turnScreenOff additional",
- function(){
- power.turnScreenOff(ERROR_STR);
- }
- );
-}
-
-function UTC_power_turnScreenOn_P_001()
-{
- TestEngine.log("UTC_power_turnScreenOn_P_001");
-
- testNoExceptionWithMessage("test turnScreenOn",
- function(){
- power.turnScreenOn();
- }
- );
-
- testNoExceptionWithMessage("test turnScreenOn additional",
- function(){
- power.turnScreenOn(ERROR_STR);
- }
- );
-}
-
-//=============================================================================
-TestEngine.setTestSuiteName("[Tizen][Power]", 30 * 1000);
-TestEngine.addTest(true, UTC_power_module_presence_P_001, "[Tizen][Power] UTC_power_module_presence_P_001");
-TestEngine.addTest(true, UTC_power_request_P_001, "[Tizen][Power] UTC_power_request_P_001");
-TestEngine.addTest(true, UTC_power_request_N_001, "[Tizen][Power] UTC_power_request_N_001");
-TestEngine.addTest(true, UTC_power_release_N_001, "[Tizen][Power] UTC_power_release_N_001");
-TestEngine.addTest(true, UTC_power_release_P_001, "[Tizen][Power] UTC_power_release_P_001");
-TestEngine.addTest(true, UTC_power_setScreenStateChangeListener_P_001, "[Tizen][Power] UTC_power_setScreenStateChangeListener_P_001");
-TestEngine.addTest(true, UTC_power_setScreenStateChangeListener_N_001, "[Tizen][Power] UTC_power_setScreenStateChangeListener_N_001");
-TestEngine.addTest(true, UTC_power_unsetScreenStateChangeListener_P_001, "[Tizen][Power] UTC_power_unsetScreenStateChangeListener_P_001");
-TestEngine.addTest(true, UTC_power_getScreenBrightness_P_001, "[Tizen][Power] UTC_power_getScreenBrightness_P_001");
-TestEngine.addTest(true, UTC_power_setScreenBrightness_P_001, "[Tizen][Power] UTC_power_setScreenBrightness_P_001");
-TestEngine.addTest(true, UTC_power_setScreenBrightness_N_001, "[Tizen][Power] UTC_power_setScreenBrightness_N_001");
-TestEngine.addTest(true, UTC_power_isScreenOn_P_001, "[Tizen][Power] UTC_power_isScreenOn_P_001");
-TestEngine.addTest(true, UTC_power_restoreScreenBrightness_P_001, "[Tizen][Power] UTC_power_restoreScreenBrightness_P_001");
-TestEngine.addTest(true, UTC_power_turnScreenOff_P_001, "[Tizen][Power] UTC_power_turnScreenOff_P_001");
-TestEngine.addTest(true, UTC_power_turnScreenOn_P_001, "[Tizen][Power] UTC_power_turnScreenOn_P_001");
-//=============================================================================
-
-function testNoExceptionWithMessage(message, fun) {
- var testResult = true;
- try
- {
- fun();
- }
- catch (e)
- {
- testResult = false;
- }
- TestEngine.test(message, testResult);
-}
-
+++ /dev/null
-//
-// Tizen Web Device API
-// Copyright (c) 2013 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 <stdio.h>
-#include <string.h>
-#include <JavaScriptCore/JavaScript.h>
-#include "StandaloneConsole.h"
-#include <Ecore.h>
-#include <GlobalContextManager.h>
-#include <JSPowerManager.h>
-
-#include <Commons/FunctionDefinition.h>
-#include <Commons/FunctionDeclaration.h>
-#include <pthread.h>
-
-using namespace std;
-using namespace DeviceAPI::Test;
-using namespace DeviceAPI::Common;
-using namespace DeviceAPI::Power;
-using namespace WrtDeviceApis::Commons;
-
-
-namespace DeviceAPI{
-namespace Power{
-AceFunction getPowerFunctionData(const std::string & functionId){
- return AceFunction();
-}
-}
-}
-
-void loopQuit(void *data, Ecore_Thread *thread){
- ecore_main_loop_quit();
-}
-
-void threadRun(void *data, Ecore_Thread *thread){
- StandaloneConsole *console = (StandaloneConsole*)data;
- StandaloneConsole::commandline(console);
-}
-
-int main(int argc, char** argv){
-
- if (!ecore_init())
- {
- printf("ERROR: Cannot init Ecore!\n");
- return -1;
- }
- ecore_main_loop_glib_integrate();
-
- DPL::Log::LogSystemSingleton::Instance().SetTag("STANDALONE");
- //DPL::Event::GetMainEventDispatcherInstance().ResetCrossEventCallHandler();
- try{
- WrtAccessSingleton::Instance().initialize(0);
- }catch(...){
- printf("ERROR: Cannot init WrtAccessSingleton\n");
- return -1;
- }
-
-
- StandaloneConsole console;
- console.initialize();
- GlobalContextManager::getInstance()->addGlobalContext(console.getGlobalContext());
- console.registModule("power", JSPowerManager::getClassRef(), NULL);
-
- if( argc > 1 ){
- for(unsigned int i = 1 ; i< (unsigned int)argc; i++){
- console.RunScript(argv[i]);
- }
- }
-
- ecore_thread_run(threadRun, loopQuit, NULL, &console);
-
- ecore_main_loop_begin();
- ecore_shutdown();
- return 0;
-}
${LIBS_COMMON}
${tizen_impl}
${application_impl}
- "-Wl,--no-as-needed" ${application_config}
${platform_pkgs_push_LIBRARIES}
)
TARGET_LINK_LIBRARIES(${TARGET_NAME}
${LIBS_COMMON}
${filesystem_impl}
- "-Wl,--no-as-needed" ${filesystem_config}
${platform_pkgs_systemsetting_LIBRARIES}
)
projects / platform / framework / web / wrt-plugins-tizen.git / commitdiff