2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
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
8 // http://www.apache.org/licenses/LICENSE-2.0
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.
18 * @file FIo_ChannelServiceProxy.cpp
19 * @brief This is the implementation file for the _ChannelServiceProxy class.
24 #include <unique_ptr.h>
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"
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;
42 namespace Tizen { namespace Io
45 _ChannelServiceProxy::_ChannelServiceProxy(void)
51 _ChannelServiceProxy::~_ChannelServiceProxy(void)
57 _ChannelServiceProxy::Construct(void)
59 SysAssertf(__pIpcClient == null, "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class.");
62 static _StringHashProvider hashProvider;
63 static _StringComparer stringComparer;
65 __listeners.Construct(0, 0, hashProvider, stringComparer);
67 unique_ptr<_IpcClient> pIpcClient(new (std::nothrow) _IpcClient);
68 SysTryReturnResult(NID_IO, pIpcClient != null, E_OUT_OF_MEMORY, "Not enough memory.");
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));
73 __pIpcClient = pIpcClient.release();
80 _ChannelServiceProxy::OnIpcResponseReceived(_IpcClient& client, const IPC::Message& message)
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()
92 _ChannelServiceProxy::RegisterChannel(const String& channelId,
93 const _IChannelServiceEventListener& listener)
95 SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
97 SysLog(NID_IO, "Register a channel : %ls", channelId.GetPointer());
101 bool contain = false;
102 String key = channelId;
104 __listeners.ContainsKey(key, contain);
108 __listeners.Add(key, const_cast<_IChannelServiceEventListener*>(&listener));
113 __listeners.SetValue(key, const_cast<_IChannelServiceEventListener*>(&listener));
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.");
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));
127 _ChannelServiceProxy::UnregisterChannel(const String& channelId)
129 SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
131 SysLog(NID_IO, "Unregister a channel : %ls", channelId.GetPointer());
133 result r = E_SUCCESS;
135 String key = channelId;
137 r = __listeners.Remove(key);
138 SysTryReturnResult(NID_IO, !IsFailed(r), E_OBJ_NOT_FOUND, "Failed to unregister a channel.");
144 _ChannelServiceProxy::SendRequest(const String& src,
146 const ArrayList& args,
149 SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
151 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
153 result r = E_SUCCESS;
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.");
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));
167 _ChannelServiceProxy::SendNullRequest(const String& src,
171 SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
173 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
175 result r = E_SUCCESS;
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.");
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));
189 _ChannelServiceProxy::SendResponse(const String& src,
191 const ArrayList& args,
194 SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
196 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
198 result r = E_SUCCESS;
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.");
204 r = __pIpcClient->SendRequest(pMsg.get());
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));
213 _ChannelServiceProxy::SendNullResponse(const String& src,
217 SysAssertf(__pIpcClient != null, "Not yet constructed. Construct() should be called before use.\n");
219 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
221 result r = E_SUCCESS;
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.");
227 r = __pIpcClient->SendRequest(pMsg.get());
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));
236 _ChannelServiceProxy::OnSendRequestMessage(const String& src, const String& dest, const ArrayList& args, int requestId)
238 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
240 _IChannelServiceEventListener* pListener = null;
244 __listeners.GetValue(key, pListener);
248 int argCount = args.GetCount();
249 Object* pObject = null;
250 ArrayList* pArrayList = new (std::nothrow) ArrayList;
251 if (pArrayList == null)
253 const_cast<ArrayList*>(&args)->RemoveAll(true);
257 pArrayList->Construct();
259 for (int i = 0; i < argCount; i++)
261 pObject = (Object*)args.GetAt(i);
262 pArrayList->Add(*pObject);
265 pListener->OnChannelRequestReceivedN(src, dest, requestId, pArrayList);
267 const_cast<ArrayList*>(&args)->RemoveAll(false);
273 const_cast<ArrayList*>(&args)->RemoveAll(true);
280 _ChannelServiceProxy::OnSendNullRequestMessage(const String& src, const String& dest, int requestId)
282 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
284 _IChannelServiceEventListener* pListener = null;
288 __listeners.GetValue(key, pListener);
292 pListener->OnChannelRequestReceivedN(src, dest, requestId, null);
301 _ChannelServiceProxy::OnSendResponseMessage(const String& src, const String& dest, const ArrayList& args, int requestId)
303 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
305 _IChannelServiceEventListener* pListener = null;
309 __listeners.GetValue(key, pListener);
313 int argCount = args.GetCount();
314 Object* pObject = null;
315 ArrayList* pArrayList = new (std::nothrow) ArrayList;
316 if (pArrayList == null)
318 const_cast<ArrayList*>(&args)->RemoveAll(true);
322 pArrayList->Construct();
324 for (int i = 0; i < argCount; i++)
326 pObject = (Object*)args.GetAt(i);
327 pArrayList->Add(*pObject);
330 pListener->OnChannelResponseReceivedN(src, dest, requestId, pArrayList);
332 const_cast<ArrayList*>(&args)->RemoveAll(false);
338 const_cast<ArrayList*>(&args)->RemoveAll(true);
345 _ChannelServiceProxy::OnSendNullResponseMessage(const String& src, const String& dest, int requestId)
347 SysLog(NID_IO, "[%ls] ---> [%ls]", src.GetPointer(), dest.GetPointer());
349 _IChannelServiceEventListener* pListener = null;
353 __listeners.GetValue(key, pListener);
357 pListener->OnChannelResponseReceivedN(src, dest, requestId, null);