src/modules/API/Messaging/ReqReceiverMessage.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  * @file       ReqReceiverMessage.cpp
  18  * @author     Pawel Misiak (p.misiak@samsung.com)
  19  * @version    0.1
  20  * @brief
  21  */
  22
  23 #include "ReqReceiverMessage.h"
  24 #include <vector>
  25 #include <dpl/singleton_impl.h>
  26 #include <Commons/Exception.h>
  27 #include "IMessaging.h"
  28 #include "IMessage.h"
  29
  30 using namespace std;
  31 using namespace WrtDeviceApis;
  32 using namespace WrtDeviceApis::Commons;
  33
  34 IMPLEMENT_SINGLETON(WrtDeviceApis::Messaging::Api::ReqReceiverMessage)
  35
  36 namespace WrtDeviceApis {
  37 namespace Messaging {
  38 namespace Api {
  39
  40 ReqReceiverMessage::ReqReceiverMessage() :
  41     EventSendMessageReqReceiver(Commons::ThreadEnum::MESSAGING_THREAD),
  42     EventUpdateMessageReqReceiver(Commons::ThreadEnum::MESSAGING_THREAD),
  43     EventDeleteMessageReqReceiver(Commons::ThreadEnum::MESSAGING_THREAD),
  44     EventFindMessageReqReceiver(Commons::ThreadEnum::MESSAGING_THREAD)
  45 {
  46     LogDebug("create receiver for messaging");
  47 }
  48
  49 ReqReceiverMessage::~ReqReceiverMessage()
  50 {
  51 }
  52
  53 void ReqReceiverMessage::sendMessage(const EventSendMessagePtr& event)
  54 {
  55     LogDebug("enter");
  56     EventSendMessageReqReceiver::PostRequest(event);
  57 }
  58
  59 void ReqReceiverMessage::updateMessage(const EventUpdateMessagePtr& event)
  60 {
  61     LogDebug("enter");
  62     EventUpdateMessageReqReceiver::PostRequest(event);
  63 }
  64
  65 void ReqReceiverMessage::deleteMessage(const EventDeleteMessagePtr& event)
  66 {
  67     LogDebug("enter");
  68     EventDeleteMessageReqReceiver::PostRequest(event);
  69 }
  70
  71 void ReqReceiverMessage::findMessage(const EventFindMessagePtr& event)
  72 {
  73     LogDebug("enter");
  74     EventFindMessageReqReceiver::PostRequest(event);
  75 }
  76
  77 void ReqReceiverMessage::OnRequestReceived(const EventSendMessagePtr& event)
  78 {
  79     LogDebug("enter");
  80
  81     Try {
  82         IMessagePtr msg = event->getMessage();
  83         //this prevents calling BONDI, WAC2.0 callback immidiately after leaving this function
  84         //callback will be called after receving Commons callback.
  85         msg->setRequestReceiver(this);
  86         msg->setSendMessageEvent(event);
  87         if (!event->checkCancelled()) {
  88             event->setCancelAllowed(false);
  89             event->switchToManualAnswer();
  90             msg->send();
  91         } else {
  92             event->setCancelAllowed(true);
  93         }
  94     }
  95     Catch(Commons::PlatformException) {
  96         event->setExceptionCode(Commons::ExceptionCodes::UnknownException);
  97         Commons::EventRequestReceiver< EventSendMessage >::ManualAnswer(event);
  98     }
  99 }
 100
 101 void ReqReceiverMessage::OnRequestReceived(const EventUpdateMessagePtr& event)
 102 {
 103     LogDebug("enter");
 104
 105     Try {
 106         IMessagePtr msg = event->msg;
 107         if (!event->checkCancelled()) {
 108             event->setCancelAllowed(false);
 109             msg->update(true);
 110         } else {
 111             event->setCancelAllowed(true);
 112         }
 113     }
 114     Catch(Commons::PlatformException) {
 115         LogError("Commons exception");
 116         event->setExceptionCode(Commons::ExceptionCodes::UnknownException);
 117     }
 118 }
 119
 120 void ReqReceiverMessage::OnRequestReceived(const EventDeleteMessagePtr& event)
 121 {
 122     LogDebug("enter");
 123
 124     Try {
 125         IMessagePtr msg = event->msg;
 126         msg->remove();
 127     }
 128     Catch(Commons::PlatformException) {
 129         LogError("Commons exception");
 130         event->setExceptionCode(Commons::ExceptionCodes::UnknownException);
 131     }
 132 }
 133
 134 void ReqReceiverMessage::OnRequestReceived(const EventFindMessagePtr& event)
 135 {
 136     LogDebug("enter");
 137
 138     Try {
 139         if (!event->checkCancelled()) {
 140             vector<IMessagePtr> msgs;
 141             for (size_t i = 0; i < event->folderTypes.size(); i++) {
 142                 vector<IMessagePtr> tmp =
 143                     IMessaging::getInstance().findMessages(
 144                         event->messageTypes,
 145                         event->folderTypes[i],
 146                         event->messageFilter);
 147                 msgs.insert(msgs.end(), tmp.begin(), tmp.end());
 148             }
 149             event->msgs = msgs;
 150         }
 151         //this is only searching so can be cancelled at any time
 152         event->setCancelAllowed(true);
 153     }
 154     Catch(Commons::PlatformException) {
 155         LogError("Commons exception");
 156         event->setExceptionCode(Commons::ExceptionCodes::UnknownException);
 157     }
 158 }
 159 }}
 160 }