|
1 /* |
|
2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <errno.h> |
|
20 #include <pthread.h> |
|
21 #include <iostream> |
|
22 #include <sstream> |
|
23 |
|
24 #include "logger.h" |
|
25 |
|
26 #include "dynamiclibloader.h" |
|
27 #include "runtimeexception.h" |
|
28 #include "javaosheaders.h" |
|
29 |
|
30 #include "midpruntimepushsupport.h" |
|
31 |
|
32 #include "pushcontrollerstarterimpl.h" |
|
33 #include "serverconnectionfactory.h" |
|
34 #include "serverconnection.h" |
|
35 #include "pushregistrymessages.h" |
|
36 #include "comms.h" |
|
37 #include "commsclientendpoint.h" |
|
38 #include "commsmessage.h" |
|
39 #include "javacommonutils.h" |
|
40 #include "pusherrorcodes.h" |
|
41 #include "pushexception.h" |
|
42 #include "pushconstant.h" |
|
43 #include "javauid.h" |
|
44 #include "libraryloaderexception.h" |
|
45 |
|
46 using namespace java::push; |
|
47 using namespace java::runtime; |
|
48 using namespace java::comms; |
|
49 using namespace java::util; |
|
50 using namespace std; |
|
51 |
|
52 #if defined(__SYMBIAN32__) && defined(__WINSCW__) |
|
53 #include <pls.h> |
|
54 #else |
|
55 static PushControllerStarterImpl* sPushContStarter = 0; |
|
56 #endif |
|
57 |
|
58 #ifdef __SYMBIAN32__ |
|
59 PushControllerStarter& getPushControllerStarter() |
|
60 { |
|
61 #else |
|
62 extern "C" PushControllerStarter& getPushControllerStarter() |
|
63 { |
|
64 #endif |
|
65 |
|
66 JELOG2(EJavaPush); |
|
67 |
|
68 #if defined(__SYMBIAN32__) && defined(__WINSCW__) |
|
69 TUid uid = TUid::Uid(0xE0000050); |
|
70 PushControllerStarterImpl* retObj = Pls<PushControllerStarterImpl>(uid); |
|
71 return *retObj; |
|
72 #else |
|
73 if (sPushContStarter == 0) |
|
74 { |
|
75 sPushContStarter = new PushControllerStarterImpl(); |
|
76 } |
|
77 return *sPushContStarter; |
|
78 #endif |
|
79 } |
|
80 |
|
81 /** |
|
82 * |
|
83 */ |
|
84 PushControllerStarterImpl::PushControllerStarterImpl() |
|
85 : mSrvConnPluginMgr(0),mAppStateController(0),mState(INITIAL_STATE), |
|
86 mThreadId(0),mMonitor(Monitor::createMonitor()),mConnCompletedMonitor(0), |
|
87 mIsUpdate(false),mNumOfPendingUpdates(0) |
|
88 { |
|
89 JELOG2(EJavaPush); |
|
90 mSrvConnPluginMgr.reset(new PushServerConnPluginManager(this,this,this)); |
|
91 } |
|
92 |
|
93 /** |
|
94 * |
|
95 */ |
|
96 PushControllerStarterImpl::~PushControllerStarterImpl() |
|
97 { |
|
98 JELOG2(EJavaPush); |
|
99 try |
|
100 { |
|
101 CommsClientEndpoint& comms = getComms(); |
|
102 comms.unregisterListener(PLUGIN_ID_PUSH_CONTROLLER_C,this); |
|
103 } |
|
104 catch (...) {} |
|
105 } |
|
106 |
|
107 /** |
|
108 * This operation throws exception if initialization of all connections |
|
109 * fails. RuntimeStarter closes application if it gets exception from this |
|
110 * operation. |
|
111 * MidpStarterPushSupport::closeRuntimeRequestFromPush() |
|
112 * operation is called from error() operation if opening all connections fails. |
|
113 */ |
|
114 void PushControllerStarterImpl::startListen(const java::util::Uid& aUid, |
|
115 MidpStarterPushSupport* aAppStateController) |
|
116 { |
|
117 JELOG2(EJavaPush); |
|
118 |
|
119 setState(LOADING_PUSH_CONNS); |
|
120 mAppStateController = aAppStateController; |
|
121 |
|
122 registerCommsListener(); |
|
123 mIsUpdate = false; |
|
124 mUid = aUid; |
|
125 bool retValue = sendGetAllPushRegsMsg(false); |
|
126 if (false == retValue) |
|
127 setState(INITIAL_STATE); |
|
128 } |
|
129 |
|
130 /** |
|
131 * |
|
132 */ |
|
133 void PushControllerStarterImpl::updatePushRegs(const java::util::Uid& aUid, |
|
134 MidpStarterPushSupport* aAppStateController) |
|
135 |
|
136 { |
|
137 JELOG2(EJavaPush); |
|
138 updatePushRegs2(aUid,aAppStateController,false); |
|
139 } |
|
140 |
|
141 /** |
|
142 * This operation can not throw exceptions. |
|
143 * This operation is always called from comms thread so locks for mNumOfPendingUpdates |
|
144 * datamember is not needed. Value of mNumOfPendingUpdates datamember is increased if |
|
145 * previous updating is ongoing when next update request arrives. |
|
146 */ |
|
147 void PushControllerStarterImpl::updatePushRegs2(const java::util::Uid& aUid, |
|
148 MidpStarterPushSupport* aAppStateController, |
|
149 bool aThrowingExceptionAllowed) |
|
150 { |
|
151 JELOG2(EJavaPush); |
|
152 |
|
153 try |
|
154 { |
|
155 if (LOADING_PUSH_CONNS == getState()) |
|
156 { |
|
157 ++mNumOfPendingUpdates; |
|
158 return; |
|
159 } |
|
160 |
|
161 registerCommsListener(); |
|
162 mUid = aUid; |
|
163 mAppStateController = aAppStateController; |
|
164 mIsUpdate = true; |
|
165 sendGetAllPushRegsMsg(aThrowingExceptionAllowed); |
|
166 ++mNumOfPendingUpdates; |
|
167 } |
|
168 catch (...) |
|
169 { |
|
170 ELOG(EJavaPush,"ERROR!!! updatePushRegs2(): Unexpected exception was caught"); |
|
171 if (true == aThrowingExceptionAllowed) |
|
172 throw; |
|
173 } |
|
174 } |
|
175 |
|
176 /** |
|
177 * |
|
178 */ |
|
179 void PushControllerStarterImpl::close() |
|
180 { |
|
181 JELOG2(EJavaPush); |
|
182 try |
|
183 { |
|
184 //Destructor of PushServerConnPluginManager class calls |
|
185 //ServerConnectionFactory::closeAllConnections() operation for each plugin. |
|
186 delete mSrvConnPluginMgr.release(); |
|
187 setState(INITIAL_STATE); |
|
188 } |
|
189 catch (...) |
|
190 { |
|
191 ELOG(EJavaPush,"ERROR!!! PushControllerStarterImpl::close(): Unexpected exception was caught"); |
|
192 } |
|
193 } |
|
194 |
|
195 /** |
|
196 * |
|
197 */ |
|
198 void PushControllerStarterImpl::msgArrived(const std::wstring& aInfo) |
|
199 { |
|
200 JELOG2(EJavaPush); |
|
201 |
|
202 if (0 != mAppStateController) |
|
203 { |
|
204 mAppStateController->startMidletRequestFromPush(aInfo); |
|
205 } |
|
206 } |
|
207 |
|
208 /** |
|
209 * |
|
210 */ |
|
211 void PushControllerStarterImpl::error(const std::wstring& aUri,int aErrCode, |
|
212 const std::string& aErrText) |
|
213 { |
|
214 JELOG2(EJavaPush); |
|
215 |
|
216 ELOG2(EJavaPush, "ERROR!!! err code: %d, err txt: %s",aErrCode,aErrText.c_str()); |
|
217 int numOfSuccessfulConns = getPushServerConnPluginManager().setConnFailed(aUri); |
|
218 if (0 == numOfSuccessfulConns) |
|
219 { |
|
220 sendAllConnsFailedMsg(); |
|
221 closeRuntime(); |
|
222 } |
|
223 } |
|
224 |
|
225 /** |
|
226 * |
|
227 */ |
|
228 void PushControllerStarterImpl::processMessage(CommsMessage& aMessage) |
|
229 { |
|
230 JELOG2(EJavaPush); |
|
231 |
|
232 switch (aMessage.getMessageId()) |
|
233 { |
|
234 case IPC_PR_LIST_OF_ALL_PUSH_REGS: |
|
235 { |
|
236 handleListOfAllPushRegistrationsMsg(aMessage); |
|
237 break; |
|
238 } |
|
239 case IPC_PR_CONN_MANAGED_BY_OTHER_MIDLET: |
|
240 { |
|
241 mConnCompletedMonitor->notify(); |
|
242 break; |
|
243 } |
|
244 default: |
|
245 ELOG1(EJavaPush, "ERROR!!! Unsupported method arrives to processMessage(): %d", |
|
246 aMessage.getMessageId()); |
|
247 }//end switch |
|
248 } |
|
249 |
|
250 /** |
|
251 * |
|
252 */ |
|
253 bool PushControllerStarterImpl::sendGetAllPushRegsMsg(bool aThrowingExceptionAllowed) |
|
254 { |
|
255 JELOG2(EJavaPush); |
|
256 |
|
257 CommsMessage getAllPushRegsMsg; |
|
258 getAllPushRegsMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
259 getAllPushRegsMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
260 getAllPushRegsMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C); |
|
261 getAllPushRegsMsg.setMessageId(IPC_PR_GET_ALL_PUSH_REGS); |
|
262 |
|
263 getAllPushRegsMsg << mUid; |
|
264 CommsClientEndpoint& comms = getComms(); |
|
265 EState stateOfObj = getState(); |
|
266 setState(LOADING_PUSH_CONNS); |
|
267 int retValue = comms.send(getAllPushRegsMsg); |
|
268 if (0 != retValue) |
|
269 { |
|
270 setState(stateOfObj); |
|
271 std::string errTxt("Sending a comms request failed: "); |
|
272 errTxt.append(java::util::JavaCommonUtils::intToString(retValue)); |
|
273 ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str()); |
|
274 if (false == aThrowingExceptionAllowed) |
|
275 { |
|
276 sendAllConnsFailedMsg(); |
|
277 closeRuntime(); |
|
278 return false; |
|
279 } |
|
280 throw PushException(GENERAL_COMMS_ERROR,errTxt,__FILE__,__FUNCTION__,__LINE__); |
|
281 } |
|
282 //setState(LOADING_PUSH_CONNS); |
|
283 return true; |
|
284 } |
|
285 |
|
286 /** |
|
287 * |
|
288 */ |
|
289 void PushControllerStarterImpl::handleListOfAllPushRegistrationsMsg(CommsMessage& aMessage) |
|
290 { |
|
291 JELOG2(EJavaPush); |
|
292 |
|
293 try |
|
294 { |
|
295 //std::string tmpErrTxt("Retrieving push registrations failed"); |
|
296 validateCommonParamsOfReplyCommsMsg(0,IPC_PR_LIST_OF_ALL_PUSH_REGS, |
|
297 aMessage,mUid); |
|
298 std::wstring uriStr; |
|
299 std::wstring filterStr; |
|
300 PushServerConnPluginManager::UriList_t uriList; |
|
301 while ((aMessage >> uriStr)) |
|
302 { |
|
303 if (!(aMessage >> filterStr)) |
|
304 { |
|
305 throw PushException(INCORRECT_COMMS_MSG,"Could not resolve 'filter' parameter", |
|
306 __FILE__,__FUNCTION__,__LINE__); |
|
307 } |
|
308 PushRegData tmpObj(uriStr,filterStr); |
|
309 uriList.push_back(tmpObj); |
|
310 } |
|
311 |
|
312 if (false == mIsUpdate) |
|
313 getPushServerConnPluginManager().startListen(uriList,false,true); |
|
314 else |
|
315 { |
|
316 getPushServerConnPluginManager().updatePushRegs(uriList,*this); |
|
317 //In this case updatePushRegs() has called closeRuntime() operation |
|
318 //so no sense to retrieve new updates. |
|
319 if (INITIAL_STATE == getState()) |
|
320 return; |
|
321 |
|
322 if (1 < mNumOfPendingUpdates) |
|
323 { |
|
324 --mNumOfPendingUpdates; |
|
325 sendGetAllPushRegsMsg(false); |
|
326 return; |
|
327 } |
|
328 else if (1 == mNumOfPendingUpdates) |
|
329 --mNumOfPendingUpdates; |
|
330 }//end else |
|
331 |
|
332 setState(PUSH_CONNS_LOADED); |
|
333 } |
|
334 catch (PushException& ex) |
|
335 { |
|
336 setState(INITIAL_STATE); |
|
337 ELOG1(EJavaPush, "ERROR!!! PushControllerStarterImpl::getAndInitAllPushRegs(): %s", |
|
338 ex.toString().c_str()); |
|
339 //"All connection has failed" message is sent to pushregistryplugin if any error occurs |
|
340 //when push connections are retrieved. This prevents infinite loop if pushregistryplugin |
|
341 //has problems to provide push connections. |
|
342 sendAllConnsFailedMsg(); |
|
343 closeRuntime(); |
|
344 |
|
345 } |
|
346 catch (...) |
|
347 { |
|
348 setState(INITIAL_STATE); |
|
349 ELOG(EJavaPush,"ERROR!!! getAndInitAllPushRegs(): Unexpected exception was caught"); |
|
350 sendAllConnsFailedMsg(); |
|
351 closeRuntime(); |
|
352 } |
|
353 mIsUpdate = false; |
|
354 mMonitor->notify(); |
|
355 } |
|
356 |
|
357 /** |
|
358 * |
|
359 */ |
|
360 void PushControllerStarterImpl::registerDynamicPushConn(const std::wstring& aUri, |
|
361 const std::wstring& aMidlet, |
|
362 const std::wstring& aFilter, |
|
363 const Uid& aUid, |
|
364 bool aIsUidOfThisMidlet) |
|
365 { |
|
366 JELOG2(EJavaPush); |
|
367 |
|
368 bool pushSrvConnObjectCreated = false; |
|
369 try |
|
370 { |
|
371 int isUidOfThisMidlet = 0; |
|
372 if (true == aIsUidOfThisMidlet) |
|
373 { |
|
374 loadPushConns(aUid); |
|
375 isUidOfThisMidlet = 1; |
|
376 PushRegData tmpRegData(aUri,aFilter); |
|
377 PushServerConnPluginManager::UriList_t pushList; |
|
378 pushList.push_back(tmpRegData); |
|
379 getPushServerConnPluginManager().startListen(pushList,true,false); |
|
380 pushSrvConnObjectCreated = true; |
|
381 } |
|
382 |
|
383 if (false == aIsUidOfThisMidlet) |
|
384 { |
|
385 registerCommsListener(); |
|
386 //We have to open a connection in this situation to be sure that connection |
|
387 //is not already reserved. Connection is closed immediately. |
|
388 if (false == getPushServerConnPluginManager().isValidPushUri(aUri)) |
|
389 { |
|
390 throw PushException(PUSH_CONNECTION_ALREADY_EXISTS, |
|
391 "Connection is reserved by another application", |
|
392 __FILE__,__FUNCTION__,__LINE__); |
|
393 } |
|
394 } |
|
395 |
|
396 sendRegDynPushConnMsg(aUri,aMidlet,aFilter,aUid,isUidOfThisMidlet); |
|
397 |
|
398 if (false == aIsUidOfThisMidlet) |
|
399 { |
|
400 startToWaitCompletionOfOper(); |
|
401 } |
|
402 } |
|
403 catch (PushException& ex) |
|
404 { |
|
405 ELOG1(EJavaPush, "ERROR!!! PushControllerStarterImpl::registerDynamicPushConn(): %s", |
|
406 ex.toString().c_str()); |
|
407 if (true == pushSrvConnObjectCreated) |
|
408 { |
|
409 //ScopedLock is not needed in this situation. |
|
410 getPushServerConnPluginManager().deletePushServerConn(aUri); |
|
411 } |
|
412 throw; |
|
413 } |
|
414 catch (java::util::LibraryLoaderException& ex) |
|
415 { |
|
416 ELOG1(EJavaPush, "ERROR!!! PushControllerStarterImpl::registerDynamicPushConn(): %s", |
|
417 ex.toString().c_str()); |
|
418 throw; |
|
419 } |
|
420 catch (...) |
|
421 { |
|
422 ELOG(EJavaPush,"ERROR!!! Unexpected exception was caught"); |
|
423 if (true == pushSrvConnObjectCreated) |
|
424 getPushServerConnPluginManager().deletePushServerConn(aUri); |
|
425 throw java::util::ExceptionBase("Unexpected error occurred",__FILE__,__FUNCTION__,__LINE__); |
|
426 } |
|
427 } |
|
428 |
|
429 /** |
|
430 * |
|
431 */ |
|
432 void PushControllerStarterImpl::listConnections(bool aAvailable,const java::util::Uid& aUid, |
|
433 std::list<std::wstring>& aUriList) |
|
434 { |
|
435 JELOG2(EJavaPush); |
|
436 |
|
437 //loadPushConns(aUid); |
|
438 //mSrvConnPluginMgr->listConnections(aAvailable,aUriList); |
|
439 |
|
440 int available = 0; |
|
441 if (true == aAvailable) |
|
442 available = 1; |
|
443 |
|
444 CommsMessage getPushConns; |
|
445 getPushConns.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
446 getPushConns.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
447 getPushConns.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C); |
|
448 getPushConns.setMessageId(IPC_PR_LIST_CONNECTIONS); |
|
449 getPushConns << aUid; |
|
450 getPushConns << available; |
|
451 CommsClientEndpoint& comms = getComms(); |
|
452 CommsMessage replyMsgToListConns; |
|
453 int retValue = comms.sendReceive(getPushConns,replyMsgToListConns,COMMS_TIMEOUT); |
|
454 //std::string tmpErrTxt("Retrieving push URIs failed"); |
|
455 validateCommonParamsOfReplyCommsMsg(retValue,IPC_PR_LIST_CONNECTIONS_REPLY, |
|
456 replyMsgToListConns,aUid); |
|
457 |
|
458 std::wstring uriStr; |
|
459 while ((replyMsgToListConns >> uriStr)) |
|
460 { |
|
461 aUriList.push_back(uriStr); |
|
462 } |
|
463 } |
|
464 |
|
465 /** |
|
466 * |
|
467 */ |
|
468 std::wstring PushControllerStarterImpl::getFilter(const std::wstring& aUri, |
|
469 const java::util::Uid& aSuiteUid) |
|
470 { |
|
471 JELOG2(EJavaPush); |
|
472 |
|
473 //loadPushConns(aUid); |
|
474 //ServerConnection& conn = mSrvConnPluginMgr->getPushConnection(aUri); |
|
475 //return conn.getFilter(); |
|
476 |
|
477 return sendPushDataQuery(aUri,aSuiteUid,FILTER_OF_PUSH_CONN); |
|
478 } |
|
479 |
|
480 /** |
|
481 * |
|
482 */ |
|
483 std::wstring PushControllerStarterImpl::getClassNameOfMidlet(const std::wstring& aUri, |
|
484 const java::util::Uid& aSuiteUid) |
|
485 { |
|
486 JELOG2(EJavaPush); |
|
487 |
|
488 return sendPushDataQuery(aUri,aSuiteUid,CLASSNAME_OF_PUSH_CONN); |
|
489 } |
|
490 |
|
491 /** |
|
492 * |
|
493 */ |
|
494 bool PushControllerStarterImpl::isPushConnection(const std::wstring& aUri, |
|
495 const java::util::Uid& aUid) |
|
496 { |
|
497 JELOG2(EJavaPush); |
|
498 |
|
499 try |
|
500 { |
|
501 loadPushConns(aUid); |
|
502 getPushServerConnPluginManager().getPushConnection(aUri); |
|
503 return true; |
|
504 } |
|
505 catch (...) |
|
506 { |
|
507 ELOG(EJavaPush,"ERROR!!! Exception was caught"); |
|
508 return false; |
|
509 } |
|
510 } |
|
511 |
|
512 /** |
|
513 * |
|
514 */ |
|
515 void PushControllerStarterImpl::unregisterDynamicPushConn(const std::wstring& aUri, |
|
516 const Uid& aUid, |
|
517 bool aIsUidOfThisMidlet) |
|
518 { |
|
519 JELOG2(EJavaPush); |
|
520 |
|
521 int isUidOfThisMidlet = 0; |
|
522 if (true == aIsUidOfThisMidlet) |
|
523 { |
|
524 loadPushConns(aUid); |
|
525 isUidOfThisMidlet = 1; |
|
526 } |
|
527 else |
|
528 { |
|
529 registerCommsListener(); |
|
530 } |
|
531 |
|
532 CommsMessage regDynPushRegMsg; |
|
533 regDynPushRegMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
534 regDynPushRegMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
535 regDynPushRegMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C); |
|
536 regDynPushRegMsg.setMessageId(IPC_PR_UNREGISTER_DYNAMIC_PUSH_CONN); |
|
537 regDynPushRegMsg << aUid; |
|
538 regDynPushRegMsg << aUri; |
|
539 regDynPushRegMsg << isUidOfThisMidlet; |
|
540 CommsClientEndpoint& comms = getComms(); |
|
541 CommsMessage statusOfUnRegDynConnMsg; |
|
542 int retValue = comms.sendReceive(regDynPushRegMsg,statusOfUnRegDynConnMsg,COMMS_TIMEOUT); |
|
543 //std::string tmpErrTxt("Unegistering a push connection failed"); |
|
544 validateCommonParamsOfReplyCommsMsg(retValue,IPC_PR_UNREGISTER_DYNAMIC_PUSH_CONN_REPLY, |
|
545 statusOfUnRegDynConnMsg,aUid); |
|
546 |
|
547 //Unregister dynamic push connection from ServerConnection Plugin if it belongs to 'this' |
|
548 //MIDlet. |
|
549 if (true == aIsUidOfThisMidlet) |
|
550 getPushServerConnPluginManager().unregisterDynamicPushConn(aUri); |
|
551 else |
|
552 { |
|
553 startToWaitCompletionOfOper(); |
|
554 } |
|
555 } |
|
556 |
|
557 /** |
|
558 * |
|
559 */ |
|
560 long long PushControllerStarterImpl::registerAlarm(const long long& aAlarmTimeInMilliSecs, |
|
561 const Uid& aSuiteUid, |
|
562 const std::wstring& aClassNameOfMidlet, |
|
563 bool aIsUidOfThisMidlet) |
|
564 { |
|
565 JELOG2(EJavaPush); |
|
566 |
|
567 LOG1WSTR(EJavaPush,EInfo, "registerAlarm() aClassNameOfMidlet: %s",aClassNameOfMidlet); |
|
568 |
|
569 int isUidOfThisMidlet = 0; |
|
570 if (true == aIsUidOfThisMidlet) |
|
571 isUidOfThisMidlet = 1; |
|
572 |
|
573 CommsMessage regAlarmMsg; |
|
574 regAlarmMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
575 regAlarmMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
576 regAlarmMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C); |
|
577 regAlarmMsg.setMessageId(IPC_PR_REGISTER_ALARM); |
|
578 regAlarmMsg << aSuiteUid; |
|
579 regAlarmMsg << aAlarmTimeInMilliSecs; |
|
580 regAlarmMsg << aClassNameOfMidlet; |
|
581 regAlarmMsg << isUidOfThisMidlet; |
|
582 |
|
583 CommsClientEndpoint& comms = getComms(); |
|
584 CommsMessage statusOfRegAlarmMsg; |
|
585 int retValue = comms.sendReceive(regAlarmMsg,statusOfRegAlarmMsg,COMMS_TIMEOUT); |
|
586 //std::string tmpErrTxt("Setting an alarm failed"); |
|
587 validateCommonParamsOfReplyCommsMsg(retValue,IPC_PR_REGISTER_ALARM_REPLY,statusOfRegAlarmMsg, |
|
588 aSuiteUid); |
|
589 |
|
590 long long retTime = 0LL; |
|
591 if (!(statusOfRegAlarmMsg >> retTime)) |
|
592 { |
|
593 std::string errTxt("Cannot resolve 'time' from the IPC_PR_REGISTER_ALARM_REPLY msg"); |
|
594 throw PushException(INCORRECT_COMMS_MSG,errTxt,__FILE__,__FUNCTION__,__LINE__); |
|
595 } |
|
596 |
|
597 return retTime; |
|
598 } |
|
599 |
|
600 /** |
|
601 * Note: This operation ignores all errors. |
|
602 */ |
|
603 void PushControllerStarterImpl::sendAllConnsFailedMsg() |
|
604 { |
|
605 JELOG2(EJavaPush); |
|
606 |
|
607 try |
|
608 { |
|
609 CommsMessage allConnsFailedMsg; |
|
610 allConnsFailedMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
611 allConnsFailedMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
612 allConnsFailedMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C); |
|
613 allConnsFailedMsg.setMessageId(IPC_PR_ALL_CONNS_FAILED); |
|
614 allConnsFailedMsg << mUid; |
|
615 CommsClientEndpoint& comms = getComms(); |
|
616 int retValue = comms.send(allConnsFailedMsg); |
|
617 if (0 != retValue) |
|
618 { |
|
619 std::string errTxt("sendAllConnsFailedMsg() Sending a comms request failed: "); |
|
620 errTxt.append(java::util::JavaCommonUtils::intToString(retValue)); |
|
621 ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str()); |
|
622 } |
|
623 } |
|
624 catch (...) |
|
625 { |
|
626 ELOG(EJavaPush, "ERROR!!! Unexpected exception caught in the PushControllerStarterImpl::sendAllConnsFailedMsg()"); |
|
627 } |
|
628 } |
|
629 |
|
630 /** |
|
631 * |
|
632 */ |
|
633 void PushControllerStarterImpl::closeRuntime() |
|
634 { |
|
635 JELOG2(EJavaPush); |
|
636 |
|
637 if (0 != mAppStateController) |
|
638 { |
|
639 mAppStateController->closeRuntimeRequestFromPush(); |
|
640 setState(INITIAL_STATE); |
|
641 } |
|
642 } |
|
643 |
|
644 /** |
|
645 * |
|
646 */ |
|
647 void PushControllerStarterImpl::setPendingStatus(const std::wstring& aUri, |
|
648 bool aMsgWaitsHandling) |
|
649 { |
|
650 JELOG2(EJavaPush); |
|
651 |
|
652 try |
|
653 { |
|
654 int msgWaitsHandling = 0; |
|
655 if (true == aMsgWaitsHandling) |
|
656 msgWaitsHandling = 1; |
|
657 |
|
658 CommsMessage pendingStatusMsg; |
|
659 pendingStatusMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
660 pendingStatusMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
661 pendingStatusMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C); |
|
662 pendingStatusMsg.setMessageId(IPC_PR_PENDING_STATUS); |
|
663 pendingStatusMsg << mUid; |
|
664 pendingStatusMsg << aUri; |
|
665 pendingStatusMsg << msgWaitsHandling; |
|
666 CommsClientEndpoint& comms = getComms(); |
|
667 int retValue = comms.send(pendingStatusMsg); |
|
668 if (0 != retValue) |
|
669 { |
|
670 std::string errTxt("setPendingStatus(): Sending a comms request failed: "); |
|
671 errTxt.append(java::util::JavaCommonUtils::intToString(retValue)); |
|
672 ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str()); |
|
673 } |
|
674 } |
|
675 catch (...) |
|
676 { |
|
677 ELOG(EJavaPush, "ERROR!!! Unexpected exception caught in the PushControllerStarterImpl::setPendingStatus()"); |
|
678 } |
|
679 } |
|
680 |
|
681 /** |
|
682 * |
|
683 */ |
|
684 void PushControllerStarterImpl::connCompleted(const wstring& aUri) |
|
685 { |
|
686 JELOG2(EJavaPush); |
|
687 |
|
688 try |
|
689 { |
|
690 CommsMessage unRegCompletedMsg; |
|
691 unRegCompletedMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
692 unRegCompletedMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
693 unRegCompletedMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C); |
|
694 unRegCompletedMsg.setMessageId(IPC_PR_CONN_COMPLETED); |
|
695 unRegCompletedMsg << aUri; |
|
696 CommsClientEndpoint& comms = getComms(); |
|
697 int retValue = comms.send(unRegCompletedMsg); |
|
698 if (0 != retValue) |
|
699 { |
|
700 std::string errTxt("connCompleted(): Sending a comms request failed: "); |
|
701 errTxt.append(java::util::JavaCommonUtils::intToString(retValue)); |
|
702 ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str()); |
|
703 } |
|
704 } |
|
705 catch (...) |
|
706 { |
|
707 ELOG(EJavaPush, |
|
708 "ERROR!!! Unexpected exception caught in the PushControllerStarterImpl::unregCompleted()"); |
|
709 } |
|
710 } |
|
711 |
|
712 /** |
|
713 * |
|
714 */ |
|
715 CommsClientEndpoint& PushControllerStarterImpl::getComms() |
|
716 { |
|
717 JELOG2(EJavaPush); |
|
718 |
|
719 CommsClientEndpoint* commsObj = CommsClientEndpoint::find(L"javacaptain"); |
|
720 if (0 == commsObj) |
|
721 { |
|
722 throw PushException(GENERAL_COMMS_ERROR,"Retrieving CommsClientEndpoint object failed", |
|
723 __FILE__,__FUNCTION__,__LINE__); |
|
724 } |
|
725 return *commsObj; |
|
726 } |
|
727 |
|
728 /** |
|
729 * |
|
730 */ |
|
731 void PushControllerStarterImpl::validateUid(const Uid& aUid,CommsMessage& aMessage, |
|
732 const std::string& aFile, |
|
733 const std::string& aFunction,int aLine) |
|
734 { |
|
735 JELOG2(EJavaPush); |
|
736 Uid uid; |
|
737 if (!(aMessage >> uid)) |
|
738 { |
|
739 std::string errTxt("Cannot resolve uid from the comms msg"); |
|
740 throw PushException(INCORRECT_COMMS_MSG,errTxt,aFile.c_str(),aFunction.c_str(),aLine); |
|
741 } |
|
742 if (uid != aUid) |
|
743 { |
|
744 std::wstring errTxt(L"Push comms msg with incorrect uid arrived: "); |
|
745 errTxt.append(uid.toString()); |
|
746 ELOG1WSTR(EJavaPush,"ERROR!!!", errTxt); |
|
747 throw PushException(INCORRECT_COMMS_MSG,errTxt,aFile,aFunction,aLine); |
|
748 } |
|
749 } |
|
750 |
|
751 /** |
|
752 * |
|
753 */ |
|
754 void PushControllerStarterImpl::checkErrorParamsOfCommsMsg(CommsMessage& aMessage) |
|
755 { |
|
756 JELOG2(EJavaPush); |
|
757 |
|
758 int status = 0; |
|
759 if (!(aMessage >> status)) |
|
760 { |
|
761 std::string errTxt("Cannot resolve status from the comms msg"); |
|
762 throw PushException(INCORRECT_COMMS_MSG,errTxt,__FILE__,__FUNCTION__,__LINE__); |
|
763 } |
|
764 |
|
765 if (0 != status) |
|
766 { |
|
767 std::string errStatusText(""); |
|
768 //Error check is not needed here. |
|
769 aMessage >> errStatusText; |
|
770 |
|
771 //Exception text already contains error code. |
|
772 throw PushException(0,errStatusText,__FILE__,__FUNCTION__,__LINE__); |
|
773 } |
|
774 |
|
775 //Error text is skipped in the success case. |
|
776 std::string errTxt; |
|
777 aMessage >> errTxt; |
|
778 } |
|
779 |
|
780 /** |
|
781 * |
|
782 */ |
|
783 void PushControllerStarterImpl::validateCommonParamsOfReplyCommsMsg |
|
784 (int aRetValue,int aMsgId,CommsMessage& aMsg,const Uid& aUid) |
|
785 { |
|
786 JELOG2(EJavaPush); |
|
787 |
|
788 if (0 != aRetValue) |
|
789 { |
|
790 std::string errTxt("Sending a comms request failed: "); |
|
791 errTxt.append(java::util::JavaCommonUtils::intToString(aRetValue)); |
|
792 ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str()); |
|
793 throw PushException(GENERAL_COMMS_ERROR,errTxt,__FILE__,__FUNCTION__,__LINE__); |
|
794 } |
|
795 |
|
796 if (aMsgId != aMsg.getMessageId()) |
|
797 { |
|
798 std::string errTxt("Incorrect message arrived: "); |
|
799 errTxt.append(java::util::JavaCommonUtils::intToString(aMsg.getMessageId())); |
|
800 ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str()); |
|
801 throw PushException(GENERAL_COMMS_ERROR,errTxt,__FILE__,__FUNCTION__,__LINE__); |
|
802 } |
|
803 |
|
804 validateUid(aUid,aMsg,__FILE__,__FUNCTION__,__LINE__); |
|
805 checkErrorParamsOfCommsMsg(aMsg); |
|
806 } |
|
807 |
|
808 /** |
|
809 * We have to call this operation in each methods of PushRegistry interface |
|
810 * because it might be that push connections are not retrieved before MIDlet |
|
811 * calls methods of PushRegistry. Other case is that all existing connections are |
|
812 * failed before a new push connection is registered to teh MIDlet. In this case push |
|
813 * connections must be retrieved from java captain. |
|
814 */ |
|
815 void PushControllerStarterImpl::loadPushConns(const java::util::Uid& aUid) |
|
816 { |
|
817 JELOG2(EJavaPush); |
|
818 |
|
819 EState state = getState(); |
|
820 if (INITIAL_STATE == state) |
|
821 { |
|
822 updatePushRegs2(aUid,mAppStateController,true); |
|
823 mMonitor->wait(); |
|
824 } |
|
825 else if (LOADING_PUSH_CONNS == state) |
|
826 { |
|
827 mMonitor->wait(); |
|
828 } |
|
829 } |
|
830 |
|
831 /** |
|
832 * |
|
833 */ |
|
834 std::wstring PushControllerStarterImpl::sendPushDataQuery(const std::wstring& aUri, |
|
835 const java::util::Uid& aSuiteUid, |
|
836 const EPushInfoQueryParams& aQueryCondition) |
|
837 { |
|
838 JELOG2(EJavaPush); |
|
839 |
|
840 CommsMessage pushQuery; |
|
841 pushQuery.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
842 pushQuery.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
843 pushQuery.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C); |
|
844 pushQuery.setMessageId(IPC_PR_DATA_OF_PUSH_CONN_QUERY); |
|
845 pushQuery << aSuiteUid; |
|
846 pushQuery << aUri; |
|
847 pushQuery << (int) aQueryCondition; |
|
848 CommsClientEndpoint& comms = getComms(); |
|
849 CommsMessage statusOfPushQueryMsg; |
|
850 int retValue = comms.sendReceive(pushQuery,statusOfPushQueryMsg,COMMS_TIMEOUT); |
|
851 //std::string tmpErrTxt("Retrieving data of the push connection failed"); |
|
852 validateCommonParamsOfReplyCommsMsg(retValue,IPC_PR_DATA_OF_PUSH_CONN_QUERY_REPLY, |
|
853 statusOfPushQueryMsg,aSuiteUid); |
|
854 |
|
855 std::wstring returnedStr; |
|
856 if (!(statusOfPushQueryMsg >> returnedStr)) |
|
857 { |
|
858 std::string errTxt("Cannot resolve 'filter' from the IPC_PR_DATA_OF_PUSH_CONN_QUERY_REPLY msg"); |
|
859 throw PushException(INCORRECT_COMMS_MSG,errTxt,__FILE__,__FUNCTION__,__LINE__); |
|
860 } |
|
861 return returnedStr; |
|
862 } |
|
863 |
|
864 /** |
|
865 * |
|
866 */ |
|
867 void PushControllerStarterImpl::sendRegDynPushConnMsg(const std::wstring& aUri, |
|
868 const std::wstring& aMidlet, |
|
869 const std::wstring& aFilter, |
|
870 const java::util::Uid& aUid, |
|
871 int aIsUidOfThisMidlet) |
|
872 { |
|
873 JELOG2(EJavaPush); |
|
874 |
|
875 CommsMessage regDynPushRegMsg; |
|
876 regDynPushRegMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
877 regDynPushRegMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
878 regDynPushRegMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C); |
|
879 regDynPushRegMsg.setMessageId(IPC_PR_REGISTER_DYNAMIC_PUSH_CONN); |
|
880 regDynPushRegMsg << aUid; |
|
881 regDynPushRegMsg << aUri; |
|
882 regDynPushRegMsg << aMidlet; |
|
883 regDynPushRegMsg << aFilter; |
|
884 regDynPushRegMsg << aIsUidOfThisMidlet; |
|
885 CommsClientEndpoint& comms = getComms(); |
|
886 CommsMessage statusOfDynRegMsg; |
|
887 int retValue = comms.sendReceive(regDynPushRegMsg,statusOfDynRegMsg,COMMS_TIMEOUT); |
|
888 //std::string tmpErrTxt("Registering a push connection failed"); |
|
889 validateCommonParamsOfReplyCommsMsg(retValue,IPC_PR_REGISTER_DYNAMIC_PUSH_CONN_REPLY, |
|
890 statusOfDynRegMsg,aUid); |
|
891 } |
|
892 |
|
893 /** |
|
894 * |
|
895 */ |
|
896 PushServerConnPluginManager& PushControllerStarterImpl::getPushServerConnPluginManager() |
|
897 { |
|
898 if (0 == mSrvConnPluginMgr.get()) |
|
899 mSrvConnPluginMgr.reset(new PushServerConnPluginManager(this,this,this)); |
|
900 return *mSrvConnPluginMgr.get(); |
|
901 } |
|
902 |
|
903 /** |
|
904 * |
|
905 */ |
|
906 void PushControllerStarterImpl::setState(const EState& aState) |
|
907 { |
|
908 JELOG2(EJavaPush); |
|
909 ScopedLock lockObj(mMutex); |
|
910 mState = aState; |
|
911 } |
|
912 |
|
913 /** |
|
914 * |
|
915 */ |
|
916 PushControllerStarterImpl::EState PushControllerStarterImpl::getState() const |
|
917 { |
|
918 JELOG2(EJavaPush); |
|
919 ScopedLock lockObj(mMutex); |
|
920 return mState; |
|
921 } |
|
922 |
|
923 /** |
|
924 * |
|
925 */ |
|
926 void PushControllerStarterImpl::registerCommsListener() |
|
927 { |
|
928 CommsClientEndpoint& comms = getComms(); |
|
929 int retValue = comms.registerListener(PLUGIN_ID_PUSH_CONTROLLER_C,this); |
|
930 if ((0 != retValue) && (retValue != EEXIST)) |
|
931 { |
|
932 std::string errTxt("Registering to comms failed: "); |
|
933 errTxt.append(java::util::JavaCommonUtils::intToString(retValue)); |
|
934 ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str()); |
|
935 throw PushException(GENERAL_COMMS_ERROR,errTxt,__FILE__,__FUNCTION__,__LINE__); |
|
936 } |
|
937 } |
|
938 |
|
939 /** |
|
940 * |
|
941 */ |
|
942 void PushControllerStarterImpl::startToWaitCompletionOfOper() |
|
943 { |
|
944 JELOG2(EJavaPush); |
|
945 |
|
946 if (0 == mConnCompletedMonitor.get()) |
|
947 mConnCompletedMonitor.reset(Monitor::createMonitor()); |
|
948 mConnCompletedMonitor->wait(); |
|
949 } |
|
950 |