src/io/FIo_ChannelServiceProxy.cpp

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