src/standards/W3C/Widget/JSWidget.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /**
  17  *
  18  * @file        JSWidget.cpp
  19  * @author      Grzegorz Krawczyk (g.krawczyk@samsung.com)
  20  * @version     0.1
  21  */
  22
  23 #include "JSWidget.h"
  24 #include <memory>
  25 #include <CommonsJavaScript/Converter.h>
  26 #include <dpl/log/log.h>
  27 #include <dpl/assert.h>
  28 #include <Widget/WidgetFactory.h>
  29 #include <CommonsJavaScript/JSDOMExceptionFactory.h>
  30 #include "JSPreferences.h"
  31 #include <Widget/IWidget.h>
  32 #include <LocalStorage/LocalStorageMgr.h>
  33 #include <Commons/WrtAccess/WrtAccess.h>
  34 #include <js-overlay/js_iframe_support.h>
  35
  36
  37 #define CATCH_EXCEPTION_NO_MODIFABLE \
  38     Catch(Commons::LocalStorageValueNoModifableException) {\
  39         LogError("The item is read only");\
  40         return JSDOMExceptionFactory::\
  41             NoModificationAllowedException.make(context, exception);\
  42     }
  43
  44 #define CATCH_EXCEPTION_CONVERSION \
  45     Catch(Commons::ConversionException) {\
  46         LogError("Error on conversion");\
  47         return JSDOMExceptionFactory::\
  48             UnknownException.make(context, exception);\
  49     }
  50
  51 #define CATCH_EXCEPTION_NULL_PTR \
  52     Catch(Commons::NullPointerException) {\
  53         LogError("Error on pointer, null value");\
  54         return JSDOMExceptionFactory::\
  55             UnknownException.make(context, exception);\
  56     }
  57
  58 #define CATCH_EXCEPTION_PLATFORM_ERROR \
  59     Catch(Commons::PlatformException){\
  60         LogError("PlatformException occured");\
  61         return JSDOMExceptionFactory::\
  62             UnknownException.make(context, exception);\
  63     }
  64
  65 #define CATCH_EXCEPTION_SECURITY \
  66     Catch(Commons::SecurityException){\
  67         LogError("Security exception occured");\
  68         return JSDOMExceptionFactory::\
  69             SecurityException.make(context, exception);\
  70     }
  71
  72 #define CATCH_EXCEPTION_OUT_OF_RANGE \
  73     Catch(Commons::OutOfRangeException) {\
  74         LogError("OutOfRangeException");\
  75         return JSDOMExceptionFactory::\
  76             QuotaExceededException.make(context, exception);\
  77     }
  78
  79 #define CATCH_EXCEPTION_INVALID_ARG \
  80     Catch(Commons::InvalidArgumentException) {\
  81         LogError("Pair for given key doesnt exist");\
  82         return JSValueMakeNull(context);\
  83     }
  84
  85 #define WIDGET_PLUGIN_NAME "Widget"
  86
  87 #define WRT_WIDGET_PROPERTY_AUTHOR       "author"
  88 #define WRT_WIDGET_PROPERTY_AUTHOR_EMAIL "authorEmail"
  89 #define WRT_WIDGET_PROPERTY_AUTHOR_HREF  "authorHref"
  90 #define WRT_WIDGET_PROPERTY_DESCRIPTION  "description"
  91 #define WRT_WIDGET_PROPERTY_ID           "id"
  92 #define WRT_WIDGET_PROPERTY_NAME         "name"
  93 #define WRT_WIDGET_PROPERTY_SHORT_NAME   "shortName"
  94 #define WRT_WIDGET_PROPERTY_VERSION      "version"
  95 #define WRT_WIDGET_PROPERTY_HEIGHT       "height"
  96 #define WRT_WIDGET_PROPERTY_WIDTH        "width"
  97
  98 namespace WrtPlugins {
  99 namespace W3C {
 100
 101 using namespace WrtDeviceApis;
 102 using namespace WrtDeviceApis::Commons;
 103 using namespace WrtDeviceApis::CommonsJavaScript;
 104 using namespace WrtDeviceApis::Widget;
 105
 106
 107 struct WidgetPrivateObject
 108 {
 109     Widget::Api::IWidgetPtr iwidget;
 110     JSObjectRef preferencesObject;
 111     //TEMP
 112     int widgetId;
 113     JSObjectRef widgetObject;
 114 };
 115 typedef std::shared_ptr<WidgetPrivateObject> WidgetPrivateObjectPtr;
 116
 117 typedef WrtDeviceApis::CommonsJavaScript::PrivateObjectT
 118     <WidgetPrivateObjectPtr>::Type JSWidgetPrivateObject;
 119
 120 WrtDeviceApis::Widget::Api::IWidgetPtr getIWidget(JSObjectRef arg)
 121 {
 122     JSWidgetPrivateObject* priv =
 123         static_cast<JSWidgetPrivateObject*>(JSObjectGetPrivate(arg));
 124
 125     if (!priv) {
 126         LogError("Private object not initialized");
 127         ThrowMsg(Commons::NullPointerException,
 128                  "Private object not initialized");
 129     }
 130
 131     return priv->getObject()->iwidget;
 132 }
 133
 134
 135 LocalStorage::Api::ILocalStoragePtr getLocalStorage(int widgetId)
 136 {
 137     LocalStorage::Api::ILocalStoragePtr storage(
 138         LocalStorage::Api::getLocalStorage(widgetId));
 139
 140     return storage;
 141 }
 142
 143 JSObjectRef getPreferences(JSObjectRef arg)
 144 {
 145     JSWidgetPrivateObject* priv =
 146         static_cast<JSWidgetPrivateObject*>(JSObjectGetPrivate(arg));
 147
 148     if (!priv) {
 149         LogError("Private object not initialized");
 150         return NULL;
 151     }
 152
 153     return priv->getObject()->preferencesObject;
 154 }
 155
 156 JSObjectRef createPreferencesObject(JSContextRef context,
 157                                     JSObjectRef widgetObject,
 158                                     int widgetId)
 159 {
 160     Assert(widgetObject && "Widget Object can'n be null");
 161     //delete is invoked in JSPreferences::finalize
 162     LocalStoragePrivateData* priv = new LocalStoragePrivateData;
 163     Assert(priv && "Private data is null");
 164     priv->istorage = getLocalStorage(widgetId);
 165     priv->widgetObject = widgetObject;
 166
 167     JSObjectRef preferences = JSObjectMake(context,
 168                                            JSPreferences::getClassRef(),
 169                                            priv);
 170
 171     if(!preferences){
 172         LogError("Preferences object is null");
 173         delete priv;
 174     }
 175     //Unprotect is called in JSWidget::finalize
 176     JSValueProtect(context, preferences);
 177
 178     return preferences;
 179 };
 180
 181
 182 JSClassDefinition JSWidget::m_classInfo = {
 183     0,
 184     kJSClassAttributeNone,
 185     WIDGET_PLUGIN_NAME,
 186     0,
 187     m_property,
 188     NULL,
 189     initialize,
 190     finalize,
 191     hasProperty,
 192     getProperty,
 193     setProperty,
 194     NULL, //DeleteProperty,
 195     NULL, //GetPropertyNames,
 196     NULL, //CallAsFunction,
 197     callAsConstructor,
 198     NULL, //HasInstance,
 199     NULL, //ConvertToType,
 200 };
 201
 202 JSStaticValue JSWidget::m_property[] = {
 203     { WRT_WIDGET_PROPERTY_AUTHOR, JSWidget::getAuthor,
 204       0, kJSPropertyAttributeReadOnly },
 205     { WRT_WIDGET_PROPERTY_AUTHOR_EMAIL, JSWidget::getAuthorEmail,
 206       0, kJSPropertyAttributeReadOnly },
 207     { WRT_WIDGET_PROPERTY_AUTHOR_HREF, JSWidget::getAuthorHref,
 208       0, kJSPropertyAttributeReadOnly },
 209     { WRT_WIDGET_PROPERTY_DESCRIPTION, JSWidget::getDescription,
 210       0, kJSPropertyAttributeReadOnly },
 211     { WRT_WIDGET_PROPERTY_ID, JSWidget::getId,
 212       0, kJSPropertyAttributeReadOnly },
 213     { WRT_WIDGET_PROPERTY_NAME, JSWidget::getName,
 214       0, kJSPropertyAttributeReadOnly },
 215     { WRT_WIDGET_PROPERTY_SHORT_NAME, JSWidget::getShortName,
 216       0, kJSPropertyAttributeReadOnly },
 217     { WRT_WIDGET_PROPERTY_VERSION, JSWidget::getVersion,
 218       0, kJSPropertyAttributeReadOnly },
 219     { WRT_WIDGET_PROPERTY_HEIGHT, JSWidget::getHeight,
 220       0, kJSPropertyAttributeReadOnly },
 221     { WRT_WIDGET_PROPERTY_WIDTH, JSWidget::getWidth,
 222       0, kJSPropertyAttributeReadOnly },
 223     { 0, 0, 0, 0 }
 224 };
 225
 226 const JSClassRef JSWidget::getClassRef()
 227 {
 228     if (!m_jsClassRef) {
 229         m_jsClassRef = JSClassCreate(&m_classInfo);
 230     }
 231     return m_jsClassRef;
 232 }
 233
 234 const JSClassDefinition* JSWidget::getClassInfo()
 235 {
 236     return &m_classInfo;
 237 }
 238
 239 JSClassRef JSWidget::m_jsClassRef = JSClassCreate(JSWidget::getClassInfo());
 240
 241 JSContextRef JSWidget::m_globalContext = NULL;
 242
 243 void JSWidget::initialize(JSContextRef context,
 244         JSObjectRef object)
 245 {
 246     LogDebug("entered. Context : " << context);
 247     LogDebug("Object: " << object);
 248
 249     JSWidgetPrivateObject* priv =
 250         static_cast<JSWidgetPrivateObject*>(JSObjectGetPrivate(object));
 251
 252     if (!priv) {
 253         LogDebug("creation private object");
 254
 255         Try {
 256             using namespace WrtDeviceApis::Commons;
 257
 258             Widget::Api::IWidgetPtr widget =
 259                 Api::WidgetFactory::createWidget();
 260             int widgetId = WrtAccessSingleton::Instance().getWidgetId();
 261             JSObjectRef preferences =
 262                 createPreferencesObject(context,
 263                                         object,
 264                                         widgetId);
 265             if(!preferences){
 266                 LogError("Failed to create preferences object");
 267             }
 268
 269             WidgetPrivateObjectPtr widgetPriv(new WidgetPrivateObject);
 270             widgetPriv->iwidget = widget;
 271             widgetPriv->preferencesObject = preferences;
 272
 273             priv = new JSWidgetPrivateObject(context, widgetPriv);
 274             JSObjectSetPrivate(object, priv);
 275             LogDebug("private object created");
 276
 277         }
 278         Catch(Commons::InvalidArgumentException){
 279             LogError("You should register widget id in ON_WIDGET_START");
 280             return;
 281         }
 282
 283     }
 284 }
 285
 286 void JSWidget::finalize(JSObjectRef object)
 287 {
 288     LogDebug("entered");
 289     JSWidgetPrivateObject* priv =
 290         static_cast<JSWidgetPrivateObject*>(JSObjectGetPrivate(object));
 291
 292     JSValueUnprotect(priv->getContext(),
 293                      priv->getObject()->preferencesObject);
 294
 295     delete priv;
 296     LogDebug("private object is released");
 297 }
 298
 299 void JSWidget::acquireGlobalContext(java_script_context_t global_context,
 300         js_object_instance_t iframe,
 301         js_object_instance_t object)
 302 {
 303     IFrameSupport::RegisterWidget(global_context, iframe, object);
 304     if (!m_globalContext) {
 305         m_globalContext = static_cast<JSContextRef>(global_context);
 306         LogInfo("Global context acquired.");
 307     } else {
 308         LogInfo("Global context already set.");
 309     }
 310 }
 311
 312 JSValueRef JSWidget::getAuthor(JSContextRef context,
 313         JSObjectRef object,
 314         JSStringRef propertyName,
 315         JSValueRef* exception)
 316 {
 317     LogDebug("entered");
 318
 319     Try {
 320         Converter converter(context);
 321         return converter.toJSValueRef(getIWidget(object)->getAuthor());
 322     }
 323     CATCH_EXCEPTION_CONVERSION
 324     CATCH_EXCEPTION_NULL_PTR
 325     CATCH_EXCEPTION_PLATFORM_ERROR
 326 }
 327
 328 JSValueRef JSWidget::getAuthorEmail(JSContextRef context,
 329         JSObjectRef object,
 330         JSStringRef propertyName,
 331         JSValueRef* exception)
 332 {
 333     Try {
 334         Converter converter(context);
 335         return converter.toJSValueRef(getIWidget(object)->getAuthorEmail());
 336     }
 337     CATCH_EXCEPTION_CONVERSION
 338     CATCH_EXCEPTION_NULL_PTR
 339     CATCH_EXCEPTION_PLATFORM_ERROR
 340 }
 341
 342 JSValueRef JSWidget::getAuthorHref(JSContextRef context,
 343         JSObjectRef object,
 344         JSStringRef propertyName,
 345         JSValueRef* exception)
 346 {
 347     Try {
 348         Converter converter(context);
 349         return converter.toJSValueRef(getIWidget(object)->getAuthorHref());
 350     }
 351     CATCH_EXCEPTION_CONVERSION
 352     CATCH_EXCEPTION_NULL_PTR
 353     CATCH_EXCEPTION_PLATFORM_ERROR
 354 }
 355
 356 JSValueRef JSWidget::getDescription(JSContextRef context,
 357         JSObjectRef object,
 358         JSStringRef propertyName,
 359         JSValueRef* exception)
 360 {
 361     Try {
 362         Converter converter(context);
 363         return converter.toJSValueRef(getIWidget(object)->getDescription());
 364     }
 365     CATCH_EXCEPTION_CONVERSION
 366     CATCH_EXCEPTION_NULL_PTR
 367     CATCH_EXCEPTION_PLATFORM_ERROR
 368 }
 369
 370 JSValueRef JSWidget::getId(JSContextRef context,
 371         JSObjectRef object,
 372         JSStringRef propertyName,
 373         JSValueRef* exception)
 374 {
 375     Try {
 376         Converter converter(context);
 377         return converter.toJSValueRef(getIWidget(object)->getId());
 378     }
 379     CATCH_EXCEPTION_CONVERSION
 380     CATCH_EXCEPTION_NULL_PTR
 381     CATCH_EXCEPTION_PLATFORM_ERROR
 382 }
 383
 384 JSValueRef JSWidget::getName(JSContextRef context,
 385         JSObjectRef object,
 386         JSStringRef propertyName,
 387         JSValueRef* exception)
 388 {
 389     Try {
 390         Converter converter(context);
 391         return converter.toJSValueRef(getIWidget(object)->getName());
 392     }
 393     CATCH_EXCEPTION_CONVERSION
 394     CATCH_EXCEPTION_NULL_PTR
 395     CATCH_EXCEPTION_PLATFORM_ERROR
 396 }
 397
 398 JSValueRef JSWidget::getShortName(JSContextRef context,
 399         JSObjectRef object,
 400         JSStringRef propertyName,
 401         JSValueRef* exception)
 402 {
 403     Try {
 404         Converter converter(context);
 405         return converter.toJSValueRef(getIWidget(object)->getShortName());
 406     }
 407     CATCH_EXCEPTION_CONVERSION
 408     CATCH_EXCEPTION_NULL_PTR
 409     CATCH_EXCEPTION_PLATFORM_ERROR
 410 }
 411
 412 JSValueRef JSWidget::getVersion(JSContextRef context,
 413         JSObjectRef object,
 414         JSStringRef propertyName,
 415         JSValueRef* exception)
 416 {
 417     Try {
 418         Converter converter(context);
 419         return converter.toJSValueRef(getIWidget(object)->getVersion());
 420     }
 421     CATCH_EXCEPTION_CONVERSION
 422     CATCH_EXCEPTION_NULL_PTR
 423     CATCH_EXCEPTION_PLATFORM_ERROR
 424 }
 425
 426 JSValueRef JSWidget::getHeight(JSContextRef context,
 427         JSObjectRef object,
 428         JSStringRef propertyName,
 429         JSValueRef* exception)
 430 {
 431     Try {
 432         Converter converter(context);
 433         unsigned int height = getIWidget(object)->getHeight();
 434         if (0 == height) {
 435             height = 1;
 436         }
 437         return converter.toJSValueRef(height);
 438     }
 439     CATCH_EXCEPTION_CONVERSION
 440     CATCH_EXCEPTION_NULL_PTR
 441     CATCH_EXCEPTION_PLATFORM_ERROR
 442 }
 443
 444 JSValueRef JSWidget::getWidth(JSContextRef context,
 445         JSObjectRef object,
 446         JSStringRef propertyName,
 447         JSValueRef* exception)
 448 {
 449     Try {
 450         Converter converter(context);
 451         unsigned int width = getIWidget(object)->getWidth();
 452         if (0 == width) {
 453             width = 1;
 454         }
 455         return converter.toJSValueRef(width);
 456     }
 457     CATCH_EXCEPTION_CONVERSION
 458     CATCH_EXCEPTION_NULL_PTR
 459     CATCH_EXCEPTION_PLATFORM_ERROR
 460 }
 461
 462 bool JSWidget::hasProperty(JSContextRef context,
 463                            JSObjectRef object,
 464                            JSStringRef propertyName)
 465 {
 466     LogDebug("enter");
 467
 468     Try{
 469         Converter converter(context);
 470
 471         std::string key = converter.toString(propertyName);
 472         if (key == "preferences") {
 473             return true;
 474         }
 475     }
 476     Catch(Commons::InvalidArgumentException) {
 477         LogDebug("Pair for given key doesnt exist");
 478     }
 479
 480     Catch(Commons::ConversionException) {
 481         LogError("Error on conversion");
 482     }
 483
 484     Catch(Commons::NullPointerException) {
 485         LogError("Error on pointer, null value");
 486     }
 487
 488     Catch(Commons::PlatformException){
 489         LogError("PlatformException occured");
 490     }
 491     return false;
 492 }
 493
 494 JSValueRef JSWidget::getProperty(JSContextRef context,
 495                                  JSObjectRef object,
 496                                  JSStringRef propertyName,
 497                                  JSValueRef* exception)
 498 {
 499     LogDebug("Object: " << object);
 500
 501     Try {
 502         Converter converter(context);
 503
 504         std::string key = converter.toString(propertyName);
 505
 506         if (key=="preferences") {
 507             Converter converter(context);
 508             JSObjectRef pref = getPreferences(object);
 509             if (!pref)
 510             {
 511                 LogError("Preferences object is NULL");
 512                 return JSValueMakeUndefined(context);
 513             }
 514             return pref;
 515         }
 516         LogError("Property NOT supported: " << propertyName);
 517         return JSValueMakeUndefined(context);
 518     }
 519
 520     CATCH_EXCEPTION_CONVERSION
 521     CATCH_EXCEPTION_NULL_PTR
 522     CATCH_EXCEPTION_INVALID_ARG
 523 }
 524
 525 bool JSWidget::setProperty(JSContextRef context,
 526                            JSObjectRef object,
 527                            JSStringRef propertyName,
 528                            JSValueRef jvalue,
 529                            JSValueRef* exception)
 530 {
 531     LogDebug("enter");
 532
 533     Try{
 534         Converter converter(context);
 535
 536         std::string key = converter.toString(propertyName);
 537         if (key == "preferences"){
 538             LogError("Object is read only");
 539             return true;
 540         }
 541     }
 542     CATCH_EXCEPTION_INVALID_ARG
 543     CATCH_EXCEPTION_CONVERSION
 544     CATCH_EXCEPTION_NULL_PTR
 545
 546     return false;
 547 }
 548
 549 JSObjectRef JSWidget::callAsConstructor(JSContextRef context,
 550                                         JSObjectRef constructor,
 551                                         size_t argumentCount,
 552                                         const JSValueRef arguments[],
 553                                         JSValueRef* exception)
 554 {
 555     LogDebug("widget constructor");
 556     if (!m_globalContext) {
 557         LogError("Global context not set. Creating 'widget' object with "
 558                 "local context!");
 559         return JSObjectMake(context, JSWidget::getClassRef(), NULL);
 560     }
 561     return JSObjectMake(m_globalContext, JSWidget::getClassRef(), NULL);
 562 }
 563
 564 #undef CATCH_EXCEPTION_NO_MODIFABLE
 565 #undef CATCH_EXCEPTION_CONVERSION
 566 #undef CATCH_EXCEPTION_NULL_PTR
 567 #undef CATCH_EXCEPTION_PLATFORM_ERROR
 568 #undef CATCH_EXCEPTION_SECURITY
 569 #undef CATCH_EXCEPTION_OUT_OF_RANGE
 570 #undef CATCH_EXCEPTION_INVALID_ARG
 571
 572 }
 573 }