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