src/Contact/AddressBookController.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 <JSTizenExceptionFactory.h>
  27 #include <JSTizenException.h>
  28 #include "AddressBookController.h"
  29 #include "ContactConverter.h"
  30 #include "JSAddressBookChangeCallbackManager.h"
  31 #include "ContactAsyncCallbackManager.h"
  32 #include "ContactQueue.h"
  33 #include <Logger.h>
  34
  35 namespace DeviceAPI {
  36 namespace Contact {
  37
  38 using namespace DeviceAPI::Common;
  39 using namespace WrtDeviceApis::Commons;
  40 using namespace WrtDeviceApis::CommonsJavaScript;
  41
  42 AddressBookController::AddressBookController(JSContextRef context, AddressBookPtr addressBook) :
  43                 EventAddressBookAddBatchEventAnswerReceiver(ThreadEnum::NULL_THREAD),
  44                 EventAddressBookUpdateBatchEventAnswerReceiver(ThreadEnum::NULL_THREAD),
  45                 EventAddressBookRemoveBatchEventAnswerReceiver(ThreadEnum::NULL_THREAD),
  46                 EventAddressBookFindEventAnswerReceiver(ThreadEnum::NULL_THREAD),
  47                 EventAddressBookChangeListenerListener(ThreadEnum::NULL_THREAD),
  48                 AddressBookPrivObject(context, addressBook)
  49 {
  50         LoggerD("AddressBookController constructed : " << this);
  51         if (!addressBook) {
  52                 LoggerW("controller has no addressBook object");
  53         }
  54 }
  55
  56 AddressBookController::~AddressBookController()
  57 {
  58         LoggerD("AddressBookController destructed : " << this);
  59 }
  60
  61 void AddressBookAsyncAnswerHandler::addBatch(const EventAddressBookAddBatchPtr &event)
  62 {
  63         LoggerD("entered");
  64         ContactQueueManagerSingleton::Instance().decreaseQueueList();
  65         bool isEmpty = ContactQueueManagerSingleton::Instance().empty();
  66         if(!isEmpty){
  67                 ContactQueueManagerSingleton::Instance().pop();
  68         }
  69
  70         JSCallbackManagerPtr callbackManager =
  71                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  72         if (!callbackManager) {
  73                 LoggerE("no callback manager");
  74                 return;
  75         }
  76
  77         ContactAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
  78
  79         if(event->checkCancelled()) {
  80                 LoggerD("Operation cancelled");
  81                 return;
  82         }
  83
  84         JSContextRef gContext = callbackManager->getContext();
  85
  86         JSValueRef error = NULL;
  87         if (ExceptionCodes::None != event->getExceptionCode())
  88         {
  89                 switch (event->getExceptionCode())
  90                 {
  91                 case ExceptionCodes::PlatformException:
  92                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
  93                         break;
  94                 case ExceptionCodes::InvalidArgumentException:
  95                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Invalid value error");
  96                         break;
  97                 case ExceptionCodes::ConversionException:
  98                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
  99                         break;
 100                 default:
 101                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
 102                         break;
 103                 }
 104
 105                 callbackManager->callOnError(error);
 106                 return;
 107         }
 108
 109         Try {
 110                 if (!event->getResult())
 111                         ThrowMsg(PlatformException, "No result.");
 112
 113                 ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(gContext);
 114                 ContactArrayPtr contacts = event->getContacts();
 115
 116                 JSValueRef result = converter->toJSValueRef(contacts);
 117
 118                 callbackManager->callOnSuccess(result);
 119                 return;
 120         } Catch(Exception) {
 121                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 122                 error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
 123
 124                 callbackManager->callOnError(error);
 125                 return;
 126         }
 127 }
 128
 129 void AddressBookAsyncAnswerHandler::updateBatch(const EventAddressBookUpdateBatchPtr &event)
 130 {
 131         LoggerD("entered");
 132         ContactQueueManagerSingleton::Instance().decreaseQueueList();
 133         bool isEmpty = ContactQueueManagerSingleton::Instance().empty();
 134         if(!isEmpty){
 135                 ContactQueueManagerSingleton::Instance().pop();
 136         }
 137
 138         JSCallbackManagerPtr callbackManager =
 139                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 140         if (!callbackManager) {
 141                 LoggerE("no callback manager");
 142                 return;
 143         }
 144
 145         ContactAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 146
 147         if(event->checkCancelled()) {
 148                 LoggerD("Operation cancelled");
 149                 return;
 150         }
 151
 152         JSContextRef gContext = callbackManager->getContext();
 153
 154         JSValueRef error = NULL;
 155         if (ExceptionCodes::None != event->getExceptionCode())
 156         {
 157                 switch (event->getExceptionCode())
 158                 {
 159                 case ExceptionCodes::PlatformException:
 160                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
 161                         break;
 162                 case ExceptionCodes::NotFoundException:
 163                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
 164                         break;
 165                 case ExceptionCodes::InvalidArgumentException:
 166                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Invalid value error");
 167                         break;
 168                 case ExceptionCodes::ConversionException:
 169                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
 170                         break;
 171                 default:
 172                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
 173                         break;
 174                 }
 175
 176                 callbackManager->callOnError(error);
 177                 return;
 178         }
 179
 180         callbackManager->callOnSuccess();
 181 }
 182
 183 void AddressBookAsyncAnswerHandler::removeBatch(const EventAddressBookRemoveBatchPtr &event)
 184 {
 185         LoggerD("entered");
 186         ContactQueueManagerSingleton::Instance().decreaseQueueList();
 187         bool isEmpty = ContactQueueManagerSingleton::Instance().empty();
 188         if(!isEmpty){
 189                 ContactQueueManagerSingleton::Instance().pop();
 190         }
 191
 192         JSCallbackManagerPtr callbackManager =
 193                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 194         if (!callbackManager) {
 195                 LoggerE("no callback manager");
 196                 return;
 197         }
 198
 199         ContactAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 200
 201         if(event->checkCancelled()) {
 202                 LoggerD("Operation cancelled");
 203                 return;
 204         }
 205
 206         JSContextRef gContext = callbackManager->getContext();
 207
 208         JSValueRef error = NULL;
 209         if (ExceptionCodes::None != event->getExceptionCode())
 210         {
 211                 switch (event->getExceptionCode())
 212                 {
 213                 case ExceptionCodes::PlatformException:
 214                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
 215                         break;
 216                 case ExceptionCodes::NotFoundException:
 217                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "record not found");
 218                         break;
 219                 case ExceptionCodes::InvalidArgumentException:
 220                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Invalid value error");
 221                         break;
 222                 case ExceptionCodes::ConversionException:
 223                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
 224                         break;
 225                 default:
 226                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
 227                         break;
 228                 }
 229                 callbackManager->callOnError(error);
 230                 return;
 231         }
 232
 233         callbackManager->callOnSuccess();
 234 }
 235
 236 void AddressBookAsyncAnswerHandler::find(const EventAddressBookFindPtr &event)
 237 {
 238         LoggerD("entered");
 239         JSCallbackManagerPtr callbackManager =
 240                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 241         if (!callbackManager)
 242         {
 243                 LoggerE("no callback manager");
 244                 return;
 245         }
 246
 247         ContactAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 248
 249         if(event->checkCancelled()) {
 250                 LoggerD("Operation cancelled");
 251                 return;
 252         }
 253
 254         JSContextRef gContext = callbackManager->getContext();
 255
 256         JSValueRef error = NULL;
 257         if (ExceptionCodes::None != event->getExceptionCode())
 258         {
 259                 switch (event->getExceptionCode())
 260                 {
 261                 case ExceptionCodes::PlatformException:
 262                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_SUPPORTED_ERROR, "Not support such a filter");
 263                         break;
 264                 case ExceptionCodes::InvalidArgumentException:
 265                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Invalid value error");
 266                         break;
 267                 case ExceptionCodes::ConversionException:
 268                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::TYPE_MISMATCH_ERROR, "Wrong argument");
 269                         break;
 270                 default:
 271                         error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
 272                         break;
 273                 }
 274
 275                 callbackManager->callOnError(error);
 276                 return;
 277         }
 278
 279         Try {
 280                 if (!event->getResult())
 281                         ThrowMsg(PlatformException, "No result.");
 282
 283                 ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(gContext);
 284                 ContactArrayPtr contacts = event->getContacts();
 285
 286                 JSValueRef result = converter->toJSValueRef(contacts);
 287
 288                 callbackManager->callOnSuccess(result);
 289                 return;
 290         } Catch(Exception) {
 291                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 292                 error = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Internal error");
 293
 294                 callbackManager->callOnError(error);
 295                 return;
 296         }
 297 }
 298
 299 void AddressBookAsyncAnswerHandler::changeListenerError(const EventAddressBookChangeListenerPtr &event)
 300 {
 301         LoggerD("entered");
 302         JSValueRef errorObject;
 303
 304         JSCallbackManagerPtr cbm = DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 305         if (!cbm)
 306         {
 307                 LoggerE("no callback manager");
 308                 return;
 309         }
 310
 311         JSContextRef gContext = cbm->getContext();
 312
 313         if (event->getExceptionCode() == ExceptionCodes::NotFoundException)
 314                 errorObject = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::NOT_FOUND_ERROR, "Not found error");
 315         else
 316                 errorObject = JSTizenExceptionFactory::makeErrorObject(gContext, JSTizenException::UNKNOWN_ERROR, "Unknown error");
 317
 318         cbm->callOnError(errorObject);
 319 }
 320
 321 void AddressBookAsyncAnswerHandler::changeListenerContactAdded(const EventAddressBookChangeListenerPtr &event)
 322 {
 323         LoggerD("entered");
 324         JSAddressBookChangeCallbackManagerPtr cbm =
 325                 DPL::StaticPointerCast<JSAddressBookChangeCallbackManager>(event->getPrivateData());
 326         if (!cbm)
 327         {
 328                 LoggerE("no callback manager");
 329                 return;
 330         }
 331
 332         EventInfoAddressBookChangePtr _eventInfo = event->getEventInfo();
 333         if(_eventInfo->getCallbackType() != EventInfoAddressBookChange::OnContactsAdded)
 334         {
 335                 LoggerE("wrong type");
 336                 return;
 337         }
 338
 339         EventInfoAddressBookChangeAddedPtr eventInfo = DPL::DynamicPointerCast<EventInfoAddressBookChangeAdded>(_eventInfo);
 340
 341         if (!eventInfo->getContactsIsSet())
 342         {
 343                 LoggerE("no data set");
 344                 return;
 345         }
 346
 347         ContactConverterFactory::ConverterType converter =
 348                         ContactConverterFactory::getConverter(cbm->getContext());
 349
 350         JSValueRef contacts;
 351         Try {
 352                 contacts = converter->toJSValueRef(eventInfo->getContacts());
 353         } Catch (Exception) {
 354                 LoggerE("Conversion error");
 355                 return;
 356         }
 357
 358         cbm->callOnContactsAdded(contacts);
 359 }
 360
 361 void AddressBookAsyncAnswerHandler::changeListenerContactUpdated(const EventAddressBookChangeListenerPtr &event)
 362 {
 363         LoggerD("entered");
 364         JSAddressBookChangeCallbackManagerPtr cbm =
 365                 DPL::StaticPointerCast<JSAddressBookChangeCallbackManager>(event->getPrivateData());
 366         if (!cbm)
 367         {
 368                 LoggerE("no callback manager");
 369                 return;
 370         }
 371
 372         EventInfoAddressBookChangePtr _eventInfo = event->getEventInfo();
 373         if(_eventInfo->getCallbackType() != EventInfoAddressBookChange::OnContactsUpdated)
 374         {
 375                 LoggerE("wrong type");
 376                 return;
 377         }
 378
 379         EventInfoAddressBookChangeUpdatedPtr eventInfo = DPL::DynamicPointerCast<EventInfoAddressBookChangeUpdated>(_eventInfo);
 380
 381         if (!eventInfo->getContactsIsSet())
 382         {
 383                 LoggerE("no data set");
 384                 return;
 385         }
 386
 387         ContactConverterFactory::ConverterType converter =
 388                         ContactConverterFactory::getConverter(cbm->getContext());
 389
 390         JSValueRef contacts;
 391         Try {
 392                 contacts = converter->toJSValueRef(eventInfo->getContacts());
 393         } Catch (Exception) {
 394                 LoggerE("Conversion error");
 395                 return;
 396         }
 397
 398         cbm->callOnContactsUpdated(contacts);
 399 }
 400
 401 void AddressBookAsyncAnswerHandler::changeListenerContactRemoved(const EventAddressBookChangeListenerPtr &event)
 402 {
 403         LoggerD("entered");
 404         JSAddressBookChangeCallbackManagerPtr cbm =
 405                 DPL::StaticPointerCast<JSAddressBookChangeCallbackManager>(event->getPrivateData());
 406         if (!cbm)
 407         {
 408                 LoggerE("no callback manager");
 409                 return;
 410         }
 411
 412         EventInfoAddressBookChangePtr _eventInfo = event->getEventInfo();
 413         if(_eventInfo->getCallbackType() != EventInfoAddressBookChange::OnContactsRemoved)
 414         {
 415                 LoggerE("wrong type");
 416                 return;
 417         }
 418
 419         EventInfoAddressBookChangeRemovedPtr eventInfo = DPL::DynamicPointerCast<EventInfoAddressBookChangeRemoved>(_eventInfo);
 420         if (!eventInfo->getContactIdsIsSet())
 421         {
 422                 LoggerE("no data set");
 423                 return;
 424         }
 425
 426         ContactConverterFactory::ConverterType converter =
 427                         ContactConverterFactory::getConverter(cbm->getContext());
 428
 429         JSValueRef contactIds;
 430         Try {
 431                 contactIds = converter->toJSValueRef(eventInfo->getContactIds());
 432         } Catch (Exception) {
 433                 LoggerE("Conversion error");
 434                 return;
 435         }
 436
 437         cbm->callOnContactsDeleted(contactIds);
 438 }
 439
 440 void AddressBookController::OnAnswerReceived(const EventAddressBookAddBatchPtr &event)
 441 {
 442         AddressBookAsyncAnswerHandler::addBatch(event);
 443 }
 444
 445 void AddressBookController::OnAnswerReceived(const EventAddressBookUpdateBatchPtr &event)
 446 {
 447         AddressBookAsyncAnswerHandler::updateBatch(event);
 448 }
 449
 450 void AddressBookController::OnAnswerReceived(const EventAddressBookRemoveBatchPtr &event)
 451 {
 452         AddressBookAsyncAnswerHandler::removeBatch(event);
 453 }
 454
 455 void AddressBookController::OnAnswerReceived(const EventAddressBookFindPtr &event)
 456 {
 457         AddressBookAsyncAnswerHandler::find(event);
 458 }
 459
 460 void AddressBookController::onAnswerReceived(const EventAddressBookChangeListenerPtr &event)
 461 {
 462         EventInfoAddressBookChangePtr eventInfo = event->getEventInfo();
 463         if(eventInfo == NULL)
 464         {
 465                 LoggerE("wrong type");
 466                 return;
 467         }
 468
 469         EventInfoAddressBookChange::CallbackType type = eventInfo->getCallbackType();
 470         if(type == EventInfoAddressBookChange::OnContactsAdded)
 471                 AddressBookAsyncAnswerHandler::changeListenerContactAdded(event);
 472         else if(type == EventInfoAddressBookChange::OnContactsUpdated)
 473                 AddressBookAsyncAnswerHandler::changeListenerContactUpdated(event);
 474         else if(type == EventInfoAddressBookChange::OnContactsRemoved)
 475                 AddressBookAsyncAnswerHandler::changeListenerContactRemoved(event);
 476         else if(type == EventInfoAddressBookChange::OnError)
 477                 AddressBookAsyncAnswerHandler::changeListenerError(event);
 478 }
 479
 480 } // Contact
 481 } // DeviceAPI