src/Contact/ContactManagerController.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file        ContactManagerController.cpp
  20  * @author      Kisub Song (kisubs.song@samsung.com)
  21  * @version     0.1
  22  * @brief
  23  */
  24
  25 #include <CommonsJavaScript/JSCallbackManager.h>
  26 #include <JSWebAPIErrorFactory.h>
  27 #include "ContactConverter.h"
  28 #include "ContactManagerController.h"
  29 #include "ContactAsyncCallbackManager.h"
  30 #include "JSContactManagerChangeCallbackManager.h"
  31 #include "ContactQueue.h"
  32 #include <Logger.h>
  33
  34 namespace DeviceAPI {
  35 namespace Contact {
  36
  37 using namespace DeviceAPI::Common;
  38 using namespace WrtDeviceApis::Commons;
  39 using namespace WrtDeviceApis::CommonsJavaScript;
  40
  41 ContactManagerController::ContactManagerController(JSContextRef context, ContactManagerPtr contactManager) :
  42                 EventContactManagerGetAddressBooksAnswerReceiver(ThreadEnum::NULL_THREAD),
  43                 EventContactManagerUpdateBatchAnswerReceiver(ThreadEnum::NULL_THREAD),
  44                 EventContactManagerRemoveBatchAnswerReceiver(ThreadEnum::NULL_THREAD),
  45                 EventContactManagerFindAnswerReceiver(ThreadEnum::NULL_THREAD),
  46                 EventContactManagerChangeListenerListener(ThreadEnum::NULL_THREAD),
  47                 SecurityAccessor(),
  48                 ContactManagerPrivObject(context, contactManager)
  49 {
  50         LoggerD("ContactManagerController constructed : " << this);
  51 }
  52
  53 ContactManagerController::~ContactManagerController()
  54 {
  55         LoggerD("ContactManagerController destructed : " << this);
  56 }
  57
  58 void ContactManagerAsyncAnswerHandler::getAddressBooks(const EventContactManagerGetAddressBooksPtr &event, SecurityAccessor *securityAccessor)
  59 {
  60         LoggerD("entered");
  61         JSCallbackManagerPtr callbackManager =
  62                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  63         if (!callbackManager) {
  64                 LoggerE("no callback manager");
  65                 return;
  66         }
  67
  68         ContactAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
  69
  70         if(event->checkCancelled()) {
  71                 LoggerD("Operation cancelled");
  72                 return;
  73         }
  74
  75         JSContextRef gContext = callbackManager->getContext();
  76
  77         JSValueRef error = NULL;
  78         if (ExceptionCodes::None != event->getExceptionCode())
  79         {
  80                 switch (event->getExceptionCode())
  81                 {
  82                 case ExceptionCodes::PlatformException:
  83                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
  84                         break;
  85                 case ExceptionCodes::InvalidArgumentException:
  86                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Invalid value error");
  87                         break;
  88                 case ExceptionCodes::ConversionException:
  89                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Wrong argument");
  90                         break;
  91                 default:
  92                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
  93                         break;
  94                 }
  95
  96                 callbackManager->callOnError(error);
  97                 return;
  98         }
  99
 100         Try {
 101                 if (!event->getResult())
 102                         ThrowMsg(PlatformException, "No result.");
 103
 104                 ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(gContext);
 105                 AddressBookArrayPtr addressBooks = event->getAddressBooks();
 106
 107                 JSValueRef result = converter->toJSValueRef(addressBooks, securityAccessor);
 108
 109                 callbackManager->callOnSuccess(result);
 110                 return;
 111         } Catch(Exception) {
 112                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 113                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 114
 115                 callbackManager->callOnError(error);
 116                 return;
 117         }
 118 }
 119
 120 void ContactManagerAsyncAnswerHandler::updateBatch(const EventContactManagerUpdateBatchPtr &event)
 121 {
 122         LoggerD("entered");
 123
 124         ContactQueueManagerSingleton::Instance().decreaseQueueList();
 125         bool isEmpty = ContactQueueManagerSingleton::Instance().empty();
 126         if(!isEmpty){
 127                 ContactQueueManagerSingleton::Instance().pop();
 128         }
 129
 130         JSCallbackManagerPtr callbackManager =
 131                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 132         if (!callbackManager) {
 133                 LoggerE("no callback manager");
 134                 return;
 135         }
 136
 137         ContactAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 138
 139         if(event->checkCancelled()) {
 140                 LoggerD("Operation cancelled");
 141                 return;
 142         }
 143
 144         JSContextRef gContext = callbackManager->getContext();
 145
 146         JSValueRef error = NULL;
 147         if (ExceptionCodes::None != event->getExceptionCode())
 148         {
 149                 switch (event->getExceptionCode())
 150                 {
 151                 case ExceptionCodes::PlatformException:
 152                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 153                         break;
 154                 case ExceptionCodes::NotFoundException:
 155                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "record not found");
 156                         break;
 157                 case ExceptionCodes::InvalidArgumentException:
 158                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Invalid value error");
 159                         break;
 160                 case ExceptionCodes::ConversionException:
 161                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
 162                         break;
 163                 default:
 164                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
 165                         break;
 166                 }
 167
 168                 callbackManager->callOnError(error);
 169                 return;
 170         }
 171
 172         callbackManager->callOnSuccess();
 173 }
 174
 175 void ContactManagerAsyncAnswerHandler::removeBatch(const EventContactManagerRemoveBatchPtr &event)
 176 {
 177         LoggerD("entered");
 178         ContactQueueManagerSingleton::Instance().decreaseQueueList();
 179         bool isEmpty = ContactQueueManagerSingleton::Instance().empty();
 180         if(!isEmpty){
 181                 ContactQueueManagerSingleton::Instance().pop();
 182         }
 183
 184         JSCallbackManagerPtr callbackManager =
 185                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 186         if (!callbackManager) {
 187                 LoggerE("no callback manager");
 188                 return;
 189         }
 190
 191         ContactAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 192
 193         if(event->checkCancelled()) {
 194                 LoggerD("Operation cancelled");
 195                 return;
 196         }
 197
 198         JSContextRef gContext = callbackManager->getContext();
 199
 200         JSValueRef error = NULL;
 201         if (ExceptionCodes::None != event->getExceptionCode())
 202         {
 203                 switch (event->getExceptionCode())
 204                 {
 205                 case ExceptionCodes::PlatformException:
 206                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 207                         break;
 208                 case ExceptionCodes::NotFoundException:
 209                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "record not found");
 210                         break;
 211                 case ExceptionCodes::InvalidArgumentException:
 212                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Invalid value error");
 213                         break;
 214                 case ExceptionCodes::ConversionException:
 215                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
 216                         break;
 217                 default:
 218                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
 219                         break;
 220                 }
 221                 callbackManager->callOnError(error);
 222                 return;
 223         }
 224
 225         callbackManager->callOnSuccess();
 226 }
 227
 228 void ContactManagerAsyncAnswerHandler::find(const EventContactManagerFindPtr &event, SecurityAccessor *securityAccessor)
 229 {
 230         LoggerD("entered");
 231         JSCallbackManagerPtr callbackManager =
 232                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 233         if (!callbackManager)
 234         {
 235                 LoggerE("no callback manager");
 236                 return;
 237         }
 238
 239         ContactAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 240
 241         if(event->checkCancelled()) {
 242                 LoggerD("Operation cancelled");
 243                 return;
 244         }
 245
 246         JSContextRef gContext = callbackManager->getContext();
 247
 248         JSValueRef error = NULL;
 249         if (ExceptionCodes::None != event->getExceptionCode())
 250         {
 251                 switch (event->getExceptionCode())
 252                 {
 253                 case ExceptionCodes::PlatformException:
 254                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, "Not support such a filter");
 255                         break;
 256                 case ExceptionCodes::InvalidArgumentException:
 257                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Invalid value error");
 258                         break;
 259                 case ExceptionCodes::ConversionException:
 260                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Wrong argument");
 261                         break;
 262                 default:
 263                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
 264                         break;
 265                 }
 266
 267                 callbackManager->callOnError(error);
 268                 return;
 269         }
 270
 271         Try {
 272                 if (!event->getResult())
 273                         ThrowMsg(PlatformException, "No result.");
 274
 275                 ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(gContext);
 276                 PersonArrayPtr contacts = event->getPersons();
 277
 278                 JSValueRef result = converter->toJSValueRef(contacts, securityAccessor);
 279
 280                 callbackManager->callOnSuccess(result);
 281                 return;
 282         } Catch(Exception) {
 283                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 284                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 285
 286                 callbackManager->callOnError(error);
 287                 return;
 288         }
 289 }
 290
 291 void ContactManagerAsyncAnswerHandler::changeListenerError(const EventContactManagerChangeListenerPtr &event)
 292 {
 293         LoggerD("entered");
 294         JSValueRef errorObject;
 295
 296         JSCallbackManagerPtr cbm = DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 297         if (!cbm)
 298         {
 299                 LoggerE("no callback manager");
 300                 return;
 301         }
 302
 303         JSContextRef gContext = cbm->getContext();
 304
 305         if (event->getExceptionCode() == ExceptionCodes::NotFoundException)
 306                 errorObject = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "Not found error");
 307         else
 308                 errorObject = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Unknown error");
 309
 310         cbm->callOnError(errorObject);
 311 }
 312
 313 void ContactManagerAsyncAnswerHandler::changeListenerPersonAdded(const EventContactManagerChangeListenerPtr &event, SecurityAccessor *securityAccessor)
 314 {
 315         LoggerD("entered");
 316         JSContactManagerChangeCallbackManagerPtr cbm =
 317                 DPL::StaticPointerCast<JSContactManagerChangeCallbackManager>(event->getPrivateData());
 318         if (!cbm)
 319         {
 320                 LoggerE("no callback manager");
 321                 return;
 322         }
 323
 324         EventInfoContactManagerChangePtr _eventInfo = event->getEventInfo();
 325         if(_eventInfo->getCallbackType() != EventInfoContactManagerChange::OnPersonsAdded)
 326         {
 327                 LoggerE("wrong type");
 328                 return;
 329         }
 330
 331         EventInfoContactManagerChangeAddedPtr eventInfo = DPL::DynamicPointerCast<EventInfoContactManagerChangeAdded>(_eventInfo);
 332
 333         if (!eventInfo->getPersonsIsSet())
 334         {
 335                 LoggerE("no data set");
 336                 return;
 337         }
 338
 339         ContactConverterFactory::ConverterType converter =
 340                         ContactConverterFactory::getConverter(cbm->getContext());
 341
 342         JSValueRef contacts;
 343         Try {
 344                 contacts = converter->toJSValueRef(eventInfo->getPersons(), securityAccessor);
 345         } Catch (Exception) {
 346                 LoggerE("Conversion error");
 347                 return;
 348         }
 349
 350         cbm->callOnPersonsAdded(contacts);
 351 }
 352
 353 void ContactManagerAsyncAnswerHandler::changeListenerPersonUpdated(const EventContactManagerChangeListenerPtr &event, SecurityAccessor *securityAccessor)
 354 {
 355         LoggerD("entered");
 356         JSContactManagerChangeCallbackManagerPtr cbm =
 357                 DPL::StaticPointerCast<JSContactManagerChangeCallbackManager>(event->getPrivateData());
 358         if (!cbm)
 359         {
 360                 LoggerE("no callback manager");
 361                 return;
 362         }
 363
 364         EventInfoContactManagerChangePtr _eventInfo = event->getEventInfo();
 365         if(_eventInfo->getCallbackType() != EventInfoContactManagerChange::OnPersonsUpdated)
 366         {
 367                 LoggerE("wrong type");
 368                 return;
 369         }
 370
 371         EventInfoContactManagerChangeUpdatedPtr eventInfo = DPL::DynamicPointerCast<EventInfoContactManagerChangeUpdated>(_eventInfo);
 372
 373         if (!eventInfo->getPersonsIsSet())
 374         {
 375                 LoggerE("no data set");
 376                 return;
 377         }
 378
 379         ContactConverterFactory::ConverterType converter =
 380                         ContactConverterFactory::getConverter(cbm->getContext());
 381
 382         JSValueRef contacts;
 383         Try {
 384                 contacts = converter->toJSValueRef(eventInfo->getPersons(), securityAccessor);
 385         } Catch (Exception) {
 386                 LoggerE("Conversion error");
 387                 return;
 388         }
 389
 390         cbm->callOnPersonsUpdated(contacts);
 391 }
 392
 393 void ContactManagerAsyncAnswerHandler::changeListenerPersonRemoved(const EventContactManagerChangeListenerPtr &event)
 394 {
 395         LoggerD("entered");
 396         JSContactManagerChangeCallbackManagerPtr cbm =
 397                 DPL::StaticPointerCast<JSContactManagerChangeCallbackManager>(event->getPrivateData());
 398         if (!cbm)
 399         {
 400                 LoggerE("no callback manager");
 401                 return;
 402         }
 403
 404         EventInfoContactManagerChangePtr _eventInfo = event->getEventInfo();
 405         if(_eventInfo->getCallbackType() != EventInfoContactManagerChange::OnPersonsRemoved)
 406         {
 407                 LoggerE("wrong type");
 408                 return;
 409         }
 410
 411         EventInfoContactManagerChangeRemovedPtr eventInfo = DPL::DynamicPointerCast<EventInfoContactManagerChangeRemoved>(_eventInfo);
 412         if (!eventInfo->getPersonIdsIsSet())
 413         {
 414                 LoggerE("no data set");
 415                 return;
 416         }
 417
 418         ContactConverterFactory::ConverterType converter =
 419                         ContactConverterFactory::getConverter(cbm->getContext());
 420
 421         JSValueRef contactIds;
 422         Try {
 423                 contactIds = converter->toJSValueRef(eventInfo->getPersonIds());
 424         } Catch (Exception) {
 425                 LoggerE("Conversion error");
 426                 return;
 427         }
 428
 429         cbm->callOnPersonsDeleted(contactIds);
 430 }
 431
 432 void ContactManagerController::OnAnswerReceived(const EventContactManagerGetAddressBooksPtr &event)
 433 {
 434         ContactManagerAsyncAnswerHandler::getAddressBooks(event, this);
 435 }
 436
 437 void ContactManagerController::OnAnswerReceived(const EventContactManagerUpdateBatchPtr &event)
 438 {
 439         ContactManagerAsyncAnswerHandler::updateBatch(event);
 440 }
 441
 442 void ContactManagerController::OnAnswerReceived(const EventContactManagerRemoveBatchPtr &event)
 443 {
 444         ContactManagerAsyncAnswerHandler::removeBatch(event);
 445 }
 446
 447 void ContactManagerController::OnAnswerReceived(const EventContactManagerFindPtr &event)
 448 {
 449         ContactManagerAsyncAnswerHandler::find(event, this);
 450 }
 451
 452 void ContactManagerController::onAnswerReceived(const EventContactManagerChangeListenerPtr &event)
 453 {
 454         EventInfoContactManagerChangePtr eventInfo = event->getEventInfo();
 455         if(eventInfo == NULL)
 456         {
 457                 LoggerE("wrong type");
 458                 return;
 459         }
 460
 461         EventInfoContactManagerChange::CallbackType type = eventInfo->getCallbackType();
 462         if(type == EventInfoContactManagerChange::OnPersonsAdded)
 463                 ContactManagerAsyncAnswerHandler::changeListenerPersonAdded(event, this);
 464         else if(type == EventInfoContactManagerChange::OnPersonsUpdated)
 465                 ContactManagerAsyncAnswerHandler::changeListenerPersonUpdated(event, this);
 466         else if(type == EventInfoContactManagerChange::OnPersonsRemoved)
 467                 ContactManagerAsyncAnswerHandler::changeListenerPersonRemoved(event);
 468         else if(type == EventInfoContactManagerChange::OnError)
 469                 ContactManagerAsyncAnswerHandler::changeListenerError(event);
 470 }
 471
 472 } // Contact
 473 } // DeviceAPI