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