2 // Open Service Platform
3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
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
9 // http://www.apache.org/licenses/LICENSE-2.0
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.
19 * @file FIo_ChannelServiceProxy.cpp
20 * @brief This is the implementation file for the _ChannelServiceProxy class.
25 #include <unique_ptr.h>
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"
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;
43 namespace Tizen { namespace Io
46 _ChannelServiceProxy::_ChannelServiceProxy(void)
52 _ChannelServiceProxy::~_ChannelServiceProxy(void)
58 _ChannelServiceProxy::Construct(void)
60 SysAssertf(__pIpcClient == null, "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class.");
63 static _StringHashProvider hashProvider;
64 static _StringComparer stringComparer;
66 __listeners.Construct(0, 0, hashProvider, stringComparer);
68 unique_ptr<_IpcClient> pIpcClient(new (std::nothrow) _IpcClient);
69 SysTryReturnResult(NID_IO, pIpcClient != null, E_OUT_OF_MEMORY, "Not enough memory.");
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));
74 __pIpcClient = pIpcClient.release();
81 _ChannelServiceProxy::OnIpcResponseReceived(_IpcClient& client, const IPC::Message& message)
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()
93 _ChannelServiceProxy::RegisterChannel(const String& channelId,
94 const _IChannelServiceEventListener& listener)
96 SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
98 SysLog(NID_IO, "Register a channel : %ls", channelId.GetPointer());
100 result r = E_SUCCESS;
102 bool contain = false;
103 String key = channelId;
105 __listeners.ContainsKey(key, contain);
109 __listeners.Add(key, const_cast<_IChannelServiceEventListener*>(&listener));
114 __listeners.SetValue(key, const_cast<_IChannelServiceEventListener*>(&listener));
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.");
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));
128 _ChannelServiceProxy::UnregisterChannel(const String& channelId)
130 SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
132 SysLog(NID_IO, "Unregister a channel : %ls", channelId.GetPointer());
134 result r = E_SUCCESS;
136 String key = channelId;
138 r = __listeners.Remove(key);
139 SysTryReturnResult(NID_IO, !IsFailed(r), E_OBJ_NOT_FOUND, "Failed to unregister a channel.");
145 _ChannelServiceProxy::SendRequest(const String& src,
147 const ArrayList& args,
150 SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
152 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
154 result r = E_SUCCESS;
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.");
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));
168 _ChannelServiceProxy::SendNullRequest(const String& src,
172 SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
174 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
176 result r = E_SUCCESS;
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.");
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));
190 _ChannelServiceProxy::SendResponse(const String& src,
192 const ArrayList& args,
195 SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
197 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
199 result r = E_SUCCESS;
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.");
205 r = __pIpcClient->SendRequest(pMsg.get());
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));
214 _ChannelServiceProxy::SendNullResponse(const String& src,
218 SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
220 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
222 result r = E_SUCCESS;
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.");
228 r = __pIpcClient->SendRequest(pMsg.get());
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));
237 _ChannelServiceProxy::OnSendRequestMessage(const String& src, const String& dest, const ArrayList& args, int requestId)
239 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
241 _IChannelServiceEventListener* pListener = null;
245 __listeners.GetValue(key, pListener);
249 int argCount = args.GetCount();
250 Object* pObject = null;
251 ArrayList* pArrayList = new (std::nothrow) ArrayList;
252 if (pArrayList == null)
254 const_cast<ArrayList*>(&args)->RemoveAll(true);
258 pArrayList->Construct();
260 for (int i = 0; i < argCount; i++)
262 pObject = (Object*)args.GetAt(i);
263 pArrayList->Add(*pObject);
266 pListener->OnChannelRequestReceivedN(src, dest, requestId, pArrayList);
268 const_cast<ArrayList*>(&args)->RemoveAll(false);
274 const_cast<ArrayList*>(&args)->RemoveAll(true);
281 _ChannelServiceProxy::OnSendNullRequestMessage(const String& src, const String& dest, int requestId)
283 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
285 _IChannelServiceEventListener* pListener = null;
289 __listeners.GetValue(key, pListener);
293 pListener->OnChannelRequestReceivedN(src, dest, requestId, null);
302 _ChannelServiceProxy::OnSendResponseMessage(const String& src, const String& dest, const ArrayList& args, int requestId)
304 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
306 _IChannelServiceEventListener* pListener = null;
310 __listeners.GetValue(key, pListener);
314 int argCount = args.GetCount();
315 Object* pObject = null;
316 ArrayList* pArrayList = new (std::nothrow) ArrayList;
317 if (pArrayList == null)
319 const_cast<ArrayList*>(&args)->RemoveAll(true);
323 pArrayList->Construct();
325 for (int i = 0; i < argCount; i++)
327 pObject = (Object*)args.GetAt(i);
328 pArrayList->Add(*pObject);
331 pListener->OnChannelResponseReceivedN(src, dest, requestId, pArrayList);
333 const_cast<ArrayList*>(&args)->RemoveAll(false);
339 const_cast<ArrayList*>(&args)->RemoveAll(true);
346 _ChannelServiceProxy::OnSendNullResponseMessage(const String& src, const String& dest, int requestId)
348 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
350 _IChannelServiceEventListener* pListener = null;
354 __listeners.GetValue(key, pListener);
358 pListener->OnChannelResponseReceivedN(src, dest, requestId, null);