1 |
|
2 |
|
3 #include <e32base.h> |
|
4 #include <exterror.h> |
|
5 #include <gsmerror.h> |
|
6 |
|
7 // phoneclientengine |
|
8 #include <cphcltussd.h> // USSD API |
|
9 #include "cphcltussdimp.h" // USSD INTERNAL API |
|
10 #include <cphcltussdsatclient.h> // USSD SAT API |
|
11 #include <etelsat.h> |
|
12 |
|
13 // qt stuff |
|
14 #include <QObject> |
|
15 #include <QtTest/QtTest> |
|
16 #include <QMetaType> |
|
17 |
|
18 // unit test |
|
19 #include "ut_testenv.h" |
|
20 #include "ut_ussd.h" |
|
21 |
|
22 // want to use TestMode class inside QVariant (using QFETCH) |
|
23 Q_DECLARE_METATYPE(TestMode) |
|
24 |
|
25 |
|
26 // ==================================================================== |
|
27 // Test cases |
|
28 // ==================================================================== |
|
29 |
|
30 |
|
31 void Ut_Ussd::testTestEnv() |
|
32 { |
|
33 TestEnv::create(); |
|
34 QTest::qSleep(200); |
|
35 |
|
36 TestEnv* env = &TestEnv::env(); |
|
37 QVERIFY2(env,"TestEnv null"); |
|
38 |
|
39 CPhSrvUssdManager* m = &TestEnv::env().ussdManager(); |
|
40 QVERIFY2(m,"TestEnv::ussdManager null"); |
|
41 |
|
42 TestMode tm1(TestMode::NoResp,KErrUnknown,123); |
|
43 TestEnv::env().setTestMode(tm1); |
|
44 QCOMPARE( (int)TestEnv::env().testMode().m_event, (int)TestMode::NoResp); |
|
45 QCOMPARE( TestEnv::env().testMode().m_error, KErrUnknown); |
|
46 QCOMPARE( TestEnv::env().testMode().m_timeout, 123); |
|
47 TestMode tm2(KErrNotSupported,456); |
|
48 TestEnv::env().setTestMode(tm2); |
|
49 QCOMPARE( (int)TestEnv::env().testMode().m_event, (int)TestMode::Normal); |
|
50 QCOMPARE( TestEnv::env().testMode().m_error, KErrNotSupported); |
|
51 QCOMPARE( TestEnv::env().testMode().m_timeout, 456); |
|
52 TestMode tm3(TestMode::Normal); |
|
53 TestEnv::env().setTestMode(tm3); |
|
54 QCOMPARE( (int)TestEnv::env().testMode().m_event, (int)TestMode::Normal); |
|
55 QCOMPARE( TestEnv::env().testMode().m_error, KErrNone); |
|
56 QCOMPARE( TestEnv::env().testMode().m_timeout, (int)TestMode::Immediate); |
|
57 |
|
58 TestEnv::destroy(); |
|
59 QTest::qSleep(200); |
|
60 } |
|
61 |
|
62 void Ut_Ussd::openAndCloseApi() |
|
63 { |
|
64 TestEnv::create(); |
|
65 QTest::qSleep(200); |
|
66 |
|
67 createUssdApi(false); |
|
68 |
|
69 delete m_ussdApi; |
|
70 m_ussdApi = 0; |
|
71 |
|
72 TestEnv::destroy(); |
|
73 QTest::qSleep(200); |
|
74 } |
|
75 |
|
76 void Ut_Ussd::sendUssd16bit_data() |
|
77 { |
|
78 QTest::addColumn<bool>("ui"); |
|
79 QTest::addColumn<QString>("message"); |
|
80 QTest::addColumn<TestMode>("testmode"); |
|
81 |
|
82 // without ui |
|
83 QTest::newRow("1.1") << false << "123" << TestMode(KErrNone); |
|
84 QTest::newRow("1.2") << false << "***" << TestMode(KErrNone,3000); |
|
85 QTest::newRow("1.3") << false << "qwerty" << TestMode(KErrUnknown); |
|
86 // show ui |
|
87 QTest::newRow("2.1") << true << "#*555*" << TestMode(KErrNone,20); |
|
88 QTest::newRow("2.2") << true << "#*555*" << TestMode(KErrCancel,500); |
|
89 QTest::newRow("2.3") << true << "#*555*" << TestMode(KErrInUse,1000); |
|
90 QTest::newRow("2.4") << true << "#*555*" << TestMode(KErrAccessDenied,90); |
|
91 QTest::newRow("2.5") << true << "#*555*" << TestMode(KErrGsmSSCallBarred,190); |
|
92 QTest::newRow("2.6") << true << "#*555*" << TestMode(KErrGsmSMSNoNetworkService,700); |
|
93 QTest::newRow("2.7") << true << "#*555*" << TestMode(KErrGsmOfflineOpNotAllowed,1200); |
|
94 QTest::newRow("2.8") << true << "#*555*" << TestMode(KErrSatControl,200); |
|
95 QTest::newRow("2.9") << true << "#*555*" << TestMode(KErrUnknown,920); |
|
96 |
|
97 } |
|
98 |
|
99 void Ut_Ussd::sendUssd16bit() |
|
100 { |
|
101 TestEnv::create(); |
|
102 QTest::qSleep(200); |
|
103 |
|
104 QFETCH(bool, ui); |
|
105 QFETCH(QString, message); |
|
106 QFETCH(TestMode, testmode); |
|
107 TestEnv::env().setTestMode(testmode); |
|
108 |
|
109 // create api |
|
110 createUssdApi(ui); |
|
111 |
|
112 // send USSD |
|
113 TBuf<100> buf16; |
|
114 buf16.Copy( (const TUint16*)message.constData(), message.length() ); |
|
115 int result = m_ussdApi->SendUssd( buf16 ); |
|
116 QCOMPARE(result, testmode.m_error); |
|
117 QTest::qSleep(100); |
|
118 |
|
119 // close api |
|
120 delete m_ussdApi; |
|
121 m_ussdApi = NULL; |
|
122 QTest::qSleep(100); |
|
123 |
|
124 TestEnv::destroy(); |
|
125 QTest::qSleep(200); |
|
126 } |
|
127 |
|
128 void Ut_Ussd::sendCancel() |
|
129 { |
|
130 TestEnv::create(); |
|
131 QTest::qSleep(200); |
|
132 |
|
133 // create api |
|
134 createUssdApi(false); |
|
135 |
|
136 // send USSD |
|
137 _LIT( KMsg, "#12345*" ); |
|
138 TestEnv::env().setTestMode(TestMode(KErrNone)); |
|
139 int result = m_ussdApi->SendUssd( KMsg ); |
|
140 QCOMPARE(result, KErrNone); |
|
141 m_ussdApi->SendUssdCancel(); |
|
142 |
|
143 // close api |
|
144 delete m_ussdApi; |
|
145 m_ussdApi = NULL; |
|
146 QTest::qSleep(100); |
|
147 |
|
148 TestEnv::destroy(); |
|
149 QTest::qSleep(200); |
|
150 } |
|
151 |
|
152 |
|
153 void Ut_Ussd::sendUssd8bit_data() |
|
154 { |
|
155 QTest::addColumn<bool>("ui"); |
|
156 QTest::addColumn<QString>("message"); |
|
157 QTest::addColumn<TestMode>("testmode"); |
|
158 |
|
159 // without ui |
|
160 QTest::newRow("1.1") << false << "8" << TestMode(KErrNone); |
|
161 QTest::newRow("1.2") << false << "#*888*" << TestMode(KErrUnknown,600); |
|
162 QTest::newRow("1.3") << false << "illegal" << TestMode(KErrNotSupported); |
|
163 // show ui |
|
164 QTest::newRow("2.1") << true << "#*555*" << TestMode(KErrNone,20); |
|
165 QTest::newRow("2.2") << true << "#*555*" << TestMode(KErrCancel,500); |
|
166 QTest::newRow("2.3") << true << "#*555*" << TestMode(KErrInUse,1000); |
|
167 QTest::newRow("2.4") << true << "#*555*" << TestMode(KErrAccessDenied,90); |
|
168 QTest::newRow("2.5") << true << "#*555*" << TestMode(KErrGsmSSCallBarred,190); |
|
169 QTest::newRow("2.6") << true << "#*555*" << TestMode(KErrGsmSMSNoNetworkService,700); |
|
170 QTest::newRow("2.7") << true << "#*555*" << TestMode(KErrGsmOfflineOpNotAllowed,1200); |
|
171 QTest::newRow("2.8") << true << "#*555*" << TestMode(KErrSatControl,200); |
|
172 QTest::newRow("2.9") << true << "#*555*" << TestMode(KErrUnknown,920); |
|
173 } |
|
174 |
|
175 void Ut_Ussd::sendUssd8bit() |
|
176 { |
|
177 TestEnv::create(); |
|
178 QTest::qSleep(200); |
|
179 |
|
180 QFETCH(bool, ui); |
|
181 QFETCH(QString, message); |
|
182 QFETCH(TestMode, testmode); |
|
183 TestEnv::env().setTestMode(testmode); |
|
184 |
|
185 // create api |
|
186 createUssdApi(ui); |
|
187 |
|
188 // send USSD |
|
189 TBuf<100> buf16; |
|
190 buf16.Copy( (const TUint16*)message.constData(), message.length() ); |
|
191 TBuf8<100> buf8; |
|
192 buf8.Copy( buf16 ); |
|
193 int result = m_ussdApi->SendUssd( buf8 ); |
|
194 QCOMPARE(result, testmode.m_error); |
|
195 QTest::qSleep(100); |
|
196 |
|
197 // close api |
|
198 delete m_ussdApi; |
|
199 m_ussdApi = 0; |
|
200 QTest::qSleep(100); |
|
201 |
|
202 TestEnv::destroy(); |
|
203 QTest::qSleep(200); |
|
204 } |
|
205 |
|
206 void Ut_Ussd::openAndCloseSatApi() |
|
207 { |
|
208 TestEnv::create(); |
|
209 QTest::qSleep(200); |
|
210 |
|
211 m_ussdSatApi = NULL; |
|
212 createUssdSatApi(m_ussdSatApi); |
|
213 |
|
214 delete m_ussdSatApi; |
|
215 m_ussdSatApi = 0; |
|
216 |
|
217 TestEnv::destroy(); |
|
218 QTest::qSleep(200); |
|
219 } |
|
220 |
|
221 void Ut_Ussd::sendSatMessage_data() |
|
222 { |
|
223 QTest::addColumn<bool>("ui"); |
|
224 QTest::addColumn<QString>("message"); |
|
225 QTest::addColumn<TestMode>("testmode"); |
|
226 |
|
227 // without ui |
|
228 QTest::newRow("1.1") << false << "123456" << TestMode(KErrNone); |
|
229 QTest::newRow("1.2") << false << "*100#" << TestMode(KErrNone,1000); |
|
230 QTest::newRow("1.3") << false << "8" << TestMode(KErrNone,400); |
|
231 //QTest::newRow("1.4") << false << "illegal" << TestMode(KErrNotSupported); |
|
232 |
|
233 } |
|
234 |
|
235 void Ut_Ussd::sendSatMessage() |
|
236 { |
|
237 TestEnv::create(); |
|
238 QTest::qSleep(200); |
|
239 |
|
240 QFETCH(bool, ui); |
|
241 QFETCH(QString, message); |
|
242 QFETCH(TestMode, testmode); |
|
243 TestEnv::env().setTestMode(testmode); |
|
244 |
|
245 // create api |
|
246 createUssdSatApi(ui); |
|
247 |
|
248 TBuf<RSat::KStringMaxSize> receiveMessage; |
|
249 TBool sendCompletedFirst( EFalse ); |
|
250 TUint8 receiveDcs = 0; |
|
251 TBuf<100> sendMessage; |
|
252 sendMessage.Copy( (const TUint16*)message.constData(), |
|
253 message.length() ); |
|
254 |
|
255 TInt ret = m_ussdSatApi->SendSatMessage( |
|
256 sendMessage, |
|
257 CPhCltUssdSatClient::EPhCltDcsUnknown, |
|
258 receiveMessage, |
|
259 sendCompletedFirst, |
|
260 receiveDcs ); |
|
261 |
|
262 qDebug("receive error=%d", ret); |
|
263 qDebug("receive receive msg=%s", &receiveMessage); |
|
264 qDebug("receive isCompleteFirst=%d", &sendCompletedFirst); |
|
265 qDebug("receive receive Dcs=%d", &receiveDcs); |
|
266 |
|
267 QVERIFY2(ret == testmode.m_error , "testSendSatMessage failed "); |
|
268 |
|
269 // close api |
|
270 delete m_ussdSatApi; |
|
271 m_ussdSatApi = NULL; |
|
272 QTest::qSleep(100); |
|
273 |
|
274 TestEnv::destroy(); |
|
275 QTest::qSleep(200); |
|
276 } |
|
277 |
|
278 void Ut_Ussd::sendReceive_data() |
|
279 { |
|
280 QTest::addColumn<bool>("ui"); |
|
281 QTest::addColumn<QString>("msg1"); |
|
282 QTest::addColumn<QString>("msg2"); |
|
283 QTest::addColumn<TestMode>("testmode"); |
|
284 |
|
285 // without ui, empty resp |
|
286 QTest::newRow("1.1") << false << "*100#" << "" << TestMode(KErrNone,1000); |
|
287 QTest::newRow("1.2") << false << "*100#" << "" << TestMode(KErrNotSupported,400); |
|
288 // without ui, text resp |
|
289 QTest::newRow("2.1") << false << "*100#" << "12345" << TestMode(KErrNone,100); |
|
290 QTest::newRow("2.2") << false << "*100#" << "12345" << TestMode(KErrUnknown,800); |
|
291 |
|
292 // show ui, empty resp |
|
293 QTest::newRow("3.1") << true << "*100#" << "" << TestMode(KErrNone,700); |
|
294 QTest::newRow("3.2") << true << "*100#" << "" << TestMode(KErrNotFound,400); |
|
295 // show ui, text resp |
|
296 QTest::newRow("4.1") << true << "*100#" << "12345" << TestMode(KErrNone,2000); |
|
297 QTest::newRow("4.2") << true << "*100#" << "12345" << TestMode(-800,800); |
|
298 |
|
299 } |
|
300 |
|
301 |
|
302 void Ut_Ussd::sendReceive() |
|
303 { |
|
304 TestEnv::create(); |
|
305 QTest::qSleep(200); |
|
306 |
|
307 QFETCH(bool, ui); |
|
308 QFETCH(QString, msg1); |
|
309 QFETCH(QString, msg2); |
|
310 QFETCH(TestMode, testmode); |
|
311 |
|
312 createUssdApi(ui); |
|
313 |
|
314 TestEnv::env().setTestMode(TestMode(KErrNone)); |
|
315 send(msg1); |
|
316 TestEnv::env().setTestMode(testmode); |
|
317 receive(msg2, RMobileUssdMessaging::EUssdMTReply); |
|
318 activeSleep(500); |
|
319 networkRelease( KErrNone ); |
|
320 activeSleep(500); |
|
321 |
|
322 // close api |
|
323 delete m_ussdApi; |
|
324 m_ussdApi = NULL; |
|
325 QTest::qSleep(100); |
|
326 |
|
327 TestEnv::destroy(); |
|
328 QTest::qSleep(200); |
|
329 } |
|
330 |
|
331 void Ut_Ussd::testMultipleIncomingMessages() |
|
332 { |
|
333 TestEnv::create(); |
|
334 QTest::qSleep(200); |
|
335 |
|
336 QString msg1 = "your favorite color?\n1=red\n2=blue"; |
|
337 QString msg2 = "your favorite food?\n1=rice\n2=potatoes"; |
|
338 QString msg3 = "thank you"; |
|
339 receive(msg1,RMobileUssdMessaging::EUssdMTRequest); |
|
340 activeSleep(1000); |
|
341 receive(msg2,RMobileUssdMessaging::EUssdMTRequest); |
|
342 activeSleep(1000); |
|
343 receive(msg3,RMobileUssdMessaging::EUssdMTNotify); |
|
344 activeSleep(1000); |
|
345 |
|
346 TestEnv::destroy(); |
|
347 QTest::qSleep(200); |
|
348 } |
|
349 |
|
350 void Ut_Ussd::testUssdInternalApi_data() |
|
351 { |
|
352 QTest::addColumn<bool>("ui"); |
|
353 QTest::addColumn<QString>("msg1"); |
|
354 QTest::addColumn<QString>("msg2"); |
|
355 QTest::addColumn<TestMode>("testmode"); |
|
356 |
|
357 // without ui |
|
358 QTest::newRow("1.1") << false << "1" << "" << TestMode(KErrNone,100); |
|
359 QTest::newRow("1.2") << false << "1" << "23" << TestMode(KErrNone,200); |
|
360 QTest::newRow("1.3") << false << "1" << "" << TestMode(KErrUnknown,300); |
|
361 QTest::newRow("1.4") << false << "1" << "23" << TestMode(KErrNotFound,400); |
|
362 // show ui |
|
363 QTest::newRow("1.1") << true << "1" << "" << TestMode(KErrNone,100); |
|
364 QTest::newRow("1.2") << true << "1" << "23" << TestMode(KErrNone,200); |
|
365 QTest::newRow("1.3") << true << "1" << "" << TestMode(KErrUnknown,300); |
|
366 QTest::newRow("1.4") << true << "1" << "23" << TestMode(KErrNotFound,400); |
|
367 } |
|
368 |
|
369 void Ut_Ussd::testUssdInternalApi() |
|
370 { |
|
371 TestEnv::create(); |
|
372 QTest::qSleep(200); |
|
373 |
|
374 QFETCH(bool, ui); |
|
375 QFETCH(QString, msg1); // send |
|
376 QFETCH(QString, msg2); // receive1 |
|
377 QFETCH(TestMode, testmode); |
|
378 |
|
379 createUssdInternalApi(ui); |
|
380 |
|
381 int err = m_ussdInternalApi->AppStarting(); |
|
382 QCOMPARE(err,KErrNone); |
|
383 QTest::qSleep(100); |
|
384 |
|
385 err = m_ussdInternalApi->AppToBackground(); |
|
386 QCOMPARE(err,KErrNone); |
|
387 QTest::qSleep(100); |
|
388 |
|
389 err = m_ussdInternalApi->AppToForeground(); |
|
390 QTest::qSleep(100); |
|
391 |
|
392 err = m_ussdInternalApi->AppTerminating(EPhCltUserExit); |
|
393 QCOMPARE(err,KErrNone); |
|
394 QTest::qSleep(100); |
|
395 |
|
396 err = m_ussdInternalApi->AppStarting(); |
|
397 QCOMPARE(err,KErrNone); |
|
398 QTest::qSleep(100); |
|
399 |
|
400 TBuf<200> reply_buf16; |
|
401 reply_buf16.Copy( (const TUint16*)msg1.constData(), msg1.length() ); |
|
402 int result = m_ussdInternalApi->SendUssd( reply_buf16 ); |
|
403 QCOMPARE(result, TestEnv::env().testMode().m_error); |
|
404 QTest::qSleep(100); |
|
405 |
|
406 receive(msg2, RMobileUssdMessaging::EUssdMTNotify); |
|
407 activeSleep(100); |
|
408 |
|
409 err = m_ussdInternalApi->AppTerminating(EPhCltSendCompleted); |
|
410 QCOMPARE(err,KErrNone); |
|
411 QTest::qSleep(100); |
|
412 |
|
413 // close internal api |
|
414 delete m_ussdInternalApi; |
|
415 m_ussdInternalApi = NULL; |
|
416 QTest::qSleep(100); |
|
417 |
|
418 TestEnv::destroy(); |
|
419 QTest::qSleep(200); |
|
420 } |
|
421 |
|
422 void Ut_Ussd::createUssdApi(bool ui) |
|
423 { |
|
424 TRAPD(leave, m_ussdApi = CPhCltUssd::NewL(ui)); |
|
425 QTest::qSleep(200); |
|
426 if (leave != KErrNone) |
|
427 QFAIL("CPhCltUssd::NewL Leave"); |
|
428 if (NULL == m_ussdApi) |
|
429 QFAIL("CPhCltUssd pointer null"); |
|
430 qDebug("m_ussdApi=%d", m_ussdApi); |
|
431 } |
|
432 |
|
433 void Ut_Ussd::createUssdInternalApi(bool ui) |
|
434 { |
|
435 TRAPD(leave, m_ussdInternalApi = CPhCltUssdImp::NewL(ui)); |
|
436 QTest::qSleep(200); |
|
437 if (leave != KErrNone) |
|
438 QFAIL("CPhCltUssdInt::NewL Leave"); |
|
439 if (NULL == m_ussdInternalApi) |
|
440 QFAIL("CPhCltUssdInt pointer null"); |
|
441 qDebug("m_ussdInternalApi=%d", m_ussdInternalApi); |
|
442 } |
|
443 |
|
444 void Ut_Ussd::createUssdSatApi(bool ui) |
|
445 { |
|
446 TRAPD(leave, m_ussdSatApi = CPhCltUssdSatClient::NewL(ui)); |
|
447 QTest::qSleep(200); |
|
448 if (leave != KErrNone) |
|
449 QFAIL("CPhCltUssdSatClient::NewL Leave"); |
|
450 if (NULL == m_ussdSatApi) |
|
451 QFAIL("CPhCltUssdSatClient pointer null"); |
|
452 qDebug("m_ussdSatApi=%d", m_ussdSatApi); |
|
453 } |
|
454 |
|
455 void Ut_Ussd::send(const QString& msg) |
|
456 { |
|
457 qDebug("Ut_Ussd::send SendUssd in"); |
|
458 QVERIFY(m_ussdApi); |
|
459 TBuf<200> send_buf16; |
|
460 send_buf16.Copy( (const TUint16*)msg.constData(), msg.length() ); |
|
461 qDebug("Ut_Ussd::send SendUssd before"); |
|
462 int result = m_ussdApi->SendUssd( send_buf16 ); |
|
463 qDebug("Ut_Ussd::send SendUssd after"); |
|
464 QCOMPARE(result, TestEnv::env().testMode().m_error); |
|
465 qDebug("Ut_Ussd::send SendUssd out"); |
|
466 } |
|
467 |
|
468 // type = { |
|
469 // RMobileUssdMessaging::EUssdMTRequest |
|
470 // RMobileUssdMessaging::EUssdMTReply |
|
471 // RMobileUssdMessaging::EUssdMTNotify |
|
472 // } |
|
473 |
|
474 void Ut_Ussd::receive(const QString& msg, int type) |
|
475 { |
|
476 qDebug("Ut_Ussd::send receive in"); |
|
477 QTest::qSleep(TestEnv::env().testMode().m_timeout); |
|
478 TBuf<200> rcv_buf16; |
|
479 rcv_buf16.Copy( (const TUint16*)msg.constData(), msg.length() ); |
|
480 TBuf8<200> rcv_buf8; |
|
481 rcv_buf8.Copy( rcv_buf16 ); |
|
482 // prepare attributes |
|
483 RMobileUssdMessaging::TMobileUssdAttributesV1 attr; |
|
484 attr.iFlags = RMobileUssdMessaging::KUssdMessageType; |
|
485 attr.iType = (RMobileUssdMessaging::TMobileUssdMessageType)type; |
|
486 RMobileUssdMessaging::TMobileUssdAttributesV1Pckg attrpkg(attr); |
|
487 |
|
488 TestEnv::env().etelMsgLoop().receive( rcv_buf8, attrpkg ); |
|
489 qDebug("Ut_Ussd::send receive out"); |
|
490 } |
|
491 |
|
492 void Ut_Ussd::networkRelease(int error) |
|
493 { |
|
494 qDebug("Ut_Ussd::send networkRelease in"); |
|
495 RMobilePhone::TMobilePhoneSendSSRequestV3 attr; |
|
496 attr.iOpCode = error; |
|
497 RMobilePhone::TMobilePhoneSendSSRequestV3Pckg attrpkg(attr); |
|
498 |
|
499 TestEnv::env().etelMsgLoop().networkRelease( _L8(""), attrpkg ); |
|
500 qDebug("Ut_Ussd::send networkRelease out"); |
|
501 } |
|
502 |
|
503 |
|
504 // global variables |
|
505 CPeriodic* activeSleepTimer = 0; |
|
506 |
|
507 TInt ActiveSleepTimerCallback(TAny* aPtr) |
|
508 { |
|
509 if ( activeSleepTimer ) { |
|
510 qDebug("Ut_Ussd::ActiveSleepTimerCallback Cancel"); |
|
511 activeSleepTimer->Cancel(); |
|
512 } |
|
513 CActiveSchedulerWait* wait = (CActiveSchedulerWait*) aPtr; |
|
514 if (wait) { |
|
515 qDebug("Ut_Ussd::ActiveSleepTimerCallback AsyncStop"); |
|
516 wait->AsyncStop(); |
|
517 } |
|
518 return 0; |
|
519 } |
|
520 |
|
521 // This is a special SLEEP method that allows active objects to run meanwhile. |
|
522 // Note: because of its active nature, this sleep method is very inaccurate. |
|
523 void Ut_Ussd::activeSleep(int ms) |
|
524 { |
|
525 qDebug("Ut_Ussd::activeSleep in"); |
|
526 |
|
527 CActiveSchedulerWait* wait = new CActiveSchedulerWait; |
|
528 activeSleepTimer = CPeriodic::NewL(CActive::EPriorityStandard+1); |
|
529 TTimeIntervalMicroSeconds32 delay(1000*ms); |
|
530 activeSleepTimer->Start(delay,delay, |
|
531 TCallBack(ActiveSleepTimerCallback,(TAny*)wait)); |
|
532 if ( wait && wait->IsStarted() ) { |
|
533 wait->AsyncStop(); |
|
534 delete activeSleepTimer; |
|
535 activeSleepTimer = 0; |
|
536 delete wait; |
|
537 wait = NULL; |
|
538 qDebug("Ut_Ussd::activeSleep out unnormal"); |
|
539 return; |
|
540 } |
|
541 |
|
542 if (wait) { |
|
543 qDebug("Ut_Ussd::activeSleep start snyc before"); |
|
544 wait->Start(); |
|
545 qDebug("Ut_Ussd::activeSleep start snyc after"); |
|
546 } |
|
547 delete activeSleepTimer; |
|
548 activeSleepTimer = 0; |
|
549 delete wait; |
|
550 wait = NULL; |
|
551 qDebug("Ut_Ussd::activeSleep out"); |
|
552 } |
|
553 |
|
554 //End of file |
|
555 |
|