src/io/FIo_ChannelServiceProxy.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   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        FIo_ChannelServiceProxy.cpp
  19  * @brief       This is the implementation file for the _ChannelServiceProxy class.
  20  *
  21  */
  22
  23 #include <string.h>
  24 #include <unique_ptr.h>
  25
  26 #include <FBaseSysLog.h>
  27 #include <FAppPkg_PackageManagerImpl.h>
  28 #include <FApp_AppInfo.h>
  29 #include "FIo_IpcClient.h"
  30 #include "FIo_ChannelServiceProxy.h"
  31 #include "FIo_ChannelMessages.h"
  32
  33 using namespace std;
  34
  35 using namespace Tizen::App;
  36 using namespace Tizen::App::Package;
  37 using namespace Tizen::Io;
  38 using namespace Tizen::Base;
  39 using namespace Tizen::Base::Collection;
  40 using namespace Tizen::Base::Runtime;
  41
  42 namespace Tizen { namespace Io
  43 {
  44
  45 _ChannelServiceProxy::_ChannelServiceProxy(void)
  46         : __pIpcClient(null)
  47 {
  48
  49 }
  50
  51 _ChannelServiceProxy::~_ChannelServiceProxy(void)
  52 {
  53
  54 }
  55
  56 result
  57 _ChannelServiceProxy::Construct(void)
  58 {
  59         SysAssertf(__pIpcClient == null, "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class.");
  60
  61         result r = E_SUCCESS;
  62         static _StringHashProvider hashProvider;
  63         static _StringComparer stringComparer;
  64
  65         __listeners.Construct(0, 0, hashProvider, stringComparer);
  66
  67         unique_ptr<_IpcClient> pIpcClient(new (std::nothrow) _IpcClient);
  68         SysTryReturnResult(NID_IO, pIpcClient != null, E_OUT_OF_MEMORY, "Not enough memory.");
  69
  70         r = pIpcClient->Construct("osp.io.ipcserver.channelmanager", this);
  71         SysTryReturn(NID_IO, r == E_SUCCESS, r, r, "[%s] Failed to connect to the IPC server.", GetErrorMessage(r));
  72
  73         __pIpcClient = pIpcClient.release();
  74
  75         return E_SUCCESS;
  76 }
  77
  78
  79 void
  80 _ChannelServiceProxy::OnIpcResponseReceived(_IpcClient& client, const IPC::Message& message)
  81 {
  82         IPC_BEGIN_MESSAGE_MAP(_ChannelServiceProxy, message)
  83         IPC_MESSAGE_HANDLER_EX(ChannelServiceMsg_sendRequestAsync, &client, OnSendRequestMessage)
  84         IPC_MESSAGE_HANDLER_EX(ChannelServiceMsg_sendNullRequestAsync, &client, OnSendNullRequestMessage)
  85         IPC_MESSAGE_HANDLER_EX(ChannelServiceMsg_sendResponseAsync, &client, OnSendResponseMessage)
  86         IPC_MESSAGE_HANDLER_EX(ChannelServiceMsg_sendNullResponseAsync, &client, OnSendNullResponseMessage)
  87         IPC_END_MESSAGE_MAP_EX()
  88 }
  89
  90
  91 result
  92 _ChannelServiceProxy::RegisterChannel(const String& channelId,
  93                                                                    const _IChannelServiceEventListener& listener)
  94 {
  95         SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
  96
  97         SysLog(NID_IO, "Register a channel : %ls", channelId.GetPointer());
  98
  99         result r = E_SUCCESS;
 100         int ret = 0;
 101         bool contain = false;
 102         String key = channelId;
 103
 104         __listeners.ContainsKey(key, contain);
 105
 106         if (!contain)
 107         {
 108                 __listeners.Add(key, const_cast<_IChannelServiceEventListener*>(&listener));
 109
 110         }
 111         else
 112         {
 113                 __listeners.SetValue(key, const_cast<_IChannelServiceEventListener*>(&listener));
 114         }
 115
 116         unique_ptr<IPC::Message> pMsg(new (std::nothrow) ChannelServiceMsg_register(channelId, &ret));
 117         SysTryReturnResult(NID_IO, pMsg != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 118
 119         r = __pIpcClient->SendRequest(pMsg.get());
 120         SysTryReturn(NID_IO, r == E_SUCCESS, r, r, "[%s] Failed to register a channel.", GetErrorMessage(r));
 121         SysTryReturn(NID_IO, ret == E_SUCCESS, ret, ret, "[%s] Failed to register a channel.", GetErrorMessage(ret));
 122
 123         return E_SUCCESS;
 124 }
 125
 126 result
 127 _ChannelServiceProxy::UnregisterChannel(const String& channelId)
 128 {
 129         SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
 130
 131         SysLog(NID_IO, "Unregister a channel : %ls", channelId.GetPointer());
 132
 133         result r = E_SUCCESS;
 134
 135         String key = channelId;
 136
 137         r = __listeners.Remove(key);
 138         SysTryReturnResult(NID_IO, !IsFailed(r), E_OBJ_NOT_FOUND, "Failed to unregister a channel.");
 139
 140         return E_SUCCESS;
 141 }
 142
 143 result
 144 _ChannelServiceProxy::SendRequest(const String& src,
 145                                                          const String& dest,
 146                                                          const ArrayList& args,
 147                                                          int messageId)
 148 {
 149         SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
 150
 151         SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
 152
 153         result r = E_SUCCESS;
 154         int ret = 0;
 155
 156         unique_ptr<IPC::Message> pMsg(new (std::nothrow) ChannelServiceMsg_sendRequest(src, dest, args, messageId, &ret));
 157         SysTryReturnResult(NID_IO, pMsg != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 158
 159         r = __pIpcClient->SendRequest(pMsg.get());
 160         SysTryReturn(NID_IO, r == E_SUCCESS, r, r, "[%s] Failed to send a request.", GetErrorMessage(r));
 161         SysTryReturn(NID_IO, ret == E_SUCCESS, ret, ret, "[%s] Failed to send a request.", GetErrorMessage(ret));
 162
 163         return E_SUCCESS;
 164 }
 165
 166 result
 167 _ChannelServiceProxy::SendNullRequest(const String& src,
 168                                                          const String& dest,
 169                                                          int messageId)
 170 {
 171         SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
 172
 173         SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
 174
 175         result r = E_SUCCESS;
 176         int ret = 0;
 177
 178         unique_ptr<IPC::Message> pMsg(new (std::nothrow) ChannelServiceMsg_sendNullRequest(src, dest, messageId, &ret));
 179         SysTryReturnResult(NID_IO, pMsg != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 180
 181         r = __pIpcClient->SendRequest(pMsg.get());
 182         SysTryReturn(NID_IO, r == E_SUCCESS, r, r, "[%s] Failed to send a request.", GetErrorMessage(r));
 183         SysTryReturn(NID_IO, ret == E_SUCCESS, ret, ret, "[%s] Failed to send a request.", GetErrorMessage(ret));
 184
 185         return E_SUCCESS;
 186 }
 187
 188 result
 189 _ChannelServiceProxy::SendResponse(const String& src,
 190                                                           const String& dest,
 191                                                           const ArrayList& args,
 192                                                           int messageId)
 193 {
 194         SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
 195
 196         SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
 197
 198         result r = E_SUCCESS;
 199         int ret = 0;
 200
 201         unique_ptr<IPC::Message> pMsg(new (std::nothrow) ChannelServiceMsg_sendResponse(src, dest, args, messageId, &ret));
 202         SysTryReturnResult(NID_IO, pMsg != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 203
 204         r = __pIpcClient->SendRequest(pMsg.get());
 205
 206         SysTryReturn(NID_IO, r == E_SUCCESS, r, r, "[%s] Failed to send a request.", GetErrorMessage(r));
 207         SysTryReturn(NID_IO, ret == E_SUCCESS, ret, ret, "[%s] Failed to send a request.", GetErrorMessage(ret));
 208
 209         return E_SUCCESS;
 210 }
 211
 212 result
 213 _ChannelServiceProxy::SendNullResponse(const String& src,
 214                                                           const String& dest,
 215                                                           int messageId)
 216 {
 217         SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
 218
 219         SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
 220
 221         result r = E_SUCCESS;
 222         int ret = 0;
 223
 224         unique_ptr<IPC::Message> pMsg(new (std::nothrow) ChannelServiceMsg_sendNullResponse(src, dest, messageId, &ret));
 225         SysTryReturnResult(NID_IO, pMsg != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 226
 227         r = __pIpcClient->SendRequest(pMsg.get());
 228
 229         SysTryReturn(NID_IO, r == E_SUCCESS, r, r, "[%s] Failed to send a request.", GetErrorMessage(r));
 230         SysTryReturn(NID_IO, ret == E_SUCCESS, ret, ret, "[%s] Failed to send a request.", GetErrorMessage(ret));
 231
 232         return E_SUCCESS;
 233 }
 234
 235 bool
 236 _ChannelServiceProxy::OnSendRequestMessage(const String& src, const String& dest, const ArrayList& args, int requestId)
 237 {
 238         SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
 239
 240         _IChannelServiceEventListener* pListener = null;
 241
 242         String key = dest;
 243
 244         __listeners.GetValue(key, pListener);
 245
 246         if (pListener)
 247         {
 248                 int argCount = args.GetCount();
 249                 Object* pObject = null;
 250                 ArrayList* pArrayList = new (std::nothrow) ArrayList;
 251                 if (pArrayList == null)
 252                 {
 253                         const_cast<ArrayList*>(&args)->RemoveAll(true);
 254                         return false;
 255                 }
 256
 257                 pArrayList->Construct();
 258
 259                 for (int i = 0; i < argCount; i++)
 260                 {
 261                         pObject = (Object*)args.GetAt(i);
 262                         pArrayList->Add(*pObject);
 263                 }
 264
 265                 pListener->OnChannelRequestReceivedN(src, dest, requestId, pArrayList);
 266
 267                 const_cast<ArrayList*>(&args)->RemoveAll(false);
 268
 269                 return true;
 270         }
 271         else
 272         {
 273                 const_cast<ArrayList*>(&args)->RemoveAll(true);
 274         }
 275
 276         return false;
 277 }
 278
 279 bool
 280 _ChannelServiceProxy::OnSendNullRequestMessage(const String& src, const String& dest, int requestId)
 281 {
 282         SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
 283
 284         _IChannelServiceEventListener* pListener = null;
 285
 286         String key = dest;
 287
 288         __listeners.GetValue(key, pListener);
 289
 290         if (pListener)
 291         {
 292                 pListener->OnChannelRequestReceivedN(src, dest, requestId, null);
 293
 294                 return true;
 295         }
 296
 297         return false;
 298 }
 299
 300 bool
 301 _ChannelServiceProxy::OnSendResponseMessage(const String& src, const String& dest, const ArrayList& args, int requestId)
 302 {
 303         SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
 304
 305         _IChannelServiceEventListener* pListener = null;
 306
 307         String key = dest;
 308
 309         __listeners.GetValue(key, pListener);
 310
 311         if (pListener)
 312         {
 313                 int argCount = args.GetCount();
 314                 Object* pObject = null;
 315                 ArrayList* pArrayList = new (std::nothrow) ArrayList;
 316                 if (pArrayList == null)
 317                 {
 318                         const_cast<ArrayList*>(&args)->RemoveAll(true);
 319                         return false;
 320                 }
 321
 322                 pArrayList->Construct();
 323
 324                 for (int i = 0; i < argCount; i++)
 325                 {
 326                         pObject = (Object*)args.GetAt(i);
 327                         pArrayList->Add(*pObject);
 328                 }
 329
 330                 pListener->OnChannelResponseReceivedN(src, dest, requestId, pArrayList);
 331
 332                 const_cast<ArrayList*>(&args)->RemoveAll(false);
 333
 334                 return true;
 335         }
 336         else
 337         {
 338                 const_cast<ArrayList*>(&args)->RemoveAll(true);
 339         }
 340
 341         return false;
 342 }
 343
 344 bool
 345 _ChannelServiceProxy::OnSendNullResponseMessage(const String& src, const String& dest, int requestId)
 346 {
 347         SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
 348
 349         _IChannelServiceEventListener* pListener = null;
 350
 351         String key = dest;
 352
 353         __listeners.GetValue(key, pListener);
 354
 355         if (pListener)
 356         {
 357                 pListener->OnChannelResponseReceivedN(src, dest, requestId, null);
 358         }
 359
 360         return false;
 361 }
 362
 363 }}