src/standards/Tizen/Notification/JSNotificationManager.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 #include <CommonsJavaScript/Converter.h>
  18 #include <CommonsJavaScript/Validator.h>
  19 #include <CommonsJavaScript/JSUtils.h>
  20 #include <CommonsJavaScript/JSCallbackManager.h>
  21 #include <CommonsJavaScript/Utils.h>
  22 #include <Tizen/Common/SecurityExceptions.h>
  23 #include <Tizen/Common/JSTizenExceptionFactory.h>
  24 #include <Tizen/Common/JSTizenException.h>
  25 #include <API/Notification/NotificationFactory.h>
  26 #include "JSNotificationManager.h"
  27 #include "NotificationConverter.h"
  28
  29 //#include "plugin_config.h"
  30
  31 using namespace std;
  32 using namespace DPL;
  33 using namespace WrtDeviceApis;
  34 using namespace WrtDeviceApis::CommonsJavaScript;
  35 using namespace TizenApis::Commons;
  36
  37 namespace TizenApis {
  38 namespace Tizen1_0 {
  39
  40 JSClassDefinition JSNotificationManager::m_classInfo =
  41 {
  42         0,
  43         kJSClassAttributeNone,
  44         "NotificationManager",
  45         NULL,
  46         NULL,
  47         m_function,
  48         initialize,
  49         finalize,
  50         NULL,
  51         NULL,
  52         NULL,
  53         NULL,
  54         NULL,
  55         NULL,
  56         NULL,
  57         hasInstance,
  58         NULL
  59 };
  60
  61
  62 JSStaticFunction JSNotificationManager::m_function[] =
  63 {
  64         { "post", JSNotificationManager::post, kJSPropertyAttributeNone },
  65         { "update", JSNotificationManager::update, kJSPropertyAttributeNone },
  66         { "get", JSNotificationManager::get, kJSPropertyAttributeNone },
  67         { "getAll", JSNotificationManager::getAll, kJSPropertyAttributeNone },
  68         { "cancel", JSNotificationManager::cancel, kJSPropertyAttributeNone },
  69         { "cancelAll", JSNotificationManager::cancelAll, kJSPropertyAttributeNone },
  70         { 0, 0, 0 }
  71 };
  72
  73
  74 const JSClassRef JSNotificationManager::getClassRef()
  75 {
  76         if (!m_jsClassRef) {
  77                 m_jsClassRef = JSClassCreate(&m_classInfo);
  78         }
  79         return m_jsClassRef;
  80 }
  81
  82 const JSClassDefinition* JSNotificationManager::getClassInfo()
  83 {
  84         return &m_classInfo;
  85 }
  86
  87 JSClassRef JSNotificationManager::m_jsClassRef = JSClassCreate(JSNotificationManager::getClassInfo());
  88
  89 void JSNotificationManager::initialize(JSContextRef context, JSObjectRef object)
  90 {
  91         LogDebug("JSNotificationManager::initialize ");
  92
  93         JSNotificationManagerPriv* priv = static_cast<JSNotificationManagerPriv*>(JSObjectGetPrivate(object));
  94
  95         if (priv == NULL)
  96         {
  97                 LogDebug("JSNotificationManager::initialize create");
  98
  99                 TizenApis::Api::Notification::INotificationManagerPtr  notificationManager(
 100                         TizenApis::Api::Notification::NotificationFactory::getInstance().getNotificationManager());
 101
 102                 priv = new JSNotificationManagerPriv( context, notificationManager);
 103
 104                 if(!JSObjectSetPrivate(object, static_cast<void*>(priv)))
 105                 {
 106                         LogError("Object can't store private data.");
 107                         delete priv;
 108                 }
 109         }
 110         else
 111         {
 112                 LogDebug("JSNotificationManager::already exist ");
 113         }
 114 }
 115
 116 void JSNotificationManager::finalize(JSObjectRef object)
 117 {
 118         JSNotificationManagerPriv* priv = static_cast<JSNotificationManagerPriv*>(JSObjectGetPrivate(object));
 119
 120         LogDebug("JSNotificationManager::Finalrize");
 121
 122         if (priv != NULL)
 123         {
 124                 JSObjectSetPrivate(object, NULL);
 125                 delete priv;
 126         }
 127 }
 128
 129 bool JSNotificationManager::hasInstance(JSContextRef context, JSObjectRef constructor,
 130                 JSValueRef possibleInstance, JSValueRef* exception)
 131 {
 132         return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
 133 }
 134
 135
 136 JSValueRef JSNotificationManager::cancel(JSContextRef context, JSObjectRef object,
 137         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 138         JSValueRef* exception)
 139 {
 140         JSNotificationManagerPriv* priv = static_cast<JSNotificationManagerPriv*>(JSObjectGetPrivate(thisObject));
 141         JSValueRef reserveArguments;
 142
 143
 144         try
 145         {
 146                 if (argumentCount == 1)
 147                         reserveArguments = arguments[0];
 148                 else
 149                         reserveArguments = JSValueMakeUndefined(context);
 150
 151                 if (priv == NULL)
 152                 {
 153                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Private object is null");
 154                 }
 155                 NotificationConverter converter(priv->getContext());
 156                 std::string id = converter.toString(reserveArguments);
 157
 158                 TizenApis::Api::Notification::INotificationManagerPtr notificationManager(priv->getObject());
 159                 notificationManager->cancel(id);
 160         }
 161         Catch (WrtDeviceApis::Commons::ConversionException)
 162         {
 163                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 164                 return JSTizenExceptionFactory::postException(context, exception,
 165                                         JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
 166
 167         }
 168         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 169         {
 170                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 171                 return JSTizenExceptionFactory::postException(context, exception,
 172                         JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
 173         }
 174         Catch(WrtDeviceApis::Commons::UnsupportedException)
 175         {
 176                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 177                 return JSTizenExceptionFactory::postException(context, exception,
 178                                 JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
 179         }
 180         Catch(WrtDeviceApis::Commons::NotFoundException)
 181         {
 182                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 183                 return JSTizenExceptionFactory::postException(context, exception,
 184                                 JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
 185         }
 186         Catch (WrtDeviceApis::Commons::SecurityException)
 187         {
 188                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 189                 return JSTizenExceptionFactory::postException(context, exception,
 190                         JSTizenException::PERMISSION_DENIED_ERROR, _rethrown_exception.GetMessage());
 191         }
 192         Catch (WrtDeviceApis::Commons::Exception)
 193         {
 194                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 195                 return JSTizenExceptionFactory::postException(context, exception,
 196                         JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
 197         }
 198
 199         return JSValueMakeUndefined(context);
 200
 201 }
 202
 203 JSValueRef JSNotificationManager::cancelAll(JSContextRef context, JSObjectRef object,
 204         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 205         JSValueRef* exception)
 206 {
 207         JSNotificationManagerPriv* priv = static_cast<JSNotificationManagerPriv*>(JSObjectGetPrivate(thisObject));
 208
 209         try
 210         {
 211                 if (priv == NULL)
 212                 {
 213                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Private object is null");
 214                 }
 215                 TizenApis::Api::Notification::INotificationManagerPtr notificationManager(priv->getObject());
 216                 notificationManager->cancelAll();
 217
 218         }
 219         Catch (WrtDeviceApis::Commons::ConversionException)
 220         {
 221                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 222                 return JSTizenExceptionFactory::postException(context, exception,
 223                                         JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
 224
 225         }
 226         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 227         {
 228                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 229                 return JSTizenExceptionFactory::postException(context, exception,
 230                         JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
 231         }
 232         Catch(WrtDeviceApis::Commons::UnsupportedException)
 233         {
 234                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 235                 return JSTizenExceptionFactory::postException(context, exception,
 236                                 JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
 237         }
 238         Catch (WrtDeviceApis::Commons::SecurityException)
 239         {
 240                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 241                 return JSTizenExceptionFactory::postException(context, exception,
 242                         JSTizenException::PERMISSION_DENIED_ERROR, _rethrown_exception.GetMessage());
 243         }
 244         Catch (WrtDeviceApis::Commons::Exception)
 245         {
 246                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 247                 return JSTizenExceptionFactory::postException(context, exception,
 248                         JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
 249         }
 250         return JSValueMakeUndefined(context);
 251
 252 }
 253
 254
 255 JSValueRef JSNotificationManager::update(JSContextRef context, JSObjectRef object,
 256         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 257         JSValueRef* exception)
 258 {
 259         JSNotificationManagerPriv* priv = static_cast<JSNotificationManagerPriv*>(JSObjectGetPrivate(thisObject));
 260         JSValueRef reserveArguments;
 261
 262         try
 263         {
 264                 if (priv == NULL)
 265                 {
 266                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Private object is null");
 267                 }
 268
 269                 if (argumentCount == 1)
 270                         reserveArguments = arguments[0];
 271                 else
 272                         reserveArguments = JSValueMakeUndefined(context);
 273
 274                 NotificationConverter converter(priv->getContext());
 275                 TizenApis::Api::Notification::INotificationManagerPtr notificationManager(priv->getObject());
 276                 TizenApis::Api::Notification::INotificationPtr notification =  converter.toINotificationPtr(reserveArguments);
 277                 notificationManager->update(notification);
 278         }
 279         Catch (WrtDeviceApis::Commons::ConversionException)
 280         {
 281                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 282                 return JSTizenExceptionFactory::postException(context, exception,
 283                                         JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
 284
 285         }
 286         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 287         {
 288                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 289                 return JSTizenExceptionFactory::postException(context, exception,
 290                         JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
 291         }
 292         Catch(WrtDeviceApis::Commons::UnsupportedException)
 293         {
 294                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 295                 return JSTizenExceptionFactory::postException(context, exception,
 296                                 JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
 297         }
 298         Catch (WrtDeviceApis::Commons::SecurityException)
 299         {
 300                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 301                 return JSTizenExceptionFactory::postException(context, exception,
 302                         JSTizenException::PERMISSION_DENIED_ERROR, _rethrown_exception.GetMessage());
 303         }
 304         Catch (WrtDeviceApis::Commons::Exception)
 305         {
 306                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 307                 return JSTizenExceptionFactory::postException(context, exception,
 308                         JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
 309         }
 310         return JSValueMakeUndefined(context);
 311 }
 312
 313 JSValueRef JSNotificationManager::get(JSContextRef context, JSObjectRef object,
 314         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 315         JSValueRef* exception)
 316 {
 317         JSNotificationManagerPriv* priv = static_cast<JSNotificationManagerPriv*>(JSObjectGetPrivate(thisObject));
 318         JSValueRef reserveArguments;
 319
 320         try
 321         {
 322                 if (argumentCount == 1)
 323                         reserveArguments = arguments[0];
 324                 else
 325                         reserveArguments = JSValueMakeUndefined(context);
 326
 327                 if (priv == NULL)
 328                 {
 329                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Private object is null");
 330                 }
 331
 332                 NotificationConverter converter(priv->getContext());
 333                 std::string id = converter.toString(reserveArguments);
 334
 335                 TizenApis::Api::Notification::INotificationManagerPtr notificationManager(priv->getObject());
 336                 TizenApis::Api::Notification::INotificationPtr notification =  notificationManager->get(id);
 337                 return converter.toJSValueRef(notification);
 338         }
 339         Catch (WrtDeviceApis::Commons::ConversionException)
 340         {
 341                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 342                 return JSTizenExceptionFactory::postException(context, exception,
 343                                         JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
 344
 345         }
 346         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 347         {
 348                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 349                 return JSTizenExceptionFactory::postException(context, exception,
 350                         JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
 351         }
 352         Catch(WrtDeviceApis::Commons::NotFoundException)
 353         {
 354                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 355                 return JSTizenExceptionFactory::postException(context, exception,
 356                                 JSTizenException::NOT_FOUND_ERROR, _rethrown_exception.GetMessage());
 357         }
 358
 359         Catch(WrtDeviceApis::Commons::UnsupportedException)
 360         {
 361                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 362                 return JSTizenExceptionFactory::postException(context, exception,
 363                                 JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
 364         }
 365         Catch (WrtDeviceApis::Commons::SecurityException)
 366         {
 367                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 368                 return JSTizenExceptionFactory::postException(context, exception,
 369                         JSTizenException::PERMISSION_DENIED_ERROR, _rethrown_exception.GetMessage());
 370         }
 371         Catch (WrtDeviceApis::Commons::Exception)
 372         {
 373                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 374                 return JSTizenExceptionFactory::postException(context, exception,
 375                         JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
 376         }
 377         return JSValueMakeUndefined(context);
 378
 379 }
 380
 381 JSValueRef JSNotificationManager::post(JSContextRef context, JSObjectRef object,
 382         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 383         JSValueRef* exception)
 384 {
 385         JSNotificationManagerPriv* priv = static_cast<JSNotificationManagerPriv*>(JSObjectGetPrivate(thisObject));
 386         JSValueRef reserveArguments;
 387
 388         try
 389         {
 390
 391                 if (priv == NULL)
 392                 {
 393                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Private object is null");
 394                 }
 395
 396                 if (argumentCount == 1)
 397                         reserveArguments = arguments[0];
 398                 else
 399                         reserveArguments = JSValueMakeUndefined(context);
 400
 401                 NotificationConverter converter(priv->getContext());
 402                 TizenApis::Api::Notification::INotificationManagerPtr notificationManager(priv->getObject());
 403                 TizenApis::Api::Notification::INotificationPtr notification =  converter.toINotificationPtr(reserveArguments);
 404                 notificationManager->post(notification);
 405         }
 406         Catch (WrtDeviceApis::Commons::ConversionException)
 407         {
 408                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 409                 return JSTizenExceptionFactory::postException(context, exception,
 410                                         JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
 411
 412         }
 413         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 414         {
 415                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 416                 return JSTizenExceptionFactory::postException(context, exception,
 417                         JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
 418         }
 419         Catch(WrtDeviceApis::Commons::UnsupportedException)
 420         {
 421                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 422                 return JSTizenExceptionFactory::postException(context, exception,
 423                                 JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
 424         }
 425         Catch (WrtDeviceApis::Commons::SecurityException)
 426         {
 427                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 428                 return JSTizenExceptionFactory::postException(context, exception,
 429                         JSTizenException::PERMISSION_DENIED_ERROR, _rethrown_exception.GetMessage());
 430         }
 431         Catch (WrtDeviceApis::Commons::Exception)
 432         {
 433                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 434                 return JSTizenExceptionFactory::postException(context, exception,
 435                         JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
 436         }
 437         return JSValueMakeUndefined(context);
 438
 439 }
 440
 441 JSValueRef JSNotificationManager::getAll(JSContextRef context, JSObjectRef object,
 442         JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
 443         JSValueRef* exception)
 444 {
 445         JSNotificationManagerPriv* priv = static_cast<JSNotificationManagerPriv*>(JSObjectGetPrivate(thisObject));
 446
 447         try
 448         {
 449                 if (priv == NULL)
 450                 {
 451                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Private object is null");
 452                 }
 453
 454                 NotificationConverter converter(priv->getContext());
 455                 TizenApis::Api::Notification::INotificationManagerPtr notificationManager(priv->getObject());
 456                 std::vector<TizenApis::Api::Notification::INotificationPtr> notificationArray =  notificationManager->getAll();
 457                 return converter.toJSValueRef(notificationArray);
 458         }
 459         Catch (WrtDeviceApis::Commons::ConversionException)
 460         {
 461                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 462                 return JSTizenExceptionFactory::postException(context, exception,
 463                                         JSTizenException::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
 464
 465         }
 466         Catch (WrtDeviceApis::Commons::InvalidArgumentException)
 467         {
 468                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 469                 return JSTizenExceptionFactory::postException(context, exception,
 470                         JSTizenException::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
 471         }
 472         Catch(WrtDeviceApis::Commons::UnsupportedException)
 473         {
 474                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 475                 return JSTizenExceptionFactory::postException(context, exception,
 476                                 JSTizenException::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
 477         }
 478         Catch (WrtDeviceApis::Commons::SecurityException)
 479         {
 480                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 481                 return JSTizenExceptionFactory::postException(context, exception,
 482                         JSTizenException::PERMISSION_DENIED_ERROR, _rethrown_exception.GetMessage());
 483         }
 484         Catch (WrtDeviceApis::Commons::Exception)
 485         {
 486                 LogWarning("Exception: "<<_rethrown_exception.GetMessage());
 487                 return JSTizenExceptionFactory::postException(context, exception,
 488                         JSTizenException::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
 489         }
 490         return JSValueMakeUndefined(context);
 491
 492 }
 493
 494 }
 495 }
 496